main.c File Reference

#include "wine/debug.h"
#include "quartz_private.h"
#include "uuids.h"

Include dependency graph for main.c:

Go to the source code of this file.

Classes
struct	IClassFactoryImpl
struct	object_creation_info

Macros
#define	OUR_GUID_ENTRY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)    { { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } , #name },

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (quartz)
HRESULT WINAPI	QUARTZ_DllGetClassObject (REFCLSID, REFIID, LPVOID *)
BOOL WINAPI	QUARTZ_DllMain (HINSTANCE, DWORD, LPVOID)
HRESULT WINAPI	QUARTZ_DllRegisterServer (void)
HRESULT WINAPI	QUARTZ_DllUnregisterServer (void)
bool	array_reserve (void **elements, size_t *capacity, size_t count, size_t size)
BOOL WINAPI	DllMain (HINSTANCE instance, DWORD reason, void *reserved)
static IClassFactoryImpl *	impl_from_IClassFactory (IClassFactory *iface)
static HRESULT WINAPI	DSCF_QueryInterface (IClassFactory *iface, REFIID riid, void **ppobj)
static ULONG WINAPI	DSCF_AddRef (IClassFactory *iface)
static ULONG WINAPI	DSCF_Release (IClassFactory *iface)
static HRESULT WINAPI	DSCF_CreateInstance (IClassFactory *iface, IUnknown *pOuter, REFIID riid, void **ppobj)
static HRESULT WINAPI	DSCF_LockServer (IClassFactory *iface, BOOL lock)
HRESULT WINAPI	DllGetClassObject (REFCLSID rclsid, REFIID riid, LPVOID *ppv)
HRESULT WINAPI	DllRegisterServer (void)
HRESULT WINAPI	DllUnregisterServer (void)
HRESULT CALLBACK	ICaptureGraphBuilder_FindInterface_Proxy (ICaptureGraphBuilder *This, const GUID *pCategory, IBaseFilter *pf, REFIID riid, void **ppint)
HRESULT __RPC_STUB	ICaptureGraphBuilder_FindInterface_Stub (ICaptureGraphBuilder *This, const GUID *pCategory, IBaseFilter *pf, REFIID riid, IUnknown **ppint)
HRESULT CALLBACK	ICaptureGraphBuilder2_FindInterface_Proxy (ICaptureGraphBuilder2 *This, const GUID *pCategory, const GUID *pType, IBaseFilter *pf, REFIID riid, void **ppint)
HRESULT __RPC_STUB	ICaptureGraphBuilder2_FindInterface_Stub (ICaptureGraphBuilder2 *This, const GUID *pCategory, const GUID *pType, IBaseFilter *pf, REFIID riid, IUnknown **ppint)
const char *	qzdebugstr_guid (const GUID *id)
int WINAPI	AmpFactorToDB (int ampfactor)
int WINAPI	DBToAmpFactor (int db)
DWORD WINAPI	AMGetErrorTextA (HRESULT hr, LPSTR buffer, DWORD maxlen)
DWORD WINAPI	AMGetErrorTextW (HRESULT hr, LPWSTR buffer, DWORD maxlen)

Variables
static const struct object_creation_info	object_creation []
static const IClassFactoryVtbl	DSCF_Vtbl
struct {
const GUID   riid
const char *   name
}	InterfaceDesc []

Macro Definition Documentation

OUR_GUID_ENTRY

