static NTSTATUS EnumRunningObjectTable(
_In_ PVOID ThreadParam
)
{
IRunningObjectTable* iRunningObjectTable = NULL;
IEnumMoniker* iEnumMoniker = NULL;
IMoniker* iMoniker = NULL;
IBindCtx* iBindCtx = NULL;
IMalloc* iMalloc = NULL;
ULONG count = 0;
HWND listViewHandle = (HWND)ThreadParam;
if (!SUCCEEDED(CoGetMalloc(1, &iMalloc)))
return STATUS_INSUFFICIENT_RESOURCES;
// Query the running object table address
if (SUCCEEDED(GetRunningObjectTable(0, &iRunningObjectTable)))
{
// Enum the objects registered
if (SUCCEEDED(IRunningObjectTable_EnumRunning(iRunningObjectTable, &iEnumMoniker)))
{
while (IEnumMoniker_Next(iEnumMoniker, 1, &iMoniker, &count) == S_OK)
{
if (SUCCEEDED(CreateBindCtx(0, &iBindCtx)))
{
OLECHAR* displayName = NULL;
// Query the object name
if (SUCCEEDED(IMoniker_GetDisplayName(iMoniker, iBindCtx, NULL, &displayName)))
{
// Set the items name column
PhAddListViewItem(listViewHandle, MAXINT, displayName, NULL);
// Free the object name
IMalloc_Free(iMalloc, displayName);
}
IBindCtx_Release(iBindCtx);
}
IEnumMoniker_Release(iMoniker);
}
IEnumMoniker_Release(iEnumMoniker);
}
IRunningObjectTable_Release(iRunningObjectTable);
}
IMalloc_Release(iMalloc);
return STATUS_SUCCESS;
}
static gboolean
gst_dshowvideodec_get_filter_output_format (GstDshowVideoDec * vdec,
GUID * subtype, VIDEOINFOHEADER ** format, guint * size)
{
IPin *output_pin = NULL;
IEnumMediaTypes *enum_mediatypes = NULL;
HRESULT hres;
ULONG fetched;
BOOL ret = FALSE;
if (!vdec->decfilter)
return FALSE;
if (!gst_dshow_get_pin_from_filter (vdec->decfilter, PINDIR_OUTPUT,
&output_pin)) {
GST_ELEMENT_ERROR (vdec, CORE, NEGOTIATION,
("failed getting ouput pin from the decoder"), (NULL));
return FALSE;
}
hres = IPin_EnumMediaTypes (output_pin, &enum_mediatypes);
if (hres == S_OK && enum_mediatypes) {
AM_MEDIA_TYPE *mediatype = NULL;
IEnumMediaTypes_Reset (enum_mediatypes);
while (hres =
IEnumMoniker_Next (enum_mediatypes, 1, &mediatype, &fetched),
hres == S_OK) {
RPC_STATUS rpcstatus;
if ((UuidCompare (&mediatype->subtype, subtype, &rpcstatus) == 0
&& rpcstatus == RPC_S_OK) &&
(UuidCompare (&mediatype->formattype, &FORMAT_VideoInfo,
&rpcstatus) == 0 && rpcstatus == RPC_S_OK)) {
*size = mediatype->cbFormat;
*format = g_malloc0 (*size);
memcpy (*format, mediatype->pbFormat, *size);
ret = TRUE;
}
gst_dshow_free_mediatype (mediatype);
if (ret)
break;
}
IEnumMediaTypes_Release (enum_mediatypes);
}
if (output_pin) {
IPin_Release (output_pin);
}
return ret;
}
/* Helper function, checks if filter with given name was enumerated. */
static BOOL enum_find_filter(const WCHAR *wszFilterName, IEnumMoniker *pEnum)
{
IMoniker *pMoniker = NULL;
BOOL found = FALSE;
ULONG nb;
HRESULT hr;
static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
while(!found && IEnumMoniker_Next(pEnum, 1, &pMoniker, &nb) == S_OK)
{
IPropertyBag * pPropBagCat = NULL;
VARIANT var;
VariantInit(&var);
hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (LPVOID*)&pPropBagCat);
ok(SUCCEEDED(hr), "IMoniker_BindToStorage failed with %x\n", hr);
if (FAILED(hr) || !pPropBagCat)
{
VariantClear(&var);
IMoniker_Release(pMoniker);
continue;
}
hr = IPropertyBag_Read(pPropBagCat, wszFriendlyName, &var, NULL);
ok(SUCCEEDED(hr), "IPropertyBag_Read failed with %x\n", hr);
if (SUCCEEDED(hr))
{
CHAR val1[512], val2[512];
WideCharToMultiByte(CP_ACP, 0, V_BSTR(&var), -1, val1, sizeof(val1), 0, 0);
WideCharToMultiByte(CP_ACP, 0, wszFilterName, -1, val2, sizeof(val2), 0, 0);
if (!lstrcmpA(val1, val2)) found = TRUE;
}
IPropertyBag_Release(pPropBagCat);
IMoniker_Release(pMoniker);
VariantClear(&var);
}
return found;
}
/******************************************************************************
* ClassMoniker_ComposeWith
******************************************************************************/
static HRESULT WINAPI ClassMoniker_ComposeWith(IMoniker* iface,
IMoniker* pmkRight,
BOOL fOnlyIfNotGeneric,
IMoniker** ppmkComposite)
{
HRESULT res=S_OK;
DWORD mkSys,mkSys2;
IEnumMoniker* penumMk=0;
IMoniker *pmostLeftMk=0;
IMoniker* tempMkComposite=0;
TRACE("(%p,%d,%p)\n", pmkRight, fOnlyIfNotGeneric, ppmkComposite);
if ((ppmkComposite==NULL)||(pmkRight==NULL))
return E_POINTER;
*ppmkComposite=0;
IMoniker_IsSystemMoniker(pmkRight,&mkSys);
/* If pmkRight is an anti-moniker, the returned moniker is NULL */
if(mkSys==MKSYS_ANTIMONIKER)
return res;
else
/* if pmkRight is a composite whose leftmost component is an anti-moniker, */
/* the returned moniker is the composite after the leftmost anti-moniker is removed. */
if(mkSys==MKSYS_GENERICCOMPOSITE){
res=IMoniker_Enum(pmkRight,TRUE,&penumMk);
if (FAILED(res))
return res;
res=IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL);
IMoniker_IsSystemMoniker(pmostLeftMk,&mkSys2);
if(mkSys2==MKSYS_ANTIMONIKER){
IMoniker_Release(pmostLeftMk);
tempMkComposite=iface;
IMoniker_AddRef(iface);
while(IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL)==S_OK){
res=CreateGenericComposite(tempMkComposite,pmostLeftMk,ppmkComposite);
IMoniker_Release(tempMkComposite);
IMoniker_Release(pmostLeftMk);
tempMkComposite=*ppmkComposite;
IMoniker_AddRef(tempMkComposite);
}
return res;
}
else
return CreateGenericComposite(iface,pmkRight,ppmkComposite);
}
/* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
a NULL moniker and a return value of MK_E_NEEDGENERIC */
else
if (!fOnlyIfNotGeneric)
return CreateGenericComposite(iface,pmkRight,ppmkComposite);
else
return MK_E_NEEDGENERIC;
}
/**
* Cycle through available devices using the device enumerator devenum,
* retrieve the device with type specified by devtype and return the
* pointer to the object found in *pfilter.
* If pfilter is NULL, list all device names.
*/
static int
dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum,
enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype, IBaseFilter **pfilter)
{
struct dshow_ctx *ctx = avctx->priv_data;
IBaseFilter *device_filter = NULL;
IEnumMoniker *classenum = NULL;
IMoniker *m = NULL;
const char *device_name = ctx->device_name[devtype];
int skip = (devtype == VideoDevice) ? ctx->video_device_number
: ctx->audio_device_number;
int r;
const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory,
&CLSID_AudioInputDeviceCategory };
const char *devtypename = (devtype == VideoDevice) ? "video" : "audio only";
const char *sourcetypename = (sourcetype == VideoSourceDevice) ? "video" : "audio";
r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[sourcetype],
(IEnumMoniker **) &classenum, 0);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices (or none found).\n",
devtypename);
return AVERROR(EIO);
}
while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) {
IPropertyBag *bag = NULL;
char *friendly_name = NULL;
char *unique_name = NULL;
VARIANT var;
IBindCtx *bind_ctx = NULL;
LPOLESTR olestr = NULL;
LPMALLOC co_malloc = NULL;
int i;
r = CoGetMalloc(1, &co_malloc);
if (r != S_OK)
goto fail1;
r = CreateBindCtx(0, &bind_ctx);
if (r != S_OK)
goto fail1;
/* GetDisplayname works for both video and audio, DevicePath doesn't */
r = IMoniker_GetDisplayName(m, bind_ctx, NULL, &olestr);
if (r != S_OK)
goto fail1;
unique_name = dup_wchar_to_utf8(olestr);
/* replace ':' with '_' since we use : to delineate between sources */
for (i = 0; i < strlen(unique_name); i++) {
if (unique_name[i] == ':')
unique_name[i] = '_';
}
r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag);
if (r != S_OK)
goto fail1;
var.vt = VT_BSTR;
r = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL);
if (r != S_OK)
goto fail1;
friendly_name = dup_wchar_to_utf8(var.bstrVal);
if (pfilter) {
if (strcmp(device_name, friendly_name) && strcmp(device_name, unique_name))
goto fail1;
if (!skip--) {
r = IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Unable to BindToObject for %s\n", device_name);
goto fail1;
}
}
} else {
av_log(avctx, AV_LOG_INFO, " \"%s\"\n", friendly_name);
av_log(avctx, AV_LOG_INFO, " Alternative name \"%s\"\n", unique_name);
}
fail1:
if (olestr && co_malloc)
IMalloc_Free(co_malloc, olestr);
if (bind_ctx)
IBindCtx_Release(bind_ctx);
av_free(friendly_name);
av_free(unique_name);
if (bag)
IPropertyBag_Release(bag);
IMoniker_Release(m);
}
IEnumMoniker_Release(classenum);
if (pfilter) {
if (!device_filter) {
av_log(avctx, AV_LOG_ERROR, "Could not find %s device with name [%s] among source devices of type %s.\n",
devtypename, device_name, sourcetypename);
return AVERROR(EIO);
}
*pfilter = device_filter;
}
return 0;
}
/**
* Cycle through available devices using the device enumerator devenum,
* retrieve the device with type specified by devtype and return the
* pointer to the object found in *pfilter.
* If pfilter is NULL, list all device names.
*/
static int
dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum,
enum dshowDeviceType devtype, IBaseFilter **pfilter)
{
struct dshow_ctx *ctx = avctx->priv_data;
IBaseFilter *device_filter = NULL;
IEnumMoniker *classenum = NULL;
IMoniker *m = NULL;
const char *device_name = ctx->device_name[devtype];
int skip = (devtype == VideoDevice) ? ctx->video_device_number
: ctx->audio_device_number;
int r;
const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory,
&CLSID_AudioInputDeviceCategory };
const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[devtype],
(IEnumMoniker **) &classenum, 0);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices.\n",
devtypename);
return AVERROR(EIO);
}
while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) {
IPropertyBag *bag = NULL;
char *buf = NULL;
VARIANT var;
r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag);
if (r != S_OK)
goto fail1;
var.vt = VT_BSTR;
r = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL);
if (r != S_OK)
goto fail1;
buf = dup_wchar_to_utf8(var.bstrVal);
if (pfilter) {
if (strcmp(device_name, buf))
goto fail1;
if (!skip--)
IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter);
} else {
av_log(avctx, AV_LOG_INFO, " \"%s\"\n", buf);
}
fail1:
if (buf)
av_free(buf);
if (bag)
IPropertyBag_Release(bag);
IMoniker_Release(m);
}
IEnumMoniker_Release(classenum);
if (pfilter) {
if (!device_filter) {
av_log(avctx, AV_LOG_ERROR, "Could not find %s device.\n",
devtypename);
return AVERROR(EIO);
}
*pfilter = device_filter;
}
return 0;
}
static GstCaps *
gst_dshowvideodec_src_getcaps (GstPad * pad)
{
GstDshowVideoDec *vdec = (GstDshowVideoDec *) gst_pad_get_parent (pad);
GstCaps *caps = NULL;
if (!vdec->srccaps)
vdec->srccaps = gst_caps_new_empty ();
if (vdec->decfilter) {
IPin *output_pin = NULL;
IEnumMediaTypes *enum_mediatypes = NULL;
HRESULT hres;
ULONG fetched;
if (!gst_dshow_get_pin_from_filter (vdec->decfilter, PINDIR_OUTPUT,
&output_pin)) {
GST_ELEMENT_ERROR (vdec, STREAM, FAILED,
("failed getting ouput pin from the decoder"), (NULL));
goto beach;
}
hres = IPin_EnumMediaTypes (output_pin, &enum_mediatypes);
if (hres == S_OK && enum_mediatypes) {
AM_MEDIA_TYPE *mediatype = NULL;
IEnumMediaTypes_Reset (enum_mediatypes);
while (hres =
IEnumMoniker_Next (enum_mediatypes, 1, &mediatype, &fetched),
hres == S_OK) {
RPC_STATUS rpcstatus;
VIDEOINFOHEADER *video_info;
GstCaps *mediacaps = NULL;
/* RGB24 */
if ((UuidCompare (&mediatype->subtype, &MEDIASUBTYPE_RGB24,
&rpcstatus) == 0 && rpcstatus == RPC_S_OK)
&& (UuidCompare (&mediatype->formattype, &FORMAT_VideoInfo,
&rpcstatus) == 0 && rpcstatus == RPC_S_OK)) {
video_info = (VIDEOINFOHEADER *) mediatype->pbFormat;
/* ffmpegcolorspace handles RGB24 in BIG_ENDIAN */
mediacaps = gst_caps_new_simple ("video/x-raw-rgb",
"bpp", G_TYPE_INT, 24,
"depth", G_TYPE_INT, 24,
"width", G_TYPE_INT, video_info->bmiHeader.biWidth,
"height", G_TYPE_INT, video_info->bmiHeader.biHeight,
"framerate", GST_TYPE_FRACTION,
(int) (10000000 / video_info->AvgTimePerFrame), 1, "endianness",
G_TYPE_INT, G_BIG_ENDIAN, "red_mask", G_TYPE_INT, 255,
"green_mask", G_TYPE_INT, 65280, "blue_mask", G_TYPE_INT,
16711680, NULL);
if (mediacaps) {
vdec->mediatypes = g_list_append (vdec->mediatypes, mediatype);
gst_caps_append (vdec->srccaps, mediacaps);
} else {
gst_dshow_free_mediatype (mediatype);
}
} else {
gst_dshow_free_mediatype (mediatype);
}
}
IEnumMediaTypes_Release (enum_mediatypes);
}
if (output_pin) {
IPin_Release (output_pin);
}
}
if (vdec->srccaps)
caps = gst_caps_ref (vdec->srccaps);
beach:
gst_object_unref (vdec);
return caps;
}
static HRESULT GetSplitter(MediaDetImpl *This)
{
IFileSourceFilter *file;
LPOLESTR name;
AM_MEDIA_TYPE mt;
GUID type[2];
IFilterMapper2 *map;
IEnumMoniker *filters;
IMoniker *mon;
VARIANT var;
GUID clsid;
IBaseFilter *splitter;
IEnumPins *pins;
IPin *source_pin, *splitter_pin;
HRESULT hr;
hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
&IID_IFilterMapper2, (void **) &map);
if (FAILED(hr))
return hr;
hr = IBaseFilter_QueryInterface(This->source, &IID_IFileSourceFilter,
(void **) &file);
if (FAILED(hr))
{
IFilterMapper2_Release(map);
return hr;
}
hr = IFileSourceFilter_GetCurFile(file, &name, &mt);
IFileSourceFilter_Release(file);
CoTaskMemFree(name);
if (FAILED(hr))
{
IFilterMapper2_Release(map);
return hr;
}
type[0] = mt.majortype;
type[1] = mt.subtype;
CoTaskMemFree(mt.pbFormat);
hr = IFilterMapper2_EnumMatchingFilters(map, &filters, 0, TRUE,
MERIT_UNLIKELY, FALSE, 1, type,
NULL, NULL, FALSE, TRUE,
0, NULL, NULL, NULL);
IFilterMapper2_Release(map);
if (FAILED(hr))
return hr;
hr = E_NOINTERFACE;
while (IEnumMoniker_Next(filters, 1, &mon, NULL) == S_OK)
{
hr = GetFilterInfo(mon, &clsid, &var);
IMoniker_Release(mon);
if (FAILED(hr))
continue;
hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER,
&IID_IBaseFilter, (void **) &splitter);
if (FAILED(hr))
{
VariantClear(&var);
continue;
}
hr = IGraphBuilder_AddFilter(This->graph, splitter,
V_UNION(&var, bstrVal));
VariantClear(&var);
This->splitter = splitter;
if (FAILED(hr))
goto retry;
hr = IBaseFilter_EnumPins(This->source, &pins);
if (FAILED(hr))
goto retry;
IEnumPins_Next(pins, 1, &source_pin, NULL);
IEnumPins_Release(pins);
hr = IBaseFilter_EnumPins(splitter, &pins);
if (FAILED(hr))
{
IPin_Release(source_pin);
goto retry;
}
IEnumPins_Next(pins, 1, &splitter_pin, NULL);
IEnumPins_Release(pins);
hr = IPin_Connect(source_pin, splitter_pin, NULL);
IPin_Release(source_pin);
IPin_Release(splitter_pin);
if (SUCCEEDED(hr))
break;
retry:
IBaseFilter_Release(splitter);
This->splitter = NULL;
}
IEnumMoniker_Release(filters);
if (FAILED(hr))
return hr;
return S_OK;
}
static GValueArray *
gst_dshowaudiosrc_get_device_name_values (GstDshowAudioSrc * src)
{
GValueArray *array = g_value_array_new (0);
GValue value = { 0 };
ICreateDevEnum *devices_enum = NULL;
IEnumMoniker *moniker_enum = NULL;
IMoniker *moniker = NULL;
HRESULT hres = S_FALSE;
ULONG fetched;
g_value_init (&value, G_TYPE_STRING);
hres = CoCreateInstance (&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
&IID_ICreateDevEnum, (void **) &devices_enum);
if (hres != S_OK) {
GST_CAT_ERROR (dshowaudiosrc_debug,
"Can't create an instance of the system device enumerator (error=%d)",
hres);
array = NULL;
goto clean;
}
hres =
ICreateDevEnum_CreateClassEnumerator (devices_enum,
&CLSID_AudioInputDeviceCategory, &moniker_enum, 0);
if (hres != S_OK || !moniker_enum) {
GST_CAT_ERROR (dshowaudiosrc_debug,
"Can't get enumeration of audio devices (error=%d)", hres);
array = NULL;
goto clean;
}
IEnumMoniker_Reset (moniker_enum);
while (hres = IEnumMoniker_Next (moniker_enum, 1, &moniker, &fetched),
hres == S_OK) {
IPropertyBag *property_bag = NULL;
hres =
IMoniker_BindToStorage (moniker, NULL, NULL, &IID_IPropertyBag,
(void **) &property_bag);
if (SUCCEEDED (hres) && property_bag) {
VARIANT varFriendlyName;
VariantInit (&varFriendlyName);
hres =
IPropertyBag_Read (property_bag, L"FriendlyName", &varFriendlyName,
NULL);
if (hres == S_OK && varFriendlyName.bstrVal) {
gchar *friendly_name =
g_utf16_to_utf8 ((const gunichar2 *) varFriendlyName.bstrVal,
wcslen (varFriendlyName.bstrVal), NULL, NULL, NULL);
g_value_set_string (&value, friendly_name);
g_value_array_append (array, &value);
g_value_unset (&value);
g_free (friendly_name);
SysFreeString (varFriendlyName.bstrVal);
}
IPropertyBag_Release (property_bag);
}
IMoniker_Release (moniker);
}
clean:
if (moniker_enum) {
IEnumMoniker_Release (moniker_enum);
}
if (devices_enum) {
ICreateDevEnum_Release (devices_enum);
}
return array;
}
static HRESULT DXDiag_InitDXDiagDirectShowFiltersContainer(IDxDiagContainer* pSubCont) {
HRESULT hr = S_OK;
static const WCHAR szName[] = {'s','z','N','a','m','e',0};
static const WCHAR szCatName[] = {'s','z','C','a','t','N','a','m','e',0};
static const WCHAR szClsidCat[] = {'s','z','C','l','s','i','d','C','a','t',0};
static const WCHAR szClsidFilter[] = {'s','z','C','l','s','i','d','F','i','l','t','e','r',0};
static const WCHAR dwInputs[] = {'d','w','I','n','p','u','t','s',0};
static const WCHAR dwOutputs[] = {'d','w','O','u','t','p','u','t','s',0};
static const WCHAR dwMerit[] = {'d','w','M','e','r','i','t',0};
/*
static const WCHAR szFileName[] = {'s','z','F','i','l','e','N','a','m','e',0};
static const WCHAR szFileVersion[] = {'s','z','F','i','l','e','V','e','r','s','i','o','n',0};
*/
VARIANT v;
static const WCHAR wszClsidName[] = {'C','L','S','I','D',0};
static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
static const WCHAR wszFilterDataName[] = {'F','i','l','t','e','r','D','a','t','a',0};
/*static const WCHAR wszMeritName[] = {'M','e','r','i','t',0};*/
ICreateDevEnum* pCreateDevEnum = NULL;
IEnumMoniker* pEmCat = NULL;
IMoniker* pMCat = NULL;
/** */
hr = CoCreateInstance(&CLSID_SystemDeviceEnum,
NULL,
CLSCTX_INPROC_SERVER,
&IID_ICreateDevEnum,
(void**) &pCreateDevEnum);
if (FAILED(hr)) return hr;
hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &CLSID_ActiveMovieCategories, &pEmCat, 0);
if (FAILED(hr)) goto out_show_filters;
VariantInit(&v);
while (S_OK == IEnumMoniker_Next(pEmCat, 1, &pMCat, NULL)) {
IPropertyBag* pPropBag = NULL;
CLSID clsidCat;
hr = IMoniker_BindToStorage(pMCat, NULL, NULL, &IID_IPropertyBag, (void**) &pPropBag);
if (SUCCEEDED(hr)) {
WCHAR* wszCatName = NULL;
WCHAR* wszCatClsid = NULL;
hr = IPropertyBag_Read(pPropBag, wszFriendlyName, &v, 0);
wszCatName = SysAllocString(V_BSTR(&v));
VariantClear(&v);
hr = IPropertyBag_Read(pPropBag, wszClsidName, &v, 0);
wszCatClsid = SysAllocString(V_BSTR(&v));
hr = CLSIDFromString(V_UNION(&v, bstrVal), &clsidCat);
VariantClear(&v);
/*
hr = IPropertyBag_Read(pPropBag, wszMeritName, &v, 0);
hr = IDxDiagContainerImpl_AddProp(pSubCont, dwMerit, &v);
VariantClear(&v);
*/
if (SUCCEEDED(hr)) {
IEnumMoniker* pEnum = NULL;
IMoniker* pMoniker = NULL;
hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &clsidCat, &pEnum, 0);
FIXME("\tClassEnumerator for clsid(%s) pEnum(%p)\n", debugstr_guid(&clsidCat), pEnum);
if (FAILED(hr) || pEnum == NULL) {
goto class_enum_failed;
}
while (NULL != pEnum && S_OK == IEnumMoniker_Next(pEnum, 1, &pMoniker, NULL)) {
IPropertyBag* pPropFilterBag = NULL;
FIXME("\tIEnumMoniker_Next(%p, 1, %p)\n", pEnum, pMoniker);
hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (void**) &pPropFilterBag);
if (SUCCEEDED(hr)) {
LPBYTE pData = NULL;
LPBYTE pCurrent = NULL;
struct REG_RF* prrf = NULL;
VARIANT v_data;
DWORD it;
DWORD dwNOutputs = 0;
DWORD dwNInputs = 0;
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = SysAllocString(wszCatName);
hr = IDxDiagContainerImpl_AddProp(pSubCont, szCatName, &v);
VariantClear(&v);
V_VT(&v) = VT_BSTR;
V_BSTR(&v) = SysAllocString(wszCatClsid);
hr = IDxDiagContainerImpl_AddProp(pSubCont, szClsidCat, &v);
VariantClear(&v);
hr = IPropertyBag_Read(pPropFilterBag, wszFriendlyName, &v, 0);
hr = IDxDiagContainerImpl_AddProp(pSubCont, szName, &v);
FIXME("\tName:%s\n", debugstr_w(V_BSTR(&v)));
VariantClear(&v);
hr = IPropertyBag_Read(pPropFilterBag, wszClsidName, &v, 0);
FIXME("\tClsid:%s\n", debugstr_w(V_BSTR(&v)));
hr = IDxDiagContainerImpl_AddProp(pSubCont, szClsidFilter, &v);
VariantClear(&v);
hr = IPropertyBag_Read(pPropFilterBag, wszFilterDataName, &v, NULL);
hr = SafeArrayAccessData(V_UNION(&v, parray), (LPVOID*) &pData);
prrf = (struct REG_RF*) pData;
pCurrent = pData;
VariantInit(&v_data);
V_VT(&v_data) = VT_UI4;
V_UI4(&v_data) = prrf->dwVersion;
hr = IDxDiagContainerImpl_AddProp(pSubCont, szName, &v_data);
VariantClear(&v_data);
V_VT(&v_data) = VT_UI4;
V_UI4(&v_data) = prrf->dwMerit;
hr = IDxDiagContainerImpl_AddProp(pSubCont, dwMerit, &v_data);
VariantClear(&v_data);
pCurrent += sizeof(struct REG_RF);
for (it = 0; it < prrf->dwPins; ++it) {
struct REG_RFP* prrfp = (struct REG_RFP*) pCurrent;
UINT j;
if (prrfp->dwFlags & REG_PINFLAG_B_OUTPUT) ++dwNOutputs;
else ++dwNInputs;
pCurrent += sizeof(struct REG_RFP);
if (prrfp->bCategory) {
pCurrent += sizeof(DWORD);
}
for (j = 0; j < prrfp->dwMediaTypes; ++j) {
struct REG_TYPE* prt = (struct REG_TYPE *)pCurrent;
pCurrent += sizeof(*prt);
}
for (j = 0; j < prrfp->dwMediums; ++j) {
DWORD dwOffset = *(DWORD*) pCurrent;
pCurrent += sizeof(dwOffset);
}
}
V_VT(&v_data) = VT_UI4;
V_UI4(&v_data) = dwNInputs;
hr = IDxDiagContainerImpl_AddProp(pSubCont, dwInputs, &v_data);
VariantClear(&v_data);
V_VT(&v_data) = VT_UI4;
V_UI4(&v_data) = dwNOutputs;
hr = IDxDiagContainerImpl_AddProp(pSubCont, dwOutputs, &v_data);
VariantClear(&v_data);
SafeArrayUnaccessData(V_UNION(&v, parray));
VariantClear(&v);
}
IPropertyBag_Release(pPropFilterBag);
pPropFilterBag = NULL;
}
IEnumMoniker_Release(pEnum);
pEnum = NULL;
}
class_enum_failed:
SysFreeString(wszCatName);
SysFreeString(wszCatClsid);
IPropertyBag_Release(pPropBag);
pPropBag = NULL;
}
IEnumMoniker_Release(pMCat);
pMCat = NULL;
}
out_show_filters:
if (NULL != pEmCat) {
IEnumMoniker_Release(pEmCat);
pEmCat = NULL;
}
if (NULL != pCreateDevEnum) {
ICreateDevEnum_Release(pCreateDevEnum);
pCreateDevEnum = NULL;
}
return hr;
}
static void test_devenum(IBindCtx *bind_ctx)
{
HRESULT res;
ICreateDevEnum* create_devenum;
IEnumMoniker* enum_moniker = NULL;
int i;
res = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
&IID_ICreateDevEnum, (LPVOID*)&create_devenum);
if (res != S_OK) {
skip("Cannot create SystemDeviceEnum object (%x)\n", res);
return;
}
for (i = 0; i < (sizeof(am_categories) / sizeof(struct category)); i++)
{
if (winetest_debug > 1)
trace("%s:\n", am_categories[i].name);
res = ICreateDevEnum_CreateClassEnumerator(create_devenum, am_categories[i].clsid, &enum_moniker, 0);
ok(SUCCEEDED(res), "Cannot create enum moniker (res = %x)\n", res);
if (res == S_OK)
{
IMoniker* moniker;
while (IEnumMoniker_Next(enum_moniker, 1, &moniker, NULL) == S_OK)
{
IPropertyBag* prop_bag = NULL;
VARIANT var;
HRESULT hr;
VariantInit(&var);
hr = IMoniker_BindToStorage(moniker, bind_ctx, NULL, &IID_IPropertyBag, (LPVOID*)&prop_bag);
ok(hr == S_OK, "IMoniker_BindToStorage failed with error %x\n", hr);
if (SUCCEEDED(hr))
{
hr = IPropertyBag_Read(prop_bag, friendly_name, &var, NULL);
ok((hr == S_OK) || broken(hr == 0x80070002), "IPropertyBag_Read failed with error %x\n", hr);
if (SUCCEEDED(hr))
{
if (winetest_debug > 1)
trace(" %s\n", wine_dbgstr_w(V_UNION(&var, bstrVal)));
VariantClear(&var);
}
else
{
trace(" ???\n");
}
}
if (prop_bag)
IPropertyBag_Release(prop_bag);
IMoniker_Release(moniker);
}
IEnumMoniker_Release(enum_moniker);
}
}
ICreateDevEnum_Release(create_devenum);
}