#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winerror.h"
#include "winreg.h"
#include "objbase.h"
#include "wine/debug.h"
#include "dmo.h"

Include dependency graph for dmoreg.c:

Classes
struct	IEnumDMOImpl

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msdmo)

BOOL	array_reserve (void *elements, unsigned int capacity, unsigned int count, unsigned int size)

static IEnumDMOImpl *	impl_from_IEnumDMO (IEnumDMO *iface)

static const WCHAR *	GUIDToString (WCHAR string, const GUID guid)

static HRESULT	string_to_guid (const WCHAR string, GUID guid)

static BOOL	IsMediaTypeEqual (const DMO_PARTIAL_MEDIATYPE mt1, const DMO_PARTIAL_MEDIATYPE mt2)

static HRESULT	write_types (HKEY hkey, LPCWSTR name, const DMO_PARTIAL_MEDIATYPE *types, DWORD count)

HRESULT WINAPI	DMORegister (LPCWSTR szName, REFCLSID clsidDMO, REFGUID guidCategory, DWORD dwFlags, DWORD cInTypes, const DMO_PARTIAL_MEDIATYPE pInTypes, DWORD cOutTypes, const DMO_PARTIAL_MEDIATYPE pOutTypes)

static HRESULT	unregister_dmo_from_category (const WCHAR dmoW, const WCHAR catW, HKEY categories)

HRESULT WINAPI	DMOUnregister (REFCLSID dmo, REFGUID category)

HRESULT WINAPI	DMOGetName (REFCLSID clsidDMO, WCHAR name[80])

static HRESULT	dup_partial_mediatype (const DMO_PARTIAL_MEDIATYPE types, DWORD count, DMO_PARTIAL_MEDIATYPE *ret)

static HRESULT	IEnumDMO_Constructor (REFGUID guidCategory, DWORD dwFlags, DWORD cInTypes, const DMO_PARTIAL_MEDIATYPE pInTypes, DWORD cOutTypes, const DMO_PARTIAL_MEDIATYPE pOutTypes, IEnumDMO **obj)

static ULONG WINAPI	IEnumDMO_fnAddRef (IEnumDMO *iface)

static HRESULT WINAPI	IEnumDMO_fnQueryInterface (IEnumDMO iface, REFIID riid, void *ppvObj)

static ULONG WINAPI	IEnumDMO_fnRelease (IEnumDMO *iface)

static BOOL	any_types_match (const DMO_PARTIAL_MEDIATYPE a, unsigned int a_count, const DMO_PARTIAL_MEDIATYPE b, unsigned int b_count)

static HRESULT WINAPI	IEnumDMO_fnNext (IEnumDMO iface, DWORD cItemsToFetch, CLSID pCLSID, WCHAR *Names, DWORD pcItemsFetched)

static HRESULT WINAPI	IEnumDMO_fnSkip (IEnumDMO *iface, DWORD cItemsToSkip)

static HRESULT WINAPI	IEnumDMO_fnReset (IEnumDMO *iface)

static HRESULT WINAPI	IEnumDMO_fnClone (IEnumDMO iface, IEnumDMO *ppEnum)

HRESULT WINAPI	DMOEnum (REFGUID category, DWORD flags, DWORD cInTypes, const DMO_PARTIAL_MEDIATYPE pInTypes, DWORD cOutTypes, const DMO_PARTIAL_MEDIATYPE pOutTypes, IEnumDMO **ppEnum)

HRESULT WINAPI	DMOGetTypes (REFCLSID clsid, ULONG input_count, ULONG ret_input_count, DMO_PARTIAL_MEDIATYPE input, ULONG output_count, ULONG ret_output_count, DMO_PARTIAL_MEDIATYPE output)

Variables
static const IEnumDMOVtbl	edmovt

Macro Definition Documentation

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file dmoreg.c.

Function Documentation

◆ any_types_match()