#define OUR_GUID_ENTRY	(		name,
			l,
			w1,
			w2,
			b1,
			b2,
			b3,
			b4,
			b5,
			b6,
			b7,
			b8
	)		{ { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } , #name },

Definition at line 611 of file main.c.

Function Documentation

AMGetErrorTextA()

DWORD WINAPI AMGetErrorTextA	(	HRESULT	hr,
		LPSTR	buffer,
		DWORD	maxlen
	)

Definition at line 699 of file main.c.

{
    DWORD res;
    WCHAR errorW[MAX_ERROR_TEXT_LEN];
 
    TRACE("hr %#lx, buffer %p, maxlen %lu.\n", hr, buffer, maxlen);
 
    if (!buffer)
        return 0;
 
    res = AMGetErrorTextW(hr, errorW, ARRAY_SIZE(errorW));
    if (!res)
        return 0;
 
    res = WideCharToMultiByte(CP_ACP, 0, errorW, -1, NULL, 0, 0, 0);
    if (res > maxlen || !res)
        return 0;
    return WideCharToMultiByte(CP_ACP, 0, errorW, -1, buffer, maxlen, 0, 0) - 1;
}

AMGetErrorTextW()

DWORD WINAPI AMGetErrorTextW	(	HRESULT	hr,
		LPWSTR	buffer,
		DWORD	maxlen
	)

Definition at line 722 of file main.c.

{
    unsigned int len;
    WCHAR error[MAX_ERROR_TEXT_LEN];
 
    TRACE("hr %#lx, buffer %p, maxlen %lu.\n", hr, buffer, maxlen);
 
    if (!buffer) return 0;
    swprintf(error, ARRAY_SIZE(error), L"Error: 0x%lx", hr);
    if ((len = wcslen(error)) >= maxlen)
        return 0;
    wcscpy(buffer, error);
    return len;
}

Referenced by AMGetErrorTextA().

AmpFactorToDB()

int WINAPI AmpFactorToDB

(

int

ampfactor

)

Definition at line 681 of file main.c.

{
    FIXME("(%d) Stub!\n", ampfactor);
    return 0;
}

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

DBToAmpFactor()

int WINAPI DBToAmpFactor

(

int

db

)

Definition at line 687 of file main.c.

{
    FIXME("(%d) Stub!\n", db);
    /* Avoid divide by zero (probably during range computation) in Windows Media Player 6.4 */
    if (db < -1000)
    return 0;
    return 100;
}

DllGetClassObject()

HRESULT WINAPI DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 200 of file main.c.

{
    unsigned int i;
 
    TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 
    if (IsEqualGUID( &IID_IClassFactory, riid ) || IsEqualGUID( &IID_IUnknown, riid))
    {
        for (i = 0; i < ARRAY_SIZE(object_creation); i++)
        {
            if (IsEqualGUID(object_creation[i].clsid, rclsid))
            {
                IClassFactoryImpl *factory = CoTaskMemAlloc(sizeof(*factory));
                if (factory == NULL) return E_OUTOFMEMORY;
 
                factory->IClassFactory_iface.lpVtbl = &DSCF_Vtbl;
                factory->ref = 1;
 
                factory->create_instance = object_creation[i].create_instance;
 
                *ppv = &factory->IClassFactory_iface;
                return S_OK;
            }
        }
    }
    return QUARTZ_DllGetClassObject( rclsid, riid, ppv );
}

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	instance,
		DWORD	reason,
		void *	reserved
	)

Definition at line 58 of file main.c.

{
    if (reason == DLL_PROCESS_DETACH && !reserved)
    {
        video_window_unregister_class();
        strmbase_release_typelibs();
    }
    return QUARTZ_DllMain(instance, reason, reserved);
}

DllRegisterServer()

HRESULT WINAPI DllRegisterServer

(

void

)

Definition at line 231 of file main.c.

