dmoreg.c File Reference

#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:

Go to the source code of this file.

Classes
struct	IEnumDMOImpl

Macros
#define	COBJMACROS
#define	MSDMO_MAJOR_VERSION   6

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msdmo)
static IEnumDMOImpl *	impl_from_IEnumDMO (IEnumDMO *iface)
static HRESULT	read_types (HKEY root, LPCWSTR key, ULONG *supplied, ULONG requested, DMO_PARTIAL_MEDIATYPE *types)
static LPWSTR	GUIDToString (LPWSTR lpwstr, REFGUID lpcguid)
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[])
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 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 clsidDMO, ULONG ulInputTypesRequested, ULONG *pulInputTypesSupplied, DMO_PARTIAL_MEDIATYPE *pInputTypes, ULONG ulOutputTypesRequested, ULONG *pulOutputTypesSupplied, DMO_PARTIAL_MEDIATYPE *pOutputTypes)

Variables
static const WCHAR	szDMORootKey []
static const WCHAR	szDMOInputType []
static const WCHAR	szDMOOutputType []
static const WCHAR	szDMOKeyed []
static const WCHAR	szDMOCategories []
static const WCHAR	szGUIDFmt []
static const WCHAR	szCat3Fmt []
static const WCHAR	szCat2Fmt []
static const WCHAR	szToGuidFmt []
static const IEnumDMOVtbl	edmovt

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file dmoreg.c.

MSDMO_MAJOR_VERSION

#define MSDMO_MAJOR_VERSION   6

Definition at line 35 of file dmoreg.c.

Function Documentation

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 732 of file dmoreg.c.

{
    TRACE("%s 0x%08x %d %p %d %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 %d - 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 %d - 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 create_EnumMoniker().

DMOGetName()

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

Definition at line 342 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, szDMORootKey, 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 DEVENUM_IPropertyBag_Read().

DMOGetTypes()

HRESULT WINAPI DMOGetTypes	(	REFCLSID	clsidDMO,
		ULONG	ulInputTypesRequested,
		ULONG *	pulInputTypesSupplied,
		DMO_PARTIAL_MEDIATYPE *	pInputTypes,
		ULONG	ulOutputTypesRequested,
		ULONG *	pulOutputTypesSupplied,
		DMO_PARTIAL_MEDIATYPE *	pOutputTypes
	)

Definition at line 857 of file dmoreg.c.

{
  HKEY root,hkey;
  HRESULT ret = S_OK;
  WCHAR szguid[64];
 
  TRACE ("(%s,%u,%p,%p,%u,%p,%p)\n", debugstr_guid(clsidDMO), ulInputTypesRequested,
        pulInputTypesSupplied, pInputTypes, ulOutputTypesRequested, pulOutputTypesSupplied,
        pOutputTypes);
 
  if (ERROR_SUCCESS != RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0,
                                     KEY_READ, &root))
    return E_FAIL;
 
  if (ERROR_SUCCESS != RegOpenKeyExW(root,GUIDToString(szguid,clsidDMO) , 0,
                                     KEY_READ, &hkey))
  {
    RegCloseKey(root);
    return E_FAIL;
  }
 
  if (ulInputTypesRequested > 0)
  {
    ret = read_types(hkey, szDMOInputType, pulInputTypesSupplied, ulInputTypesRequested, pInputTypes );
  }
  else
    *pulInputTypesSupplied = 0;
 
  if (ulOutputTypesRequested > 0)
  {
    HRESULT ret2;
    ret2 = read_types(hkey, szDMOOutputType, pulOutputTypesSupplied, ulOutputTypesRequested, pOutputTypes );
 
    if (ret == S_OK)
        ret = ret2;
  }
  else
    *pulOutputTypesSupplied = 0;
 
  return ret;
}

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 183 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, szDMORootKey, 0, NULL,
        REG_OPTION_NON_VOLATILE, 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,
        (lstrlenW(szName) + 1) * sizeof(WCHAR));
 
    /* Set InputTypes */
    hres = write_types(hkey, szDMOInputType, pInTypes, cInTypes);
 
    /* Set OutputTypes */
    hres = write_types(hkey, szDMOOutputType, pOutTypes, cOutTypes);
 
    if (dwFlags & DMO_REGISTERF_IS_KEYED)
    {
        /* Create Keyed key */ 
        ret = RegCreateKeyExW(hkey, szDMOKeyed, 0, NULL,
            REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hckey, NULL);
        if (ret)
            goto lend;
        RegCloseKey(hckey);
    }
 
    /* Register the category */
    ret = RegCreateKeyExW(hrkey, szDMOCategories, 0, NULL,
            REG_OPTION_NON_VOLATILE, 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%08x\n", hres);
    return hres;
}