static BOOL any_types_match	(	const DMO_PARTIAL_MEDIATYPE *	a,
		unsigned int	a_count,
		const DMO_PARTIAL_MEDIATYPE *	b,
		unsigned int	b_count
	)

static

Definition at line 447 of file dmoreg.c.

{
    unsigned int i, j;
 
    for (i = 0; i < a_count; ++i)
    {
        for (j = 0; j < b_count; ++j)
        {
            if (IsMediaTypeEqual(&a[i], &b[j]))
                return TRUE;
        }
    }
    return FALSE;
}

Referenced by IEnumDMO_fnNext().

◆ array_reserve()

BOOL array_reserve	(	void **	elements,
		unsigned int *	capacity,
		unsigned int	count,
		unsigned int	size
	)

Definition at line 35 of file dmoreg.c.

{
    unsigned int max_capacity, new_capacity;
    void *new_elements;
 
    if (count <= *capacity)
        return TRUE;
 
    max_capacity = ~0u / size;
    if (count > max_capacity)
        return FALSE;
 
    new_capacity = max(8, *capacity);
    while (new_capacity < count && new_capacity <= max_capacity / 2)
        new_capacity *= 2;
    if (new_capacity < count)
        new_capacity = count;
 
    if (!(new_elements = realloc(*elements, new_capacity * size)))
    {
        ERR("Failed to allocate memory.\n");
        return FALSE;
    }
 
    *elements = new_elements;
    *capacity = new_capacity;
    return TRUE;
}

Referenced by IEnumDMO_fnNext().

◆ DMOEnum()

HRESULT WINAPI DMOEnum	(	REFGUID	category,
		DWORD	flags,
		DWORD	cInTypes,
		const DMO_PARTIAL_MEDIATYPE *	pInTypes,
		DWORD	cOutTypes,
		const DMO_PARTIAL_MEDIATYPE *	pOutTypes,
		IEnumDMO **	ppEnum
	)

Definition at line 674 of file dmoreg.c.

{
    TRACE("%s 0x%08lx %ld %p %ld %p %p\n", debugstr_guid(category), flags, cInTypes, pInTypes,
        cOutTypes, pOutTypes, ppEnum);
 
    if (TRACE_ON(msdmo))
    {
        DWORD i;
        if (cInTypes)
        {
            for (i = 0; i < cInTypes; i++)
                TRACE("intype %ld - type %s, subtype %s\n", i, debugstr_guid(&pInTypes[i].type),
                    debugstr_guid(&pInTypes[i].subtype));
        }
 
        if (cOutTypes) {
            for (i = 0; i < cOutTypes; i++)
                TRACE("outtype %ld - type %s, subtype %s\n", i, debugstr_guid(&pOutTypes[i].type),
                    debugstr_guid(&pOutTypes[i].subtype));
        }
    }
 
    return IEnumDMO_Constructor(category, flags, cInTypes,
        pInTypes, cOutTypes, pOutTypes, ppEnum);
}

Referenced by enum_moniker_create(), and test_dmo().

◆ DMOGetName()

HRESULT WINAPI DMOGetName	(	REFCLSID	clsidDMO,
		WCHAR	name[80]
	)

Definition at line 282 of file dmoreg.c.

{
    static const INT max_name_len = 80*sizeof(WCHAR);
    DWORD count = max_name_len;
    WCHAR szguid[64];
    HKEY hrkey, hkey;
    LONG ret;
 
    TRACE("%s %p\n", debugstr_guid(clsidDMO), name);
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"DirectShow\\MediaObjects", 0, KEY_READ, &hrkey))
        return E_FAIL;
 
    ret = RegOpenKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, KEY_READ, &hkey);
    RegCloseKey(hrkey);
    if (ret)
        return E_FAIL;
 
    ret = RegQueryValueExW(hkey, NULL, NULL, NULL, (LPBYTE)name, &count);
    RegCloseKey(hkey);
 
    if (!ret && count > 1)
    {
        TRACE("name=%s\n", debugstr_w(name));
        return S_OK;
    }
 
    name[0] = 0;
    return S_FALSE;
}