{
    static const REGPINTYPES video_renderer_inputs[] =
    {
        {&MEDIATYPE_Video, &GUID_NULL},
    };
    static const REGFILTERPINS2 video_renderer_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(video_renderer_inputs),
            .lpMediaType = video_renderer_inputs,
            .dwFlags = REG_PINFLAG_B_RENDERER,
        },
    };
    static const REGFILTER2 video_renderer_default_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_PREFERRED + 1,
        .cPins2 = ARRAY_SIZE(video_renderer_pins),
        .rgPins2 = video_renderer_pins,
    };
    static const REGFILTER2 video_renderer_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_PREFERRED,
        .cPins2 = ARRAY_SIZE(video_renderer_pins),
        .rgPins2 = video_renderer_pins,
    };
 
    static const REGPINTYPES vmr9_filter_inputs[] =
    {
        {&MEDIATYPE_Video, &GUID_NULL},
    };
    static const REGFILTERPINS2 vmr9_filter_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(vmr9_filter_inputs),
            .lpMediaType = vmr9_filter_inputs,
            .dwFlags = REG_PINFLAG_B_RENDERER,
        },
    };
    static const REGFILTER2 vmr9_filter_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_DO_NOT_USE,
        .cPins2 = ARRAY_SIZE(vmr9_filter_pins),
        .rgPins2 = vmr9_filter_pins,
    };
 
    static const REGPINTYPES avi_decompressor_inputs[] =
    {
        {&MEDIATYPE_Video, &GUID_NULL},
    };
    static const REGPINTYPES avi_decompressor_outputs[] =
    {
        {&MEDIATYPE_Video, &GUID_NULL},
    };
    static const REGFILTERPINS2 avi_decompressor_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(avi_decompressor_inputs),
            .lpMediaType = avi_decompressor_inputs,
        },
        {
            .nMediaTypes = ARRAY_SIZE(avi_decompressor_outputs),
            .lpMediaType = avi_decompressor_outputs,
            .dwFlags = REG_PINFLAG_B_OUTPUT,
        },
    };
    static const REGFILTER2 avi_decompressor_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_NORMAL - 16,
        .cPins2 = ARRAY_SIZE(avi_decompressor_pins),
        .rgPins2 = avi_decompressor_pins,
    };
 
    static const REGPINTYPES async_reader_outputs[] =
    {
        {&MEDIATYPE_Stream, &GUID_NULL},
    };
    static const REGFILTERPINS2 async_reader_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(async_reader_outputs),
            .lpMediaType = async_reader_outputs,
            .dwFlags = REG_PINFLAG_B_OUTPUT,
        },
    };
    static const REGFILTER2 async_reader_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_UNLIKELY,
        .cPins2 = ARRAY_SIZE(async_reader_pins),
        .rgPins2 = async_reader_pins,
    };
 
    static const REGPINTYPES acm_wrapper_inputs[] =
    {
        {&MEDIATYPE_Audio, &GUID_NULL},
    };
    static const REGPINTYPES acm_wrapper_outputs[] =
    {
        {&MEDIATYPE_Audio, &GUID_NULL},
    };
    static const REGFILTERPINS2 acm_wrapper_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(acm_wrapper_inputs),
            .lpMediaType = acm_wrapper_inputs,
        },
        {
            .nMediaTypes = ARRAY_SIZE(acm_wrapper_outputs),
            .lpMediaType = acm_wrapper_outputs,
            .dwFlags = REG_PINFLAG_B_OUTPUT,
        },
    };
    static const REGFILTER2 acm_wrapper_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_NORMAL - 16,
        .cPins2 = ARRAY_SIZE(acm_wrapper_pins),
        .rgPins2 = acm_wrapper_pins,
    };
 
    static const REGPINTYPES mpeg_splitter_inputs[] =
    {
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Audio},
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Video},
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1System},
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1VideoCD},
    };
    static const REGPINTYPES mpeg_splitter_audio_outputs[] =
    {
        {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
        {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
    };
    static const REGPINTYPES mpeg_splitter_video_outputs[] =
    {
        {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet},
        {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload},
    };
    static const REGFILTERPINS2 mpeg_splitter_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(mpeg_splitter_inputs),
            .lpMediaType = mpeg_splitter_inputs,
        },
        {
            .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
            .nMediaTypes = ARRAY_SIZE(mpeg_splitter_audio_outputs),
            .lpMediaType = mpeg_splitter_audio_outputs,
        },
        {
            .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
            .nMediaTypes = ARRAY_SIZE(mpeg_splitter_video_outputs),
            .lpMediaType = mpeg_splitter_video_outputs,
        },
    };
    static const REGFILTER2 mpeg_splitter_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_NORMAL,
        .cPins2 = ARRAY_SIZE(mpeg_splitter_pins),
        .rgPins2 = mpeg_splitter_pins,
    };
 
    static const REGPINTYPES avi_splitter_inputs[] =
    {
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_Avi},
    };
    static const REGPINTYPES avi_splitter_outputs[] =
    {
        {&MEDIATYPE_Video, &GUID_NULL},
    };
    static const REGFILTERPINS2 avi_splitter_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(avi_splitter_inputs),
            .lpMediaType = avi_splitter_inputs,
        },
        {
            .dwFlags = REG_PINFLAG_B_OUTPUT,
            .nMediaTypes = ARRAY_SIZE(avi_splitter_outputs),
            .lpMediaType = avi_splitter_outputs,
        },
    };
    static const REGFILTER2 avi_splitter_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_NORMAL,
        .cPins2 = ARRAY_SIZE(avi_splitter_pins),
        .rgPins2 = avi_splitter_pins,
    };
 
    static const REGPINTYPES wave_parser_inputs[] =
    {
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE},
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_AU},
        {&MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF},
    };
    static const REGPINTYPES wave_parser_outputs[] =
    {
        {&MEDIATYPE_Audio, &GUID_NULL},
    };
    static const REGFILTERPINS2 wave_parser_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(wave_parser_inputs),
            .lpMediaType = wave_parser_inputs,
        },
        {
            .dwFlags = REG_PINFLAG_B_OUTPUT,
            .nMediaTypes = ARRAY_SIZE(wave_parser_outputs),
            .lpMediaType = wave_parser_outputs,
        },
    };
    static const REGFILTER2 wave_parser_reg =
    {
        .dwVersion = 2,
        .dwMerit = MERIT_UNLIKELY,
        .cPins2 = ARRAY_SIZE(wave_parser_pins),
        .rgPins2 = wave_parser_pins,
    };
 
    static const REGPINTYPES mpeg_audio_codec_inputs[] =
    {
        {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
        {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Payload},
        {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
    };
    static const REGPINTYPES mpeg_audio_codec_outputs[] =
    {
        {&MEDIATYPE_Audio, &MEDIASUBTYPE_PCM},
    };
    static const REGFILTERPINS2 mpeg_audio_codec_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(mpeg_audio_codec_inputs),
            .lpMediaType = mpeg_audio_codec_inputs,
        },
        {
            .dwFlags = REG_PINFLAG_B_OUTPUT,
            .nMediaTypes = ARRAY_SIZE(mpeg_audio_codec_outputs),
            .lpMediaType = mpeg_audio_codec_outputs,
        },
    };
    static const REGFILTER2 mpeg_audio_codec_reg =
    {
        .dwVersion = 2,
        .dwMerit = 0x03680001,
        .cPins2 = ARRAY_SIZE(mpeg_audio_codec_pins),
        .rgPins2 = mpeg_audio_codec_pins,
    };
 
    static const REGPINTYPES mpeg_video_codec_inputs[] =
    {
        {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet},
        {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload},
    };
    static const REGPINTYPES mpeg_video_codec_outputs[] =
    {
        {&MEDIATYPE_Video, &GUID_NULL},
    };
    static const REGFILTERPINS2 mpeg_video_codec_pins[] =
    {
        {
            .nMediaTypes = ARRAY_SIZE(mpeg_video_codec_inputs),
            .lpMediaType = mpeg_video_codec_inputs,
        },
        {
            .dwFlags = REG_PINFLAG_B_OUTPUT,
            .nMediaTypes = ARRAY_SIZE(mpeg_video_codec_outputs),
            .lpMediaType = mpeg_video_codec_outputs,
        },
    };
    static const REGFILTER2 mpeg_video_codec_reg =
    {
        .dwVersion = 2,
        .dwMerit = 0x40000001,
        .cPins2 = ARRAY_SIZE(mpeg_video_codec_pins),
        .rgPins2 = mpeg_video_codec_pins,
    };
 
    IFilterMapper2 *mapper;
    HRESULT hr;
 
    TRACE("\n");
 
    if (FAILED(hr = QUARTZ_DllRegisterServer()))
        return hr;
 
    if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
            &IID_IFilterMapper2, (void **)&mapper)))
        return hr;
 
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_VideoRenderer, L"Video Renderer", NULL,
            &CLSID_LegacyAmFilterCategory, NULL, &video_renderer_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_VideoRendererDefault, L"Video Renderer", NULL,
            &CLSID_LegacyAmFilterCategory, NULL, &video_renderer_default_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_VideoMixingRenderer9, L"Video Mixing Renderer 9", NULL,
            &CLSID_LegacyAmFilterCategory, NULL, &vmr9_filter_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_AVIDec, L"AVI Decompressor", NULL,
            &CLSID_LegacyAmFilterCategory, NULL, &avi_decompressor_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_AsyncReader, L"File Source (Async.)", NULL,
            &CLSID_LegacyAmFilterCategory, NULL, &async_reader_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_ACMWrapper, L"ACM Wrapper", NULL,
            &CLSID_LegacyAmFilterCategory, NULL, &acm_wrapper_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_AviSplitter, L"AVI Splitter", NULL,
            NULL, NULL, &avi_splitter_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_MPEG1Splitter, L"MPEG-I Stream Splitter", NULL,
            NULL, NULL, &mpeg_splitter_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_WAVEParser, L"Wave Parser", NULL,
            NULL, NULL, &wave_parser_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_CMpegAudioCodec, L"MPEG Audio Decoder", NULL,
            NULL, NULL, &mpeg_audio_codec_reg)))
        goto done;
    if (FAILED(hr = IFilterMapper2_RegisterFilter(mapper, &CLSID_CMpegVideoCodec, L"MPEG Video Decoder", NULL,
            NULL, NULL, &mpeg_video_codec_reg)))
        goto done;
 