Referenced by test_dmo().

DMOUnregister()

HRESULT WINAPI DMOUnregister	(	REFCLSID	dmo,
		REFGUID	category
	)

Definition at line 290 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));
 
    ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szDMORootKey, 0, KEY_WRITE, &rootkey);
    if (ret)
        return S_FALSE;
 
    GUIDToString(dmoW, dmo);
    RegDeleteKeyW(rootkey, dmoW);
 
    /* open 'Categories' */
    ret = RegOpenKeyExW(rootkey, szDMOCategories, 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 373 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 LPWSTR GUIDToString ( LPWSTR  lpwstr, REFGUID  lpcguid  )

static

Definition at line 109 of file dmoreg.c.

{
    wsprintfW(lpwstr, szGUIDFmt, lpcguid->Data1, lpcguid->Data2,
        lpcguid->Data3, lpcguid->Data4[0], lpcguid->Data4[1],
        lpcguid->Data4[2], lpcguid->Data4[3], lpcguid->Data4[4],
        lpcguid->Data4[5], lpcguid->Data4[6], lpcguid->Data4[7]);
 
    return lpwstr;
}

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

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 391 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, szDMORootKey, 0, KEY_READ, &lpedmo->hkey);
    }
    else
    {
        WCHAR szguid[64];
        WCHAR szKey[MAX_PATH];
 
        wsprintfW(szKey, szCat3Fmt, szDMORootKey, szDMOCategories, 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 456 of file dmoreg.c.

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

IEnumDMO_fnClone()

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

static

Definition at line 718 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 510 of file dmoreg.c.

{
    HKEY hkey;
    WCHAR szNextKey[MAX_PATH];
    WCHAR szGuidKey[64];
    WCHAR szKey[MAX_PATH];
    WCHAR szValue[MAX_PATH];
    DWORD len;
    UINT count = 0;
    HRESULT hres = S_OK;
    LONG ret;
    GUID guid;
 
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
 
    TRACE("(%p)->(%d %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, &guid) != S_OK)
            continue;
 
        TRACE("found %s\n", debugstr_w(szNextKey));
 
        if (!(This->dwFlags & DMO_ENUMF_INCLUDE_KEYED))
        {
            wsprintfW(szKey, szCat3Fmt, szDMORootKey, szNextKey, szDMOKeyed);
            ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
            if (ERROR_SUCCESS == ret)
            {
                RegCloseKey(hkey);
                /* Skip Keyed entries */
                continue;
            }
        }
 
        wsprintfW(szKey, szCat2Fmt, szDMORootKey, szNextKey);
        ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, szKey, 0, KEY_READ, &hkey);
        TRACE("testing %s\n", debugstr_w(szKey));
 
        if (This->pInTypes)
        {
            UINT i, j;
            DWORD cInTypes;
            DMO_PARTIAL_MEDIATYPE* pInTypes;
 
            hres = read_types(hkey, szDMOInputType, &cInTypes,
                    sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
                    (DMO_PARTIAL_MEDIATYPE*)szValue);
 
            if (FAILED(hres))
            {
                RegCloseKey(hkey);
                continue;
            }
 
            pInTypes = (DMO_PARTIAL_MEDIATYPE *)szValue;
 
            TRACE("read %d intypes for %s:\n", cInTypes, debugstr_w(szKey));
            for (i = 0; i < cInTypes; i++) {
                TRACE("intype %d: type %s, subtype %s\n", i, debugstr_guid(&pInTypes[i].type),
                    debugstr_guid(&pInTypes[i].subtype));
            }
 
            for (i = 0; i < This->cInTypes; i++)
            {
                for (j = 0; j < cInTypes; j++) 
                {
                    if (IsMediaTypeEqual(&pInTypes[j], &This->pInTypes[i]))
                        break;
                }
 
                if (j >= cInTypes)
                    break;
            }
 
            if (i < This->cInTypes)
            {
                RegCloseKey(hkey);
                continue;
            }
        }
 
        if (This->pOutTypes)
        {
            UINT i, j;
            DWORD cOutTypes;
            DMO_PARTIAL_MEDIATYPE* pOutTypes;
 
            hres = read_types(hkey, szDMOOutputType, &cOutTypes,
                    sizeof(szValue)/sizeof(DMO_PARTIAL_MEDIATYPE),
                    (DMO_PARTIAL_MEDIATYPE*)szValue);
 
            if (FAILED(hres))
            {
                RegCloseKey(hkey);
                continue;
            }
 
            pOutTypes = (DMO_PARTIAL_MEDIATYPE *)szValue;
 
            TRACE("read %d outtypes for %s:\n", cOutTypes, debugstr_w(szKey));
            for (i = 0; i < cOutTypes; i++) {
                TRACE("outtype %d: type %s, subtype %s\n", i, debugstr_guid(&pOutTypes[i].type),
                    debugstr_guid(&pOutTypes[i].subtype));
            }
 
            for (i = 0; i < This->cOutTypes; i++)
            {
                for (j = 0; j < cOutTypes; j++) 
                {
                    if (IsMediaTypeEqual(&pOutTypes[j], &This->pOutTypes[i]))
                        break;
                }
 
                if (j >= cOutTypes)
                    break;
            }
 
            if (i < 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((lstrlenW(szValue) + 1) * sizeof(WCHAR));
                if (Names[count])
                    lstrcpyW(Names[count], szValue);
            }
        }
        wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
        CLSIDFromString(szGuidKey, &pCLSID[count]);
 
        TRACE("found match %s %s\n", debugstr_w(szValue), debugstr_w(szNextKey));
        RegCloseKey(hkey);
        count++;
    }
 
    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 467 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 488 of file dmoreg.c.

{
    IEnumDMOImpl *This = impl_from_IEnumDMO(iface);
    ULONG refCount = InterlockedDecrement(&This->ref);
 
    TRACE("(%p)->(%d)\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 704 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 690 of file dmoreg.c.

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

impl_from_IEnumDMO()

static IEnumDMOImpl * impl_from_IEnumDMO ( IEnumDMO *  iface )

inlinestatic

Definition at line 100 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 129 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 IEnumDMO_fnNext().

read_types()

HRESULT read_types ( HKEY  root, LPCWSTR  key, ULONG *  supplied, ULONG  requested, DMO_PARTIAL_MEDIATYPE *  types  )

static

Definition at line 778 of file dmoreg.c.

{
    HRESULT ret = S_OK;
 
    if (MSDMO_MAJOR_VERSION > 5)
    {
        DWORD len;
        LONG rc;
 
        len = requested * sizeof(DMO_PARTIAL_MEDIATYPE);
        rc = RegQueryValueExW(root, key, NULL, NULL, (LPBYTE) types, &len);
        ret = HRESULT_FROM_WIN32(rc);
 
        *supplied = len / sizeof(DMO_PARTIAL_MEDIATYPE);
    }
    else
    {
        HKEY hkey;
        WCHAR szGuidKey[64];
 
        *supplied = 0;
        if (ERROR_SUCCESS == RegOpenKeyExW(root, key, 0, KEY_READ, &hkey))
        {
          int index = 0;
          WCHAR szNextKey[MAX_PATH];
          DWORD len;
          LONG rc = ERROR_SUCCESS;
 
          while (rc == ERROR_SUCCESS)
          {
            len = MAX_PATH;
            rc = RegEnumKeyExW(hkey, index, szNextKey, &len, NULL, NULL, NULL, NULL);
            if (rc == ERROR_SUCCESS)
            {
              HKEY subk;
              int sub_index = 0;
              LONG rcs = ERROR_SUCCESS;
              WCHAR szSubKey[MAX_PATH];
 
              RegOpenKeyExW(hkey, szNextKey, 0, KEY_READ, &subk);
              while (rcs == ERROR_SUCCESS)
              {
                len = MAX_PATH;
                rcs = RegEnumKeyExW(subk, sub_index, szSubKey, &len, NULL, NULL, NULL, NULL);
                if (rcs == ERROR_SUCCESS)
                {
                  if (*supplied >= requested)
                  {
                    /* Bailing */
                    ret = S_FALSE;
                    rc = ERROR_MORE_DATA;
                    rcs = ERROR_MORE_DATA;
                    break;
                  }
 
                  wsprintfW(szGuidKey,szToGuidFmt,szNextKey);
                  CLSIDFromString(szGuidKey, &types[*supplied].type);
                  wsprintfW(szGuidKey,szToGuidFmt,szSubKey);
                  CLSIDFromString(szGuidKey, &types[*supplied].subtype);
                  TRACE("Adding type %s subtype %s at index %i\n",
                    debugstr_guid(&types[*supplied].type),
                    debugstr_guid(&types[*supplied].subtype),
                    *supplied);
                  (*supplied)++;
                }
                sub_index++;
              }
              index++;
            }
          }
          RegCloseKey(hkey);
        }
    }
    return ret;
}

Referenced by DMOGetTypes(), and IEnumDMO_fnNext().

string_to_guid()

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

static

Definition at line 119 of file dmoreg.c.

{
    WCHAR buffer[39];
    buffer[0] = '{';
    lstrcpyW(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 270 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 140 of file dmoreg.c.

{
    LONG ret;
 
    if (MSDMO_MAJOR_VERSION > 5)
    {
        ret = RegSetValueExW(hkey, name, 0, REG_BINARY, (const BYTE*) types,
                          count* sizeof(DMO_PARTIAL_MEDIATYPE));
    }
    else
    {
        HKEY skey1,skey2,skey3;
        DWORD index = 0;
        WCHAR szGuidKey[64];
 
        ret = RegCreateKeyExW(hkey, name, 0, NULL, REG_OPTION_NON_VOLATILE,
                               KEY_WRITE, NULL, &skey1, NULL);
        if (ret)
            return HRESULT_FROM_WIN32(ret);
 
        while (index < count)
        {
            GUIDToString(szGuidKey,&types[index].type);
            ret = RegCreateKeyExW(skey1, szGuidKey, 0, NULL,
                        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey2, NULL);
            GUIDToString(szGuidKey,&types[index].subtype);
            ret = RegCreateKeyExW(skey2, szGuidKey, 0, NULL,
                        REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &skey3, NULL);
            RegCloseKey(skey3);
            RegCloseKey(skey2);
            index ++;
        }
        RegCloseKey(skey1);
    }
 
    return HRESULT_FROM_WIN32(ret);
}

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 107 of file dmoreg.c.

Referenced by IEnumDMO_Constructor().

szCat2Fmt

const WCHAR szCat2Fmt[]

static

Initial value:

=
{
    '%','s','\\','%','s',0
}

Definition at line 75 of file dmoreg.c.

Referenced by IEnumDMO_fnNext().

szCat3Fmt

const WCHAR szCat3Fmt[]

static

Initial value:

=
{
    '%','s','\\','%','s','\\','%','s',0
}

Definition at line 70 of file dmoreg.c.

Referenced by IEnumDMO_Constructor(), and IEnumDMO_fnNext().

szDMOCategories

const WCHAR szDMOCategories[]

static

Initial value:

=
{
    'C','a','t','e','g','o','r','i','e','s',0
}

Definition at line 58 of file dmoreg.c.

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

szDMOInputType

const WCHAR szDMOInputType[]

static

Initial value:

=
{
    'I','n','p','u','t','T','y','p','e','s',0
}

Definition at line 43 of file dmoreg.c.

Referenced by DMOGetTypes(), DMORegister(), and IEnumDMO_fnNext().

szDMOKeyed

const WCHAR szDMOKeyed[]

static

Initial value:

=
{
    'K','e','y','e','d',0
}

Definition at line 53 of file dmoreg.c.

Referenced by DMORegister(), and IEnumDMO_fnNext().

szDMOOutputType

const WCHAR szDMOOutputType[]

static

Initial value:

=
{
    'O','u','t','p','u','t','T','y','p','e','s',0
}

Definition at line 48 of file dmoreg.c.

Referenced by DMOGetTypes(), DMORegister(), and IEnumDMO_fnNext().

szDMORootKey

const WCHAR szDMORootKey[]

static

Initial value:

= 
{
    'D','i','r','e','c','t','S','h','o','w','\\',
    'M','e','d','i','a','O','b','j','e','c','t','s',0
}

Definition at line 37 of file dmoreg.c.

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

szGUIDFmt

const WCHAR szGUIDFmt[]

static

Initial value:

=
{
    '%','0','8','X','-','%','0','4','X','-','%','0','4','X','-','%','0',
    '2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2',
    'X','%','0','2','X','%','0','2','X','%','0','2','X',0
}

Definition at line 63 of file dmoreg.c.

Referenced by GUIDToString().

szToGuidFmt

const WCHAR szToGuidFmt[]

static

Initial value:

=
{
    '{','%','s','}',0
}

Definition at line 80 of file dmoreg.c.

Referenced by IEnumDMO_fnNext(), and read_types().