Referenced by property_bag_Read().

◆ DMOGetTypes()

HRESULT WINAPI DMOGetTypes	(	REFCLSID	clsid,
		ULONG	input_count,
		ULONG *	ret_input_count,
		DMO_PARTIAL_MEDIATYPE *	input,
		ULONG	output_count,
		ULONG *	ret_output_count,
		DMO_PARTIAL_MEDIATYPE *	output
	)

Definition at line 722 of file dmoreg.c.

{
    WCHAR guidstr[64];
    HKEY root, key;
    LSTATUS ret;
    DWORD size;
 
    TRACE("clsid %s, input_count %lu, ret_input_count %p, input %p, output_count %lu, ret_output_count %p, output %p.\n",
            debugstr_guid(clsid), input_count, ret_input_count, input, output_count, ret_output_count, output);
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"DirectShow\\MediaObjects", 0, KEY_READ, &root))
        return E_FAIL;
 
    if (RegOpenKeyExW(root, GUIDToString(guidstr, clsid), 0, KEY_READ, &key))
    {
        RegCloseKey(root);
        return E_FAIL;
    }
 
    *ret_input_count = 0;
    size = input_count * sizeof(DMO_PARTIAL_MEDIATYPE);
    ret = RegQueryValueExW(key, L"InputTypes", NULL, NULL, (BYTE *)input, &size);
    if (!ret || ret == ERROR_MORE_DATA)
        *ret_input_count = min(input_count, size / sizeof(DMO_PARTIAL_MEDIATYPE));
 
    *ret_output_count = 0;
    size = output_count * sizeof(DMO_PARTIAL_MEDIATYPE);
    ret = RegQueryValueExW(key, L"OutputTypes", NULL, NULL, (BYTE *)output, &size);
    if (!ret || ret == ERROR_MORE_DATA)
        *ret_output_count = min(output_count, size / sizeof(DMO_PARTIAL_MEDIATYPE));
 
    RegCloseKey(key);
    RegCloseKey(root);
    return S_OK;
}

Referenced by property_bag_Read().

◆ DMORegister()

HRESULT WINAPI DMORegister	(	LPCWSTR	szName,
		REFCLSID	clsidDMO,
		REFGUID	guidCategory,
		DWORD	dwFlags,
		DWORD	cInTypes,
		const DMO_PARTIAL_MEDIATYPE *	pInTypes,
		DWORD	cOutTypes,
		const DMO_PARTIAL_MEDIATYPE *	pOutTypes
	)

Definition at line 126 of file dmoreg.c.

