C语言 Win32 获取显示设备信息

函数

BOOL EnumDisplayDevicesA( LPCSTR lpDevice, DWORD iDevNum, PDISPLAY_DEVICEA lpDisplayDevice, DWORD dwFlags );

用于枚举显示设备信息。当lpDevice = NULL时，枚举视频卡(Display adapter)信息；当lpDevice = DISPLAY_DEVICE::DeviceName时，枚举显示器(monitor)信息;

函数

BOOL EnumDisplaySettingsA( LPCSTR lpszDeviceName, DWORD iModeNum, DEVMODEA *lpDevMode );

用于枚举视频模式(Video mode)信息

范例：

 #pragma once

 #include <stdio.h>
 #include <Windows.h>
 #include <VersionHelpers.h>

 struct VIDEOMODE;
 struct DISPLAY;

 typedef struct VIDEOMODE
 {
     VIDEOMODE* next;

     int        width;
     int        height;
     int        red_bits;
     int        green_bits;
     int        blue_bits;
     int        refresh_rates;

 } *PVIDEOMODE;

 typedef struct DISPLAY
 {
     DISPLAY* next;

     TCHAR    monitor_name[];
     TCHAR    adapter_name[];
     int        widthMM;
     int        heightMM;

     VIDEOMODE* pVideoMode;
     VIDEOMODE* pCurrentMode;

 } *PDISPLAY;

 class CDispDeviceInfo
 {
 public:

     CDispDeviceInfo();
     ~CDispDeviceInfo();

     bool CDispDeviceInfoInit();
     DISPLAY* EnumDisplay(int index);
     VIDEOMODE* EnumVideoModes(DISPLAY* adapter, int index);
     VIDEOMODE* GetCurrentMode();

 protected:

     void SpiltBPP(int color_bits, int* red_bits, int* green_bits, int* blue_bits);
     bool CompareVideoMode(VIDEOMODE* adapter, VIDEOMODE* result);
     DISPLAY* CreateMonitors(DISPLAY_DEVICEW* display, DISPLAY_DEVICEW* adapter);
     VIDEOMODE* CreateVideoModes(DISPLAY_DEVICEW* adapter);
     void CreateVideoMode(DEVMODE* devmode, VIDEOMODE* mode);
     void FreeDispDevicesInfo();

     DISPLAY* head;
     VIDEOMODE* CurrentMode;
 };

