Understanding Edid: Extracting Monitor Information

Extended Display Identification Data (EDID) is a useful tool for configuring display settings. EDID records are stored on your computer and contain essential information about your monitor, such as the manufacture date, model, and supported display modes. There are several ways to find your monitor's EDID, depending on your operating system and graphics card. For example, on Quadro or NVS Boards, you can access the EDID management system through the NVIDIA Control Panel by selecting View System Topology. On GeForce Boards, you can use third-party utilities such as Entech's Monitor Asset Manager to capture your monitor's EDID. For Ubuntu users, the get-edid tool can be used to retrieve and interpret monitor specifications.

Using the VCP command 78h

One user suggests that Windows does have the functionality to read the EDID data, but it is not exposed. The method to read EDID is private to the display/monitor driver, and other drivers are not allowed to interface with it.

Using the Windows API

The Windows API does not expose a direct method to retrieve a monitor's EDID data. However, there are a few workarounds and alternative approaches you can consider:

Using SetupAPI:

The SetupAPI can be used to enumerate monitors and retrieve their information. Here's an example code snippet in C# that demonstrates this approach:

Csharp

Guid MonitorGUID = new Guid(Win32.GUID_DEVINTERFACE_MONITOR);

IntPtr h = Win32.SetupDiGetClassDevs(ref MonitorGUID, IntPtr.Zero, IntPtr.Zero, (uint)(Win32.DIGCF_PRESENT | Win32.DIGCF_DEVICEINTERFACE);

If (h.ToInt64() != Win32.INVALID_HANDLE_VALUE)

{

Bool Success = true; uint i = 0; while (Success)

{

Win32.SP_DEVICE_INTERFACE_DATA dia = new Win32.SP_DEVICE_INTERFACE_DATA();

Dia.cbSize = (uint)Marshal.SizeOf(dia);

Success = Win32.SetupDiEnumDeviceInterfaces(h, IntPtr.Zero, ref MonitorGUID, i, ref dia);

If (Success)

{

Win32.SP_DEVINFO_DATA da = new Win32.SP_DEVINFO_DATA();

Da.cbSize = (uint)Marshal.SizeOf(da);

Win32.SP_DEVICE_INTERFACE_DETAIL_DATA didd = new Win32.SP_DEVICE_INTERFACE_DETAIL_DATA();

Didd.cbSize = (uint)(4 + Marshal.SystemDefaultCharSize);

Uint nRequiredSize = 0; uint nBytes = Win32.BUFFER_SIZE;

If (Win32.SetupDiGetDeviceInterfaceDetail(h, ref dia, ref didd, nBytes, out nRequiredSize, ref da)

{

IntPtr ptrInstanceBuf = Marshal.AllocHGlobal((int)nBytes);

Win32.CM_Get_Device_ID(da.DevInst, ptrInstanceBuf, (int)nBytes, 0);

String InstanceID = Marshal.PtrToStringAuto(ptrInstanceBuf);

Console.WriteLine("InstanceID: {0}", InstanceID);

Console.WriteLine("DevicePath: {0}", didd.DevicePath);

}

I++;

}

}

}

Using Registry:

The EDID data is stored in the registry folder `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\DISPLAY\Type}\SWnummer}\Device Parameters`. However, it is recommended to use the SetupAPI to retrieve the HKEY to this path instead of constructing it manually. Here's an example code snippet:

Csharp

SetupDiGetClassDevices(GUID_DEVINTERFACE_MONITOR)

SetupDiEnumDeviceInterfaces

SetupDiOpenDevRegKey

Using DisplayConfig APIs:

The DisplayConfig APIs can be used to retrieve information about the display configuration and the connected monitors. Here's an example code snippet in C++ that demonstrates how to use these APIs:

Cpp

#include Windows.h

#include SetupApi.h

#include cfgmgr32.h // MAX_DEVICE_ID_LEN

#pragma comment(lib, "setupapi.lib")

// Helper function that finds the monitor sizes in millimeters using the SetupAPI and the EDID data in the registry.

PhyMonitorSizes findMonitorSizesFromEDID()

{

PhyMonitorSizes screenSizes;

Const GUID GUID_DEVINTERFACE_MONITOR = { 0xe6f07b5f, 0xee97, 0x4a90, 0xb0, 0x76, 0x33, 0xf5, 0x7b, 0xf4, 0xea, 0xa7 };

Const HDEVINFO hDevInfo = SetupDiGetClassDevs(&GUID_DEVINTERFACE_MONITOR, NULL, NULL, DIGCF_DEVICEINTERFACE);

# Code snippet for retrieving monitor sizes using SetupAPI and EDID data

# ...

}

// Helper function that creates a mapping between device names and ids.

DevNameToDevId getDeviceNamesToIdMap()

{

DevNameToDevId namesToIdMap;

# Code snippet for retrieving display paths and mapping device names to ids

# ...

}

// Helper function for a case-insensitive string comparison.

Bool caseInsensitiveComparison(const std::wstring& Str1, const std::wstring& Str2)

{

# Code snippet for performing case-insensitive string comparison

# ...

}

The actual function that takes the HMONITOR as input and has the screen size as output.

Std::pair getMonitorSizeInMillimeter(HMONITOR hMonitor)

{

Const PhyMonitorSizes& sizesById = findMonitorSizesFromEDID();

Const DevNameToDevId& deviceIdsByName = getDeviceNamesToIdMap();

# Code snippet for retrieving device name from HMONITOR and finding the corresponding device id

# ...

}

Using EnumDisplayDevices API:

The EnumDisplayDevices API can be used to retrieve information about the display devices and their settings. Here's an example code snippet in C# that demonstrates how to use this API:

Csharp

Using System;

Using System.Runtime.InteropServices;

Using System.Collections.Generic;

Using System.Text.RegularExpressions;

Namespace Resolution

{

[StructLayout(LayoutKind.Sequential)]

Public struct DEVMODE1

{

# ...

};

[Flags()]

Public enum DisplayDeviceStateFlags : int

{

AttachedToDesktop = 0x1, MultiDriver = 0x2,

# ...

}

[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi)]

Public struct DISPLAY_DEVICE

{

# ...

}

Class User32

{

[DllImport("user32.dll")] public static extern int EnumDisplaySettings(string deviceName, int modeNum, ref DEVMODE1 devMode);

# ...

}

Public class Displays

{

Public static IList GetDisplayNames()

{

Var returnVals = new List();

For(var x=0U; x<1024; ++x)

{

DISPLAY_DEVICE outVar = new DISPLAY_DEVICE();

OutVar.cb = (short)Marshal.SizeOf(outVar);

If(User_32.EnumDisplayDevices(null, x, ref outVar, 1U)

{

# Code snippet for filtering and adding display names to the list

# ...

}

}

Return returnVals;

}

# ...

}

Using the I2C bus

The I²C bus is built into all standard monitor cables and is used by display adapters to communicate with child devices, such as a monitor. The I²C bus has only two wires: the serial clock line and the serial data line. Data is read from and written to these lines one bit at a time.

To read the EDID data of a monitor via the I²C bus, you can use a tool such as read-edid (Linux and DOS), PowerStrip (Windows), or the X.Org Server (Linux and BSD Unix). On most Linux systems, simply running the command "read-edid" or "get-edid" will display the EDID information of the connected monitor.

For VGA monitors, you can use a tool like a BusPirate or a PocketBeagle to read the EDID data via the I²C bus. You can also use a Raspberry Pi, but note that its peripheral support for I²C has been reported to be subpar.

> $ edid-decode < /sys/devices/pci0000:00/0000:00:03.0/0000:0f:00.0/drm/card0/card0-HDMI-A-1/edid

Serial number: 00 b3 00 37 00 00 00 00 01 19

[followed by more data and the decoded output] ...

Additionally, you can use software like Extron EDID Manager to read and troubleshoot EDID communication issues between the display device and the source.

Using the CapabilitiesRequestAndCapabilitiesReply function

The CapabilitiesRequestAndCapabilitiesReply function can be used to retrieve a string describing a monitor's capabilities. This function works using the VESA Monitor Control Command Set (MCCS) standard over an I2C interface.

To use this function, you need to include the header file in your code. Here's an example code snippet that demonstrates how to use the CapabilitiesRequestAndCapabilitiesReply function:

Cpp

#include

DWORD cchStringLength = 0;

BOOL bSuccess = 0;

LPSTR szCapabilitiesString = NULL;

// Get the length of the capabilities string

BSuccess = GetCapabilitiesStringLength(hPhysicalMonitor, &cchStringLength);

If (bSuccess) {

// Allocate memory for the capabilities string buffer

SzCapabilitiesString = (LPSTR)malloc(cchStringLength);

If (szCapabilitiesString != NULL) {

// Get the monitor's capabilities string

BSuccess = CapabilitiesRequestAndCapabilitiesReply(hPhysicalMonitor, szCapabilitiesString, cchStringLength);

// Process the capabilities string or use it as needed

// Free the allocated memory

Free(szCapabilitiesString);

}

}

In this code, hPhysicalMonitor is the handle to the physical monitor for which you want to retrieve the capabilities string. You can obtain this handle by calling functions such as GetPhysicalMonitorsFromHMONITOR or GetPhysicalMonitorsFromIDirect3DDevice9.

The CapabilitiesRequestAndCapabilitiesReply function takes three parameters:

• HMonitor [in]: The handle to the physical monitor.
• PszASCIICapabilitiesString [out]: A pointer to a buffer that will receive the monitor's capabilities string. You must allocate this buffer before calling the function.
• DwCapabilitiesStringLengthInCharacters [in]: The size of the pszASCIICapabilitiesString buffer in characters, including the terminating null character.

The function returns TRUE if it succeeds and FALSE if it fails. You can call the GetLastError function to retrieve extended error information in case of failure.

It is important to note that not all monitors fully implement the VESA MCCS standard. Therefore, using the CapabilitiesRequestAndCapabilitiesReply function on arbitrary monitors may result in undefined behaviour. It is recommended to physically validate the behaviour of the monitor before using these functions.

Using third-party utilities

There are several third-party utilities available that can read the EDID of your display and allow you to export the data to a file.

Monitor Asset Manager by EnTech Taiwan is a monitor information utility that queries the monitor directly and is useful for troubleshooting potential EDID and video card incompatibilities. It supports all 32-bit and 64-bit versions of Windows and is fully multi-monitor-capable. It provides detailed information on monitor colour and timing characteristics, including DPM and GTF/CVT support, colour chromaticity values, native and recommended resolutions, and device minimum requirements and maximum limits.

MonitorInfoView by Nir Sofer is another small utility that displays essential information about your monitor, such as manufacture week/year, monitor manufacturer, monitor model, and supported display modes. It works on Windows 11/10/8/7/Vista/XP, but not on Windows 98/ME.

DumpEDID is another small utility by Nir Sofer that extracts and analyses EDID records from your computer and displays them in the console window. It works on Windows 2000/XP/2003/Vista/7/8, but not on Windows 98/ME.

For Linux users, there are several options available, including monitor-edid, ddccontrol, xrandr, and edid-decode.

Frequently asked questions