{
    WCHAR szguid[64];
    HRESULT hres;
    HKEY hrkey = 0;
    HKEY hkey = 0;
    HKEY hckey = 0;
    HKEY hclskey = 0;
    LONG ret;
 
    TRACE("%s %s %s\n", debugstr_w(szName), debugstr_guid(clsidDMO), debugstr_guid(guidCategory));
 
    if (IsEqualGUID(guidCategory, &GUID_NULL))
        return E_INVALIDARG;
 
    ret = RegCreateKeyExW(HKEY_CLASSES_ROOT, L"DirectShow\\MediaObjects", 0,
            NULL, 0, KEY_WRITE, NULL, &hrkey, NULL);
    if (ret)
        return E_FAIL;
 
    /* Create clsidDMO key under MediaObjects */ 
    ret = RegCreateKeyExW(hrkey, GUIDToString(szguid, clsidDMO), 0, NULL,
        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
    if (ret)
        goto lend;
 
    /* Set default Name value */
    ret = RegSetValueExW(hkey, NULL, 0, REG_SZ, (const BYTE*) szName,
        (wcslen(szName) + 1) * sizeof(WCHAR));
 
    /* Set InputTypes */
    hres = write_types(hkey, L"InputTypes", pInTypes, cInTypes);
 
    /* Set OutputTypes */
    hres = write_types(hkey, L"OutputTypes", pOutTypes, cOutTypes);
 
    if (dwFlags & DMO_REGISTERF_IS_KEYED)
    {
        /* Create Keyed key */ 
        ret = RegCreateKeyExW(hkey, L"Keyed", 0, NULL, 0, KEY_WRITE, NULL, &hckey, NULL);
        if (ret)
            goto lend;
        RegCloseKey(hckey);
    }
 
    /* Register the category */
    ret = RegCreateKeyExW(hrkey, L"Categories", 0, NULL, 0, KEY_WRITE, NULL, &hckey, NULL);
    if (ret)
        goto lend;
 
    RegCloseKey(hkey);
 
    ret = RegCreateKeyExW(hckey, GUIDToString(szguid, guidCategory), 0, NULL,
            REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hkey, NULL);
    if (ret)
        goto lend;
    ret = RegCreateKeyExW(hkey, GUIDToString(szguid, clsidDMO), 0, NULL,
        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hclskey, NULL);
    if (ret)
        goto lend;
 
lend:
    if (hkey)
        RegCloseKey(hkey);
    if (hckey)
        RegCloseKey(hckey);
    if (hclskey)
        RegCloseKey(hclskey);
    if (hrkey)
        RegCloseKey(hrkey);
 
    hres = HRESULT_FROM_WIN32(ret);
    TRACE(" hresult=0x%08lx\n", hres);
    return hres;
}

Referenced by test_dmo().

◆ DMOUnregister()

HRESULT WINAPI DMOUnregister	(	REFCLSID	dmo,
		REFGUID	category
	)

Definition at line 231 of file dmoreg.c.

{
    HKEY rootkey = 0, categorieskey = 0;
    WCHAR dmoW[64], catW[64];
    HRESULT hr = S_FALSE;
    LONG ret;
 
    TRACE("%s %s\n", debugstr_guid(dmo), debugstr_guid(category));
 
    if (RegOpenKeyExW(HKEY_CLASSES_ROOT, L"DirectShow\\MediaObjects", 0, KEY_WRITE, &rootkey))
        return S_FALSE;
 
    GUIDToString(dmoW, dmo);
    RegDeleteKeyW(rootkey, dmoW);
 
    /* open 'Categories' */
    ret = RegOpenKeyExW(rootkey, L"Categories", 0, KEY_WRITE|KEY_ENUMERATE_SUB_KEYS, &categorieskey);
    RegCloseKey(rootkey);
    if (ret)
    {
        hr = HRESULT_FROM_WIN32(ret);
        goto lend;
    }
 
    /* remove from all categories */
    if (IsEqualGUID(category, &GUID_NULL))
    {
        DWORD index = 0, len = ARRAY_SIZE(catW);
 
        while (!RegEnumKeyExW(categorieskey, index++, catW, &len, NULL, NULL, NULL, NULL))
            hr = unregister_dmo_from_category(dmoW, catW, categorieskey);
    }
    else
    {
        GUIDToString(catW, category);
        hr = unregister_dmo_from_category(dmoW, catW, categorieskey);
    }
 
lend:
    if (categorieskey)
        RegCloseKey(categorieskey);
 
    return hr;
}

Referenced by test_dmo().

◆ dup_partial_mediatype()

static HRESULT dup_partial_mediatype	(	const DMO_PARTIAL_MEDIATYPE *	types,
		DWORD	count,
		DMO_PARTIAL_MEDIATYPE **	ret
	)

static

Definition at line 313 of file dmoreg.c.

{
    *ret = NULL;
 
    if (count == 0)
        return S_OK;
 
    *ret = HeapAlloc(GetProcessHeap(), 0, count*sizeof(*types));
    if (!*ret)
        return E_OUTOFMEMORY;
 
    memcpy(*ret, types, count*sizeof(*types));
    return S_OK;
}

Referenced by IEnumDMO_Constructor().

◆ GUIDToString()

static const WCHAR * GUIDToString	(	WCHAR *	string,
		const GUID *	guid
	)

static

Definition at line 85 of file dmoreg.c.

{
    swprintf(string, 37, L"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
            guid->Data1, guid->Data2, guid->Data3,
            guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
            guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
    return string;
}

Referenced by DMOGetName(), DMOGetTypes(), DMORegister(), DMOUnregister(), and IEnumDMO_Constructor().

◆ IEnumDMO_Constructor()

static HRESULT IEnumDMO_Constructor	(	REFGUID	guidCategory,
		DWORD	dwFlags,
		DWORD	cInTypes,
		const DMO_PARTIAL_MEDIATYPE *	pInTypes,
		DWORD	cOutTypes,
		const DMO_PARTIAL_MEDIATYPE *	pOutTypes,
		IEnumDMO **	obj
	)

static

Definition at line 331 of file dmoreg.c.

{
    IEnumDMOImpl* lpedmo;
    HRESULT hr;
 
    *obj = NULL;
 
    lpedmo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumDMOImpl));
    if (!lpedmo)
        return E_OUTOFMEMORY;
 
    lpedmo->IEnumDMO_iface.lpVtbl = &edmovt;
    lpedmo->ref = 1;
    lpedmo->index = -1;
    lpedmo->category = *guidCategory;
    lpedmo->dwFlags = dwFlags;
    lpedmo->cInTypes = cInTypes;
    lpedmo->cOutTypes = cOutTypes;
    lpedmo->hkey = NULL;
 
    hr = dup_partial_mediatype(pInTypes, cInTypes, &lpedmo->pInTypes);
    if (FAILED(hr))
        goto lerr;
 
    hr = dup_partial_mediatype(pOutTypes, cOutTypes, &lpedmo->pOutTypes);
    if (FAILED(hr))
        goto lerr;
 
    /* If not filtering by category enum from media objects root */
    if (IsEqualGUID(guidCategory, &GUID_NULL))
    {
        RegOpenKeyExW(HKEY_CLASSES_ROOT, L"DirectShow\\MediaObjects", 0, KEY_READ, &lpedmo->hkey);
    }
    else
    {
        WCHAR szguid[64];
        WCHAR szKey[MAX_PATH];
 
        swprintf(szKey, ARRAY_SIZE(szKey), L"DirectShow\\MediaObjects\\Categories\\%s",
                GUIDToString(szguid, guidCategory));
        RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &lpedmo->hkey);
    }
 