done:
    IFilterMapper2_Release(mapper);
    return hr;
}

DllUnregisterServer()

HRESULT WINAPI DllUnregisterServer

(

void

)

Definition at line 569 of file main.c.

{
    IFilterMapper2 *mapper;
    HRESULT hr;
 
    TRACE("\n");
 
    if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
            &IID_IFilterMapper2, (void **)&mapper)))
        return hr;
 
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, &CLSID_LegacyAmFilterCategory, NULL, &CLSID_VideoRenderer)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, &CLSID_LegacyAmFilterCategory, NULL, &CLSID_VideoRendererDefault)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, &CLSID_LegacyAmFilterCategory, NULL, &CLSID_VideoMixingRenderer9)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, &CLSID_LegacyAmFilterCategory, NULL, &CLSID_AVIDec)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, &CLSID_LegacyAmFilterCategory, NULL, &CLSID_AsyncReader)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, &CLSID_LegacyAmFilterCategory, NULL, &CLSID_ACMWrapper)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_AviSplitter)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_MPEG1Splitter)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_WAVEParser)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_CMpegAudioCodec)))
        goto done;
    if (FAILED(hr = IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_CMpegVideoCodec)))
        goto done;
 
done:
    IFilterMapper2_Release(mapper);
    if (SUCCEEDED(hr))
        hr = QUARTZ_DllUnregisterServer();
 
    return hr;
}