CDispDevice.h

 #include "CDispDevice.h"

 CDispDeviceInfo::CDispDeviceInfo()
 {
     head = nullptr;
     CurrentMode = nullptr;
 }

 CDispDeviceInfo::~CDispDeviceInfo()
 {
     this->FreeDispDevicesInfo();
 }

 bool CDispDeviceInfo::CDispDeviceInfoInit()
 {
     DWORD adapterIndex, displayIndex;
     DISPLAY_DEVICEW adapter, display;

     for (adapterIndex = ; ; adapterIndex++) {

         ZeroMemory(&adapter, sizeof(DISPLAY_DEVICEW));
         adapter.cb = sizeof(DISPLAY_DEVICEW);

         if (!EnumDisplayDevices(NULL, adapterIndex, &adapter, ))
             break;

         // skip unactive adapter
         if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
             continue;

         for (displayIndex = ; ; displayIndex++) {

             ZeroMemory(&display, sizeof(DISPLAY_DEVICEW));
             display.cb = sizeof(DISPLAY_DEVICEW);

             if (!EnumDisplayDevices(adapter.DeviceName, displayIndex, &display, ))
                 break;

             // skip unactive monitor
             if (!(display.StateFlags & DISPLAY_DEVICE_ACTIVE))
                 continue;

             PDISPLAY pDisp = CreateMonitors(&display, &adapter);
             if (head) {
                 pDisp->next = head;
             }
             else
             {
                 head = pDisp;
                 head->next = nullptr;
             }

         }
     }

     return true;
 }

 DISPLAY* CDispDeviceInfo::EnumDisplay(int index)
 {
     PDISPLAY iter = head;

     if (!head)
         return nullptr;

     for (int i = ; i < index; i++) {
         if (!(iter = iter->next))
             return nullptr;
     }

     return iter;
 }

 VIDEOMODE* CDispDeviceInfo::EnumVideoModes(DISPLAY* adapter, int index)
 {
     PVIDEOMODE iter = adapter->pVideoMode;

     if(!adapter->pVideoMode)
         return nullptr;

     for (int i = ; i < index; i++) {
         if (!(iter = iter->next))
             return nullptr;
     }

     return iter;
 }

 void CDispDeviceInfo::SpiltBPP(int bpp, int* red_bits, int* green_bits, int* blue_bits)
 {
     if (bpp >= ) {
         bpp = ;
     }

     *red_bits = *green_bits = *blue_bits = bpp / ;
     int delta = bpp - (*red_bits * );
     if (delta >= ) {
         *green_bits = *green_bits + ;
     }
     if (delta == ) {
         *red_bits = *red_bits + ;
     }
 }

 bool CDispDeviceInfo::CompareVideoMode(VIDEOMODE* src, VIDEOMODE* result)
 {
     if (!(result && src))
     {
         return false;
     }

     int r_bpp = result->red_bits + result->green_bits + result->blue_bits;
     int r_area = result->width * result->height;
     int t_bpp = src->red_bits + src->green_bits + src->blue_bits;
     int t_area = src->width * src->height;

     if (src->refresh_rates == result->refresh_rates && r_bpp == t_bpp && r_area == t_area)
         return true;

     return false;
 }

 DISPLAY* CDispDeviceInfo::CreateMonitors(DISPLAY_DEVICEW* display, DISPLAY_DEVICEW* adapter)
 {
     DEVMODE dm;
     HDC dc;
     DISPLAY* pm;

     pm = (DISPLAY*)calloc(, sizeof(DISPLAY));

     EnumDisplaySettings(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &dm);

     dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL);
     if (!IsWindows8Point1OrGreater()) {
         pm->widthMM = GetDeviceCaps(dc, HORZSIZE);
         pm->heightMM = GetDeviceCaps(dc, VERTSIZE);
     }
     else
     {
         pm->widthMM = (int)(dm.dmPelsWidth * 25.4f / GetDeviceCaps(dc, LOGPIXELSX));
         pm->heightMM = (int)(dm.dmPelsHeight * 25.4f / GetDeviceCaps(dc, LOGPIXELSY));
     }
     DeleteDC(dc);

     wcscpy_s(pm->adapter_name, adapter->DeviceString);
     wcscpy_s(pm->monitor_name, display->DeviceString);

     pm->pVideoMode = this->CreateVideoModes(adapter);

     return pm;
 }

 VIDEOMODE* CDispDeviceInfo::CreateVideoModes(DISPLAY_DEVICEW* adapter)
 {
     DEVMODEW devmode;
     VIDEOMODE Mode, Current, * pMode = NULL;
     bool firstCreate = true;

     ZeroMemory(&devmode, sizeof(devmode));
     devmode.dmSize = sizeof(devmode);
     if(!EnumDisplaySettings(adapter->DeviceName, , &devmode)){
         return false;
     }
     else {
         // Get current mode
         EnumDisplaySettings(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &devmode);
         this->CreateVideoMode(&devmode, &Current);
     }

     for (DWORD modesIndex = ;; modesIndex++) {

         ZeroMemory(&devmode, sizeof(devmode));
         devmode.dmSize = sizeof(devmode);
         if (!EnumDisplaySettings(adapter->DeviceName, modesIndex, &devmode))
             break;

         // skip modes less than 15 BPP
         if (devmode.dmBitsPerPel < )
             continue;

         this->CreateVideoMode(&devmode, &Mode);

         // check duplicated mode
         if (this->CompareVideoMode(&Mode, pMode))
             continue;
         if (!firstCreate) {
             PVIDEOMODE pNextMode = (VIDEOMODE*)calloc(, sizeof(VIDEOMODE));
             memcpy(pNextMode, &Mode, sizeof(Mode));
             pNextMode->next = pMode;
             pMode = pNextMode;

             // store current mode
             if (this->CompareVideoMode(&Mode, &Current)) {
                 this->CurrentMode = pMode;
             }

         }
         else {
             pMode = (VIDEOMODE*)calloc(, sizeof(VIDEOMODE));
             memcpy(pMode, &Mode, sizeof(Mode));
         }

         firstCreate = false;
     }

     return pMode;
 }

 VIDEOMODE* CDispDeviceInfo::GetCurrentMode()
 {
     return CurrentMode;
 }

 void CDispDeviceInfo::CreateVideoMode(DEVMODE* devmode, VIDEOMODE* mode)
 {
     ZeroMemory(mode, sizeof(mode));
     mode->width = devmode->dmPelsWidth;
     mode->height = devmode->dmPelsHeight;
     mode->refresh_rates = devmode->dmDisplayFrequency;
     this->SpiltBPP(devmode->dmBitsPerPel, &mode->red_bits, &mode->green_bits, &mode->blue_bits);
 }

 void CDispDeviceInfo::FreeDispDevicesInfo()
 {
     DISPLAY* dis_tmp;
     VIDEOMODE* vid_tmp;
     dis_tmp = head;

     for (; head;) {
         if (head->pVideoMode) {
             vid_tmp = head->pVideoMode;

             for (; head->pVideoMode;) {
                 head->pVideoMode = head->pVideoMode->next;
                 free(vid_tmp);
                 vid_tmp = head->pVideoMode;
             }

         }

         head = head->next;
         free(dis_tmp);
         dis_tmp = head;
     }
 }

CDispDevice.cpp

 #include "CDispDevice.h"

 int main(int argc, char** argv)
 {
     DISPLAY* disp;
     VIDEOMODE* vidmodes;
     CDispDeviceInfo info;
     info.CDispDeviceInfoInit();

     vidmodes = info.GetCurrentMode();
     printf("Current Mode: %d x %d (%d %d %d) %dHz\n", vidmodes->width, vidmodes->height,
         vidmodes->red_bits, vidmodes->green_bits, vidmodes->blue_bits, vidmodes->refresh_rates);

     for (int i = ; disp = info.EnumDisplay(i);i++) {
         wprintf(TEXT("Adapter Name: %s\n"), disp->adapter_name);
         wprintf(TEXT("Monitor Name: %s\n"), disp->monitor_name);
         printf("Monitor properties: Width: %dmm Height: %dmm\n", disp->widthMM, disp->heightMM);
         printf("Display Modes : \n");
         for (int k = ; vidmodes = info.EnumVideoModes(disp, k); k++) {
             printf("%d:%d x %d (%d %d %d) %dHz\n",k , vidmodes->width, vidmodes->height,
                 vidmodes->red_bits, vidmodes->green_bits, vidmodes->blue_bits, vidmodes->refresh_rates);
         }
     }
     return ;
 }

main.cpp

运行环境： Visual Studio 2019