nel/src/misc/system_utils.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2014-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program 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
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdmisc.h"
  21 #include "nel/misc/system_utils.h"
  22 #include "nel/misc/utf_string_view.h"
  23
  24 #ifdef NL_OS_WINDOWS
  25 #define INITGUID
  26 #include <ddraw.h>
  27 #include <windows.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30 #ifdef DXGI_STATUS_OCCLUDED
  31 #undef DXGI_STATUS_OCCLUDED
  32 #undef DXGI_STATUS_CLIPPED
  33 #undef DXGI_STATUS_NO_REDIRECTION
  34 #undef DXGI_STATUS_NO_DESKTOP_ACCESS
  35 #undef DXGI_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE
  36 #undef DXGI_STATUS_MODE_CHANGED
  37 #undef DXGI_STATUS_MODE_CHANGE_IN_PROGRESS
  38 #endif
  39 #ifdef DXGI_ERROR_INVALID_CALL
  40 #undef DXGI_ERROR_INVALID_CALL
  41 #undef DXGI_ERROR_NOT_FOUND
  42 #undef DXGI_ERROR_MORE_DATA
  43 #undef DXGI_ERROR_UNSUPPORTED
  44 #undef DXGI_ERROR_DEVICE_REMOVED
  45 #undef DXGI_ERROR_DEVICE_HUNG
  46 #undef DXGI_ERROR_DEVICE_RESET
  47 #undef DXGI_ERROR_WAS_STILL_DRAWING
  48 #undef DXGI_ERROR_FRAME_STATISTICS_DISJOINT
  49 #undef DXGI_ERROR_GRAPHICS_VIDPN_SOURCE_IN_USE
  50 #undef DXGI_ERROR_DRIVER_INTERNAL_ERROR
  51 #undef DXGI_ERROR_NONEXCLUSIVE
  52 #undef DXGI_ERROR_NOT_CURRENTLY_AVAILABLE
  53 #undef DXGI_ERROR_REMOTE_CLIENT_DISCONNECTED
  54 #undef DXGI_ERROR_REMOTE_OUTOFMEMORY
  55 #endif
  56 #include <dxgi.h>
  57 #include <initguid.h>
  58 #include <CGuid.h>
  59 #       include <ObjBase.h>
  60 #       ifdef _WIN32_WINNT_WIN7
  61                 // only supported by Windows 7 Platform SDK
  62 #               include <ShObjIdl.h>
  63 #               define TASKBAR_PROGRESS 1
  64 #       endif
  65 #elif defined(NL_OS_UNIX) && !defined(NL_OS_MAC)
  66 #include "nel/misc/file.h"
  67 #endif
  68
  69 #ifdef DEBUG_NEW
  70         #define new DEBUG_NEW
  71 #endif
  72
  73 using namespace std;
  74
  75 // Key in registry
  76 static string RootKey;
  77 static const uint32 KeyMaxLength = 1024;
  78
  79 namespace NLMISC {
  80
  81 nlWindow CSystemUtils::s_window = EmptyWindow;
  82
  83 #ifdef NL_OS_WINDOWS
  84 static bool s_mustUninit = false;
  85 #endif
  86
  87 bool CSystemUtils::init()
  88 {
  89 #ifdef NL_OS_WINDOWS
  90         // initialize COM
  91         if (!s_mustUninit)
  92         {
  93                 HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
  94                 if (FAILED(hr)) return false;
  95
  96                 s_mustUninit = true;
  97         }
  98 #endif
  99
 100         return true;
 101 }
 102
 103 bool CSystemUtils::uninit()
 104 {
 105 #ifdef NL_OS_WINDOWS
 106         // uninitialize COM
 107         if (s_mustUninit)
 108         {
 109                 CoUninitialize();
 110
 111                 s_mustUninit = false;
 112         }
 113 #endif
 114
 115         return true;
 116 }
 117
 118 void CSystemUtils::setWindow(nlWindow window)
 119 {
 120         s_window = window;
 121 }
 122
 123 bool CSystemUtils::updateProgressBar(uint value, uint total)
 124 {
 125 #ifdef TASKBAR_PROGRESS
 126         if (s_window == NULL)
 127         {
 128                 nldebug("No window has be set with CSystemUtils::setWindow(), progress bar can't be displayed");
 129                 return false;
 130         }
 131
 132         ITaskbarList3 *pTaskbarList = NULL;
 133
 134         // instanciate the taskbar control COM object
 135         HRESULT hr = CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pTaskbarList));
 136         // error can be ignored because Windows versions before Windows 7 doesn't support it
 137         if (FAILED(hr) || !pTaskbarList) return false;
 138
 139         if (total)
 140         {
 141                 // update the taskbar progress
 142                 hr = pTaskbarList->SetProgressValue(s_window, (ULONGLONG)value, (ULONGLONG)total);
 143         }
 144         else
 145         {
 146                 // don't update anymore the progress
 147                 hr = pTaskbarList->SetProgressState(s_window, value == 0 ? TBPF_INDETERMINATE:TBPF_NOPROGRESS);
 148         }
 149
 150         // release the interface
 151         pTaskbarList->Release();
 152
 153 #endif // TASKBAR_PROGRESS
 154
 155         return true;
 156 }
 157
 158 bool CSystemUtils::copyTextToClipboard(const std::string &text)
 159 {
 160         if (text.empty()) return false;
 161
 162         bool res = false;
 163
 164 #ifdef NL_OS_WINDOWS
 165         if (OpenClipboard(NULL))
 166         {
 167                 // check if unicode format is supported by clipboard
 168                 bool isUnicode = (IsClipboardFormatAvailable(CF_UNICODETEXT) == TRUE);
 169
 170                 // allocates a buffer to copy text in global memory
 171                 std::string textMbcs;
 172                 std::wstring textWide;
 173                 if (!isUnicode)
 174                 {
 175                         textMbcs = NLMISC::utf8ToMbcs(text); // Prefer system for API
 176                         if (text.size() && !textMbcs.size())
 177                                 textMbcs = CUtfStringView(text).toAscii(); // Fallback to 7-bit ASCII
 178                 }
 179                 else
 180                 {
 181                         textWide = NLMISC::utf8ToWide(text); // Prefer system for API
 182                         if (text.size() && !textWide.size())
 183                                 textWide = CUtfStringView(text).toWide();
 184                 }
 185                 HGLOBAL mem = GlobalAlloc(GHND | GMEM_DDESHARE, isUnicode
 186                         ? ((textWide.size() + 1) * sizeof(wchar_t))
 187                         : (textMbcs.size() + 1));
 188
 189                 if (mem)
 190                 {
 191                         // create a lock on this buffer
 192                         void *hLock = GlobalLock(mem);
 193                         if (hLock)
 194                         {
 195                                 // copy text to this buffer
 196                                 if (isUnicode)
 197                                         wcscpy((wchar_t *)hLock, textWide.c_str());
 198                                 else
 199                                         strcpy((char *)hLock, textMbcs.c_str());
 200
 201                                 // unlock buffer
 202                                 GlobalUnlock(mem);
 203
 204                                 // empty clipboard
 205                                 EmptyClipboard();
 206
 207                                 // set new data to clipboard in the right format
 208                                 SetClipboardData(isUnicode ? CF_UNICODETEXT : CF_TEXT, mem);
 209
 210                                 res = true;
 211                         }
 212                 }
 213
 214                 CloseClipboard();
 215         }
 216 #endif
 217
 218         return res;
 219 }
 220
 221 bool CSystemUtils::pasteTextFromClipboard(std::string &text)
 222 {
 223         bool res = false;
 224
 225 #ifdef NL_OS_WINDOWS
 226         if (OpenClipboard(NULL))
 227         {
 228                 // check if unicode format is supported by clipboard
 229                 bool isUnicode = (IsClipboardFormatAvailable(CF_UNICODETEXT) == TRUE);
 230
 231                 // get data from clipboard (if not of this type, they are converted)
 232                 // warning, this code can't be debuggued in VC++ IDE, hObj will be always NULL
 233                 HANDLE hObj = GetClipboardData(isUnicode ? CF_UNICODETEXT : CF_TEXT);
 234
 235                 if (hObj)
 236                 {
 237                         // create a lock on clipboard data
 238                         void *hLock = GlobalLock(hObj);
 239
 240                         if (hLock != NULL)
 241                         {
 242                                 // retrieve clipboard data
 243                                 if (isUnicode)
 244                                 {
 245                                         const wchar_t *str = (const wchar_t *)hLock;
 246                                         text = NLMISC::wideToUtf8(str); // Prefer system for API
 247                                         if (!text.size() && str[0])
 248                                                 text = CUtfStringView(str).toUtf8();
 249                                         else
 250                                                 text = CUtfStringView(text).toUtf8(true); // Sanitize UTF-8 user input
 251                                 }
 252                                 else
 253                                 {
 254                                         const char *str = (const char *)hLock;
 255                                         text = NLMISC::mbcsToUtf8(str); // Prefer system for API
 256                                         if (!text.size() && str[0])
 257                                                 text = CUtfStringView(str).toAscii(); // Fallback to 7-bit ASCII
 258                                         else
 259                                                 text = CUtfStringView(text).toUtf8(true); // Sanitize UTF-8 user input
 260                                 }
 261
 262                                 // unlock data
 263                                 GlobalUnlock(hObj);
 264
 265                                 res = true;
 266                         }
 267                 }
 268
 269                 CloseClipboard();
 270         }
 271 #endif
 272
 273         return res;
 274 }
 275
 276 bool CSystemUtils::supportUnicode()
 277 {
 278         static bool init = false;
 279         static bool unicodeSupported = false;
 280         if (!init)
 281         {
 282                 init = true;
 283 #ifdef NL_OS_WINDOWS
 284                 OSVERSIONINFOA osvi;
 285                 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 286
 287                 // get Windows version
 288                 if (GetVersionExA(&osvi))
 289                 {
 290                         if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
 291                         {
 292                                 // unicode is supported since Windows NT 4.0
 293                                 if (osvi.dwMajorVersion >= 4)
 294                                 {
 295                                         unicodeSupported = true;
 296                                 }
 297                         }
 298                 }
 299 #else
 300                 unicodeSupported = true;
 301 #endif
 302         }
 303         return unicodeSupported;
 304 }
 305
 306 bool CSystemUtils::isAzertyKeyboard()
 307 {
 308 #ifdef NL_OS_WINDOWS
 309         uint16 klId = uint16((uintptr_t)GetKeyboardLayout(0) & 0xFFFF);
 310         // 0x040c is French, 0x080c is Belgian
 311         if (klId == 0x040c || klId == 0x080c)
 312                 return true;
 313 #endif
 314         return false;
 315 }
 316
 317 bool CSystemUtils::isScreensaverEnabled()
 318 {
 319         bool res = false;
 320 #ifdef NL_OS_WINDOWS
 321 //      old code, is not working anymore
 322 //      BOOL bRetValue;
 323 //      SystemParametersInfoA(SPI_GETSCREENSAVEACTIVE, 0, &bRetValue, 0);
 324 //      res = (bRetValue == TRUE);
 325         HKEY hKeyScreenSaver = NULL;
 326         LSTATUS lReturn = RegOpenKeyExA(HKEY_CURRENT_USER, "Control Panel\\Desktop", 0, KEY_QUERY_VALUE, &hKeyScreenSaver);
 327         if (lReturn == ERROR_SUCCESS)
 328         {
 329                 DWORD dwType = 0L;
 330                 DWORD dwSize = KeyMaxLength;
 331                 unsigned char Buffer[KeyMaxLength] = {0};
 332
 333                 lReturn = RegQueryValueExA(hKeyScreenSaver, "SCRNSAVE.EXE", NULL, &dwType, NULL, &dwSize);
 334                 // if SCRNSAVE.EXE is present, check also if it's empty
 335                 if (lReturn == ERROR_SUCCESS)
 336                         res = (Buffer[0] != '\0');
 337         }
 338         RegCloseKey(hKeyScreenSaver);
 339 #endif
 340         return res;
 341 }
 342
 343 bool CSystemUtils::enableScreensaver(bool screensaver)
 344 {
 345         bool res = false;
 346 #ifdef NL_OS_WINDOWS
 347         res = (SystemParametersInfoA(SPI_SETSCREENSAVEACTIVE, screensaver ? TRUE:FALSE, NULL, 0) == TRUE);
 348 #endif
 349         return res;
 350 }
 351
 352 std::string CSystemUtils::getRootKey()
 353 {
 354         return RootKey;
 355 }
 356
 357 void CSystemUtils::setRootKey(const std::string &root)
 358 {
 359         RootKey = root;
 360 }
 361
 362 string CSystemUtils::getRegKey(const string &entry)
 363 {
 364         string ret;
 365 #ifdef NL_OS_WINDOWS
 366         HKEY hkey;
 367
 368         if (RegOpenKeyExW(HKEY_CURRENT_USER, nlUtf8ToWide(RootKey), 0, KEY_READ, &hkey) == ERROR_SUCCESS)
 369         {
 370                 DWORD   dwType  = 0L;
 371                 DWORD   dwSize  = KeyMaxLength;
 372                 wchar_t buffer[KeyMaxLength];
 373
 374                 if (RegQueryValueExW(hkey, nlUtf8ToWide(entry), NULL, &dwType, (LPBYTE)buffer, &dwSize) != ERROR_SUCCESS)
 375                 {
 376                         nlwarning("Can't get the reg key '%s'", entry.c_str());
 377                 }
 378                 else
 379                 {
 380                         ret = wideToUtf8(buffer);
 381                 }
 382
 383                 RegCloseKey(hkey);
 384         }
 385         else
 386         {
 387                 nlwarning("Can't get the reg key '%s'", entry.c_str());
 388         }
 389 #endif
 390         return ret;
 391 }
 392
 393 bool CSystemUtils::setRegKey(const string &valueName, const string &value)
 394 {
 395         bool res = false;
 396 #ifdef NL_OS_WINDOWS
 397         HKEY hkey;
 398         DWORD dwDisp;
 399
 400         if (RegCreateKeyExW(HKEY_CURRENT_USER, nlUtf8ToWide(RootKey), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwDisp) == ERROR_SUCCESS)
 401         {
 402                 // we must use the real Unicode string size in bytes
 403                 std::wstring wvalue = nlUtf8ToWide(value);
 404                 if (RegSetValueExW(hkey, nlUtf8ToWide(valueName), 0, REG_SZ, (const BYTE *)wvalue.c_str(), (wvalue.size() + 1) * sizeof(WCHAR)) == ERROR_SUCCESS)
 405                         res = true;
 406                 RegCloseKey(hkey);
 407         }
 408         else
 409         {
 410                 nlwarning("Can't set the reg key '%s' '%s'", valueName.c_str(), value.c_str());
 411         }
 412 #endif
 413
 414         return res;
 415 }
 416
 417 uint CSystemUtils::getCurrentColorDepth()
 418 {
 419         uint depth = 0;
 420
 421 #ifdef NL_OS_WINDOWS
 422         HWND desktopWnd = GetDesktopWindow();
 423         if (desktopWnd)
 424         {
 425                 HDC desktopDC = GetWindowDC(desktopWnd);
 426                 if (desktopDC)
 427                 {
 428                         depth = (uint) GetDeviceCaps(desktopDC, BITSPIXEL);
 429                         ReleaseDC(desktopWnd, desktopDC);
 430                 }
 431         }
 432 #else
 433         depth = 24; // temporary fix for compilation under Linux
 434 /*
 435         Display *display = XOpenDisplay(NULL);
 436         if (display)
 437         {
 438                 depth = (uint) DefaultDepth(display, DefaultScreen(display));
 439                 XCloseDisplay(display);
 440         }
 441 */
 442 #endif
 443         return depth;
 444 }
 445
 446 /// Detect whether the current process is a windowed application. Return true if definitely yes, false if unknown
 447 bool CSystemUtils::detectWindowedApplication()
 448 {
 449 #ifdef NL_OS_WINDOWS
 450         if (GetConsoleWindow() == NULL)
 451                 return true;
 452 #endif
 453         return false;
 454 }
 455
 456 #ifdef NL_OS_WINDOWS
 457 #ifndef SAFE_RELEASE
 458 #define SAFE_RELEASE(p)      { if (p) { (p)->Release(); (p) = NULL; } }
 459 #endif
 460
 461 typedef HRESULT (WINAPI* LPDIRECTDRAWCREATE)(GUID FAR *lpGUID, LPDIRECTDRAW FAR *lplpDD, IUnknown FAR *pUnkOuter);
 462 typedef HRESULT (WINAPI* LPCREATEDXGIFACTORY)(REFIID, void**);
 463
 464 static std::string FormatError(HRESULT hr)
 465 {
 466         return NLMISC::toString("%s (0x%x)", formatErrorMessage(hr).c_str(), hr);
 467 }
 468
 469 struct SAdapter
 470 {
 471         uint id;
 472         std::string name;
 473         sint memory;
 474         GUID guid;
 475         HMONITOR hMonitor;
 476         bool found;
 477
 478         SAdapter()
 479         {
 480                 id = 0;
 481                 memory = -1;
 482                 guid = GUID_NULL;
 483                 hMonitor = NULL;
 484                 found = false;
 485         }
 486 };
 487
 488 static std::list<SAdapter> s_dxgiAdapters;
 489
 490 static void EnumerateUsingDXGI(IDXGIFactory *pDXGIFactory)
 491 {
 492         nlassert(pDXGIFactory != NULL);
 493
 494         for(uint index = 0; ; ++index)
 495         {
 496                 IDXGIAdapter *pAdapter = NULL;
 497                 HRESULT hr = pDXGIFactory->EnumAdapters(index, &pAdapter);
 498                 // DXGIERR_NOT_FOUND is expected when the end of the list is hit
 499                 if (FAILED(hr)) break;
 500
 501                 DXGI_ADAPTER_DESC desc;
 502                 memset(&desc, 0, sizeof(DXGI_ADAPTER_DESC));
 503
 504                 if (SUCCEEDED(pAdapter->GetDesc(&desc)))
 505                 {
 506                         SAdapter adapter;
 507                         adapter.id = index;
 508                         adapter.name = wideToUtf8(desc.Description);
 509                         adapter.memory = desc.DedicatedVideoMemory / 1024;
 510                         adapter.found = true;
 511
 512                         nldebug("DXGI Adapter: %u - %s - DedicatedVideoMemory: %d KiB", index, adapter.name.c_str(), adapter.memory);
 513
 514                         s_dxgiAdapters.push_back(adapter);
 515                 }
 516
 517                 SAFE_RELEASE(pAdapter);
 518         }
 519 }
 520
 521 BOOL WINAPI DDEnumCallbackEx(GUID FAR* lpGUID, LPSTR lpDriverDescription, LPSTR lpDriverName, LPVOID lpContext, HMONITOR hm)
 522 {
 523         SAdapter * pAdapter = (SAdapter*)lpContext;
 524
 525         if (pAdapter->hMonitor == hm)
 526         {
 527                 pAdapter->name = lpDriverDescription;
 528                 pAdapter->guid = *lpGUID;
 529                 pAdapter->found = true;
 530         }
 531
 532         return TRUE;
 533 }
 534
 535 #endif
 536
 537 sint CSystemUtils::getTotalVideoMemory()
 538 {
 539         sint res = -1;
 540
 541 #if defined(NL_OS_WINDOWS)
 542         // using DXGI
 543         HINSTANCE hDXGI = LoadLibraryA("dxgi.dll");
 544
 545         if (hDXGI)
 546         {
 547
 548                 // We prefer the use of DXGI 1.1
 549                 LPCREATEDXGIFACTORY pCreateDXGIFactory = (LPCREATEDXGIFACTORY)GetProcAddress(hDXGI, "CreateDXGIFactory1");
 550
 551                 if (!pCreateDXGIFactory)
 552                 {
 553                         pCreateDXGIFactory = (LPCREATEDXGIFACTORY)GetProcAddress(hDXGI, "CreateDXGIFactory");
 554                 }
 555
 556                 if (pCreateDXGIFactory)
 557                 {
 558                         IDXGIFactory *pDXGIFactory = NULL;
 559                         HRESULT hr = pCreateDXGIFactory(__uuidof(IDXGIFactory), (LPVOID*)&pDXGIFactory);
 560
 561                         if (SUCCEEDED(hr))
 562                         {
 563                                 EnumerateUsingDXGI(pDXGIFactory);
 564
 565                                 SAFE_RELEASE(pDXGIFactory);
 566
 567                                 if (!s_dxgiAdapters.empty())
 568                                 {
 569                                         // TODO: determine what adapter is used by NeL
 570                                         res = s_dxgiAdapters.front().memory;
 571                                 }
 572                                 else
 573                                 {
 574                                         nlwarning("Unable to find an DXGI adapter");
 575                                 }
 576                         }
 577                         else
 578                         {
 579                                 nlwarning("Unable to create DXGI factory");
 580                         }
 581                 }
 582                 else
 583                 {
 584                         nlwarning("dxgi.dll missing entry-point");
 585                 }
 586
 587                 FreeLibrary(hDXGI);
 588         }
 589
 590         if (res == -1)
 591         {
 592                 // using DirectDraw
 593                 HMODULE hInstDDraw = LoadLibraryA("ddraw.dll");
 594
 595                 if (hInstDDraw)
 596                 {
 597                         SAdapter adapter;
 598                         adapter.hMonitor = MonitorFromWindow(s_window, MONITOR_DEFAULTTONULL);
 599
 600                         LPDIRECTDRAWENUMERATEEXA pDirectDrawEnumerateEx = (LPDIRECTDRAWENUMERATEEXA)GetProcAddress(hInstDDraw, "DirectDrawEnumerateExA");
 601                         LPDIRECTDRAWCREATE pDDCreate = (LPDIRECTDRAWCREATE)GetProcAddress(hInstDDraw, "DirectDrawCreate");
 602
 603                         if (pDirectDrawEnumerateEx && pDDCreate)
 604                         {
 605                                 HRESULT hr = pDirectDrawEnumerateEx(DDEnumCallbackEx, (VOID*)&adapter, DDENUM_ATTACHEDSECONDARYDEVICES);
 606
 607                                 if (SUCCEEDED(hr) && adapter.found)
 608                                 {
 609                                         LPDIRECTDRAW pDDraw = NULL;
 610                                         hr = pDDCreate(&adapter.guid, &pDDraw, NULL);
 611
 612                                         if (SUCCEEDED(hr))
 613                                         {
 614                                                 LPDIRECTDRAW7 pDDraw7 = NULL;
 615                                                 hr = pDDraw->QueryInterface(IID_IDirectDraw7, (VOID**)&pDDraw7);
 616
 617                                                 if (SUCCEEDED(hr))
 618                                                 {
 619                                                         DDSCAPS2 ddscaps;
 620                                                         memset(&ddscaps, 0, sizeof(DDSCAPS2));
 621                                                         ddscaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM;
 622
 623                                                         DWORD pdwAvailableVidMem;
 624                                                         hr = pDDraw7->GetAvailableVidMem(&ddscaps, &pdwAvailableVidMem, NULL);
 625
 626                                                         if (SUCCEEDED(hr))
 627                                                         {
 628                                                                 res = (sint)pdwAvailableVidMem / 1024;
 629                                                                 nlinfo("DirectDraw Adapter: %s - DedicatedVideoMemory: %d KiB", adapter.name.c_str(), adapter.memory);
 630                                                         }
 631                                                         else
 632                                                         {
 633                                                                 nlwarning("Unable to get DirectDraw available video memory: %s", FormatError(hr).c_str());
 634                                                         }
 635
 636                                                         SAFE_RELEASE(pDDraw7);
 637                                                 }
 638                                                 else
 639                                                 {
 640                                                         nlwarning("Unable to query IDirectDraw7 interface: %s", FormatError(hr).c_str());
 641                                                 }
 642                                         }
 643                                         else
 644                                         {
 645                                                 nlwarning("Unable to call DirectDrawCreate: %s", FormatError(hr).c_str());
 646                                         }
 647                                 }
 648                                 else
 649                                 {
 650                                         nlwarning("Unable to enumerate DirectDraw adapters (%s): %s", (adapter.found ? "found":"not found"), FormatError(hr).c_str());
 651                                 }
 652                         }
 653                         else
 654                         {
 655                                 nlwarning("Unable to get pointer on DirectDraw functions (DirectDrawEnumerateExA %p, DirectDrawCreate %p)", pDirectDrawEnumerateEx, pDDCreate);
 656                         }
 657
 658                         FreeLibrary(hInstDDraw);
 659                 }
 660                 else
 661                 {
 662                         nlwarning("Unable to load ddraw.dll");
 663                 }
 664         }
 665 #elif defined(NL_OS_MAC)
 666         // the right method is using OpenGL
 667 #else
 668         if (res == -1)
 669         {
 670                 // use nvidia-smi
 671                 std::string command = "nvidia-smi -q -d MEMORY";
 672
 673                 std::string out = getCommandOutput(command);
 674
 675                 if (out.empty())
 676                 {
 677                         nlwarning("Unable to launch %s", command.c_str());
 678                 }
 679                 else
 680                 {
 681                         std::vector<std::string> lines;
 682                         explode(out, std::string("\n"), lines, true);
 683
 684                         // process each line
 685                         for(uint i = 0; i < lines.size(); ++i)
 686                         {
 687                                 //        Total                   : 62 MB
 688
 689                                 std::string line = lines[i];
 690
 691                                 // find Total line
 692                                 std::string::size_type pos = line.find("Total");
 693                                 if (pos == std::string::npos) continue;
 694                                 pos += 6;
 695
 696                                 // find separator
 697                                 pos = line.find(':', pos);
 698                                 if (pos == std::string::npos) continue;
 699                                 pos += 2;
 700
 701                                 // find units
 702                                 std::string::size_type posUnits = line.find(' ', pos);
 703                                 if (posUnits == std::string::npos) continue;
 704                                 ++posUnits;
 705
 706                                 // found device ID
 707                                 std::string memory = line.substr(pos, posUnits-pos-1);
 708                                 std::string units = line.substr(posUnits);
 709
 710                                 // convert video memory to sint
 711                                 if (NLMISC::fromString(memory, res))
 712                                 {
 713                                         if (units == "MB")
 714                                         {
 715                                                 res *= 1024;
 716                                         }
 717                                         else if (units == "GB")
 718                                         {
 719                                                 res *= 1024 * 1024;
 720                                         }
 721                                         else
 722                                         {
 723                                                 // reset to use other methods
 724                                                 res = -1;
 725
 726                                                 nlwarning("nvidia-smi reported %d %s as wrong video memory units", res, units.c_str());
 727                                                 break;
 728                                         }
 729
 730                                         nlinfo("nvidia-smi reported %d KiB of video memory", res);
 731                                 }
 732                                 else
 733                                 {
 734                                         // reset to use other methods
 735                                         res = -1;
 736                                 }
 737
 738                                 break;
 739                         }
 740                 }
 741         }
 742
 743         if (res == -1)
 744         {
 745                 // under Linux, no method is really reliable...
 746                 NLMISC::CIFile file;
 747
 748                 std::string logFile = "/var/log/Xorg.0.log";
 749
 750                 // parse last Xorg.0.log
 751                 if (file.open(logFile, true))
 752                 {
 753                         char buffer[256];
 754
 755                         while(!file.eof())
 756                         {
 757                                 file.getline(buffer, 256);
 758
 759                                 if (buffer[0] == '\0') break;
 760
 761                                 std::string line(buffer);
 762
 763                                 // nvidia driver
 764                                 std::string::size_type pos = line.find(") NVIDIA(");
 765
 766                                 if (pos != std::string::npos)
 767                                 {
 768                                         // [    20.883] (--) NVIDIA(0): Memory: 2097152 kBytes
 769                                         // [    28.515] (--) NVIDIA(0): Memory: 262144 kBytes
 770                                         pos = line.find("Memory: ", pos);
 771
 772                                         // found memory line
 773                                         if (pos == std::string::npos) continue;
 774                                         pos += 8;
 775
 776                                         std::string::size_type posUnits = line.find(" kBytes", pos);
 777
 778                                         // found units in KiB
 779                                         if (posUnits == std::string::npos) continue;
 780
 781                                         std::string videoMemory = line.substr(pos, posUnits-pos);
 782
 783                                         if (!NLMISC::fromString(videoMemory, res)) continue;
 784
 785                                         nlinfo("Xorg NVIDIA driver reported %d KiB of video memory", res);
 786                                         break;
 787                                 }
 788
 789                                 // intel driver
 790                                 pos = line.find(") intel(");
 791
 792                                 if (pos != std::string::npos)
 793                                 {
 794                                         // (**) intel(0): VideoRam: 131072 KB
 795                                         pos = line.find("VideoRam: ", pos);
 796
 797                                         // found memory line
 798                                         if (pos == std::string::npos) continue;
 799                                         pos += 10;
 800
 801                                         std::string::size_type posUnits = line.find(" KB", pos);
 802
 803                                         // found units in KiB
 804                                         if (posUnits == std::string::npos) continue;
 805
 806                                         std::string videoMemory = line.substr(pos, posUnits-pos);
 807
 808                                         if (!NLMISC::fromString(videoMemory, res)) continue;
 809
 810                                         nlinfo("Xorg Intel driver reported %d KiB of video memory", res);
 811                                         break;
 812                                 }
 813
 814                                 // TODO: other drivers: fglrx (ATI), radeon (ATI)
 815                         }
 816
 817                         file.close();
 818                 }
 819         }
 820
 821         if (res == -1)
 822         {
 823                 // use lspci
 824                 std::string command = "lspci";
 825
 826                 std::string out = getCommandOutput(command);
 827
 828                 if (out.empty())
 829                 {
 830                         nlwarning("Unable to launch %s", command.c_str());
 831                 }
 832                 else
 833                 {
 834                         std::vector<std::string> lines;
 835                         std::string deviceId;
 836
 837                         explode(out, std::string("\n"), lines, true);
 838
 839                         // process each line
 840                         for(uint i = 0; i < lines.size(); ++i)
 841                         {
 842                                 std::string line = lines[i];
 843
 844                                 if (line.find("VGA") == std::string::npos &&
 845                                         line.find("3D") == std::string::npos &&
 846                                         line.find("2D") == std::string::npos)
 847                                         continue;
 848
 849                                 std::string::size_type pos = line.find(' ');
 850
 851                                 if (pos == std::string::npos) continue;
 852
 853                                 // found device ID
 854                                 deviceId = line.substr(0, pos);
 855                                 break;
 856                         }
 857
 858                         if (deviceId.empty())
 859                         {
 860                                 nlwarning("Unable to find a 3D device with lspci");
 861                         }
 862                         else
 863                         {
 864                                 command = "lspci -v -s " + deviceId;
 865
 866                                 out = getCommandOutput(command);
 867
 868                                 if (out.empty())
 869                                 {
 870                                         nlwarning("Unable to launch %s", command.c_str());
 871                                 }
 872                                 else
 873                                 {
 874                                         explode(out, std::string("\n"), lines, true);
 875
 876                                         // process each line
 877                                         for(uint i = 0; i < lines.size(); ++i)
 878                                         {
 879                                                 std::string line = lines[i];
 880
 881                                                 // look for a size
 882                                                 std::string::size_type pos0 = line.find("[size=");
 883                                                 if (pos0 == std::string::npos) continue;
 884
 885                                                 // move to first digit
 886                                                 pos0 += 6;
 887
 888                                                 // end of the size
 889                                                 std::string::size_type pos1 = line.find("]", pos0);
 890                                                 if (pos1 == std::string::npos) continue;
 891
 892                                                 sint units;
 893
 894                                                 if (line.substr(pos1-1, 1) == "M")
 895                                                 {
 896                                                         // size in MiB
 897                                                         units = 1024;
 898                                                         --pos1;
 899                                                 }
 900                                                 else if (line.substr(pos1-1, 1) == "K")
 901                                                 {
 902                                                         // size in KiB
 903                                                         units = 1;
 904                                                         --pos1;
 905                                                 }
 906                                                 else
 907                                                 {
 908                                                         // size in B
 909                                                         units = 0;
 910                                                 }
 911
 912                                                 // extract the size
 913                                                 std::string sizeStr = line.substr(pos0, pos1-pos0);
 914
 915                                                 // convert size to integer with right units
 916                                                 sint tmpSize;
 917                                                 if (!NLMISC::fromString(sizeStr, tmpSize)) continue;
 918
 919                                                 tmpSize *= units;
 920
 921                                                 // take the higher size (up to 256 MiB apparently)
 922                                                 if (tmpSize > res) res = tmpSize;
 923                                         }
 924
 925                                         nlinfo("lspci reported %d KiB of video memory", res);
 926                                 }
 927                         }
 928                 }
 929         }
 930 #endif
 931
 932         return res;
 933 }
 934
 935 } // NLMISC