DSCF_AddRef()

static ULONG WINAPI DSCF_AddRef ( IClassFactory *  iface )

static

Definition at line 129 of file main.c.

{
    IClassFactoryImpl *This = impl_from_IClassFactory(iface);
    return InterlockedIncrement(&This->ref);
}

DSCF_CreateInstance()

static HRESULT WINAPI DSCF_CreateInstance ( IClassFactory *  iface, IUnknown *  pOuter, REFIID  riid, void **  ppobj  )

static

Definition at line 147 of file main.c.

{
    IClassFactoryImpl *This = impl_from_IClassFactory(iface);
    HRESULT hres;
    LPUNKNOWN punk;
 
    TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
 
    *ppobj = NULL;
    if(pOuter && !IsEqualGUID(&IID_IUnknown, riid))
        return E_NOINTERFACE;
 
    if (SUCCEEDED(hres = This->create_instance(pOuter, &punk)))
    {
        hres = IUnknown_QueryInterface(punk, riid, ppobj);
        IUnknown_Release(punk);
    }
    return hres;
}

DSCF_LockServer()

static HRESULT WINAPI DSCF_LockServer ( IClassFactory *  iface, BOOL  lock  )

static

Definition at line 168 of file main.c.

{
    FIXME("iface %p, lock %d, stub!\n", iface, lock);
    return S_OK;
}

DSCF_QueryInterface()

static HRESULT WINAPI DSCF_QueryInterface ( IClassFactory *  iface, REFIID  riid, void **  ppobj  )

static

Definition at line 114 of file main.c.

{
    if (IsEqualGUID(riid, &IID_IUnknown)
    || IsEqualGUID(riid, &IID_IClassFactory))
    {
    IClassFactory_AddRef(iface);
        *ppobj = iface;
    return S_OK;
    }
 
    *ppobj = NULL;
    WARN("(%p)->(%s,%p), not found\n", iface, debugstr_guid(riid), ppobj);
    return E_NOINTERFACE;
}

DSCF_Release()

static ULONG WINAPI DSCF_Release ( IClassFactory *  iface )

static

Definition at line 135 of file main.c.