lerr:
 
    if (FAILED(hr))
        IEnumDMO_Release(&lpedmo->IEnumDMO_iface);
    else
    {
        TRACE("returning %p\n", lpedmo);
        *obj = &lpedmo->IEnumDMO_iface;
    }
 
    return hr;
}

Referenced by DMOEnum(), and IEnumDMO_fnClone().

◆ IEnumDMO_fnAddRef()

static ULONG WINAPI IEnumDMO_fnAddRef ( IEnumDMO * iface )

static

Definition at line 397 of file dmoreg.c.

{
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
    ULONG refCount = InterlockedIncrement(&This->ref);
    TRACE("(%p)->(%ld)\n", This, refCount);
    return refCount;
}

◆ IEnumDMO_fnClone()

static HRESULT WINAPI IEnumDMO_fnClone	(	IEnumDMO *	iface,
		IEnumDMO **	ppEnum
	)

static

Definition at line 660 of file dmoreg.c.

{
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
    TRACE("(%p)->(%p)\n", This, ppEnum);
    return IEnumDMO_Constructor(&This->category, This->dwFlags, This->cInTypes, This->pInTypes,
        This->cOutTypes, This->pOutTypes, ppEnum);
}

◆ IEnumDMO_fnNext()

static HRESULT WINAPI IEnumDMO_fnNext	(	IEnumDMO *	iface,
		DWORD	cItemsToFetch,
		CLSID *	pCLSID,
		WCHAR **	Names,
		DWORD *	pcItemsFetched
	)

