开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
lldxhardware.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：18k
源码类别：

游戏引擎

开发平台：

C++ Builder

lldxhardware.cpp：源码内容
  1. /** 
  2.  * @file lldxhardware.cpp
  3.  * @brief LLDXHardware implementation
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #ifdef LL_WINDOWS
  35. // Culled from some Microsoft sample code
  37. #include "linden_common.h"
  39. #define INITGUID
  40. #include <dxdiag.h>
  41. #undef INITGUID
  43. #include <boost/tokenizer.hpp>
  45. #include "lldxhardware.h"
  46. #include "llerror.h"
  48. #include "llstring.h"
  49. #include "llstl.h"
  50. #include "lltimer.h"
  52. void (*gWriteDebug)(const char* msg) = NULL;
  53. LLDXHardware gDXHardware;
  55. //-----------------------------------------------------------------------------
  56. // Defines, and constants
  57. //-----------------------------------------------------------------------------
  58. #define SAFE_DELETE(p)       { if(p) { delete (p);     (p)=NULL; } }
  59. #define SAFE_DELETE_ARRAY(p) { if(p) { delete[] (p);   (p)=NULL; } }
  60. #define SAFE_RELEASE(p)      { if(p) { (p)->Release(); (p)=NULL; } }
  62. std::string get_string(IDxDiagContainer *containerp, WCHAR *wszPropName)
  63. {
  64.     HRESULT hr;
  65. VARIANT var;
  66. WCHAR wszPropValue[256];
  68. VariantInit( &var );
  69. hr = containerp->GetProp(wszPropName, &var );
  70. if( SUCCEEDED(hr) )
  71. {
  72. // Switch off the type.  There's 4 different types:
  73. switch( var.vt )
  74. {
  75. case VT_UI4:
  76. swprintf( wszPropValue, L"%d", var.ulVal ); /* Flawfinder: ignore */
  77. break;
  78. case VT_I4:
  79. swprintf( wszPropValue, L"%d", var.lVal ); /* Flawfinder: ignore */
  80. break;
  81. case VT_BOOL:
  82. wcscpy( wszPropValue, (var.boolVal) ? L"true" : L"false" ); /* Flawfinder: ignore */
  83. break;
  84. case VT_BSTR:
  85. wcsncpy( wszPropValue, var.bstrVal, 255 ); /* Flawfinder: ignore */
  86. wszPropValue[255] = 0;
  87. break;
  88. }
  89. }
  90. // Clear the variant (this is needed to free BSTR memory)
  91. VariantClear( &var );
  93. return utf16str_to_utf8str(wszPropValue);
  94. }
  97. LLVersion::LLVersion()
  98. {
  99. mValid = FALSE;
  100. S32 i;
  101. for (i = 0; i < 4; i++)
  102. {
  103. mFields[i] = 0;
  104. }
  105. }
  107. BOOL LLVersion::set(const std::string &version_string)
  108. {
  109. S32 i;
  110. for (i = 0; i < 4; i++)
  111. {
  112. mFields[i] = 0;
  113. }
  114. // Split the version string.
  115. std::string str(version_string);
  116. typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  117. boost::char_separator<char> sep(".", "", boost::keep_empty_tokens);
  118. tokenizer tokens(str, sep);
  120. tokenizer::iterator iter = tokens.begin();
  121. S32 count = 0;
  122. for (;(iter != tokens.end()) && (count < 4);++iter)
  123. {
  124. mFields[count] = atoi(iter->c_str());
  125. count++;
  126. }
  127. if (count < 4)
  128. {
  129. //llwarns << "Potentially bogus version string!" << version_string << llendl;
  130. for (i = 0; i < 4; i++)
  131. {
  132. mFields[i] = 0;
  133. }
  134. mValid = FALSE;
  135. }
  136. else
  137. {
  138. mValid = TRUE;
  139. }
  140. return mValid;
  141. }
  143. S32 LLVersion::getField(const S32 field_num)
  144. {
  145. if (!mValid)
  146. {
  147. return -1;
  148. }
  149. else
  150. {
  151. return mFields[field_num];
  152. }
  153. }
  155. std::string LLDXDriverFile::dump()
  156. {
  157. if (gWriteDebug)
  158. {
  159. gWriteDebug("Filename:");
  160. gWriteDebug(mName.c_str());
  161. gWriteDebug("n");
  162. gWriteDebug("Ver:");
  163. gWriteDebug(mVersionString.c_str());
  164. gWriteDebug("n");
  165. gWriteDebug("Date:");
  166. gWriteDebug(mDateString.c_str());
  167. gWriteDebug("n");
  168. }
  169. llinfos << mFilepath << llendl;
  170. llinfos << mName << llendl;
  171. llinfos << mVersionString << llendl;
  172. llinfos << mDateString << llendl;
  174. return "";
  175. }
  177. LLDXDevice::~LLDXDevice()
  178. {
  179. for_each(mDriverFiles.begin(), mDriverFiles.end(), DeletePairedPointer());
  180. }
  182. std::string LLDXDevice::dump()
  183. {
  184. if (gWriteDebug)
  185. {
  186. gWriteDebug("StartDevicen");
  187. gWriteDebug("DeviceName:");
  188. gWriteDebug(mName.c_str());
  189. gWriteDebug("n");
  190. gWriteDebug("PCIString:");
  191. gWriteDebug(mPCIString.c_str());
  192. gWriteDebug("n");
  193. }
  194. llinfos << llendl;
  195. llinfos << "DeviceName:" << mName << llendl;
  196. llinfos << "PCIString:" << mPCIString << llendl;
  197. llinfos << "Drivers" << llendl;
  198. llinfos << "-------" << llendl;
  199. for (driver_file_map_t::iterator iter = mDriverFiles.begin(),
  200.  end = mDriverFiles.end();
  201.  iter != end; iter++)
  202. {
  203. LLDXDriverFile *filep = iter->second;
  204. filep->dump();
  205. }
  206. if (gWriteDebug)
  207. {
  208. gWriteDebug("EndDevicen");
  209. }
  211. return "";
  212. }
  214. LLDXDriverFile *LLDXDevice::findDriver(const std::string &driver)
  215. {
  216. for (driver_file_map_t::iterator iter = mDriverFiles.begin(),
  217.  end = mDriverFiles.end();
  218.  iter != end; iter++)
  219. {
  220. LLDXDriverFile *filep = iter->second;
  221. if (!utf8str_compare_insensitive(filep->mName,driver))
  222. {
  223. return filep;
  224. }
  225. }
  227. return NULL;
  228. }
  230. LLDXHardware::LLDXHardware()
  231. {
  232. mVRAM = 0;
  233. gWriteDebug = NULL;
  234. }
  236. void LLDXHardware::cleanup()
  237. {
  238.   // for_each(mDevices.begin(), mDevices.end(), DeletePairedPointer());
  239. }
  241. /*
  242. std::string LLDXHardware::dumpDevices()
  243. {
  244. if (gWriteDebug)
  245. {
  246. gWriteDebug("n");
  247. gWriteDebug("StartAllDevicesn");
  248. }
  249. for (device_map_t::iterator iter = mDevices.begin(),
  250.  end = mDevices.end();
  251.  iter != end; iter++)
  252. {
  253. LLDXDevice *devicep = iter->second;
  254. devicep->dump();
  255. }
  256. if (gWriteDebug)
  257. {
  258. gWriteDebug("EndAllDevicesnn");
  259. }
  260. return "";
  261. }
  263. LLDXDevice *LLDXHardware::findDevice(const std::string &vendor, const std::string &devices)
  264. {
  265. // Iterate through different devices tokenized in devices string
  266. std::string str(devices);
  267. typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  268. boost::char_separator<char> sep("|", "", boost::keep_empty_tokens);
  269. tokenizer tokens(str, sep);
  271. tokenizer::iterator iter = tokens.begin();
  272. for (;iter != tokens.end();++iter)
  273. {
  274. std::string dev_str = *iter;
  275. for (device_map_t::iterator iter = mDevices.begin(),
  276.  end = mDevices.end();
  277.  iter != end; iter++)
  278. {
  279. LLDXDevice *devicep = iter->second;
  280. if ((devicep->mVendorID == vendor)
  281. && (devicep->mDeviceID == dev_str))
  282. {
  283. return devicep;
  284. }
  285. }
  286. }
  288. return NULL;
  289. }
  290. */
  292. BOOL LLDXHardware::getInfo(BOOL vram_only)
  293. {
  294. LLTimer hw_timer;
  295. BOOL ok = FALSE;
  296.     HRESULT       hr;
  298.     CoInitialize(NULL);
  300.     IDxDiagProvider *dx_diag_providerp = NULL;
  301.     IDxDiagContainer *dx_diag_rootp = NULL;
  302. IDxDiagContainer *devices_containerp = NULL;
  303. // IDxDiagContainer *system_device_containerp= NULL;
  304. IDxDiagContainer *device_containerp = NULL;
  305. IDxDiagContainer *file_containerp = NULL;
  306. IDxDiagContainer *driver_containerp = NULL;
  308.     // CoCreate a IDxDiagProvider*
  309. LL_DEBUGS("AppInit") << "CoCreateInstance IID_IDxDiagProvider" << LL_ENDL;
  310.     hr = CoCreateInstance(CLSID_DxDiagProvider,
  311.                           NULL,
  312.                           CLSCTX_INPROC_SERVER,
  313.                           IID_IDxDiagProvider,
  314.                           (LPVOID*) &dx_diag_providerp);
  316. if (FAILED(hr))
  317. {
  318. LL_WARNS("AppInit") << "No DXDiag provider found!  DirectX 9 not installed!" << LL_ENDL;
  319. gWriteDebug("No DXDiag provider found!  DirectX 9 not installed!n");
  320. goto LCleanup;
  321. }
  322.     if (SUCCEEDED(hr)) // if FAILED(hr) then dx9 is not installed
  323.     {
  324.         // Fill out a DXDIAG_INIT_PARAMS struct and pass it to IDxDiagContainer::Initialize
  325.         // Passing in TRUE for bAllowWHQLChecks, allows dxdiag to check if drivers are 
  326.         // digital signed as logo'd by WHQL which may connect via internet to update 
  327.         // WHQL certificates.    
  328.         DXDIAG_INIT_PARAMS dx_diag_init_params;
  329.         ZeroMemory(&dx_diag_init_params, sizeof(DXDIAG_INIT_PARAMS));
  331.         dx_diag_init_params.dwSize                  = sizeof(DXDIAG_INIT_PARAMS);
  332.         dx_diag_init_params.dwDxDiagHeaderVersion   = DXDIAG_DX9_SDK_VERSION;
  333.         dx_diag_init_params.bAllowWHQLChecks        = TRUE;
  334.         dx_diag_init_params.pReserved               = NULL;
  336. LL_DEBUGS("AppInit") << "dx_diag_providerp->Initialize" << LL_ENDL;
  337.         hr = dx_diag_providerp->Initialize(&dx_diag_init_params);
  338.         if(FAILED(hr))
  339. {
  340.             goto LCleanup;
  341. }
  343. LL_DEBUGS("AppInit") << "dx_diag_providerp->GetRootContainer" << LL_ENDL;
  344.         hr = dx_diag_providerp->GetRootContainer( &dx_diag_rootp );
  345.         if(FAILED(hr) || !dx_diag_rootp)
  346. {
  347.             goto LCleanup;
  348. }
  350. HRESULT hr;
  352. // Get display driver information
  353. LL_DEBUGS("AppInit") << "dx_diag_rootp->GetChildContainer" << LL_ENDL;
  354. hr = dx_diag_rootp->GetChildContainer(L"DxDiag_DisplayDevices", &devices_containerp);
  355. if(FAILED(hr) || !devices_containerp)
  356. {
  357.             goto LCleanup;
  358. }
  360. // Get device 0
  361. LL_DEBUGS("AppInit") << "devices_containerp->GetChildContainer" << LL_ENDL;
  362. hr = devices_containerp->GetChildContainer(L"0", &device_containerp);
  363. if(FAILED(hr) || !device_containerp)
  364. {
  365.             goto LCleanup;
  366. }
  368. // Get the English VRAM string
  369. {
  370.   std::string ram_str = get_string(device_containerp, L"szDisplayMemoryEnglish");
  372.   // We don't need the device any more
  373.   SAFE_RELEASE(device_containerp);
  375.   // Dump the string as an int into the structure
  376.   char *stopstring;
  377.   mVRAM = strtol(ram_str.c_str(), &stopstring, 10); 
  378.   LL_INFOS("AppInit") << "VRAM Detected: " << mVRAM << " DX9 string: " << ram_str << LL_ENDL;
  379. }
  381. if (vram_only)
  382. {
  383. ok = TRUE;
  384. goto LCleanup;
  385. }
  388. /* for now, we ONLY do vram_only the rest of this
  389.    is commented out, to ensure no-one is tempted
  390.    to use it
  392. // Now let's get device and driver information
  393. // Get the IDxDiagContainer object called "DxDiag_SystemDevices".
  394. // This call may take some time while dxdiag gathers the info.
  395. DWORD num_devices = 0;
  396.     WCHAR wszContainer[256];
  397. LL_DEBUGS("AppInit") << "dx_diag_rootp->GetChildContainer DxDiag_SystemDevices" << LL_ENDL;
  398. hr = dx_diag_rootp->GetChildContainer(L"DxDiag_SystemDevices", &system_device_containerp);
  399. if (FAILED(hr))
  400. {
  401. goto LCleanup;
  402. }
  404. hr = system_device_containerp->GetNumberOfChildContainers(&num_devices);
  405. if (FAILED(hr))
  406. {
  407. goto LCleanup;
  408. }
  410. LL_DEBUGS("AppInit") << "DX9 iterating over devices" << LL_ENDL;
  411. S32 device_num = 0;
  412. for (device_num = 0; device_num < (S32)num_devices; device_num++)
  413. {
  414. hr = system_device_containerp->EnumChildContainerNames(device_num, wszContainer, 256);
  415. if (FAILED(hr))
  416. {
  417. goto LCleanup;
  418. }
  420. hr = system_device_containerp->GetChildContainer(wszContainer, &device_containerp);
  421. if (FAILED(hr) || device_containerp == NULL)
  422. {
  423. goto LCleanup;
  424. }
  426. std::string device_name = get_string(device_containerp, L"szDescription");
  428. std::string device_id = get_string(device_containerp, L"szDeviceID");
  430. LLDXDevice *dxdevicep = new LLDXDevice;
  431. dxdevicep->mName = device_name;
  432. dxdevicep->mPCIString = device_id;
  433. mDevices[dxdevicep->mPCIString] = dxdevicep;
  435. // Split the PCI string based on vendor, device, subsys, rev.
  436. std::string str(device_id);
  437. typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
  438. boost::char_separator<char> sep("&\", "", boost::keep_empty_tokens);
  439. tokenizer tokens(str, sep);
  441. tokenizer::iterator iter = tokens.begin();
  442. S32 count = 0;
  443. BOOL valid = TRUE;
  444. for (;(iter != tokens.end()) && (count < 3);++iter)
  445. {
  446. switch (count)
  447. {
  448. case 0:
  449. if (strcmp(iter->c_str(), "PCI"))
  450. {
  451. valid = FALSE;
  452. }
  453. break;
  454. case 1:
  455. dxdevicep->mVendorID = iter->c_str();
  456. break;
  457. case 2:
  458. dxdevicep->mDeviceID = iter->c_str();
  459. break;
  460. default:
  461. // Ignore it
  462. break;
  463. }
  464. count++;
  465. }
  470. // Now, iterate through the related drivers
  471. hr = device_containerp->GetChildContainer(L"Drivers", &driver_containerp);
  472. if (FAILED(hr) || !driver_containerp)
  473. {
  474. goto LCleanup;
  475. }
  477. DWORD num_files = 0;
  478. hr = driver_containerp->GetNumberOfChildContainers(&num_files);
  479. if (FAILED(hr))
  480. {
  481. goto LCleanup;
  482. }
  484. S32 file_num = 0;
  485. for (file_num = 0; file_num < (S32)num_files; file_num++ )
  486. {
  488. hr = driver_containerp->EnumChildContainerNames(file_num, wszContainer, 256);
  489. if (FAILED(hr))
  490. {
  491. goto LCleanup;
  492. }
  494. hr = driver_containerp->GetChildContainer(wszContainer, &file_containerp);
  495. if (FAILED(hr) || file_containerp == NULL)
  496. {
  497. goto LCleanup;
  498. }
  500. std::string driver_path = get_string(file_containerp, L"szPath");
  501. std::string driver_name = get_string(file_containerp, L"szName");
  502. std::string driver_version = get_string(file_containerp, L"szVersion");
  503. std::string driver_date = get_string(file_containerp, L"szDatestampEnglish");
  505. LLDXDriverFile *dxdriverfilep = new LLDXDriverFile;
  506. dxdriverfilep->mName = driver_name;
  507. dxdriverfilep->mFilepath= driver_path;
  508. dxdriverfilep->mVersionString = driver_version;
  509. dxdriverfilep->mVersion.set(driver_version);
  510. dxdriverfilep->mDateString = driver_date;
  512. dxdevicep->mDriverFiles[driver_name] = dxdriverfilep;
  514. SAFE_RELEASE(file_containerp);
  515. }
  516. SAFE_RELEASE(device_containerp);
  517. }
  518. */
  519.     }
  521.     // dumpDevices();
  522.     ok = TRUE;
  524. LCleanup:
  525. if (!ok)
  526. {
  527. LL_WARNS("AppInit") << "DX9 probe failed" << LL_ENDL;
  528. gWriteDebug("DX9 probe failedn");
  529. }
  531. SAFE_RELEASE(file_containerp);
  532. SAFE_RELEASE(driver_containerp);
  533. SAFE_RELEASE(device_containerp);
  534. SAFE_RELEASE(devices_containerp);
  535.     SAFE_RELEASE(dx_diag_rootp);
  536.     SAFE_RELEASE(dx_diag_providerp);
  537.     
  538.     CoUninitialize();
  539.     
  540.     return ok;
  541.     }
  543. LLSD LLDXHardware::getDisplayInfo()
  544. {
  545. LLTimer hw_timer;
  546.     HRESULT       hr;
  547. LLSD ret;
  548.     CoInitialize(NULL);
  550.     IDxDiagProvider *dx_diag_providerp = NULL;
  551.     IDxDiagContainer *dx_diag_rootp = NULL;
  552. IDxDiagContainer *devices_containerp = NULL;
  553. IDxDiagContainer *device_containerp = NULL;
  554. IDxDiagContainer *file_containerp = NULL;
  555. IDxDiagContainer *driver_containerp = NULL;
  557.     // CoCreate a IDxDiagProvider*
  558. llinfos << "CoCreateInstance IID_IDxDiagProvider" << llendl;
  559.     hr = CoCreateInstance(CLSID_DxDiagProvider,
  560.                           NULL,
  561.                           CLSCTX_INPROC_SERVER,
  562.                           IID_IDxDiagProvider,
  563.                           (LPVOID*) &dx_diag_providerp);
  565. if (FAILED(hr))
  566. {
  567. llwarns << "No DXDiag provider found!  DirectX 9 not installed!" << llendl;
  568. gWriteDebug("No DXDiag provider found!  DirectX 9 not installed!n");
  569. goto LCleanup;
  570. }
  571.     if (SUCCEEDED(hr)) // if FAILED(hr) then dx9 is not installed
  572.     {
  573.         // Fill out a DXDIAG_INIT_PARAMS struct and pass it to IDxDiagContainer::Initialize
  574.         // Passing in TRUE for bAllowWHQLChecks, allows dxdiag to check if drivers are 
  575.         // digital signed as logo'd by WHQL which may connect via internet to update 
  576.         // WHQL certificates.    
  577.         DXDIAG_INIT_PARAMS dx_diag_init_params;
  578.         ZeroMemory(&dx_diag_init_params, sizeof(DXDIAG_INIT_PARAMS));
  580.         dx_diag_init_params.dwSize                  = sizeof(DXDIAG_INIT_PARAMS);
  581.         dx_diag_init_params.dwDxDiagHeaderVersion   = DXDIAG_DX9_SDK_VERSION;
  582.         dx_diag_init_params.bAllowWHQLChecks        = TRUE;
  583.         dx_diag_init_params.pReserved               = NULL;
  585. llinfos << "dx_diag_providerp->Initialize" << llendl;
  586.         hr = dx_diag_providerp->Initialize(&dx_diag_init_params);
  587.         if(FAILED(hr))
  588. {
  589.             goto LCleanup;
  590. }
  592. llinfos << "dx_diag_providerp->GetRootContainer" << llendl;
  593.         hr = dx_diag_providerp->GetRootContainer( &dx_diag_rootp );
  594.         if(FAILED(hr) || !dx_diag_rootp)
  595. {
  596.             goto LCleanup;
  597. }
  599. HRESULT hr;
  601. // Get display driver information
  602. llinfos << "dx_diag_rootp->GetChildContainer" << llendl;
  603. hr = dx_diag_rootp->GetChildContainer(L"DxDiag_DisplayDevices", &devices_containerp);
  604. if(FAILED(hr) || !devices_containerp)
  605. {
  606.             goto LCleanup;
  607. }
  609. // Get device 0
  610. llinfos << "devices_containerp->GetChildContainer" << llendl;
  611. hr = devices_containerp->GetChildContainer(L"0", &device_containerp);
  612. if(FAILED(hr) || !device_containerp)
  613. {
  614.             goto LCleanup;
  615. }
  617. // Get the English VRAM string
  618. std::string ram_str = get_string(device_containerp, L"szDisplayMemoryEnglish");
  621. // Dump the string as an int into the structure
  622. char *stopstring;
  623. ret["VRAM"] = strtol(ram_str.c_str(), &stopstring, 10);
  624. std::string device_name = get_string(device_containerp, L"szDescription");
  625. ret["DeviceName"] = device_name;
  626. std::string device_driver=  get_string(device_containerp, L"szDriverVersion");
  627. ret["DriverVersion"] = device_driver;
  628.         
  629.         // ATI has a slightly different version string
  630.         if(device_name.length() >= 4 && device_name.substr(0,4) == "ATI ")
  631.         {
  632.             // get the key
  633.             HKEY hKey;
  634.             const DWORD RV_SIZE = 100;
  635.             WCHAR release_version[RV_SIZE];
  637.             // Hard coded registry entry.  Using this since it's simpler for now.
  638.             // And using EnumDisplayDevices to get a registry key also requires
  639.             // a hard coded Query value.
  640.             if(ERROR_SUCCESS == RegOpenKey(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\ATI Technologies\CBT"), &hKey))
  641.             {
  642.                 // get the value
  643.                 DWORD dwType = REG_SZ;
  644.                 DWORD dwSize = sizeof(WCHAR) * RV_SIZE;
  645.                 if(ERROR_SUCCESS == RegQueryValueEx(hKey, TEXT("ReleaseVersion"), 
  646.                     NULL, &dwType, (LPBYTE)release_version, &dwSize))
  647.                 {
  648.                     // print the value
  649.                     // windows doesn't guarantee to be null terminated
  650.                     release_version[RV_SIZE - 1] = NULL;
  651.                     ret["DriverVersion"] = utf16str_to_utf8str(release_version);
  653.                 }
  654.                 RegCloseKey(hKey);
  655.             }
  656.         }    
  657.     }
  659. LCleanup:
  660. SAFE_RELEASE(file_containerp);
  661. SAFE_RELEASE(driver_containerp);
  662. SAFE_RELEASE(device_containerp);
  663. SAFE_RELEASE(devices_containerp);
  664.     SAFE_RELEASE(dx_diag_rootp);
  665.     SAFE_RELEASE(dx_diag_providerp);
  666.     
  667.     CoUninitialize();
  668. return ret;
  669. }
  671. void LLDXHardware::setWriteDebugFunc(void (*func)(const char*))
  672. {
  673. gWriteDebug = func;
  674. }
  676. #endif