/**
* Copyright 2015 JogAmp Community. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are
* permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
* of conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* The views and conclusions contained in the software and documentation are those of the
* authors and should not be interpreted as representing official policies, either expressed
* or implied, of JogAmp Community.
*
***
*
* This code is inspired by Ofek Shilon's code and blog post:
*
* See: function 'NewtEDID_GetMonitorSizeFromEDIDByModelName'
*
* In contrast to Ofek's code, function 'NewtEDID_GetMonitorSizeFromEDIDByDevice'
* uses the proper link from
* DISPLAY_DEVICE.DeviceID -> SP_DEVICE_INTERFACE_DETAIL_DATA.DevicePath,
* where DISPLAY_DEVICE.DeviceID is the monitor's enumeration via:
* EnumDisplayDevices(adapterName, monitor_idx, &ddMon, EDD_GET_DEVICE_INTERFACE_NAME);
* Hence the path to the registry-entry is well determined instead of just comparing
* the monitor's model name.
*
*/
#include
#include
#include
#include
#include
#include
#include
#include // for MAX_DEVICE_ID_LEN
#include "WindowsEDID.h"
// #define VERBOSE_ON 1
#ifdef VERBOSE_ON
#define DBG_PRINT(x, ...) _ftprintf(stderr, __T(x), ##__VA_ARGS__); fflush(stderr)
#else
#define DBG_PRINT(...)
#endif
#define NAME_SIZE 128
/* GetProcAddress doesn't exist in A/W variants under desktop Windows */
#ifndef UNDER_CE
#define GetProcAddressA GetProcAddress
#endif
#ifndef EDD_GET_DEVICE_INTERFACE_NAME
#define EDD_GET_DEVICE_INTERFACE_NAME 0x00000001
#endif
static const GUID GUID_CLASS_MONITOR = { 0x4d36e96e, 0xe325, 0x11ce, 0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18 };
static const GUID GUID_DEVINTERFACE_MONITOR = { 0xe6f07b5f, 0xee97, 0x4a90, 0xb0, 0x76, 0x33, 0xf5, 0x7b, 0xf4, 0xea, 0xa7 };
#ifdef _UNICODE
typedef HDEVINFO (WINAPI *SetupDiGetClassDevsPROCADDR)(CONST GUID *ClassGuid,PCWSTR Enumerator,HWND hwndParent,DWORD Flags);
typedef WINBOOL (WINAPI *SetupDiGetDeviceInstanceIdPROCADDR)(HDEVINFO DeviceInfoSet,PSP_DEVINFO_DATA DeviceInfoData,PCWSTR DeviceInstanceId,DWORD DeviceInstanceIdSize,PDWORD RequiredSize);
typedef WINBOOL (WINAPI *SetupDiGetDeviceInterfaceDetailPROCADDR)(HDEVINFO DeviceInfoSet,PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,PSP_DEVICE_INTERFACE_DETAIL_DATA_W DeviceInterfaceDetailData,DWORD DeviceInterfaceDetailDataSize,PDWORD RequiredSize,PSP_DEVINFO_DATA DeviceInfoData);
#else
typedef HDEVINFO (WINAPI *SetupDiGetClassDevsPROCADDR)(CONST GUID *ClassGuid,PCSTR Enumerator,HWND hwndParent,DWORD Flags);
typedef WINBOOL (WINAPI *SetupDiGetDeviceInstanceIdPROCADDR)(HDEVINFO DeviceInfoSet,PSP_DEVINFO_DATA DeviceInfoData,PSTR DeviceInstanceId,DWORD DeviceInstanceIdSize,PDWORD RequiredSize);
typedef WINBOOL (WINAPI *SetupDiGetDeviceInterfaceDetailPROCADDR)(HDEVINFO DeviceInfoSet,PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData,PSP_DEVICE_INTERFACE_DETAIL_DATA_A DeviceInterfaceDetailData,DWORD DeviceInterfaceDetailDataSize,PDWORD RequiredSize,PSP_DEVINFO_DATA DeviceInfoData);
#endif
typedef WINBOOL (WINAPI *SetupDiEnumDeviceInfoPROCADDR)(HDEVINFO DeviceInfoSet,DWORD MemberIndex,PSP_DEVINFO_DATA DeviceInfoData);
typedef WINBOOL (WINAPI *SetupDiEnumDeviceInterfacesPROCADDR)(HDEVINFO DeviceInfoSet,PSP_DEVINFO_DATA DeviceInfoData,CONST GUID *InterfaceClassGuid,DWORD MemberIndex,PSP_DEVICE_INTERFACE_DATA DeviceInterfaceData);
typedef HKEY (WINAPI *SetupDiOpenDevRegKeyPROCADDR)(HDEVINFO DeviceInfoSet,PSP_DEVINFO_DATA DeviceInfoData,DWORD Scope,DWORD HwProfile,DWORD KeyType,REGSAM samDesired);
typedef WINBOOL (WINAPI *SetupDiDestroyDeviceInfoListPROCADDR)(HDEVINFO DeviceInfoSet);
static int WinSetupAPI_avail = 0;
static SetupDiGetClassDevsPROCADDR WinSetup_SetupDiGetClassDevs = NULL;
static SetupDiGetDeviceInstanceIdPROCADDR WinSetup_SetupDiGetDeviceInstanceId = NULL;
static SetupDiGetDeviceInterfaceDetailPROCADDR WinSetup_SetupDiGetDeviceInterfaceDetail = NULL;
static SetupDiEnumDeviceInfoPROCADDR WinSetup_SetupDiEnumDeviceInfo = NULL;
static SetupDiEnumDeviceInterfacesPROCADDR WinSetup_SetupDiEnumDeviceInterfaces = NULL;
static SetupDiOpenDevRegKeyPROCADDR WinSetup_SetupDiOpenDevRegKey = NULL;
static SetupDiDestroyDeviceInfoListPROCADDR WinSetup_SetupDiDestroyDeviceInfoList = NULL;
static int _init = 0;
int NewtEDID_init() {
if( !_init ) {
WinSetupAPI_avail = 0;
HANDLE setup = LoadLibrary(TEXT("setupapi.dll"));
if( setup ) {
#ifdef _UNICODE
WinSetup_SetupDiGetClassDevs = (SetupDiGetClassDevsPROCADDR) GetProcAddressA(setup, "SetupDiGetClassDevsW");
WinSetup_SetupDiGetDeviceInstanceId = (SetupDiGetDeviceInstanceIdPROCADDR) GetProcAddressA(setup, "SetupDiGetDeviceInstanceIdW");
WinSetup_SetupDiGetDeviceInterfaceDetail = (SetupDiGetDeviceInterfaceDetailPROCADDR) GetProcAddressA(setup, "SetupDiGetDeviceInterfaceDetailW");
#else
WinSetup_SetupDiGetClassDevs = (SetupDiGetClassDevsPROCADDR) GetProcAddressA(setup, "SetupDiGetClassDevsA");
WinSetup_SetupDiGetDeviceInstanceId = (SetupDiGetDeviceInstanceIdPROCADDR) GetProcAddressA(setup, "SetupDiGetDeviceInstanceIdA");
WinSetup_SetupDiGetDeviceInterfaceDetail = (SetupDiGetDeviceInterfaceDetailPROCADDR) GetProcAddressA(setup, "SetupDiGetDeviceInterfaceDetailA");
#endif
WinSetup_SetupDiEnumDeviceInfo = (SetupDiEnumDeviceInfoPROCADDR) GetProcAddressA(setup, "SetupDiEnumDeviceInfo");
WinSetup_SetupDiEnumDeviceInterfaces = (SetupDiEnumDeviceInterfacesPROCADDR) GetProcAddressA(setup, "SetupDiEnumDeviceInterfaces");
WinSetup_SetupDiOpenDevRegKey = (SetupDiOpenDevRegKeyPROCADDR) GetProcAddressA(setup, "SetupDiOpenDevRegKey");
WinSetup_SetupDiDestroyDeviceInfoList = (SetupDiDestroyDeviceInfoListPROCADDR) GetProcAddressA(setup, "SetupDiDestroyDeviceInfoList");
if( NULL != WinSetup_SetupDiGetClassDevs &&
NULL != WinSetup_SetupDiGetDeviceInstanceId &&
NULL != WinSetup_SetupDiGetDeviceInterfaceDetail &&
NULL != WinSetup_SetupDiEnumDeviceInfo &&
NULL != WinSetup_SetupDiEnumDeviceInterfaces &&
NULL != WinSetup_SetupDiOpenDevRegKey &&
NULL != WinSetup_SetupDiDestroyDeviceInfoList ) {
WinSetupAPI_avail = 1;
}
}
_init = 1;
}
return WinSetupAPI_avail;
}
static _TCHAR* Get2ndSlashBlock(const _TCHAR* sIn, _TCHAR* sOut, size_t sOutLen)
{
_TCHAR* s = _tcschr(sIn, '\\');
if( NULL != s ) {
s += 1; // skip '\\'
_TCHAR* t = _tcschr(s, '\\');
if( NULL != t ) {
size_t len = t - s;
if( len > 0 ) {
if( sOutLen >= len ) {
// Bug 1196: Unresolved strncpy_s (MSVCRT) on WinXP.
// Mapped: _tcsncpy_s -> strncpy_s (!UNICODE).
// On WinXP MSVCRT has no strncpy_s.
// _tcsncpy_s(sOut, sOutLen, s, len);
if( len <= sOutLen-1 ) {
_tcsncpy(sOut, s, len);
return sOut;
}
}
}
}
}
return NULL;
}
static int GetMonitorSizeFromEDIDByRegKey(const HKEY hEDIDRegKey, int* widthMm, int* heightMm, int *widthCm, int *heightCm)
{
DWORD dwType, actualValueNameLength = NAME_SIZE;
_TCHAR valueName[NAME_SIZE];
BYTE edidData[1024];
DWORD edidSize = sizeof(edidData);
*widthMm = -1;
*heightMm = -1;
*widthCm = -1;
*heightCm = -1;
LONG retValue;
DWORD i;
for (i = 0, retValue = ERROR_SUCCESS; retValue != ERROR_NO_MORE_ITEMS; i++) {
retValue = RegEnumValue(hEDIDRegKey, i, &valueName[0],
&actualValueNameLength, NULL, &dwType,
edidData, // buffer
&edidSize); // buffer size
if ( retValue == ERROR_SUCCESS && edidSize >= 23 &&
0 == _tcscmp(valueName, _T("EDID")) )
{
DBG_PRINT("*** EDID Version %d.%d, data-size %d\n", (int)edidData[18], (int)edidData[19], edidSize);
if( edidSize >= 69 ) {
// 54 + 12 = 66: Horizontal display size, mm, 8 lsbits (0–4095 mm, 161 in)
// 54 + 13 = 67: Vertical display size, mm, 8 lsbits (0–4095 mm, 161 in)
// 54 + 14 = 68:
// Bits 7–4 Horizontal display size, mm, 4 msbits
// Bits 3–0 Vertical display size, mm, 4 msbits
*widthMm = ( (int)(edidData[68] & 0xF0) << 4 ) | (int)edidData[66];
*heightMm = ( (int)(edidData[68] & 0x0F) << 8 ) | (int)edidData[67];
}
*widthCm = (int) edidData[21];
*heightCm = (int) edidData[22];
return 1; // valid EDID found
}
}
return 0; // EDID not found
}
int NewtEDID_GetMonitorSizeFromEDIDByModelName(const DISPLAY_DEVICE* ddMon, int* widthMm, int* heightMm, int *widthCm, int *heightCm)
{
_TCHAR useDevModelNameStore[MAX_DEVICE_ID_LEN];
_TCHAR *useDevModelName = Get2ndSlashBlock(ddMon->DeviceID, useDevModelNameStore, MAX_DEVICE_ID_LEN);
if( NULL == useDevModelName ) {
return 0;
}
HDEVINFO devInfo = WinSetup_SetupDiGetClassDevs(
&GUID_CLASS_MONITOR, //class GUID
NULL, //enumerator
NULL, //HWND
DIGCF_PRESENT | DIGCF_PROFILE); // Flags //DIGCF_ALLCLASSES|
if (NULL == devInfo) {
return 0;
}
int bRes = 0;
DWORD i;
DWORD lastError = ERROR_SUCCESS;
for (i = 0; !bRes && ERROR_SUCCESS == lastError; i++) {
SP_DEVINFO_DATA devInfoData;
memset(&devInfoData, 0, sizeof(devInfoData));
devInfoData.cbSize = sizeof(devInfoData);
if (WinSetup_SetupDiEnumDeviceInfo(devInfo, i, &devInfoData)) {
_TCHAR devModelName[MAX_DEVICE_ID_LEN];
WinSetup_SetupDiGetDeviceInstanceId(devInfo, &devInfoData, devModelName, MAX_PATH, NULL);
if( NULL != _tcsstr(devModelName, useDevModelName) ) {
HKEY hEDIDRegKey = WinSetup_SetupDiOpenDevRegKey(devInfo, &devInfoData,
DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
if ( 0 != hEDIDRegKey && hEDIDRegKey != INVALID_HANDLE_VALUE ) {
bRes = GetMonitorSizeFromEDIDByRegKey(hEDIDRegKey, widthMm, heightMm, widthCm, heightCm);
RegCloseKey(hEDIDRegKey);
}
}
}
lastError = GetLastError();
}
WinSetup_SetupDiDestroyDeviceInfoList(devInfo);
return bRes;
}
int NewtEDID_GetMonitorSizeFromEDIDByDevice(const DISPLAY_DEVICE* ddMon, int* widthMm, int* heightMm, int *widthCm, int *heightCm)
{
HDEVINFO devInfo = WinSetup_SetupDiGetClassDevs(
&GUID_DEVINTERFACE_MONITOR,
NULL, //enumerator
NULL, //HWND
DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); // Flags //DIGCF_ALLCLASSES|
if (NULL == devInfo) {
return 0;
}
DWORD devIfaceDetailDataSize = offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA, DevicePath) + MAX_PATH * sizeof(TCHAR);
PSP_DEVICE_INTERFACE_DETAIL_DATA pDevIfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) malloc(devIfaceDetailDataSize);
int bRes = 0;
DWORD i;
DWORD lastError = ERROR_SUCCESS;
for (i = 0; !bRes && ERROR_SUCCESS == lastError; i++) {
SP_DEVICE_INTERFACE_DATA devIfaceData;
memset(&devIfaceData, 0, sizeof(devIfaceData));
devIfaceData.cbSize = sizeof(devIfaceData);
if ( WinSetup_SetupDiEnumDeviceInterfaces(devInfo, NULL, &GUID_DEVINTERFACE_MONITOR, i, &devIfaceData) ) {
memset(pDevIfaceDetailData, 0, devIfaceDetailDataSize);
pDevIfaceDetailData->cbSize = sizeof(*pDevIfaceDetailData);
DWORD devIfaceDetailDataReqSize = 0;
SP_DEVINFO_DATA devInfoData2;
memset(&devInfoData2, 0, sizeof(devInfoData2));
devInfoData2.cbSize = sizeof(devInfoData2);
if( WinSetup_SetupDiGetDeviceInterfaceDetail(devInfo, &devIfaceData, pDevIfaceDetailData, devIfaceDetailDataSize,
&devIfaceDetailDataReqSize, &devInfoData2) ) {
int found = 0 == _tcsicmp(pDevIfaceDetailData->DevicePath, ddMon->DeviceID);
DBG_PRINT("*** Got[%d].2 found %d, devicePath <%s>\n", i, found, pDevIfaceDetailData->DevicePath);
if( found ) {
HKEY hEDIDRegKey = WinSetup_SetupDiOpenDevRegKey(devInfo, &devInfoData2,
DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_READ);
DBG_PRINT("*** Got[%d] hEDIDRegKey %p\n", i, (void*)hEDIDRegKey);
if ( 0 != hEDIDRegKey && hEDIDRegKey != INVALID_HANDLE_VALUE ) {
bRes = GetMonitorSizeFromEDIDByRegKey(hEDIDRegKey, widthMm, heightMm, widthCm, heightCm);
RegCloseKey(hEDIDRegKey);
}
}
} else {
lastError = GetLastError();
DBG_PRINT("*** fail.2 at %d, werr %d\n", i, lastError);
}
} else {
lastError = GetLastError();
DBG_PRINT("*** fail.1 at %d, werr %d\n", i, lastError);
}
}
DBG_PRINT("*** Result: found %d, enum-iter %d, werr %d\n", bRes, i, (int)lastError);
WinSetup_SetupDiDestroyDeviceInfoList(devInfo);
free(pDevIfaceDetailData);
return bRes;
}
int NewtEDID_GetIndexedDisplayDevice(int useDevIdx, int useMonIdx, DISPLAY_DEVICE* ddMonOut, int getDeviceInterfaceName, int verbose)
{
DISPLAY_DEVICE ddAdp;
DWORD devIdx; // device index
DWORD monIdx; // monitor index
memset(&ddAdp, 0, sizeof(ddAdp));
ddAdp.cb = sizeof(ddAdp);
const DWORD dwFlagsMonitor = 0 != getDeviceInterfaceName ? EDD_GET_DEVICE_INTERFACE_NAME : 0;
for(devIdx = 0;
( devIdx <= useDevIdx || 0 > useDevIdx ) && EnumDisplayDevices(0, devIdx, &ddAdp, 0);
devIdx++)
{
if( NULL != ddAdp.DeviceName && 0 != _tcslen(ddAdp.DeviceName) ) {
if( verbose ) {
_ftprintf(stderr, __T("*** [%02d:__]: deviceName <%s> flags 0x%X active %d\n"),
devIdx, ddAdp.DeviceName, ddAdp.StateFlags, ( 0 != ( ddAdp.StateFlags & DISPLAY_DEVICE_ACTIVE ) ) );
_ftprintf(stderr, __T(" deviceString <%s> \n"), ddAdp.DeviceString);
_ftprintf(stderr, __T(" deviceID <%s> \n"), ddAdp.DeviceID);
}
if( devIdx == useDevIdx || 0 > useDevIdx ) {
DISPLAY_DEVICE ddMon;
memset(&ddMon, 0, sizeof(ddMon));
ddMon.cb = sizeof(ddMon);
for(monIdx = 0;
( monIdx <= useMonIdx || 0 > useMonIdx ) && EnumDisplayDevices(ddAdp.DeviceName, monIdx, &ddMon, dwFlagsMonitor);
monIdx++)
{
if( NULL != ddMon.DeviceName && 0 < _tcslen(ddMon.DeviceName) ) {
if( verbose ) {
_ftprintf(stderr, __T("*** [%02d:%02d]: deviceName <%s> flags 0x%X active %d\n"),
devIdx, monIdx, ddMon.DeviceName, ddMon.StateFlags, ( 0 != ( ddMon.StateFlags & DISPLAY_DEVICE_ACTIVE ) ) );
_ftprintf(stderr, __T(" deviceString <%s> \n"), ddMon.DeviceString);
_ftprintf(stderr, __T(" deviceID <%s> \n"), ddMon.DeviceID);
}
if( monIdx == useMonIdx ) {
*ddMonOut = ddMon;
return 1;
}
}
memset(&ddMon, 0, sizeof(ddMon));
ddMon.cb = sizeof(ddMon);
}
}
}
memset(&ddAdp, 0, sizeof(ddAdp));
ddAdp.cb = sizeof(ddAdp);
}
memset(ddMonOut, 0, sizeof(*ddMonOut));
ddMonOut->cb = sizeof(*ddMonOut);
return 0;
}
#ifdef WINDOWS_EDID_WITH_MAIN
int _tmain(int argc, _TCHAR* argv [])
{
#ifdef _UNICODE
_ftprintf(stderr, __T("_UNICODE enabled\n"));
#else
fprintf(stderr, "_UNICODE disabled\n");
#endif
if( !NewtEDID_init() ) {
_ftprintf(stderr, __T("setupapi not available\n"));
return 1;
}
DISPLAY_DEVICE ddMon;
if( 3 != argc ) {
NewtEDID_GetIndexedDisplayDevice(-1, -1, &ddMon, 0 /* getDeviceInterfaceName */, 1 /* verbose */);
_ftprintf(stderr, __T("Usage: %s dev-idx mon-idx\n"), argv[0]);
return 1;
}
int useDevIdx = _tstoi(argv[1]);
int useMonIdx = _tstoi(argv[2]);
int widthMm, heightMm;
int widthCm, heightCm;
//
// Proper method
//
if( 0 == NewtEDID_GetIndexedDisplayDevice(useDevIdx, useMonIdx, &ddMon, 1 /* getDeviceInterfaceName */, 0 /* verbose */) ) {
_ftprintf(stderr, __T("No monitor found at dev %d : mon %d\n"), useDevIdx, useMonIdx);
return 1;
}
_ftprintf(stderr, __T("Found monitor at dev %d : mon %d:\n"), useDevIdx, useMonIdx);
_ftprintf(stderr, __T(" Device Name : %s\n"), ddMon.DeviceName);
_ftprintf(stderr, __T(" Device String: %s\n"), ddMon.DeviceString);
_ftprintf(stderr, __T(" Device ID : %s\n"), ddMon.DeviceID);
fflush(NULL);
if( NewtEDID_GetMonitorSizeFromEDIDByDevice(&ddMon, &widthMm, &heightMm, &widthCm, &heightCm) ) {
_ftprintf(stderr, __T("Proper: Found EDID size [%d, %d] [mm], [%d, %d] [cm]\n"), widthMm, heightMm, widthCm, heightCm);
}
//
// Monitor model name method
//
if( 0 == NewtEDID_GetIndexedDisplayDevice(useDevIdx, useMonIdx, &ddMon, 0 /* getDeviceInterfaceName */, 0 /* verbose */) ) {
_ftprintf(stderr, __T("No monitor found at dev %d : mon %d\n"), useDevIdx, useMonIdx);
return 1;
}
_ftprintf(stderr, __T("Found monitor at dev %d : mon %d:\n"), useDevIdx, useMonIdx);
_ftprintf(stderr, __T(" Device Name : %s\n"), ddMon.DeviceName);
_ftprintf(stderr, __T(" Device String: %s\n"), ddMon.DeviceString);
_ftprintf(stderr, __T(" Device ID : %s\n"), ddMon.DeviceID);
fflush(NULL);
if( NewtEDID_GetMonitorSizeFromEDIDByModelName(&ddMon, &widthMm, &heightMm, &widthCm, &heightCm) ) {
_ftprintf(stderr, __T("ModelN: Found EDID size [%d, %d] [mm], [%d, %d] [cm]\n"), widthMm, heightMm, widthCm, heightCm);
}
return 0;
}
#endif /* WINDOWS_EDID_WITH_MAIN */