static

Definition at line 466 of file dmoreg.c.

{
    DMO_PARTIAL_MEDIATYPE *types = NULL;
    unsigned int types_size = 0;
    HKEY hkey;
    WCHAR szNextKey[MAX_PATH];
    WCHAR path[MAX_PATH];
    WCHAR szValue[MAX_PATH];
    DWORD len;
    UINT count = 0;
    HRESULT hres = S_OK;
    LONG ret;
 
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 
    TRACE("(%p)->(%ld %p %p %p)\n", This, cItemsToFetch, pCLSID, Names, pcItemsFetched);
 
    if (!pCLSID)
        return E_POINTER;
 
    if (!pcItemsFetched && cItemsToFetch > 1)
        return E_INVALIDARG;
 
    while (count < cItemsToFetch)
    {
        This->index++;
 
        len = MAX_PATH;
        ret = RegEnumKeyExW(This->hkey, This->index, szNextKey, &len, NULL, NULL, NULL, NULL);
        if (ret != ERROR_SUCCESS)
        {
            hres = HRESULT_FROM_WIN32(ret);
            break;
        }
 
        if (string_to_guid(szNextKey, &pCLSID[count]) != S_OK)
            continue;
 
        TRACE("found %s\n", debugstr_w(szNextKey));
 
        if (!(This->dwFlags & DMO_ENUMF_INCLUDE_KEYED))
        {
            swprintf(path, ARRAY_SIZE(path), L"DirectShow\\MediaObjects\\%s\\Keyed", szNextKey);
            ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &hkey);
            if (ERROR_SUCCESS == ret)
            {
                RegCloseKey(hkey);
                /* Skip Keyed entries */
                continue;
            }
        }
 
        swprintf(path, ARRAY_SIZE(path), L"DirectShow\\MediaObjects\\%s", szNextKey);
        ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &hkey);
        TRACE("Testing %s.\n", debugstr_w(path));
 
        if (This->pInTypes)
        {
            DWORD size, i;
 
            for (;;)
            {
                size = types_size;
                ret = RegQueryValueExW(hkey, L"InputTypes", NULL, NULL, (BYTE *)types, &size);
                if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)
                    break;
                if (size <= types_size)
                    break;
                if (!array_reserve((void **)&types, &types_size, size, 1))
                {
                    RegCloseKey(hkey);
                    free(types);
                    return E_OUTOFMEMORY;
                }
            }
            if (ret)
            {
                RegCloseKey(hkey);
                continue;
            }
 
            for (i = 0; i < size / sizeof(DMO_PARTIAL_MEDIATYPE); ++i)
                TRACE("intype %ld: type %s, subtype %s\n", i, debugstr_guid(&types[i].type),
                    debugstr_guid(&types[i].subtype));
 
            if (!any_types_match(types, size / sizeof(DMO_PARTIAL_MEDIATYPE), This->pInTypes, This->cInTypes))
            {
                RegCloseKey(hkey);
                continue;
            }
        }
 
        if (This->pOutTypes)
        {
            DWORD size = types_size, i;
 
            for (;;)
            {
                size = types_size;
                ret = RegQueryValueExW(hkey, L"OutputTypes", NULL, NULL, (BYTE *)types, &size);
                if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA)
                    break;
                if (size <= types_size)
                    break;
                if (!array_reserve((void **)&types, &types_size, size, 1))
                {
                    RegCloseKey(hkey);
                    free(types);
                    return E_OUTOFMEMORY;
                }
            }
            if (ret)
            {
                RegCloseKey(hkey);
                continue;
            }
 
            for (i = 0; i < size / sizeof(DMO_PARTIAL_MEDIATYPE); ++i)
                TRACE("outtype %ld: type %s, subtype %s\n", i, debugstr_guid(&types[i].type),
                    debugstr_guid(&types[i].subtype));
 
            if (!any_types_match(types, size / sizeof(DMO_PARTIAL_MEDIATYPE), This->pOutTypes, This->cOutTypes))
            {
                RegCloseKey(hkey);
                continue;
            }
        }
 
        /* Media object wasn't filtered so add it to return list */
        len = MAX_PATH * sizeof(WCHAR);
        ret = RegQueryValueExW(hkey, NULL, NULL, NULL, (LPBYTE)szValue, &len);
        if (Names)
        {
            Names[count] = NULL;
            if (ret == ERROR_SUCCESS)
            {
                Names[count] = CoTaskMemAlloc((wcslen(szValue) + 1) * sizeof(WCHAR));
                if (Names[count])
                    wcscpy(Names[count], szValue);
            }
        }
 
        TRACE("found match %s %s\n", debugstr_w(szValue), debugstr_w(szNextKey));
        RegCloseKey(hkey);
        count++;
    }
 
    free(types);
 
    if (pcItemsFetched) *pcItemsFetched = count;
    if (count < cItemsToFetch)
        hres = S_FALSE;
 
    TRACE("<-- %i found\n",count);
    return hres;
}