{
    IClassFactoryImpl *This = impl_from_IClassFactory(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    if (ref == 0)
    CoTaskMemFree(This);
 
    return ref;
}

ICaptureGraphBuilder2_FindInterface_Proxy()

HRESULT CALLBACK ICaptureGraphBuilder2_FindInterface_Proxy	(	ICaptureGraphBuilder2 *	This,
		const GUID *	pCategory,
		const GUID *	pType,
		IBaseFilter *	pf,
		REFIID	riid,
		void **	ppint
	)

Definition at line 645 of file main.c.

{
    return ICaptureGraphBuilder2_RemoteFindInterface_Proxy( This, pCategory, pType,
                                                            pf, riid, (IUnknown **)ppint );
}

ICaptureGraphBuilder2_FindInterface_Stub()

HRESULT __RPC_STUB ICaptureGraphBuilder2_FindInterface_Stub	(	ICaptureGraphBuilder2 *	This,
		const GUID *	pCategory,
		const GUID *	pType,
		IBaseFilter *	pf,
		REFIID	riid,
		IUnknown **	ppint
	)

Definition at line 656 of file main.c.

{
    return ICaptureGraphBuilder2_FindInterface( This, pCategory, pType, pf, riid, (void **)ppint );
}

ICaptureGraphBuilder_FindInterface_Proxy()

HRESULT CALLBACK ICaptureGraphBuilder_FindInterface_Proxy	(	ICaptureGraphBuilder *	This,
		const GUID *	pCategory,
		IBaseFilter *	pf,
		REFIID	riid,
		void **	ppint
	)

Definition at line 626 of file main.c.

{
    return ICaptureGraphBuilder_RemoteFindInterface_Proxy( This, pCategory, pf,
                                                           riid, (IUnknown **)ppint );
}

ICaptureGraphBuilder_FindInterface_Stub()

HRESULT __RPC_STUB ICaptureGraphBuilder_FindInterface_Stub	(	ICaptureGraphBuilder *	This,
		const GUID *	pCategory,
		IBaseFilter *	pf,
		REFIID	riid,
		IUnknown **	ppint
	)

Definition at line 636 of file main.c.

{
    return ICaptureGraphBuilder_FindInterface( This, pCategory, pf, riid, (void **)ppint );
}

impl_from_IClassFactory()

static IClassFactoryImpl * impl_from_IClassFactory ( IClassFactory *  iface )

inlinestatic

Definition at line 77 of file main.c.

{
    return CONTAINING_RECORD(iface, IClassFactoryImpl, IClassFactory_iface);
}

QUARTZ_DllGetClassObject()

HRESULT WINAPI QUARTZ_DllGetClassObject	(	REFCLSID	,
		REFIID	,
		LPVOID *
	)

Referenced by DllGetClassObject().

QUARTZ_DllMain()

BOOL WINAPI QUARTZ_DllMain	(	HINSTANCE	,
		DWORD	,
		LPVOID
	)

Referenced by DllMain().

QUARTZ_DllRegisterServer()

HRESULT WINAPI QUARTZ_DllRegisterServer

(

void

)

Referenced by DllRegisterServer().

QUARTZ_DllUnregisterServer()

HRESULT WINAPI QUARTZ_DllUnregisterServer

(

void

)

Referenced by DllUnregisterServer().

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().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

quartz

)

Variable Documentation

DSCF_Vtbl

const IClassFactoryVtbl DSCF_Vtbl

static

Initial value:

=
{
    DSCF_QueryInterface,
    DSCF_AddRef,
    DSCF_Release,
    DSCF_CreateInstance,
    DSCF_LockServer
}

Definition at line 174 of file main.c.

const struct { ... } InterfaceDesc[]

Initial value:

=
{
 
    { { 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0} }, NULL }
}

Referenced by qzdebugstr_guid(), and USBSTOR_FdoHandleStartDevice().

name

const char* name

Definition at line 616 of file main.c.

object_creation

const struct object_creation_info object_creation[]

static

Initial value:

=
{
    { &CLSID_ACMWrapper, acm_wrapper_create },
    { &CLSID_AllocPresenter, vmr7_presenter_create },
    { &CLSID_AsyncReader, async_reader_create },
    { &CLSID_AudioRender, dsound_render_create },
    { &CLSID_AVIDec, avi_dec_create },
    { &CLSID_AviSplitter, avi_splitter_create },
    { &CLSID_CMpegAudioCodec, mpeg_audio_codec_create },
    { &CLSID_CMpegVideoCodec, mpeg_video_codec_create },
    { &CLSID_DSoundRender, dsound_render_create },
    { &CLSID_FilterGraph, filter_graph_create },
    { &CLSID_FilterGraphNoThread, filter_graph_no_thread_create },
    { &CLSID_FilterMapper, filter_mapper_create },
    { &CLSID_FilterMapper2, filter_mapper_create },
    { &CLSID_MemoryAllocator, mem_allocator_create },
    { &CLSID_MPEG1Splitter, mpeg1_splitter_create },
    { &CLSID_SeekingPassThru, seeking_passthrough_create },
    { &CLSID_SystemClock, system_clock_create },
    { &CLSID_VideoRenderer, video_renderer_create },
    { &CLSID_VideoMixingRenderer, vmr7_create },
    { &CLSID_VideoMixingRenderer9, vmr9_create },
    { &CLSID_VideoRendererDefault, video_renderer_default_create },
    { &CLSID_WAVEParser, wave_parser_create },
}

Definition at line 88 of file main.c.

riid

const GUID riid

Definition at line 615 of file main.c.