dlls/dxdiagn/provider.c

   1 /*
   2  * IDxDiagProvider Implementation
   3  *
   4  * Copyright 2004-2005 Raphael Junqueira
   5  * Copyright 2010 Andrew Nguyen
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  */
  22
  23
  24 #define COBJMACROS
  25 #include "dxdiag_private.h"
  26 #include "winver.h"
  27 #include "objidl.h"
  28 #include "uuids.h"
  29 #include "vfw.h"
  30 #include "mmddk.h"
  31 #include "d3d9.h"
  32 #include "strmif.h"
  33 #include "initguid.h"
  34 #include "wine/fil_data.h"
  35 #include "psapi.h"
  36 #include "wbemcli.h"
  37 #include "dsound.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(dxdiag);
  42
  43 static HRESULT build_information_tree(IDxDiagContainerImpl_Container **pinfo_root);
  44 static void free_information_tree(IDxDiagContainerImpl_Container *node);
  45
  46 struct IDxDiagProviderImpl
  47 {
  48   IDxDiagProvider IDxDiagProvider_iface;
  49   LONG ref;
  50   BOOL init;
  51   DXDIAG_INIT_PARAMS params;
  52   IDxDiagContainerImpl_Container *info_root;
  53 };
  54
  55 static inline IDxDiagProviderImpl *impl_from_IDxDiagProvider(IDxDiagProvider *iface)
  56 {
  57      return CONTAINING_RECORD(iface, IDxDiagProviderImpl, IDxDiagProvider_iface);
  58 }
  59
  60 /* IDxDiagProvider IUnknown parts follow: */
  61 static HRESULT WINAPI IDxDiagProviderImpl_QueryInterface(IDxDiagProvider *iface, REFIID riid,
  62         void **ppobj)
  63 {
  64     IDxDiagProviderImpl *This = impl_from_IDxDiagProvider(iface);
  65
  66     if (!ppobj) return E_INVALIDARG;
  67
  68     if (IsEqualGUID(riid, &IID_IUnknown)
  69         || IsEqualGUID(riid, &IID_IDxDiagProvider)) {
  70         IUnknown_AddRef(iface);
  71         *ppobj = &This->IDxDiagProvider_iface;
  72         return S_OK;
  73     }
  74
  75     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
  76     *ppobj = NULL;
  77     return E_NOINTERFACE;
  78 }
  79
  80 static ULONG WINAPI IDxDiagProviderImpl_AddRef(IDxDiagProvider *iface)
  81 {
  82     IDxDiagProviderImpl *This = impl_from_IDxDiagProvider(iface);
  83     ULONG refCount = InterlockedIncrement(&This->ref);
  84
  85     TRACE("(%p)->(ref before=%lu)\n", This, refCount - 1);
  86
  87     DXDIAGN_LockModule();
  88
  89     return refCount;
  90 }
  91
  92 static ULONG WINAPI IDxDiagProviderImpl_Release(IDxDiagProvider *iface)
  93 {
  94     IDxDiagProviderImpl *This = impl_from_IDxDiagProvider(iface);
  95     ULONG refCount = InterlockedDecrement(&This->ref);
  96
  97     TRACE("(%p)->(ref before=%lu)\n", This, refCount + 1);
  98
  99     if (!refCount) {
 100         free_information_tree(This->info_root);
 101         HeapFree(GetProcessHeap(), 0, This);
 102     }
 103
 104     DXDIAGN_UnlockModule();
 105
 106     return refCount;
 107 }
 108
 109 /* IDxDiagProvider Interface follow: */
 110 static HRESULT WINAPI IDxDiagProviderImpl_Initialize(IDxDiagProvider *iface,
 111         DXDIAG_INIT_PARAMS *pParams)
 112 {
 113     IDxDiagProviderImpl *This = impl_from_IDxDiagProvider(iface);
 114     HRESULT hr;
 115
 116     TRACE("(%p,%p)\n", iface, pParams);
 117
 118     if (NULL == pParams) {
 119       return E_POINTER;
 120     }
 121     if (pParams->dwSize != sizeof(DXDIAG_INIT_PARAMS) ||
 122         pParams->dwDxDiagHeaderVersion != DXDIAG_DX9_SDK_VERSION) {
 123       return E_INVALIDARG;
 124     }
 125
 126     if (!This->info_root)
 127     {
 128         hr = build_information_tree(&This->info_root);
 129         if (FAILED(hr))
 130             return hr;
 131     }
 132
 133     This->init = TRUE;
 134     memcpy(&This->params, pParams, pParams->dwSize);
 135     return S_OK;
 136 }
 137
 138 static HRESULT WINAPI IDxDiagProviderImpl_GetRootContainer(IDxDiagProvider *iface,
 139         IDxDiagContainer **ppInstance)
 140 {
 141   IDxDiagProviderImpl *This = impl_from_IDxDiagProvider(iface);
 142
 143   TRACE("(%p,%p)\n", iface, ppInstance);
 144
 145   if (FALSE == This->init) {
 146     return CO_E_NOTINITIALIZED;
 147   }
 148
 149   return DXDiag_CreateDXDiagContainer(&IID_IDxDiagContainer, This->info_root,
 150           &This->IDxDiagProvider_iface, (void **)ppInstance);
 151 }
 152
 153 static const IDxDiagProviderVtbl DxDiagProvider_Vtbl =
 154 {
 155     IDxDiagProviderImpl_QueryInterface,
 156     IDxDiagProviderImpl_AddRef,
 157     IDxDiagProviderImpl_Release,
 158     IDxDiagProviderImpl_Initialize,
 159     IDxDiagProviderImpl_GetRootContainer
 160 };
 161
 162 HRESULT DXDiag_CreateDXDiagProvider(LPCLASSFACTORY iface, LPUNKNOWN punkOuter, REFIID riid, LPVOID *ppobj) {
 163   IDxDiagProviderImpl* provider;
 164
 165   TRACE("(%p, %s, %p)\n", punkOuter, debugstr_guid(riid), ppobj);
 166
 167   *ppobj = NULL;
 168   if (punkOuter) return CLASS_E_NOAGGREGATION;
 169
 170   provider = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDxDiagProviderImpl));
 171   if (NULL == provider) return E_OUTOFMEMORY;
 172   provider->IDxDiagProvider_iface.lpVtbl = &DxDiagProvider_Vtbl;
 173   provider->ref = 0; /* will be inited with QueryInterface */
 174   return IDxDiagProviderImpl_QueryInterface(&provider->IDxDiagProvider_iface, riid, ppobj);
 175 }
 176
 177 static void free_property_information(IDxDiagContainerImpl_Property *prop)
 178 {
 179     VariantClear(&prop->vProp);
 180     HeapFree(GetProcessHeap(), 0, prop->propName);
 181     HeapFree(GetProcessHeap(), 0, prop);
 182 }
 183
 184 static void free_information_tree(IDxDiagContainerImpl_Container *node)
 185 {
 186     IDxDiagContainerImpl_Container *ptr, *cursor2;
 187
 188     if (!node)
 189         return;
 190
 191     HeapFree(GetProcessHeap(), 0, node->contName);
 192
 193     LIST_FOR_EACH_ENTRY_SAFE(ptr, cursor2, &node->subContainers, IDxDiagContainerImpl_Container, entry)
 194     {
 195         IDxDiagContainerImpl_Property *prop, *prop_cursor2;
 196
 197         LIST_FOR_EACH_ENTRY_SAFE(prop, prop_cursor2, &ptr->properties, IDxDiagContainerImpl_Property, entry)
 198         {
 199             list_remove(&prop->entry);
 200             free_property_information(prop);
 201         }
 202
 203         list_remove(&ptr->entry);
 204         free_information_tree(ptr);
 205     }
 206
 207     HeapFree(GetProcessHeap(), 0, node);
 208 }
 209
 210 static IDxDiagContainerImpl_Container *allocate_information_node(const WCHAR *name)
 211 {
 212     IDxDiagContainerImpl_Container *ret;
 213
 214     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
 215     if (!ret)
 216         return NULL;
 217
 218     if (name)
 219     {
 220         ret->contName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(name) + 1) * sizeof(*name));
 221         if (!ret->contName)
 222         {
 223             HeapFree(GetProcessHeap(), 0, ret);
 224             return NULL;
 225         }
 226         lstrcpyW(ret->contName, name);
 227     }
 228
 229     list_init(&ret->subContainers);
 230     list_init(&ret->properties);
 231
 232     return ret;
 233 }
 234
 235 static IDxDiagContainerImpl_Property *allocate_property_information(const WCHAR *name)
 236 {
 237     IDxDiagContainerImpl_Property *ret;
 238
 239     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*ret));
 240     if (!ret)
 241         return NULL;
 242
 243     ret->propName = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(name) + 1) * sizeof(*name));
 244     if (!ret->propName)
 245     {
 246         HeapFree(GetProcessHeap(), 0, ret);
 247         return NULL;
 248     }
 249     lstrcpyW(ret->propName, name);
 250
 251     return ret;
 252 }
 253
 254 static inline void add_subcontainer(IDxDiagContainerImpl_Container *node, IDxDiagContainerImpl_Container *subCont)
 255 {
 256     list_add_tail(&node->subContainers, &subCont->entry);
 257     ++node->nSubContainers;
 258 }
 259
 260 static inline HRESULT add_bstr_property(IDxDiagContainerImpl_Container *node, const WCHAR *propName, const WCHAR *str)
 261 {
 262     IDxDiagContainerImpl_Property *prop;
 263     BSTR bstr;
 264
 265     prop = allocate_property_information(propName);
 266     if (!prop)
 267         return E_OUTOFMEMORY;
 268
 269     bstr = SysAllocString(str);
 270     if (!bstr)
 271     {
 272         free_property_information(prop);
 273         return E_OUTOFMEMORY;
 274     }
 275
 276     V_VT(&prop->vProp) = VT_BSTR;
 277     V_BSTR(&prop->vProp) = bstr;
 278
 279     list_add_tail(&node->properties, &prop->entry);
 280     ++node->nProperties;
 281
 282     return S_OK;
 283 }
 284
 285 static inline HRESULT add_ui4_property(IDxDiagContainerImpl_Container *node, const WCHAR *propName, DWORD data)
 286 {
 287     IDxDiagContainerImpl_Property *prop;
 288
 289     prop = allocate_property_information(propName);
 290     if (!prop)
 291         return E_OUTOFMEMORY;
 292
 293     V_VT(&prop->vProp) = VT_UI4;
 294     V_UI4(&prop->vProp) = data;
 295
 296     list_add_tail(&node->properties, &prop->entry);
 297     ++node->nProperties;
 298
 299     return S_OK;
 300 }
 301
 302 static inline HRESULT add_i4_property(IDxDiagContainerImpl_Container *node, const WCHAR *propName, LONG data)
 303 {
 304     IDxDiagContainerImpl_Property *prop;
 305
 306     prop = allocate_property_information(propName);
 307     if (!prop)
 308         return E_OUTOFMEMORY;
 309
 310     V_VT(&prop->vProp) = VT_I4;
 311     V_I4(&prop->vProp) = data;
 312
 313     list_add_tail(&node->properties, &prop->entry);
 314     ++node->nProperties;
 315
 316     return S_OK;
 317 }
 318
 319 static inline HRESULT add_bool_property(IDxDiagContainerImpl_Container *node, const WCHAR *propName, BOOL data)
 320 {
 321     IDxDiagContainerImpl_Property *prop;
 322
 323     prop = allocate_property_information(propName);
 324     if (!prop)
 325         return E_OUTOFMEMORY;
 326
 327     V_VT(&prop->vProp) = VT_BOOL;
 328     V_BOOL(&prop->vProp) = data ? VARIANT_TRUE : VARIANT_FALSE;
 329
 330     list_add_tail(&node->properties, &prop->entry);
 331     ++node->nProperties;
 332
 333     return S_OK;
 334 }
 335
 336 static inline HRESULT add_ull_as_bstr_property(IDxDiagContainerImpl_Container *node, const WCHAR *propName, ULONGLONG data )
 337 {
 338     IDxDiagContainerImpl_Property *prop;
 339     HRESULT hr;
 340
 341     prop = allocate_property_information(propName);
 342     if (!prop)
 343         return E_OUTOFMEMORY;
 344
 345     V_VT(&prop->vProp) = VT_UI8;
 346     V_UI8(&prop->vProp) = data;
 347
 348     hr = VariantChangeType(&prop->vProp, &prop->vProp, 0, VT_BSTR);
 349     if (FAILED(hr))
 350     {
 351         free_property_information(prop);
 352         return hr;
 353     }
 354
 355     list_add_tail(&node->properties, &prop->entry);
 356     ++node->nProperties;
 357
 358     return S_OK;
 359 }
 360
 361 /* Copied from programs/taskkill/taskkill.c. */
 362 static DWORD *enumerate_processes(DWORD *list_count)
 363 {
 364     DWORD *pid_list, alloc_bytes = 1024 * sizeof(*pid_list), needed_bytes;
 365
 366     pid_list = HeapAlloc(GetProcessHeap(), 0, alloc_bytes);
 367     if (!pid_list)
 368         return NULL;
 369
 370     for (;;)
 371     {
 372         DWORD *realloc_list;
 373
 374         if (!EnumProcesses(pid_list, alloc_bytes, &needed_bytes))
 375         {
 376             HeapFree(GetProcessHeap(), 0, pid_list);
 377             return NULL;
 378         }
 379
 380         /* EnumProcesses can't signal an insufficient buffer condition, so the
 381          * only way to possibly determine whether a larger buffer is required
 382          * is to see whether the written number of bytes is the same as the
 383          * buffer size. If so, the buffer will be reallocated to twice the
 384          * size. */
 385         if (alloc_bytes != needed_bytes)
 386             break;
 387
 388         alloc_bytes *= 2;
 389         realloc_list = HeapReAlloc(GetProcessHeap(), 0, pid_list, alloc_bytes);
 390         if (!realloc_list)
 391         {
 392             HeapFree(GetProcessHeap(), 0, pid_list);
 393             return NULL;
 394         }
 395         pid_list = realloc_list;
 396     }
 397
 398     *list_count = needed_bytes / sizeof(*pid_list);
 399     return pid_list;
 400 }
 401
 402 /* Copied from programs/taskkill/taskkill.c. */
 403 static BOOL get_process_name_from_pid(DWORD pid, WCHAR *buf, DWORD chars)
 404 {
 405     HANDLE process;
 406     HMODULE module;
 407     DWORD required_size;
 408
 409     process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, pid);
 410     if (!process)
 411         return FALSE;
 412
 413     if (!EnumProcessModules(process, &module, sizeof(module), &required_size))
 414     {
 415         CloseHandle(process);
 416         return FALSE;
 417     }
 418
 419     if (!GetModuleBaseNameW(process, module, buf, chars))
 420     {
 421         CloseHandle(process);
 422         return FALSE;
 423     }
 424
 425     CloseHandle(process);
 426     return TRUE;
 427 }
 428
 429 /* dxdiagn's detection scheme is simply to look for a process called conf.exe. */
 430 static BOOL is_netmeeting_running(void)
 431 {
 432     DWORD list_count;
 433     DWORD *pid_list = enumerate_processes(&list_count);
 434
 435     if (pid_list)
 436     {
 437         DWORD i;
 438         WCHAR process_name[MAX_PATH];
 439
 440         for (i = 0; i < list_count; i++)
 441         {
 442             if (get_process_name_from_pid(pid_list[i], process_name, ARRAY_SIZE(process_name)) &&
 443                     !lstrcmpW(L"conf.exe", process_name))
 444             {
 445                 HeapFree(GetProcessHeap(), 0, pid_list);
 446                 return TRUE;
 447             }
 448         }
 449         HeapFree(GetProcessHeap(), 0, pid_list);
 450     }
 451
 452     return FALSE;
 453 }
 454
 455 static HRESULT fill_language_information(IDxDiagContainerImpl_Container *node)
 456 {
 457     WCHAR system_lang[80], regional_setting[100], user_lang[80], language_str[300];
 458     HRESULT hr;
 459
 460     /* szLanguagesLocalized */
 461     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SNATIVELANGNAME, system_lang, ARRAY_SIZE(system_lang));
 462     LoadStringW(dxdiagn_instance, IDS_REGIONAL_SETTING, regional_setting, ARRAY_SIZE(regional_setting));
 463     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SNATIVELANGNAME, user_lang, ARRAY_SIZE(user_lang));
 464
 465     swprintf(language_str, ARRAY_SIZE(language_str), L"%s (%s: %s)", system_lang, regional_setting,
 466             user_lang);
 467
 468     hr = add_bstr_property(node, L"szLanguagesLocalized", language_str);
 469     if (FAILED(hr))
 470         return hr;
 471
 472     /* szLanguagesEnglish */
 473     GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SENGLANGUAGE, system_lang, ARRAY_SIZE(system_lang));
 474     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE, user_lang, ARRAY_SIZE(user_lang));
 475
 476     swprintf(language_str, ARRAY_SIZE(language_str), L"%s (%s: %s)", system_lang,
 477             L"Regional Setting", user_lang);
 478
 479     hr = add_bstr_property(node, L"szLanguagesEnglish", language_str);
 480     if (FAILED(hr))
 481         return hr;
 482
 483     return S_OK;
 484 }
 485
 486 static HRESULT fill_datetime_information(IDxDiagContainerImpl_Container *node)
 487 {
 488     SYSTEMTIME curtime;
 489     WCHAR date_str[80], time_str[80], datetime_str[200];
 490     HRESULT hr;
 491
 492     GetLocalTime(&curtime);
 493
 494     GetTimeFormatW(LOCALE_NEUTRAL, 0, &curtime, L"HH':'mm':'ss", time_str, ARRAY_SIZE(time_str));
 495
 496     /* szTimeLocalized */
 497     GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &curtime, NULL, date_str, ARRAY_SIZE(date_str));
 498
 499     swprintf(datetime_str, ARRAY_SIZE(datetime_str), L"%s, %s", date_str, time_str);
 500
 501     hr = add_bstr_property(node, L"szTimeLocalized", datetime_str);
 502     if (FAILED(hr))
 503         return hr;
 504
 505     /* szTimeEnglish */
 506     GetDateFormatW(LOCALE_NEUTRAL, 0, &curtime, L"M'/'d'/'yyyy", date_str, ARRAY_SIZE(date_str));
 507
 508     swprintf(datetime_str, ARRAY_SIZE(datetime_str), L"%s, %s", date_str, time_str);
 509
 510     hr = add_bstr_property(node, L"szTimeEnglish", datetime_str);
 511     if (FAILED(hr))
 512         return hr;
 513
 514     return S_OK;
 515 }
 516
 517 static HRESULT fill_os_string_information(IDxDiagContainerImpl_Container *node, OSVERSIONINFOW *info)
 518 {
 519     static const WCHAR *prop_list[] =
 520     {
 521         L"szOSLocalized", L"szOSExLocalized", L"szOSExLongLocalized",
 522         L"szOSEnglish", L"szOSExEnglish", L"szOSExLongEnglish"
 523     };
 524     size_t i;
 525     HRESULT hr;
 526
 527     /* FIXME: OS detection should be performed, and localized OS strings
 528      * should contain translated versions of the "build" phrase. */
 529     for (i = 0; i < ARRAY_SIZE(prop_list); i++)
 530     {
 531         hr = add_bstr_property(node, prop_list[i], L"Windows XP Professional");
 532         if (FAILED(hr))
 533             return hr;
 534     }
 535
 536     return S_OK;
 537 }
 538
 539 static HRESULT fill_processor_information(IDxDiagContainerImpl_Container *node)
 540 {
 541     IWbemLocator *wbem_locator;
 542     IWbemServices *wbem_service;
 543     IWbemClassObject *wbem_class;
 544     IEnumWbemClassObject *wbem_enum;
 545     VARIANT cpu_name, cpu_no, clock_speed;
 546     WCHAR print_buf[200];
 547     BSTR bstr;
 548     ULONG no;
 549     HRESULT hr;
 550
 551     hr = CoCreateInstance(&CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER, &IID_IWbemLocator, (void**)&wbem_locator);
 552     if(FAILED(hr))
 553         return hr;
 554
 555     bstr = SysAllocString(L"\\\\.\\root\\cimv2");
 556     if(!bstr) {
 557         IWbemLocator_Release(wbem_locator);
 558         return E_OUTOFMEMORY;
 559     }
 560     hr = IWbemLocator_ConnectServer(wbem_locator, bstr, NULL, NULL, NULL, 0, NULL, NULL, &wbem_service);
 561     IWbemLocator_Release(wbem_locator);
 562     SysFreeString(bstr);
 563     if(FAILED(hr))
 564         return hr;
 565
 566     bstr = SysAllocString(L"Win32_Processor");
 567     if(!bstr) {
 568         IWbemServices_Release(wbem_service);
 569         return E_OUTOFMEMORY;
 570     }
 571     hr = IWbemServices_CreateInstanceEnum(wbem_service, bstr, WBEM_FLAG_SYSTEM_ONLY, NULL, &wbem_enum);
 572     IWbemServices_Release(wbem_service);
 573     SysFreeString(bstr);
 574     if(FAILED(hr))
 575         return hr;
 576
 577     hr = IEnumWbemClassObject_Next(wbem_enum, 1000, 1, &wbem_class, &no);
 578     IEnumWbemClassObject_Release(wbem_enum);
 579     if(FAILED(hr))
 580         return hr;
 581
 582     hr = IWbemClassObject_Get(wbem_class, L"NumberOfLogicalProcessors", 0, &cpu_no, NULL, NULL);
 583     if(FAILED(hr)) {
 584         IWbemClassObject_Release(wbem_class);
 585         return hr;
 586     }
 587     hr = IWbemClassObject_Get(wbem_class, L"MaxClockSpeed", 0, &clock_speed, NULL, NULL);
 588     if(FAILED(hr)) {
 589         IWbemClassObject_Release(wbem_class);
 590         return hr;
 591     }
 592     hr = IWbemClassObject_Get(wbem_class, L"Name", 0, &cpu_name, NULL, NULL);
 593     IWbemClassObject_Release(wbem_class);
 594     if(FAILED(hr))
 595         return hr;
 596
 597     swprintf(print_buf, ARRAY_SIZE(print_buf), L"%s(%d CPUs), ~%dMHz",
 598              V_BSTR(&cpu_name), V_I4(&cpu_no), V_I4(&clock_speed));
 599     VariantClear(&cpu_name);
 600     VariantClear(&cpu_no);
 601     VariantClear(&clock_speed);
 602
 603     return add_bstr_property(node, L"szProcessorEnglish", print_buf);
 604 }
 605
 606 static HRESULT build_systeminfo_tree(IDxDiagContainerImpl_Container *node)
 607 {
 608     HRESULT hr;
 609     MEMORYSTATUSEX msex;
 610     OSVERSIONINFOW info;
 611     DWORD count, usedpage_mb, availpage_mb;
 612     WCHAR buffer[MAX_PATH], computer_name[MAX_COMPUTERNAME_LENGTH + 1], print_buf[200], localized_pagefile_fmt[200];
 613     DWORD_PTR args[2];
 614
 615     hr = add_ui4_property(node, L"dwDirectXVersionMajor", 9);
 616     if (FAILED(hr))
 617         return hr;
 618
 619     hr = add_ui4_property(node, L"dwDirectXVersionMinor", 0);
 620     if (FAILED(hr))
 621         return hr;
 622
 623     hr = add_bstr_property(node, L"szDirectXVersionLetter", L"c");
 624     if (FAILED(hr))
 625         return hr;
 626
 627     hr = add_bstr_property(node, L"szDirectXVersionEnglish", L"4.09.0000.0904");
 628     if (FAILED(hr))
 629         return hr;
 630
 631     hr = add_bstr_property(node, L"szDirectXVersionLongEnglish", L"= \"DirectX 9.0c (4.09.0000.0904)");
 632     if (FAILED(hr))
 633         return hr;
 634
 635     hr = add_bool_property(node, L"bDebug", FALSE);
 636     if (FAILED(hr))
 637         return hr;
 638
 639     hr = add_bool_property(node, L"bNECPC98", FALSE);
 640     if (FAILED(hr))
 641         return hr;
 642
 643     msex.dwLength = sizeof(msex);
 644     GlobalMemoryStatusEx(&msex);
 645
 646     hr = add_ull_as_bstr_property(node, L"ullPhysicalMemory", msex.ullTotalPhys);
 647     if (FAILED(hr))
 648         return hr;
 649
 650     hr = add_ull_as_bstr_property(node, L"ullUsedPageFile", msex.ullTotalPageFile - msex.ullAvailPageFile);
 651     if (FAILED(hr))
 652         return hr;
 653
 654     hr = add_ull_as_bstr_property(node, L"ullAvailPageFile", msex.ullAvailPageFile);
 655     if (FAILED(hr))
 656         return hr;
 657
 658     hr = add_bool_property(node, L"bNetMeetingRunning", is_netmeeting_running());
 659     if (FAILED(hr))
 660         return hr;
 661
 662     info.dwOSVersionInfoSize = sizeof(info);
 663     GetVersionExW(&info);
 664
 665     hr = add_ui4_property(node, L"dwOSMajorVersion", info.dwMajorVersion);
 666     if (FAILED(hr))
 667         return hr;
 668
 669     hr = add_ui4_property(node, L"dwOSMinorVersion", info.dwMinorVersion);
 670     if (FAILED(hr))
 671         return hr;
 672
 673     hr = add_ui4_property(node, L"dwOSBuildNumber", info.dwBuildNumber);
 674     if (FAILED(hr))
 675         return hr;
 676
 677     hr = add_ui4_property(node, L"dwOSPlatformID", info.dwPlatformId);
 678     if (FAILED(hr))
 679         return hr;
 680
 681     hr = add_bstr_property(node, L"szCSDVersion", info.szCSDVersion);
 682     if (FAILED(hr))
 683         return hr;
 684
 685     /* FIXME: Roundoff should not be done with truncated division. */
 686     swprintf(print_buf, ARRAY_SIZE(print_buf), L"%I64uMB RAM", msex.ullTotalPhys / (1024 * 1024));
 687     hr = add_bstr_property(node, L"szPhysicalMemoryEnglish", print_buf);
 688     if (FAILED(hr))
 689         return hr;
 690
 691     usedpage_mb = (DWORD)((msex.ullTotalPageFile - msex.ullAvailPageFile) / (1024 * 1024));
 692     availpage_mb = (DWORD)(msex.ullAvailPageFile / (1024 * 1024));
 693     LoadStringW(dxdiagn_instance, IDS_PAGE_FILE_FORMAT, localized_pagefile_fmt,
 694                 ARRAY_SIZE(localized_pagefile_fmt));
 695     args[0] = usedpage_mb;
 696     args[1] = availpage_mb;
 697     FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY, localized_pagefile_fmt,
 698                    0, 0, print_buf, ARRAY_SIZE(print_buf), (va_list *)args);
 699
 700     hr = add_bstr_property(node, L"szPageFileLocalized", print_buf);
 701     if (FAILED(hr))
 702         return hr;
 703
 704     swprintf(print_buf, ARRAY_SIZE(print_buf), L"%uMB used, %uMB available", usedpage_mb, availpage_mb);
 705
 706     hr = add_bstr_property(node, L"szPageFileEnglish", print_buf);
 707     if (FAILED(hr))
 708         return hr;
 709
 710     GetWindowsDirectoryW(buffer, MAX_PATH);
 711
 712     hr = add_bstr_property(node, L"szWindowsDir", buffer);
 713     if (FAILED(hr))
 714         return hr;
 715
 716     count = ARRAY_SIZE(computer_name);
 717     if (!GetComputerNameW(computer_name, &count))
 718         return E_FAIL;
 719
 720     hr = add_bstr_property(node, L"szMachineNameLocalized", computer_name);
 721     if (FAILED(hr))
 722         return hr;
 723
 724     hr = add_bstr_property(node, L"szMachineNameEnglish", computer_name);
 725     if (FAILED(hr))
 726         return hr;
 727
 728     hr = add_bstr_property(node, L"szSystemManufacturerEnglish", L"");
 729     if (FAILED(hr))
 730         return hr;
 731
 732     hr = add_bstr_property(node, L"szSystemModelEnglish", L"");
 733     if (FAILED(hr))
 734         return hr;
 735
 736     hr = add_bstr_property(node, L"szBIOSEnglish", L"");
 737     if (FAILED(hr))
 738         return hr;
 739
 740     hr = fill_processor_information(node);
 741     if (FAILED(hr))
 742         return hr;
 743
 744     hr = add_bstr_property(node, L"szSetupParamEnglish", L"Not present");
 745     if (FAILED(hr))
 746         return hr;
 747
 748     hr = add_bstr_property(node, L"szDxDiagVersion", L"");
 749     if (FAILED(hr))
 750         return hr;
 751
 752     hr = fill_language_information(node);
 753     if (FAILED(hr))
 754         return hr;
 755
 756     hr = fill_datetime_information(node);
 757     if (FAILED(hr))
 758         return hr;
 759
 760     hr = fill_os_string_information(node, &info);
 761     if (FAILED(hr))
 762         return hr;
 763
 764     return S_OK;
 765 }
 766
 767 /* The logic from pixelformat_for_depth() in dlls/wined3d/utils.c is reversed. */
 768 static DWORD depth_for_pixelformat(D3DFORMAT format)
 769 {
 770     switch (format)
 771     {
 772     case D3DFMT_P8: return 8;
 773     case D3DFMT_X1R5G5B5: return 15;
 774     case D3DFMT_R5G6B5: return 16;
 775     /* This case will fail to distinguish an original bpp of 24. */
 776     case D3DFMT_X8R8G8B8: return 32;
 777     default:
 778         FIXME("Unknown D3DFORMAT %d, returning 32 bpp\n", format);
 779         return 32;
 780     }
 781 }
 782
 783 static BOOL get_texture_memory(GUID *adapter, DWORD *available_mem)
 784 {
 785     IDirectDraw7 *pDirectDraw;
 786     HRESULT hr;
 787     DDSCAPS2 dd_caps;
 788
 789     hr = DirectDrawCreateEx(adapter, (void **)&pDirectDraw, &IID_IDirectDraw7, NULL);
 790     if (SUCCEEDED(hr))
 791     {
 792         dd_caps.dwCaps = DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
 793         dd_caps.dwCaps2 = dd_caps.dwCaps3 = dd_caps.dwCaps4 = 0;
 794         hr = IDirectDraw7_GetAvailableVidMem(pDirectDraw, &dd_caps, available_mem, NULL);
 795         IDirectDraw7_Release(pDirectDraw);
 796         if (SUCCEEDED(hr))
 797             return TRUE;
 798     }
 799
 800     return FALSE;
 801 }
 802
 803 static const WCHAR *vendor_id_to_manufacturer_string(DWORD vendor_id)
 804 {
 805     unsigned int i;
 806     static const struct
 807     {
 808         DWORD id;
 809         const WCHAR *name;
 810     }
 811     vendors[] =
 812     {
 813         {0x1002, L"ATI Technologies Inc."},
 814         {0x10de, L"NVIDIA"},
 815         {0x15ad, L"VMware"},
 816         {0x1af4, L"Red Hat"},
 817         {0x8086, L"Intel Corporation"},
 818     };
 819
 820     for (i = 0; i < ARRAY_SIZE(vendors); ++i)
 821     {
 822         if (vendors[i].id == vendor_id)
 823             return vendors[i].name;
 824     }
 825
 826     FIXME("Unknown PCI vendor ID 0x%04lx.\n", vendor_id);
 827
 828     return L"Unknown";
 829 }
 830
 831 static HRESULT fill_display_information_d3d(IDxDiagContainerImpl_Container *node)
 832 {
 833     IDxDiagContainerImpl_Container *display_adapter;
 834     HRESULT hr;
 835     IDirect3D9 *pDirect3D9;
 836     WCHAR buffer[256];
 837     UINT index, count;
 838
 839     pDirect3D9 = Direct3DCreate9(D3D_SDK_VERSION);
 840     if (!pDirect3D9)
 841         return E_FAIL;
 842
 843     count = IDirect3D9_GetAdapterCount(pDirect3D9);
 844     for (index = 0; index < count; index++)
 845     {
 846         D3DADAPTER_IDENTIFIER9 adapter_info;
 847         D3DDISPLAYMODE adapter_mode;
 848         D3DCAPS9 device_caps;
 849         DWORD available_mem = 0;
 850         BOOL hardware_accel;
 851
 852         swprintf(buffer, ARRAY_SIZE(buffer), L"%u", index);
 853         display_adapter = allocate_information_node(buffer);
 854         if (!display_adapter)
 855         {
 856             hr = E_OUTOFMEMORY;
 857             goto cleanup;
 858         }
 859
 860         add_subcontainer(node, display_adapter);
 861
 862         hr = IDirect3D9_GetAdapterIdentifier(pDirect3D9, index, 0, &adapter_info);
 863         if (SUCCEEDED(hr))
 864         {
 865             WCHAR driverW[sizeof(adapter_info.Driver)];
 866             WCHAR descriptionW[sizeof(adapter_info.Description)];
 867             WCHAR devicenameW[sizeof(adapter_info.DeviceName)];
 868
 869             MultiByteToWideChar(CP_ACP, 0, adapter_info.Driver, -1, driverW, ARRAY_SIZE(driverW));
 870             MultiByteToWideChar(CP_ACP, 0, adapter_info.Description, -1, descriptionW,
 871                                 ARRAY_SIZE(descriptionW));
 872             MultiByteToWideChar(CP_ACP, 0, adapter_info.DeviceName, -1, devicenameW,
 873                                 ARRAY_SIZE(devicenameW));
 874
 875             hr = add_bstr_property(display_adapter, L"szDriverName", driverW);
 876             if (FAILED(hr))
 877                 goto cleanup;
 878
 879             hr = add_bstr_property(display_adapter, L"szDescription", descriptionW);
 880             if (FAILED(hr))
 881                 goto cleanup;
 882
 883             hr = add_bstr_property(display_adapter, L"szDeviceName", devicenameW);
 884             if (FAILED(hr))
 885                 goto cleanup;
 886
 887             swprintf(buffer, ARRAY_SIZE(buffer), L"%u.%u.%04u.%04u",
 888                     HIWORD(adapter_info.DriverVersion.HighPart), LOWORD(adapter_info.DriverVersion.HighPart),
 889                     HIWORD(adapter_info.DriverVersion.LowPart), LOWORD(adapter_info.DriverVersion.LowPart));
 890
 891             hr = add_bstr_property(display_adapter, L"szDriverVersion", buffer);
 892             if (FAILED(hr))
 893                 goto cleanup;
 894
 895             swprintf(buffer, ARRAY_SIZE(buffer), L"0x%04x", adapter_info.VendorId);
 896             hr = add_bstr_property(display_adapter, L"szVendorId", buffer);
 897             if (FAILED(hr))
 898                 goto cleanup;
 899
 900             swprintf(buffer, ARRAY_SIZE(buffer), L"0x%04x", adapter_info.DeviceId);
 901             hr = add_bstr_property(display_adapter, L"szDeviceId", buffer);
 902             if (FAILED(hr))
 903                 goto cleanup;
 904
 905             swprintf(buffer, ARRAY_SIZE(buffer), L"0x%08x", adapter_info.SubSysId);
 906             hr = add_bstr_property(display_adapter, L"szSubSysId", buffer);
 907             if (FAILED(hr))
 908                 goto cleanup;
 909
 910             swprintf(buffer, ARRAY_SIZE(buffer), L"0x%04x", adapter_info.Revision);
 911             hr = add_bstr_property(display_adapter, L"szRevisionId", buffer);
 912             if (FAILED(hr))
 913                 goto cleanup;
 914
 915             StringFromGUID2(&adapter_info.DeviceIdentifier, buffer, 39);
 916             hr = add_bstr_property(display_adapter, L"szDeviceIdentifier", buffer);
 917             if (FAILED(hr))
 918                 goto cleanup;
 919
 920             hr = add_bstr_property(display_adapter, L"szManufacturer",
 921                     vendor_id_to_manufacturer_string(adapter_info.VendorId));
 922             if (FAILED(hr))
 923                 goto cleanup;
 924         }
 925
 926         hr = IDirect3D9_GetAdapterDisplayMode(pDirect3D9, index, &adapter_mode);
 927         if (SUCCEEDED(hr))
 928         {
 929             hr = add_ui4_property(display_adapter, L"dwWidth", adapter_mode.Width);
 930             if (FAILED(hr))
 931                 goto cleanup;
 932
 933             hr = add_ui4_property(display_adapter, L"dwHeight", adapter_mode.Height);
 934             if (FAILED(hr))
 935                 goto cleanup;
 936
 937             hr = add_ui4_property(display_adapter, L"dwRefreshRate", adapter_mode.RefreshRate);
 938             if (FAILED(hr))
 939                 goto cleanup;
 940
 941             hr = add_ui4_property(display_adapter, L"dwBpp", depth_for_pixelformat(adapter_mode.Format));
 942             if (FAILED(hr))
 943                 goto cleanup;
 944
 945             swprintf(buffer, ARRAY_SIZE(buffer), L"%d x %d (%d bit) (%dHz)", adapter_mode.Width,
 946                     adapter_mode.Height, depth_for_pixelformat(adapter_mode.Format),
 947                     adapter_mode.RefreshRate);
 948
 949             hr = add_bstr_property(display_adapter, L"szDisplayModeLocalized", buffer);
 950             if (FAILED(hr))
 951                 goto cleanup;
 952
 953             hr = add_bstr_property(display_adapter, L"szDisplayModeEnglish", buffer);
 954             if (FAILED(hr))
 955                 goto cleanup;
 956         }
 957
 958         hr = add_bstr_property(display_adapter, L"szKeyDeviceKey", L"");
 959         if (FAILED(hr))
 960             goto cleanup;
 961
 962         hr = add_bstr_property(display_adapter, L"szKeyDeviceID", L"");
 963         if (FAILED(hr))
 964             goto cleanup;
 965
 966         hr = add_bstr_property(display_adapter, L"szChipType", L"");
 967         if (FAILED(hr))
 968             goto cleanup;
 969
 970         hr = add_bstr_property(display_adapter, L"szDACType", L"");
 971         if (FAILED(hr))
 972             goto cleanup;
 973
 974         hr = add_bstr_property(display_adapter, L"szRevision", L"");
 975         if (FAILED(hr))
 976             goto cleanup;
 977
 978         if (!get_texture_memory(&adapter_info.DeviceIdentifier, &available_mem))
 979             WARN("get_texture_memory helper failed\n");
 980
 981         swprintf(buffer, ARRAY_SIZE(buffer), L"%.1f MB", available_mem / 1000000.0f);
 982
 983         hr = add_bstr_property(display_adapter, L"szDisplayMemoryLocalized", buffer);
 984         if (FAILED(hr))
 985             goto cleanup;
 986
 987         hr = add_bstr_property(display_adapter, L"szDisplayMemoryEnglish", buffer);
 988         if (FAILED(hr))
 989             goto cleanup;
 990
 991         hr = IDirect3D9_GetDeviceCaps(pDirect3D9, index, D3DDEVTYPE_HAL, &device_caps);
 992         hardware_accel = SUCCEEDED(hr);
 993
 994         hr = add_bool_property(display_adapter, L"b3DAccelerationEnabled", hardware_accel);
 995         if (FAILED(hr))
 996             goto cleanup;
 997
 998         hr = add_bool_property(display_adapter, L"b3DAccelerationExists", hardware_accel);
 999         if (FAILED(hr))
1000             goto cleanup;
1001
1002         hr = add_bool_property(display_adapter, L"bDDAccelerationEnabled", hardware_accel);
1003         if (FAILED(hr))
1004             goto cleanup;
1005
1006         hr = add_bool_property(display_adapter, L"bNoHardware", FALSE);
1007         if (FAILED(hr))
1008             goto cleanup;
1009
1010         hr = add_bool_property(display_adapter, L"bCanRenderWindow", TRUE);
1011         if (FAILED(hr))
1012             goto cleanup;
1013
1014         hr = add_bstr_property(display_adapter, L"szMonitorName", L"Generic PnP Monitor");
1015         if (FAILED(hr))
1016             goto cleanup;
1017
1018         hr = add_bstr_property(display_adapter, L"szMonitorMaxRes", L"Failed to get parameter");
1019         if (FAILED(hr))
1020             goto cleanup;
1021
1022         hr = add_bstr_property(display_adapter, L"szDriverAttributes", L"Final Retail");
1023         if (FAILED(hr))
1024             goto cleanup;
1025
1026         hr = add_bstr_property(display_adapter, L"szDriverLanguageEnglish", L"English");
1027         if (FAILED(hr))
1028             goto cleanup;
1029
1030         hr = add_bstr_property(display_adapter, L"szDriverLanguageLocalized", L"English");
1031         if (FAILED(hr))
1032             goto cleanup;
1033
1034         hr = add_bstr_property(display_adapter, L"szDriverDateEnglish", L"1/1/2016 10:00:00");
1035         if (FAILED(hr))
1036             goto cleanup;
1037
1038         hr = add_bstr_property(display_adapter, L"szDriverDateLocalized", L"1/1/2016 10:00:00 AM");
1039         if (FAILED(hr))
1040             goto cleanup;
1041
1042         hr = add_i4_property(display_adapter, L"lDriverSize", 10 * 1024 * 1024);
1043         if (FAILED(hr))
1044             goto cleanup;
1045
1046         hr = add_bstr_property(display_adapter, L"szMiniVdd", L"n/a");
1047         if (FAILED(hr))
1048             goto cleanup;
1049
1050         hr = add_bstr_property(display_adapter, L"szMiniVddDateLocalized", L"n/a");
1051         if (FAILED(hr))
1052             goto cleanup;
1053
1054         hr = add_bstr_property(display_adapter, L"szMiniVddDateEnglish", L"n/a");
1055         if (FAILED(hr))
1056             goto cleanup;
1057
1058         hr = add_i4_property(display_adapter, L"lMiniVddSize", 0);
1059         if (FAILED(hr))
1060             goto cleanup;
1061
1062         hr = add_bstr_property(display_adapter, L"szVdd", L"n/a");
1063         if (FAILED(hr))
1064             goto cleanup;
1065
1066         hr = add_bool_property(display_adapter, L"bDriverBeta", FALSE);
1067         if (FAILED(hr))
1068             goto cleanup;
1069
1070         hr = add_bool_property(display_adapter, L"bDriverDebug", FALSE);
1071         if (FAILED(hr))
1072             goto cleanup;
1073
1074         hr = add_bool_property(display_adapter, L"bDriverSigned", TRUE);
1075         if (FAILED(hr))
1076             goto cleanup;
1077
1078         hr = add_bool_property(display_adapter, L"bDriverSignedValid", TRUE);
1079         if (FAILED(hr))
1080             goto cleanup;
1081
1082         hr = add_bstr_property(display_adapter, L"szDriverSignDate", L"n/a");
1083         if (FAILED(hr))
1084             goto cleanup;
1085
1086         hr = add_ui4_property(display_adapter, L"dwDDIVersion", 11);
1087         if (FAILED(hr))
1088             goto cleanup;
1089
1090         hr = add_bstr_property(display_adapter, L"szDDIVersionEnglish", L"11");
1091         if (FAILED(hr))
1092             goto cleanup;
1093
1094         hr = add_bstr_property(display_adapter, L"szDDIVersionLocalized", L"11");
1095         if (FAILED(hr))
1096             goto cleanup;
1097
1098         hr = add_ui4_property(display_adapter, L"iAdapter", index);
1099         if (FAILED(hr))
1100             goto cleanup;
1101
1102         hr = add_ui4_property(display_adapter, L"dwWHQLLevel", 0);
1103         if (FAILED(hr))
1104             goto cleanup;
1105     }
1106
1107     hr = S_OK;
1108 cleanup:
1109     IDirect3D9_Release(pDirect3D9);
1110     return hr;
1111 }
1112
1113 static HRESULT fill_display_information_fallback(IDxDiagContainerImpl_Container *node)
1114 {
1115     static const WCHAR *empty_properties[] =
1116     {
1117         L"szDeviceIdentifier", L"szVendorId", L"szDeviceId", L"szKeyDeviceKey",
1118         L"szKeyDeviceID", L"szDriverName", L"szDriverVersion", L"szSubSysId",
1119         L"szRevisionId", L"szManufacturer", L"szChipType", L"szDACType", L"szRevision"
1120     };
1121
1122     IDxDiagContainerImpl_Container *display_adapter;
1123     HRESULT hr;
1124     IDirectDraw7 *pDirectDraw;
1125     DDSCAPS2 dd_caps;
1126     DISPLAY_DEVICEW disp_dev;
1127     DDSURFACEDESC2 surface_descr;
1128     DWORD tmp;
1129     WCHAR buffer[256];
1130
1131     display_adapter = allocate_information_node(L"0");
1132     if (!display_adapter)
1133         return E_OUTOFMEMORY;
1134
1135     add_subcontainer(node, display_adapter);
1136
1137     disp_dev.cb = sizeof(disp_dev);
1138     if (EnumDisplayDevicesW( NULL, 0, &disp_dev, 0 ))
1139     {
1140         hr = add_bstr_property(display_adapter, L"szDeviceName", disp_dev.DeviceName);
1141         if (FAILED(hr))
1142             return hr;
1143
1144         hr = add_bstr_property(display_adapter, L"szDescription", disp_dev.DeviceString);
1145         if (FAILED(hr))
1146             return hr;
1147     }
1148
1149     /* Silently ignore a failure from DirectDrawCreateEx. */
1150     hr = DirectDrawCreateEx(NULL, (void **)&pDirectDraw, &IID_IDirectDraw7, NULL);
1151     if (FAILED(hr))
1152         return S_OK;
1153
1154     dd_caps.dwCaps = DDSCAPS_LOCALVIDMEM | DDSCAPS_VIDEOMEMORY;
1155     dd_caps.dwCaps2 = dd_caps.dwCaps3 = dd_caps.dwCaps4 = 0;
1156     hr = IDirectDraw7_GetAvailableVidMem(pDirectDraw, &dd_caps, &tmp, NULL);
1157     if (SUCCEEDED(hr))
1158     {
1159         swprintf(buffer, ARRAY_SIZE(buffer), L"%.1f MB", tmp / 1000000.0f);
1160
1161         hr = add_bstr_property(display_adapter, L"szDisplayMemoryLocalized", buffer);
1162         if (FAILED(hr))
1163             goto cleanup;
1164
1165         hr = add_bstr_property(display_adapter, L"szDisplayMemoryEnglish", buffer);
1166         if (FAILED(hr))
1167             goto cleanup;
1168     }
1169
1170     surface_descr.dwSize = sizeof(surface_descr);
1171     hr = IDirectDraw7_GetDisplayMode(pDirectDraw, &surface_descr);
1172     if (SUCCEEDED(hr))
1173     {
1174         if (surface_descr.dwFlags & DDSD_WIDTH)
1175         {
1176             hr = add_ui4_property(display_adapter, L"dwWidth", surface_descr.dwWidth);
1177             if (FAILED(hr))
1178                 goto cleanup;
1179         }
1180
1181         if (surface_descr.dwFlags & DDSD_HEIGHT)
1182         {
1183             hr = add_ui4_property(display_adapter, L"dwHeight", surface_descr.dwHeight);
1184             if (FAILED(hr))
1185                 goto cleanup;
1186         }
1187
1188         if (surface_descr.dwFlags & DDSD_PIXELFORMAT)
1189         {
1190             hr = add_ui4_property(display_adapter, L"dwBpp",
1191                     surface_descr.ddpfPixelFormat.dwRGBBitCount);
1192             if (FAILED(hr))
1193                 goto cleanup;
1194         }
1195     }
1196
1197     hr = add_ui4_property(display_adapter, L"dwRefreshRate", 60);
1198     if (FAILED(hr))
1199         goto cleanup;
1200
1201     for (tmp = 0; tmp < ARRAY_SIZE(empty_properties); tmp++)
1202     {
1203         hr = add_bstr_property(display_adapter, empty_properties[tmp], L"");
1204         if (FAILED(hr))
1205             goto cleanup;
1206     }
1207
1208     hr = S_OK;
1209 cleanup:
1210     IDirectDraw7_Release(pDirectDraw);
1211     return hr;
1212 }
1213
1214 static HRESULT build_displaydevices_tree(IDxDiagContainerImpl_Container *node)
1215 {
1216     HRESULT hr;
1217
1218     /* Try to use Direct3D to obtain the required information first. */
1219     hr = fill_display_information_d3d(node);
1220     if (hr != E_FAIL)
1221         return hr;
1222
1223     return fill_display_information_fallback(node);
1224 }
1225
1226 struct enum_context
1227 {
1228     IDxDiagContainerImpl_Container *cont;
1229     HRESULT hr;
1230     int index;
1231 };
1232
1233 static LPWSTR guid_to_string(LPWSTR lpwstr, REFGUID lpcguid)
1234 {
1235     wsprintfW(lpwstr, L"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", lpcguid->Data1, lpcguid->Data2,
1236         lpcguid->Data3, lpcguid->Data4[0], lpcguid->Data4[1], lpcguid->Data4[2], lpcguid->Data4[3], lpcguid->Data4[4],
1237         lpcguid->Data4[5], lpcguid->Data4[6], lpcguid->Data4[7]);
1238
1239     return lpwstr;
1240 }
1241
1242 BOOL CALLBACK dsound_enum(LPGUID guid, LPCWSTR desc, LPCWSTR module, LPVOID context)
1243 {
1244     struct enum_context *enum_ctx = context;
1245     IDxDiagContainerImpl_Container *device;
1246     WCHAR buffer[256];
1247     const WCHAR *p, *name;
1248
1249     /* the default device is enumerated twice, one time without GUID */
1250     if (!guid) return TRUE;
1251
1252     swprintf(buffer, ARRAY_SIZE(buffer), L"%u", enum_ctx->index);
1253     device = allocate_information_node(buffer);
1254     if (!device)
1255     {
1256         enum_ctx->hr = E_OUTOFMEMORY;
1257         return FALSE;
1258     }
1259
1260     add_subcontainer(enum_ctx->cont, device);
1261
1262     guid_to_string(buffer, guid);
1263     enum_ctx->hr = add_bstr_property(device, L"szGuidDeviceID", buffer);
1264     if (FAILED(enum_ctx->hr))
1265         return FALSE;
1266
1267     enum_ctx->hr = add_bstr_property(device, L"szDescription", desc);
1268     if (FAILED(enum_ctx->hr))
1269         return FALSE;
1270
1271     enum_ctx->hr = add_bstr_property(device, L"szDriverPath", module);
1272     if (FAILED(enum_ctx->hr))
1273         return FALSE;
1274
1275     name = module;
1276     if ((p = wcsrchr(name, '\\'))) name = p + 1;
1277     if ((p = wcsrchr(name, '/'))) name = p + 1;
1278
1279     enum_ctx->hr = add_bstr_property(device, L"szDriverName", name);
1280     if (FAILED(enum_ctx->hr))
1281         return FALSE;
1282
1283     enum_ctx->index++;
1284     return TRUE;
1285 }
1286
1287 static HRESULT build_directsound_tree(IDxDiagContainerImpl_Container *node)
1288 {
1289     struct enum_context enum_ctx;
1290     IDxDiagContainerImpl_Container *cont;
1291
1292     cont = allocate_information_node(L"DxDiag_SoundDevices");
1293     if (!cont)
1294         return E_OUTOFMEMORY;
1295
1296     add_subcontainer(node, cont);
1297
1298     enum_ctx.cont = cont;
1299     enum_ctx.hr = S_OK;
1300     enum_ctx.index = 0;
1301
1302     DirectSoundEnumerateW(dsound_enum, &enum_ctx);
1303     if (FAILED(enum_ctx.hr))
1304         return enum_ctx.hr;
1305
1306     cont = allocate_information_node(L"DxDiag_SoundCaptureDevices");
1307     if (!cont)
1308         return E_OUTOFMEMORY;
1309
1310     add_subcontainer(node, cont);
1311
1312     enum_ctx.cont = cont;
1313     enum_ctx.hr = S_OK;
1314     enum_ctx.index = 0;
1315
1316     DirectSoundCaptureEnumerateW(dsound_enum, &enum_ctx);
1317     if (FAILED(enum_ctx.hr))
1318         return enum_ctx.hr;
1319
1320     return S_OK;
1321 }
1322
1323 static HRESULT build_directmusic_tree(IDxDiagContainerImpl_Container *node)
1324 {
1325     return S_OK;
1326 }
1327
1328 static HRESULT build_directinput_tree(IDxDiagContainerImpl_Container *node)
1329 {
1330     return S_OK;
1331 }
1332
1333 static HRESULT build_directplay_tree(IDxDiagContainerImpl_Container *node)
1334 {
1335     return S_OK;
1336 }
1337
1338 static HRESULT build_systemdevices_tree(IDxDiagContainerImpl_Container *node)
1339 {
1340     return S_OK;
1341 }
1342
1343 static HRESULT fill_file_description(IDxDiagContainerImpl_Container *node, const WCHAR *szFilePath, const WCHAR *szFileName)
1344 {
1345     HRESULT hr;
1346     WCHAR *szFile;
1347     WCHAR szVersion_v[1024];
1348     DWORD retval, hdl;
1349     void *pVersionInfo = NULL;
1350     BOOL boolret = FALSE;
1351     UINT uiLength;
1352     VS_FIXEDFILEINFO *pFileInfo;
1353
1354     TRACE("Filling container %p for %s in %s\n", node,
1355           debugstr_w(szFileName), debugstr_w(szFilePath));
1356
1357     szFile = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(szFilePath) +
1358                                             lstrlenW(szFileName) + 2 /* slash + terminator */));
1359     if (!szFile)
1360         return E_OUTOFMEMORY;
1361
1362     lstrcpyW(szFile, szFilePath);
1363     lstrcatW(szFile, L"\\");
1364     lstrcatW(szFile, szFileName);
1365
1366     retval = GetFileVersionInfoSizeW(szFile, &hdl);
1367     if (retval)
1368     {
1369         pVersionInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, retval);
1370         if (!pVersionInfo)
1371         {
1372             hr = E_OUTOFMEMORY;
1373             goto cleanup;
1374         }
1375
1376         if (GetFileVersionInfoW(szFile, 0, retval, pVersionInfo) &&
1377             VerQueryValueW(pVersionInfo, L"\\", (void **)&pFileInfo, &uiLength))
1378             boolret = TRUE;
1379     }
1380
1381     hr = add_bstr_property(node, L"szPath", szFile);
1382     if (FAILED(hr))
1383         goto cleanup;
1384
1385     hr = add_bstr_property(node, L"szName", szFileName);
1386     if (FAILED(hr))
1387         goto cleanup;
1388
1389     hr = add_bool_property(node, L"bExists", boolret);
1390     if (FAILED(hr))
1391         goto cleanup;
1392
1393     if (boolret)
1394     {
1395         swprintf(szVersion_v, ARRAY_SIZE(szVersion_v), L"%u.%02u.%04u.%04u",
1396                 HIWORD(pFileInfo->dwFileVersionMS), LOWORD(pFileInfo->dwFileVersionMS),
1397                 HIWORD(pFileInfo->dwFileVersionLS), LOWORD(pFileInfo->dwFileVersionLS));
1398
1399         TRACE("Found version as (%s)\n", debugstr_w(szVersion_v));
1400
1401         hr = add_bstr_property(node, L"szVersion", szVersion_v);
1402         if (FAILED(hr))
1403             goto cleanup;
1404
1405         hr = add_bstr_property(node, L"szAttributes", L"Final Retail");
1406         if (FAILED(hr))
1407             goto cleanup;
1408
1409         hr = add_bstr_property(node, L"szLanguageEnglish", L"English");
1410         if (FAILED(hr))
1411             goto cleanup;
1412
1413         hr = add_ui4_property(node, L"dwFileTimeHigh", pFileInfo->dwFileDateMS);
1414         if (FAILED(hr))
1415             goto cleanup;
1416
1417         hr = add_ui4_property(node, L"dwFileTimeLow", pFileInfo->dwFileDateLS);
1418         if (FAILED(hr))
1419             goto cleanup;
1420
1421         hr = add_bool_property(node, L"bBeta",
1422                 ((pFileInfo->dwFileFlags & pFileInfo->dwFileFlagsMask) & VS_FF_PRERELEASE) != 0);
1423         if (FAILED(hr))
1424             goto cleanup;
1425
1426         hr = add_bool_property(node, L"bDebug",
1427                 ((pFileInfo->dwFileFlags & pFileInfo->dwFileFlagsMask) & VS_FF_DEBUG) != 0);
1428         if (FAILED(hr))
1429             goto cleanup;
1430     }
1431
1432     hr = S_OK;
1433 cleanup:
1434     HeapFree(GetProcessHeap(), 0, pVersionInfo);
1435     HeapFree(GetProcessHeap(), 0, szFile);
1436
1437     return hr;
1438 }
1439 static HRESULT build_directxfiles_tree(IDxDiagContainerImpl_Container *node)
1440 {
1441     static const WCHAR dlls[][15] =
1442     {
1443         L"d3d8.dll",
1444         L"d3d9.dll",
1445         L"ddraw.dll",
1446         L"devenum.dll",
1447         L"dinput8.dll",
1448         L"dinput.dll",
1449         L"dmband.dll",
1450         L"dmcompos.dll",
1451         L"dmime.dll",
1452         L"dmloader.dll",
1453         L"dmscript.dll",
1454         L"dmstyle.dll",
1455         L"dmsynth.dll",
1456         L"dmusic.dll",
1457         L"dplayx.dll",
1458         L"dpnet.dll",
1459         L"dsound.dll",
1460         L"dswave.dll",
1461         L"dxdiagn.dll",
1462         L"quartz.dll"
1463     };
1464
1465     HRESULT hr;
1466     WCHAR szFilePath[MAX_PATH];
1467     INT i;
1468
1469     GetSystemDirectoryW(szFilePath, MAX_PATH);
1470
1471     for (i = 0; i < ARRAY_SIZE(dlls); i++)
1472     {
1473         WCHAR szFileID[5];
1474         IDxDiagContainerImpl_Container *file_container;
1475
1476         swprintf(szFileID, ARRAY_SIZE(szFileID), L"%d", i);
1477
1478         file_container = allocate_information_node(szFileID);
1479         if (!file_container)
1480             return E_OUTOFMEMORY;
1481
1482         hr = fill_file_description(file_container, szFilePath, dlls[i]);
1483         if (FAILED(hr))
1484         {
1485             free_information_tree(file_container);
1486             continue;
1487         }
1488
1489         add_subcontainer(node, file_container);
1490     }
1491
1492     return S_OK;
1493 }
1494
1495 static HRESULT read_property_names(IPropertyBag *pPropBag, VARIANT *friendly_name, VARIANT *clsid_name)
1496 {
1497     HRESULT hr;
1498
1499     VariantInit(friendly_name);
1500     VariantInit(clsid_name);
1501
1502     hr = IPropertyBag_Read(pPropBag, L"FriendlyName", friendly_name, 0);
1503     if (FAILED(hr))
1504         return hr;
1505
1506     hr = IPropertyBag_Read(pPropBag, L"CLSID", clsid_name, 0);
1507     if (FAILED(hr))
1508     {
1509         VariantClear(friendly_name);
1510         return hr;
1511     }
1512
1513     return S_OK;
1514 }
1515
1516 static HRESULT fill_filter_data_information(IDxDiagContainerImpl_Container *subcont, BYTE *pData, ULONG cb)
1517 {
1518     HRESULT hr;
1519     IFilterMapper2 *pFileMapper = NULL;
1520     IAMFilterData *pFilterData = NULL;
1521     BYTE *ppRF = NULL;
1522     REGFILTER2 *pRF = NULL;
1523     WCHAR bufferW[10];
1524     ULONG j;
1525     DWORD dwNOutputs = 0;
1526     DWORD dwNInputs = 0;
1527
1528     hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC, &IID_IFilterMapper2,
1529                           (void **)&pFileMapper);
1530     if (FAILED(hr))
1531         return hr;
1532
1533     hr = IFilterMapper2_QueryInterface(pFileMapper, &IID_IAMFilterData, (void **)&pFilterData);
1534     if (FAILED(hr))
1535         goto cleanup;
1536
1537     hr = IAMFilterData_ParseFilterData(pFilterData, pData, cb, &ppRF);
1538     if (FAILED(hr))
1539         goto cleanup;
1540     pRF = ((REGFILTER2**)ppRF)[0];
1541
1542     swprintf(bufferW, ARRAY_SIZE(bufferW), L"v%d", pRF->dwVersion);
1543     hr = add_bstr_property(subcont, L"szVersion", bufferW);
1544     if (FAILED(hr))
1545         goto cleanup;
1546
1547     if (pRF->dwVersion == 1)
1548     {
1549         for (j = 0; j < pRF->cPins; j++)
1550             if (pRF->rgPins[j].bOutput)
1551                 dwNOutputs++;
1552             else
1553                 dwNInputs++;
1554     }
1555     else if (pRF->dwVersion == 2)
1556     {
1557         for (j = 0; j < pRF->cPins2; j++)
1558             if (pRF->rgPins2[j].dwFlags & REG_PINFLAG_B_OUTPUT)
1559                 dwNOutputs++;
1560             else
1561                 dwNInputs++;
1562     }
1563
1564     hr = add_ui4_property(subcont, L"dwInputs", dwNInputs);
1565     if (FAILED(hr))
1566         goto cleanup;
1567
1568     hr = add_ui4_property(subcont, L"dwOutputs", dwNOutputs);
1569     if (FAILED(hr))
1570         goto cleanup;
1571
1572     hr = add_ui4_property(subcont, L"dwMerit", pRF->dwMerit);
1573     if (FAILED(hr))
1574         goto cleanup;
1575
1576     hr = S_OK;
1577 cleanup:
1578     CoTaskMemFree(pRF);
1579     if (pFilterData) IAMFilterData_Release(pFilterData);
1580     if (pFileMapper) IFilterMapper2_Release(pFileMapper);
1581
1582     return hr;
1583 }
1584
1585 static HRESULT fill_filter_container(IDxDiagContainerImpl_Container *subcont, IMoniker *pMoniker)
1586 {
1587     HRESULT hr;
1588     IPropertyBag *pPropFilterBag = NULL;
1589     BYTE *pData;
1590     VARIANT friendly_name;
1591     VARIANT clsid_name;
1592     VARIANT v;
1593
1594     VariantInit(&friendly_name);
1595     VariantInit(&clsid_name);
1596     VariantInit(&v);
1597
1598     hr = IMoniker_BindToStorage(pMoniker, NULL, NULL, &IID_IPropertyBag, (void **)&pPropFilterBag);
1599     if (FAILED(hr))
1600         return hr;
1601
1602     hr = read_property_names(pPropFilterBag, &friendly_name, &clsid_name);
1603     if (FAILED(hr))
1604         goto cleanup;
1605
1606     TRACE("Name = %s\n", debugstr_w(V_BSTR(&friendly_name)));
1607     TRACE("CLSID = %s\n", debugstr_w(V_BSTR(&clsid_name)));
1608
1609     hr = add_bstr_property(subcont, L"szName", V_BSTR(&friendly_name));
1610     if (FAILED(hr))
1611         goto cleanup;
1612
1613     hr = add_bstr_property(subcont, L"ClsidFilter", V_BSTR(&clsid_name));
1614     if (FAILED(hr))
1615         goto cleanup;
1616
1617     hr = IPropertyBag_Read(pPropFilterBag, L"FilterData", &v, NULL);
1618     if (FAILED(hr))
1619         goto cleanup;
1620
1621     hr = SafeArrayAccessData(V_ARRAY(&v), (void **)&pData);
1622     if (FAILED(hr))
1623         goto cleanup;
1624
1625     hr = fill_filter_data_information(subcont, pData, V_ARRAY(&v)->rgsabound->cElements);
1626     SafeArrayUnaccessData(V_ARRAY(&v));
1627     if (FAILED(hr))
1628         goto cleanup;
1629
1630     hr = S_OK;
1631 cleanup:
1632     VariantClear(&v);
1633     VariantClear(&clsid_name);
1634     VariantClear(&friendly_name);
1635     if (pPropFilterBag) IPropertyBag_Release(pPropFilterBag);
1636
1637     return hr;
1638 }
1639
1640 static HRESULT build_directshowfilters_tree(IDxDiagContainerImpl_Container *node)
1641 {
1642     HRESULT hr;
1643     int i = 0;
1644     ICreateDevEnum *pCreateDevEnum;
1645     IEnumMoniker *pEmCat = NULL;
1646     IMoniker *pMCat = NULL;
1647         IEnumMoniker *pEnum = NULL;
1648
1649     hr = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
1650                           &IID_ICreateDevEnum, (void **)&pCreateDevEnum);
1651     if (FAILED(hr))
1652         return hr;
1653
1654     hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &CLSID_ActiveMovieCategories, &pEmCat, 0);
1655     if (hr != S_OK)
1656         goto cleanup;
1657
1658     while (IEnumMoniker_Next(pEmCat, 1, &pMCat, NULL) == S_OK)
1659     {
1660         VARIANT vCatName;
1661         VARIANT vCatClsid;
1662         IPropertyBag *pPropBag;
1663         CLSID clsidCat;
1664         IMoniker *pMoniker = NULL;
1665
1666         hr = IMoniker_BindToStorage(pMCat, NULL, NULL, &IID_IPropertyBag, (void **)&pPropBag);
1667         if (FAILED(hr))
1668         {
1669             IMoniker_Release(pMCat);
1670             break;
1671         }
1672
1673         hr = read_property_names(pPropBag, &vCatName, &vCatClsid);
1674         IPropertyBag_Release(pPropBag);
1675         if (FAILED(hr))
1676         {
1677             IMoniker_Release(pMCat);
1678             break;
1679         }
1680
1681         hr = CLSIDFromString(V_BSTR(&vCatClsid), &clsidCat);
1682         if (FAILED(hr))
1683         {
1684             IMoniker_Release(pMCat);
1685             VariantClear(&vCatClsid);
1686             VariantClear(&vCatName);
1687             break;
1688         }
1689
1690         hr = ICreateDevEnum_CreateClassEnumerator(pCreateDevEnum, &clsidCat, &pEnum, 0);
1691         if (hr != S_OK)
1692         {
1693             IMoniker_Release(pMCat);
1694             VariantClear(&vCatClsid);
1695             VariantClear(&vCatName);
1696             continue;
1697         }
1698
1699         TRACE("Enumerating class %s\n", debugstr_guid(&clsidCat));
1700
1701         while (IEnumMoniker_Next(pEnum, 1, &pMoniker, NULL) == S_OK)
1702         {
1703             WCHAR bufferW[10];
1704             IDxDiagContainerImpl_Container *subcont;
1705
1706             swprintf(bufferW, ARRAY_SIZE(bufferW), L"%d", i);
1707             subcont = allocate_information_node(bufferW);
1708             if (!subcont)
1709             {
1710                 hr = E_OUTOFMEMORY;
1711                 IMoniker_Release(pMoniker);
1712                 break;
1713             }
1714
1715             hr = add_bstr_property(subcont, L"szCatName", V_BSTR(&vCatName));
1716             if (FAILED(hr))
1717             {
1718                 free_information_tree(subcont);
1719                 IMoniker_Release(pMoniker);
1720                 break;
1721             }
1722
1723             hr = add_bstr_property(subcont, L"ClsidCat", V_BSTR(&vCatClsid));
1724             if (FAILED(hr))
1725             {
1726                 free_information_tree(subcont);
1727                 IMoniker_Release(pMoniker);
1728                 break;
1729             }
1730
1731             hr = fill_filter_container(subcont, pMoniker);
1732             IMoniker_Release(pMoniker);
1733             if (FAILED(hr))
1734             {
1735                 WARN("Skipping invalid filter\n");
1736                 free_information_tree(subcont);
1737                 hr = S_OK;
1738                 continue;
1739             }
1740
1741             add_subcontainer(node, subcont);
1742             i++;
1743         }
1744
1745         IEnumMoniker_Release(pEnum);
1746         IMoniker_Release(pMCat);
1747         VariantClear(&vCatClsid);
1748         VariantClear(&vCatName);
1749
1750         if (FAILED(hr))
1751             break;
1752     }
1753
1754 cleanup:
1755     if (pEmCat) IEnumMoniker_Release(pEmCat);
1756     ICreateDevEnum_Release(pCreateDevEnum);
1757     return hr;
1758 }
1759
1760 static HRESULT build_logicaldisks_tree(IDxDiagContainerImpl_Container *node)
1761 {
1762     return S_OK;
1763 }
1764
1765 static HRESULT build_information_tree(IDxDiagContainerImpl_Container **pinfo_root)
1766 {
1767     static const struct
1768     {
1769         const WCHAR *name;
1770         HRESULT (*initfunc)(IDxDiagContainerImpl_Container *);
1771     } root_children[] =
1772     {
1773         {L"DxDiag_SystemInfo", build_systeminfo_tree},
1774         {L"DxDiag_DisplayDevices", build_displaydevices_tree},
1775         {L"DxDiag_DirectSound", build_directsound_tree},
1776         {L"DxDiag_DirectMusic", build_directmusic_tree},
1777         {L"DxDiag_DirectInput", build_directinput_tree},
1778         {L"DxDiag_DirectPlay", build_directplay_tree},
1779         {L"DxDiag_SystemDevices", build_systemdevices_tree},
1780         {L"DxDiag_DirectXFiles", build_directxfiles_tree},
1781         {L"DxDiag_DirectShowFilters", build_directshowfilters_tree},
1782         {L"DxDiag_LogicalDisks", build_logicaldisks_tree},
1783     };
1784
1785     IDxDiagContainerImpl_Container *info_root;
1786     size_t index;
1787
1788     info_root = allocate_information_node(NULL);
1789     if (!info_root)
1790         return E_OUTOFMEMORY;
1791
1792     for (index = 0; index < ARRAY_SIZE(root_children); index++)
1793     {
1794         IDxDiagContainerImpl_Container *node;
1795         HRESULT hr;
1796
1797         node = allocate_information_node(root_children[index].name);
1798         if (!node)
1799         {
1800             free_information_tree(info_root);
1801             return E_OUTOFMEMORY;
1802         }
1803
1804         hr = root_children[index].initfunc(node);
1805         if (FAILED(hr))
1806         {
1807             free_information_tree(node);
1808             free_information_tree(info_root);
1809             return hr;
1810         }
1811
1812         add_subcontainer(info_root, node);
1813     }
1814
1815     *pinfo_root = info_root;
1816     return S_OK;
1817 }