◆ IEnumDMO_fnQueryInterface()

static HRESULT WINAPI IEnumDMO_fnQueryInterface	(	IEnumDMO *	iface,
		REFIID	riid,
		void **	ppvObj
	)

static

Definition at line 408 of file dmoreg.c.

{
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppvObj);
 
    *ppvObj = NULL;
 
    if (IsEqualIID(riid, &IID_IEnumDMO) ||
        IsEqualIID(riid, &IID_IUnknown))
    {
        *ppvObj = iface;
        IEnumDMO_AddRef(iface);
    }
 
    return *ppvObj ? S_OK : E_NOINTERFACE;
}

◆ IEnumDMO_fnRelease()

static ULONG WINAPI IEnumDMO_fnRelease ( IEnumDMO * iface )

static

Definition at line 429 of file dmoreg.c.

{
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
    ULONG refCount = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%ld)\n", This, refCount);
 
    if (!refCount)
    {
        if (This->hkey)
            RegCloseKey(This->hkey);
        HeapFree(GetProcessHeap(), 0, This->pInTypes);
        HeapFree(GetProcessHeap(), 0, This->pOutTypes);
        HeapFree(GetProcessHeap(), 0, This);
    }
    return refCount;
}

◆ IEnumDMO_fnReset()

static HRESULT WINAPI IEnumDMO_fnReset ( IEnumDMO * iface )

static

Definition at line 646 of file dmoreg.c.

{
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 
    TRACE("(%p)\n", This);
    This->index = -1;
 
    return S_OK;
}

◆ IEnumDMO_fnSkip()

static HRESULT WINAPI IEnumDMO_fnSkip	(	IEnumDMO *	iface,
		DWORD	cItemsToSkip
	)

static

Definition at line 632 of file dmoreg.c.

{
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 
    TRACE("(%p)->(%ld)\n", This, cItemsToSkip);
    This->index += cItemsToSkip;
 
    return S_OK;
}

◆ impl_from_IEnumDMO()

static IEnumDMOImpl * impl_from_IEnumDMO ( IEnumDMO * iface )

inlinestatic

Definition at line 78 of file dmoreg.c.

{
    return CONTAINING_RECORD(iface, IEnumDMOImpl, IEnumDMO_iface);
}

Referenced by IEnumDMO_fnAddRef(), IEnumDMO_fnClone(), IEnumDMO_fnNext(), IEnumDMO_fnQueryInterface(), IEnumDMO_fnRelease(), IEnumDMO_fnReset(), and IEnumDMO_fnSkip().

◆ IsMediaTypeEqual()

static BOOL IsMediaTypeEqual	(	const DMO_PARTIAL_MEDIATYPE *	mt1,
		const DMO_PARTIAL_MEDIATYPE *	mt2
	)

static

Definition at line 104 of file dmoreg.c.

{
 
    return (IsEqualCLSID(&mt1->type, &mt2->type) ||
            IsEqualCLSID(&mt2->type, &GUID_NULL) ||
            IsEqualCLSID(&mt1->type, &GUID_NULL)) &&
            (IsEqualCLSID(&mt1->subtype, &mt2->subtype) ||
            IsEqualCLSID(&mt2->subtype, &GUID_NULL) ||
            IsEqualCLSID(&mt1->subtype, &GUID_NULL));
}

Referenced by any_types_match().

◆ string_to_guid()

static HRESULT string_to_guid	(	const WCHAR *	string,
		GUID *	guid
	)

static

Definition at line 94 of file dmoreg.c.

{
    WCHAR buffer[39];
    buffer[0] = '{';
    wcscpy(buffer + 1, string);
    buffer[37] = '}';
    buffer[38] = 0;
    return CLSIDFromString(buffer, guid);
}

Referenced by IEnumDMO_fnNext().

◆ unregister_dmo_from_category()

static HRESULT unregister_dmo_from_category	(	const WCHAR *	dmoW,
		const WCHAR *	catW,
		HKEY	categories
	)

static

Definition at line 211 of file dmoreg.c.

{
    HKEY catkey;
    LONG ret;
 
    ret = RegOpenKeyExW(categories, catW, 0, KEY_WRITE, &catkey);
    if (!ret)
    {
        ret = RegDeleteKeyW(catkey, dmoW);
        RegCloseKey(catkey);
    }
 
    return !ret ? S_OK : S_FALSE;
}

Referenced by DMOUnregister().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( msdmo )

◆ write_types()

static HRESULT write_types	(	HKEY	hkey,
		LPCWSTR	name,
		const DMO_PARTIAL_MEDIATYPE *	types,
		DWORD	count
	)

static

Definition at line 115 of file dmoreg.c.

{
    return HRESULT_FROM_WIN32(RegSetValueExW(hkey, name, 0, REG_BINARY,
            (const BYTE *)types, count * sizeof(DMO_PARTIAL_MEDIATYPE)));
}

Referenced by DMORegister().

Variable Documentation

◆ edmovt

static const IEnumDMOVtbl edmovt

static

Initial value:

=
{
    IEnumDMO_fnQueryInterface,
    IEnumDMO_fnAddRef,
    IEnumDMO_fnRelease,
    IEnumDMO_fnNext,
    IEnumDMO_fnSkip,
    IEnumDMO_fnReset,
    IEnumDMO_fnClone,
}

Definition at line 83 of file dmoreg.c.

Referenced by IEnumDMO_Constructor().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ COBJMACROS

Function Documentation

◆ any_types_match()

◆ array_reserve()

◆ DMOEnum()

◆ DMOGetName()

◆ DMOGetTypes()

◆ DMORegister()

◆ DMOUnregister()

◆ dup_partial_mediatype()

◆ GUIDToString()

◆ IEnumDMO_Constructor()

◆ IEnumDMO_fnAddRef()

◆ IEnumDMO_fnClone()

◆ IEnumDMO_fnNext()

◆ IEnumDMO_fnQueryInterface()

◆ IEnumDMO_fnRelease()

◆ IEnumDMO_fnReset()

◆ IEnumDMO_fnSkip()

◆ impl_from_IEnumDMO()

◆ IsMediaTypeEqual()

◆ string_to_guid()

◆ unregister_dmo_from_category()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

◆ write_types()

Variable Documentation

◆ edmovt