drmdevice.cpp

// SPDX-License-Identifier: AGPL-3.0-or-later

/**
 * @file drmdevice.cpp
 * DRM Device
 *
 * This file defines cDrmDevice, which keeps some functions
 * to interact with the DRM (display) system.
 *
 * @copyright 2018 by zille.  All Rights Reserved.
 * @copyright 2025 - 2026 by Andreas Baierl. All Rights Reserved.
 *
 * @license{AGPL-3.0-or-later}
 */

#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <cinttypes>
#include <string>
#include <vector>

#include <fcntl.h>
#include <unistd.h>

#ifdef USE_GLES
#include <assert.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#endif

#include <drm_fourcc.h>
#include <xf86drm.h>
#include <xf86drmMode.h>

#include "config.h"
#include "drmplane.h"
#include "drmdevice.h"
#include "logger.h"
#include "videorender.h"

/**
 * Create a drm device
 *
 * @param render         pointer to cVideoRender object
 * @param config         pointer to current plugin configuration
 */
cDrmDevice::cDrmDevice(cVideoRender *render, cDeviceConfig *config)
	: m_pRender(render),
	  m_pConfig(config),
	  m_userDrmDevice(m_pConfig->ConfigDrmDevice),
	  m_userDrmConnector(m_pConfig->ConfigDrmConnector)
{
	sDrmMode *drmMode = nullptr;
	if (m_pConfig->RequestedDrmMode.width > 0)
		drmMode = &m_pConfig->RequestedDrmMode;
	else if (m_pConfig->UserSetDrmMode.width > 0)
		drmMode = &m_pConfig->UserSetDrmMode;

	if (drmMode) {
		m_userReqDisplayWidth = drmMode->width;
		m_userReqDisplayHeight = drmMode->height;
		m_userReqDisplayRefreshRate = drmMode->refreshRateHz;
		m_userReqDisplayInterlaced = drmMode->interlaced;
		LOGDEBUG("%s requested display mode: %dx%d@%.2f%s", __FUNCTION__,
			m_userReqDisplayWidth, m_userReqDisplayHeight, m_userReqDisplayRefreshRate, m_userReqDisplayInterlaced ? "i" : "");
	}

	if (m_pConfig->ConfigOsdResolution)
		sscanf(m_pConfig->ConfigOsdResolution, "%dx%d", &m_userReqOsdWidth, &m_userReqOsdHeight);
}

cDrmDevice::~cDrmDevice(void)
{
	LOGDEBUG2(L_DRM, "drmdevice: %s", __FUNCTION__);
}

/**
 * Get the drm resources of a device
 *
 * @param fd               drm file descriptor
 * @param[out] resources   drm resources
 *
 * @retval 0               on success
 * @retval -1              on error
 *
 * @ingroup drm
 */
static int get_resources(int fd, drmModeRes **resources)
{
	*resources = drmModeGetResources(fd);
	if (*resources == NULL) {
		LOGERROR("drmdevice: %s: cannot retrieve DRM resources (%d): %m", __FUNCTION__, errno);
		return -1;
	}
	return 0;
}

/**
 * Test drm capabilities
 *
 * @retval 0   if all needed caps match
 * @retval 1   on mismatch
 */
static int TestCaps(int fd)
{
	uint64_t test;

	if (drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &test) < 0 || test == 0)
		return 1;

	if (drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1) != 0)
		return 1;

	if (drmSetClientCap(fd, DRM_CLIENT_CAP_ATOMIC, 1) != 0)
		return 1;

	if (drmGetCap(fd, DRM_CAP_PRIME, &test) < 0)
		return 1;

	if (drmGetCap(fd, DRM_PRIME_CAP_EXPORT, &test) < 0)
		return 1;

	if (drmGetCap(fd, DRM_PRIME_CAP_IMPORT, &test) < 0)
		return 1;

	return 0;
}

/**
 * Open the given device
 *
 * @param device            name of the device (e.g. "/dev/dri/card0")
 * @param[out] resources    drm resources of the device
 *
 * @retval file handle      on success
 * @retval -1               if open failed
 *
 * @ingroup drm
 */
static int OpenDrmDevice(const char* device, drmModeRes **resources)
{
	int fd = -1;

	if ((fd = open(device, O_RDWR)) < 0)
		return -1;

	if (TestCaps(fd) || get_resources(fd, resources)) {
		close(fd);
		return -1;
	}

	return fd;
}

/**
 * Find and open a suitable device with the wanted capabilities
 *
 * @return          the file descriptor of the opened device
 *
 * @ingroup drm
 */
static int FindDrmDevice(drmModeRes **resources)
{
	constexpr int MAX_DRM_DEVICES = 64;

	drmDevicePtr devices[MAX_DRM_DEVICES] = { NULL };
	int num_devices, fd = -1;

	num_devices = drmGetDevices2(0, devices, MAX_DRM_DEVICES);
	if (num_devices < 0) {
		LOGERROR("drmdevice: %s: drmGetDevices2 failed: %s", __FUNCTION__, strerror(-num_devices));
		return fd;
	}

	for (int i = 0; i < num_devices && fd < 0; i++) {
		drmDevicePtr device = devices[i];
		int ret;

		if (!(device->available_nodes & (1 << DRM_NODE_PRIMARY)))
			continue;
		fd = open(device->nodes[DRM_NODE_PRIMARY], O_RDWR);
		if (fd < 0)
			continue;

		if (TestCaps(fd)) {
			close(fd);
			fd = -1;
			continue;
		}

		ret = get_resources(fd, resources);
		if (!ret)
			break;
		close(fd);
		fd = -1;
	}
	drmFreeDevices(devices, num_devices);

	if (fd < 0)
		LOGERROR("drmdevice: %s: no drm device found!", __FUNCTION__);

	return fd;
}

/**
 * Returns the connector type name if available
 */
static std::string ConnectorName(drmModeConnector *connector)
{
	const char *typeName = drmModeGetConnectorTypeName(connector->connector_type);

	return (typeName ? typeName : std::string("Unknown")) + "-" + std::to_string(connector->connector_type_id);
}

/**
 * Find a suitable connector, preferably a connected one
 *
 * Connector selection priority:
 * 1) Try user requested connector (-x HDMI-A-1)
 * 2) Try suitable connected connector
 * 3) Try suitable unconnected connector
 *
 * @ingroup drm
 */
drmModeConnector *cDrmDevice::FindDrmConnector(int fd, drmModeRes *resources, const char *userRequestedConnector)
{
	drmModeConnector *connector = NULL;
	int i;

	// search for the user requested connector (can be unconnected)
	for (i = 0; i < resources->count_connectors && userRequestedConnector; i++) {
		connector = drmModeGetConnector(fd, resources->connectors[i]);
		if (connector && connector->count_modes > 0) {
			if (ConnectorName(connector) == userRequestedConnector)
				return connector;
		}
		drmModeFreeConnector(connector);
		connector = NULL;
	}

	if (userRequestedConnector)
		LOGWARNING("drmdevice: %s: cannot open user requested DRM connector %s, try others", __FUNCTION__, userRequestedConnector);

	// search for a connected connector
	for (i = 0; i < resources->count_connectors; i++) {
		connector = drmModeGetConnector(fd, resources->connectors[i]);
		if (connector && connector->connection == DRM_MODE_CONNECTED && connector->count_modes > 0)
			return connector;
		drmModeFreeConnector(connector);
		connector = NULL;
	}

	// search for an unconnected connector, but with available modes
	// this is a workaround for RPI: in case we don't have a monitor connected
	// we can load an edid file at boot time, where the available modes are listed.
	// To bring drmdevice up, we also have to go through the not connected connectors
	for (i = 0; i < resources->count_connectors; i++) {
		connector = drmModeGetConnector(fd, resources->connectors[i]);
		if (connector && connector->count_modes > 0)
			return connector;
		drmModeFreeConnector(connector);
		connector = NULL;
	}

	// we couldn't find a connector
	return connector;
}

/**
 * Calculate the refresh rate of the given mode to get the precise value and
 * don't use m_drmModeInfo.vrefresh.
 *
 * @param modeInfo         drm mode info
 */
static double GetRefreshRateHz(drmModeModeInfo *modeInfo)
{
	return (double)modeInfo->clock * 1000.0 / ((double)modeInfo->htotal * (double)modeInfo->vtotal);
}

/**
 * Returns true, if the interlaced flag of the mode is set
 */
static inline bool InterlacedMode(uint32_t flags)
{
	return (flags & DRM_MODE_FLAG_INTERLACE) != 0;
}

/**
 * Return true, if both values are equivalent within a tolerance
 */
static inline bool AlmostEqual(double a, double b)
{
	return std::abs(a - b) < 0.001;
}

/**
 * Test, if the given mode is included in the given array
 *
 * Only width, height, refresh rate and the interlaced flag is tested.
 * Other flags and values are ignored.
 *
 * @param mode           mode info of the mode
 * @param modes          mode array to search in
 *
 * @retval true  if the mode is included
 * @retval false if the mode is not included
 *
 * @ingroup drm
 */
static bool Contains(drmModeModeInfo *mode, const std::vector<sDrmMode> &modes)
{
	for (size_t i = 0; i < modes.size(); i++) {
		bool interlaced = InterlacedMode(mode->flags);

		if (mode->hdisplay != modes[i].width ||
		    mode->vdisplay != modes[i].height ||
		    !AlmostEqual(GetRefreshRateHz(mode), modes[i].refreshRateHz) ||
		    interlaced != modes[i].interlaced) {

			continue;
		}

		return true;
	}

	return false;
}

/**
 * Return true, if the given mode is one of the collected ones
 */
bool cDrmDevice::CanHandleMode(sDrmMode *mode)
{
	std::vector<sDrmMode> modes = m_pConfig->CollectedDrmModes;

	// sometimes the stream has no framerate, use 50.00 as default
	double refreshRateHz = mode->refreshRateHz ? mode->refreshRateHz : 50.00;
	if (!mode->refreshRateHz && mode->interlaced)
		refreshRateHz /= 2;

	for (size_t i = 0; i < modes.size(); i++) {
		if (mode->width != modes[i].width ||
		    mode->height != modes[i].height ||
		    !AlmostEqual(refreshRateHz, modes[i].refreshRateHz) ||
		    mode->interlaced != modes[i].interlaced) {

			continue;
		}

		return true;
	}

	LOGDEBUG2(L_DRM, "drmdevice: %s: can't handle mode %dx%d@%.2f%s", __FUNCTION__,
		mode->width, mode->height, mode->refreshRateHz,
		mode->interlaced ? "i" : "");

	return false;
}

/**
 * Initiate the drm device
 *
 * 1) Try to open the user requested device (with -o /dev/dri/cardX)
 * 2) On error or if not set, find a any suitable device
 * 3) Find a connector (priority: user requested, connected, unconnected)
 * 4) Find a connector mode
 * 5) Find crtc encoder
 * 6) Find suitable planes for video (NV12), OSD (ARGB) and PiP (NV12)
 * 7) Init GBM
 * 8) Init EGL
 *
 * @retval 0                on success
 * @retval -errno           on error
 */
int cDrmDevice::Init(void)
{
	drmModeRes *resources = nullptr;
	drmModeConnector *connector;
	drmModeEncoder *encoder = nullptr;
	drmModePlane *plane;
	drmModePlaneRes *planeRes;
	int i;
	uint32_t j, k;

	// first try to open the user given drm device
	if (m_userDrmDevice) {
		LOGDEBUG2(L_DRM, "drmdevice: %s: Try open user requested device %s", __FUNCTION__, m_userDrmDevice);
		m_fdDrm = OpenDrmDevice(m_userDrmDevice, &resources);
	}

	// if manually set device failed, try to find a drm device
	if (m_fdDrm < 0) {
		if (m_userDrmDevice)
			LOGWARNING("drmdevice: %s: Could not open user requested device %s, try other devices!", __FUNCTION__, m_userDrmDevice);
		m_fdDrm = FindDrmDevice(&resources);
	}

	if (m_fdDrm < 0) {
		LOGERROR("drmdevice: %s: Could not open device!", __FUNCTION__);
		return -1;
	}

	LOGDEBUG2(L_DRM, "drmdevice: %s: fd: %d DRM have %i connectors, %i crtcs, %i encoders", __FUNCTION__,
		m_fdDrm, resources->count_connectors, resources->count_crtcs,
		resources->count_encoders);

	// find a connector
	connector = FindDrmConnector(m_fdDrm, resources, m_userDrmConnector);
	if (!connector) {
		LOGERROR("drmdevice: %s: cannot retrieve DRM connector (%d): %m", __FUNCTION__, errno);
		drmModeFreeResources(resources);
		return -1;
	}
	m_connectorId = connector->connector_id;
	m_connectorName = ConnectorName(connector);
	bool connected = connector->connection == DRM_MODE_CONNECTED;

	// fill config with available connector modes for later selection from setup menu
	m_pConfig->CollectedDrmModes.clear();
	for (i = 0; i < connector->count_modes; i++) {
		drmModeModeInfo *current_mode = &connector->modes[i];
		std::vector<sDrmMode> drmModeWhitelist(DrmModeWhitelist.begin(), DrmModeWhitelist.end());
		if (!Contains(current_mode, drmModeWhitelist))
			continue;
		if (Contains(current_mode, m_pConfig->CollectedDrmModes))
			continue;
		m_pConfig->CollectedDrmModes.push_back({current_mode->hdisplay,
		                                        current_mode->vdisplay,
		                                        GetRefreshRateHz(current_mode),
		                                        InterlacedMode(current_mode->flags)});
		LOGDEBUG2(L_DRM, "drmdevice: %s: adding display mode %dx%d@%.2f%s", __FUNCTION__,
			current_mode->hdisplay, current_mode->vdisplay, GetRefreshRateHz(current_mode),
			InterlacedMode(current_mode->flags) ? "i" : "");
	}

	// find connector mode
	if (FindMode()) {
		drmModeFreeConnector(connector);
		drmModeFreeResources(resources);
		return -1;
	}

	m_pRender->SetOsdSize(OsdWidth(), OsdHeight());

	// find encoder
	for (i = 0; i < resources->count_encoders; i++) {
		encoder = drmModeGetEncoder(m_fdDrm, resources->encoders[i]);
		if (encoder && encoder->encoder_id == connector->encoder_id)
			break;
		drmModeFreeEncoder(encoder);
		encoder = NULL;
	}

	// an encoder, which is not bound to a crtc yet, has a crtc_id of 0
	if (encoder && encoder->crtc_id) {
		m_crtcId = encoder->crtc_id;
		LOGDEBUG2(L_DRM, "drmdevice: %s: have encoder, m_crtcId %d", __FUNCTION__, m_crtcId);
	} else {
		int32_t crtc_id = FindCrtcForConnector(resources, connector);
		if (crtc_id == -1) {
			LOGERROR("drmdevice: %s: No crtc found!", __FUNCTION__);
			drmModeFreeEncoder(encoder);
			drmModeFreeConnector(connector);
			drmModeFreeResources(resources);
			return -1;
		}

		m_crtcId = crtc_id;
		LOGDEBUG2(L_DRM, "drmdevice: %s: have no encoder, m_crtcId %d", __FUNCTION__, m_crtcId);
	}

	for (i = 0; i < resources->count_crtcs; i++) {
		if (resources->crtcs[i] == m_crtcId) {
			m_crtcIndex = i;
			break;
		}
	}

	m_hdrMetadata = GetPropertyID(m_connectorId, DRM_MODE_OBJECT_CONNECTOR, "HDR_OUTPUT_METADATA");
	if (m_hdrMetadata != 0)
		LOGDEBUG2(L_DRM, "drmdevice: %s: HDR output metadata ID %d in connector %d", __FUNCTION__, m_hdrMetadata, m_connectorId);

	LOGINFO("DRM Setup: Using Monitor Mode %dx%d@%.2fHz on %s (%s), m_crtcId %d crtc_idx %d",
		m_drmModeInfo.hdisplay, m_drmModeInfo.vdisplay, GetRefreshRateHz(&m_drmModeInfo), m_connectorName.c_str(), connected ? "connected" : "not connected", m_crtcId, m_crtcIndex);

	drmModeFreeConnector(connector);

	// find planes
	if ((planeRes = drmModeGetPlaneResources(m_fdDrm)) == NULL) {
		LOGERROR("drmdevice: %s: cannot retrieve PlaneResources (%d): %m", __FUNCTION__, errno);
		drmModeFreeEncoder(encoder);
		drmModeFreeResources(resources);
		return -1;
	}

	// test and list the local planes
	cDrmPlane best_primary_video_plane; // NV12 capable primary plane with the lowest plane_id
	cDrmPlane best_overlay_video_plane; // NV12 capable overlay plane with the lowest plane_id
	cDrmPlane best_primary_osd_plane;   // AR24 capable primary plane with the highest plane_id
	cDrmPlane best_overlay_osd_plane;   // AR24 capable overlay plane with the highest plane_id

	// collect candidates for pip (NV12 overlay plane). The best one is chosen after we decided which
	// planes are used for video and osd
	std::vector<cDrmPlane> overlayNV12Candidates;

	for (j = 0; j < planeRes->count_planes; j++) {
		plane = drmModeGetPlane(m_fdDrm, planeRes->planes[j]);

		if (plane == NULL) {
			LOGERROR("drmdevice: %s: cannot query DRM-KMS plane %d", __FUNCTION__, j);
			continue;
		}

		uint64_t type = 0;
		uint64_t zpos = 0;
		char pixelformats[256];

		if (plane->possible_crtcs & (1 << m_crtcIndex)) {
			if (GetPropertyValue(planeRes->planes[j], DRM_MODE_OBJECT_PLANE, "type", &type)) {
				LOGDEBUG2(L_DRM, "drmdevice: %s: Failed to get property 'type'", __FUNCTION__);
			}
			if (GetPropertyValue(planeRes->planes[j], DRM_MODE_OBJECT_PLANE, "zpos", &zpos)) {
				LOGDEBUG2(L_DRM, "drmdevice: %s: Failed to get property 'zpos'", __FUNCTION__);
			} else {
				m_useZpos = true;
			}

			LOGDEBUG2(L_DRM, "drmdevice: %s: %s: id %i possible_crtcs %i", __FUNCTION__,
				(type == DRM_PLANE_TYPE_PRIMARY) ? "PRIMARY " :
				(type == DRM_PLANE_TYPE_OVERLAY) ? "OVERLAY " :
				(type == DRM_PLANE_TYPE_CURSOR) ? "CURSOR " : "UNKNOWN",
				plane->plane_id, plane->possible_crtcs);
			strcpy(pixelformats, "            ");

			// test pixel format and plane caps
			for (k = 0; k < plane->count_formats; k++) {
				if (!encoder || (encoder->possible_crtcs & plane->possible_crtcs)) {
					char tmp[10];
					switch (plane->formats[k]) {
						case DRM_FORMAT_NV12:
							snprintf(tmp, sizeof(tmp), " %4.4s", (char *)&plane->formats[k]);
							strcat(pixelformats, tmp);
							if (type == DRM_PLANE_TYPE_PRIMARY && !best_primary_video_plane.GetId()) {
								best_primary_video_plane.SetId(plane->plane_id);
								best_primary_video_plane.SetType(type);
								best_primary_video_plane.SetZpos(zpos);
								strcat(pixelformats, "!  ");
							}
							if (type == DRM_PLANE_TYPE_OVERLAY && !best_overlay_video_plane.GetId()) {
								best_overlay_video_plane.SetId(plane->plane_id);
								best_overlay_video_plane.SetType(type);
								best_overlay_video_plane.SetZpos(zpos);
								strcat(pixelformats, "!  ");
							}
							// store overlay NV12 plane as a candidate for pip
							if (type == DRM_PLANE_TYPE_OVERLAY) {
								cDrmPlane cand;
								cand.SetId(plane->plane_id);
								cand.SetType(type);
								cand.SetZpos(zpos);
								overlayNV12Candidates.push_back(cand);
							}
							break;
						case DRM_FORMAT_ARGB8888:
							snprintf(tmp, sizeof(tmp), " %4.4s", (char *)&plane->formats[k]);
							strcat(pixelformats, tmp);
							if (type == DRM_PLANE_TYPE_PRIMARY) {
								best_primary_osd_plane.SetId(plane->plane_id);
								best_primary_osd_plane.SetType(type);
								best_primary_osd_plane.SetZpos(zpos);
								strcat(pixelformats, "!  ");
							}
							if (type == DRM_PLANE_TYPE_OVERLAY) {
								best_overlay_osd_plane.SetId(plane->plane_id);
								best_overlay_osd_plane.SetType(type);
								best_overlay_osd_plane.SetZpos(zpos);
								strcat(pixelformats, "!  ");
							}
							break;
						default:
							break;
					}
				}
			}
			LOGDEBUG2(L_DRM, "drmdevice: %s: %s", __FUNCTION__, pixelformats);
		}
		drmModeFreePlane(plane);
	}

	// See which planes we should use for video and osd
	if (best_primary_video_plane.GetId() && best_overlay_osd_plane.GetId()) {
		m_videoPlane.SetId(best_primary_video_plane.GetId());
		m_videoPlane.SetType(best_primary_video_plane.GetType());
		m_zposPrimary = best_primary_video_plane.GetZpos();
		m_videoPlane.SetZpos(m_zposPrimary);
		m_osdPlane.SetId(best_overlay_osd_plane.GetId());
		m_osdPlane.SetType(best_overlay_osd_plane.GetType());
		m_zposOverlay = best_overlay_osd_plane.GetZpos();
		m_osdPlane.SetZpos(m_zposOverlay);
	} else if (best_overlay_video_plane.GetId() && best_primary_osd_plane.GetId()) {
		m_videoPlane.SetId(best_overlay_video_plane.GetId());
		m_videoPlane.SetType(best_overlay_video_plane.GetType());
		m_zposOverlay = best_overlay_video_plane.GetZpos();
		m_videoPlane.SetZpos(m_zposOverlay);
		m_osdPlane.SetId(best_primary_osd_plane.GetId());
		m_osdPlane.SetType(best_primary_osd_plane.GetType());
		m_zposPrimary = best_primary_osd_plane.GetZpos();
		m_osdPlane.SetZpos(m_zposPrimary);
		m_useZpos = true;
	} else {
		LOGERROR("drmdevice: %s: No suitable planes found!", __FUNCTION__);
		return -1;
	}

	// now pick the best pip plane from the NV12 overlay candidates we collected above
	cDrmPlane best_overlay_pip_plane;
	for (cDrmPlane &cand : overlayNV12Candidates) {
		uint32_t pid = cand.GetId();
		if (pid == m_videoPlane.GetId() || pid == m_osdPlane.GetId())
			continue;
		if (!best_overlay_pip_plane.GetId() || pid > best_overlay_pip_plane.GetId()) {
			best_overlay_pip_plane = cand;
		}
	}

	if (best_overlay_pip_plane.GetId()) {
		m_pipPlane.SetId(best_overlay_pip_plane.GetId());
		m_pipPlane.SetType(best_overlay_pip_plane.GetType());
		m_zposPip = best_overlay_pip_plane.GetZpos();
		m_pipPlane.SetZpos(m_zposPip);
	} else {
		LOGWARNING("drmdevice: %s: No suitable plane for Picture-in-Picture found. PIP will be disabled.", __FUNCTION__);
	}

	// debug output
	if (best_primary_video_plane.GetId()) {
		LOGDEBUG2(L_DRM, "drmdevice: %s: best_primary_video_plane: plane_id %d, type %s, zpos %" PRIu64 "", __FUNCTION__,
			best_primary_video_plane.GetId(), best_primary_video_plane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY", best_primary_video_plane.GetZpos());
	}
	if (best_overlay_video_plane.GetId()) {
		LOGDEBUG2(L_DRM, "drmdevice: %s: best_overlay_video_plane: plane_id %d, type %s, zpos %" PRIu64 "", __FUNCTION__,
			best_overlay_video_plane.GetId(), best_overlay_video_plane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY", best_overlay_video_plane.GetZpos());
	}
	if (best_primary_osd_plane.GetId()) {
		LOGDEBUG2(L_DRM, "drmdevice: %s: best_primary_osd_plane: plane_id %d, type %s, zpos %" PRIu64 "", __FUNCTION__,
			best_primary_osd_plane.GetId(), best_primary_osd_plane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY", best_primary_osd_plane.GetZpos());
	}
	if (best_overlay_osd_plane.GetId()) {
		LOGDEBUG2(L_DRM, "drmdevice: %s: best_overlay_osd_plane: plane_id %d, type %s, zpos %" PRIu64 "", __FUNCTION__,
			best_overlay_osd_plane.GetId(), best_overlay_osd_plane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY", best_overlay_osd_plane.GetZpos());
	}
	if (best_overlay_pip_plane.GetId()) {
		LOGDEBUG2(L_DRM, "drmdevice: %s: best_overlay_pip_plane: plane_id %d, type %s, zpos %" PRIu64 "", __FUNCTION__,
			best_overlay_pip_plane.GetId(), best_overlay_pip_plane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY", best_overlay_pip_plane.GetZpos());
	}

	// fill the plane's properties to speed up SetPropertyRequest later
	m_videoPlane.FillProperties(m_fdDrm);
	m_osdPlane.FillProperties(m_fdDrm);

	if (m_pipPlane.GetId())
		m_pipPlane.FillProperties(m_fdDrm);

	// Check, if we can set z-order (meson and rpi have fixed z-order, which cannot be changed)
	if (m_useZpos && !m_videoPlane.HasZpos(m_fdDrm)) {
		m_useZpos = false;
	}
	if (m_useZpos && !m_osdPlane.HasZpos(m_fdDrm)) {
		m_useZpos = false;
	}
	if (m_useZpos && m_pipPlane.GetId() && !m_pipPlane.HasZpos(m_fdDrm)) {
		m_useZpos = false;
	}

	// m_useZpos was set, if video is on OVERLAY, and osd is on PRIMARY
	// Check if the OVERLAY plane really got a higher zpos than the PRIMARY plane
	// If not, change their zpos values or hardcode them to
	// 1 OVERLAY (Video)
	// 0 PRIMARY (Osd)
	if (m_useZpos && m_zposOverlay <= m_zposPrimary) {
		char str_zpos[256];
		strcpy(str_zpos, "drmdevice: Init: zpos values are wrong, so ");
		if (m_zposOverlay == m_zposPrimary) {
			// is this possible?
			strcat(str_zpos, "hardcode them to 0 and 1, because they are equal");
			m_zposPrimary = 0;
			m_zposOverlay = 1;
		} else {
			strcat(str_zpos, "switch them");
			uint64_t zpos_tmp = m_zposPrimary;
			m_zposPrimary = m_zposOverlay;
			m_zposOverlay = zpos_tmp;
		}
		LOGDEBUG2(L_DRM, "%s", str_zpos);
	}

	if (drmSetMaster(m_fdDrm) < 0) {
		LOGDEBUG2(L_DRM, "drmdevice: Failed to set drm master, try authorize instead: %s", strerror(errno));

		drm_magic_t magic;
		if (drmGetMagic(m_fdDrm, &magic) < 0)
			LOGFATAL("drmdevice: Failed to get drm magic: %s", strerror(errno));

		if (drmAuthMagic(m_fdDrm, magic) < 0)
			LOGFATAL("drmdevice: Failed to authorize drm magic: %s", strerror(errno));
	}

	drmModeFreePlaneResources(planeRes);
	drmModeFreeEncoder(encoder);
	drmModeFreeResources(resources);

	if (m_pipPlane.GetId()) {
		LOGINFO("DRM setup - CRTC: %i video_plane: %i (%s %" PRIu64 ") osd_plane: %i (%s %" PRIu64 ") pip_plane: %i (%s %" PRIu64 ") m_useZpos: %d",
			m_crtcId,
			m_videoPlane.GetId(),
			m_videoPlane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY",
			m_videoPlane.GetZpos(),
			m_osdPlane.GetId(),
			m_osdPlane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY",
			m_osdPlane.GetZpos(),
			m_pipPlane.GetId(),
			m_pipPlane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY",
			m_pipPlane.GetZpos(),
			m_useZpos);
	} else {
		LOGINFO("DRM setup - CRTC: %i video_plane: %i (%s %" PRIu64 ") osd_plane: %i (%s %" PRIu64 ") m_useZpos: %d (pip disbled)",
			m_crtcId,
			m_videoPlane.GetId(),
			m_videoPlane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY",
			m_videoPlane.GetZpos(),
			m_osdPlane.GetId(),
			m_osdPlane.GetType() == DRM_PLANE_TYPE_PRIMARY ? "PRIMARY" : "OVERLAY",
			m_osdPlane.GetZpos(),
			m_useZpos);
	}

	return 0;
}

/**
 * Find a suitable mode from the current connector
 *
 * Mode selection priority:
 *   1) user requested
 *   2) progressive mode with biggest width at 50Hz
 *   3) progressive mode with biggest width at 60Hz
 *   4) progressive mode with biggest width at any refresh rate
 *
 * @retval 0     a mode was found
 * @retval -1    no mode was found
 */
int cDrmDevice::FindMode(void)
{
	drmModeConnector *connector = drmModeGetConnector(m_fdDrm, m_connectorId);
	drmModeModeInfo *drmmode = nullptr;

	if (!connector) {
		LOGERROR("drmdevice: %s: cannot retrieve DRM connector %d (%d): %m", __FUNCTION__, m_connectorId, errno);
		return -1;
	}

	// find the user requested mode
	if (m_userReqDisplayWidth > 0) {
		for (int i = 0; i < connector->count_modes; i++) {
			drmModeModeInfo *current_mode = &connector->modes[i];
			if(current_mode->hdisplay == m_userReqDisplayWidth &&
			   current_mode->vdisplay == m_userReqDisplayHeight &&
			   AlmostEqual(GetRefreshRateHz(current_mode), m_userReqDisplayRefreshRate) &&
			   InterlacedMode(current_mode->flags) == m_userReqDisplayInterlaced) {

				drmmode = current_mode;
				LOGDEBUG2(L_DRM, "drmdevice: %s: Use user requested mode: %dx%d@%.2f%s", __FUNCTION__,
					drmmode->hdisplay, drmmode->vdisplay, GetRefreshRateHz(drmmode), InterlacedMode(drmmode->flags) ? "i" : "");
				break;
			}
		}
		if (!drmmode)
			LOGWARNING("drmdevice: %s: User requested mode not found, try default modes", __FUNCTION__);
	}

	double preferredHz[3] = {50.0, 60.0, 0.0};

	// find the highest resolution (progressive) mode with 50, 60 or any refresh rate
	if (!drmmode) {
		int j = 0;
		while (!drmmode && preferredHz[j]) {
			for (int i = 0, width = 0; i < connector->count_modes; i++) {
				drmModeModeInfo *current_mode = &connector->modes[i];
				if (InterlacedMode(current_mode->flags))
					continue;
				if (preferredHz[j] && std::round(GetRefreshRateHz(current_mode) * 100.0) / 100.0 != preferredHz[j])
					continue;

				int current_width = current_mode->hdisplay;
				if (current_width > width) {
					drmmode = current_mode;
					width = current_width;
				}
			}
			j++;
		}

		if (drmmode)
			LOGDEBUG2(L_DRM, "drmdevice: %s: Use mode with the biggest width: %dx%d@%.2f", __FUNCTION__,
				drmmode->hdisplay, drmmode->vdisplay, GetRefreshRateHz(drmmode));
	}

	if (drmmode)
		memcpy(&m_drmModeInfo, drmmode, sizeof(drmModeModeInfo));

	drmModeFreeConnector(connector);

	if (!drmmode) {
		LOGERROR("drmdevice: %s: No monitor mode found! Probably no monitor connected, giving up!", __FUNCTION__);
		return -1;
	}

	m_pConfig->CurrentDrmMode = {
		m_drmModeInfo.hdisplay,
		m_drmModeInfo.vdisplay,
		GetRefreshRateHz(&m_drmModeInfo),
		InterlacedMode(m_drmModeInfo.flags)
	};

	if (!m_pConfig->AutoDetectedDrmMode.width)
		m_pConfig->AutoDetectedDrmMode = m_pConfig->CurrentDrmMode;

	// drmmode points into the already freed connector, use the copy
	m_pRender->SetScreenSize(m_drmModeInfo.hdisplay, m_drmModeInfo.vdisplay, GetRefreshRateHz(&m_drmModeInfo), InterlacedMode(m_drmModeInfo.flags));

	return 0;
}

/**
 * Re-Init the drm device with a new connector mode
 *
 * Mode selection priority:
 * 1) selected mode from setup menu or mode depending on video resolution (RequestedDrmMode)
 * 2) command line requested mode (UserSetDrmMode)
 * 3) other suitable mode:
 *   - mode with biggest width at 50Hz
 *   - mode with biggest width at 60Hz
 *   - mode with biggest width at any refresh rate
 */
int cDrmDevice::ReInit(void)
{
	sDrmMode *drmMode = nullptr;

	if (m_pConfig->RequestedDrmMode.width > 0)
		drmMode = &m_pConfig->RequestedDrmMode;
	else if (m_pConfig->UserSetDrmMode.width > 0)
		drmMode = &m_pConfig->UserSetDrmMode;

	if (drmMode) {
		m_userReqDisplayWidth = drmMode->width;
		m_userReqDisplayHeight = drmMode->height;
		m_userReqDisplayRefreshRate = drmMode->refreshRateHz;
		m_userReqDisplayInterlaced = drmMode->interlaced;
		LOGDEBUG("%s requested display mode: %dx%d@%.2f%s", __FUNCTION__,
			m_userReqDisplayWidth, m_userReqDisplayHeight, m_userReqDisplayRefreshRate, m_userReqDisplayInterlaced ? "i" : "");
	}

	return FindMode();
}

#ifdef USE_GLES
/**
 * Init gbm device and surface
 *
 * @retval 0           on success
 * @retval -1          on error
 */
int cDrmDevice::InitGbm(void)
{
	int w = OsdWidth();
	int h = OsdHeight();
	uint32_t format = DRM_FORMAT_ARGB8888;
	uint64_t modifier = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;

	m_pGbmDevice = gbm_create_device(m_fdDrm);
	if (!m_pGbmDevice) {
		LOGERROR("drmdevice: %s: failed to create gbm device!", __FUNCTION__);
		return -1;
	}

	m_pGbmSurface = gbm_surface_create(m_pGbmDevice, w, h, format, modifier);
	if (!m_pGbmSurface) {
		gbm_device_destroy(m_pGbmDevice);
		m_pGbmDevice = nullptr;
		LOGERROR("drmdevice: %s: failed to create %d x %d surface bo", __FUNCTION__, w, h);
		return -1;
	}

	return 0;
}

/**
 * Free gbm device and surface
 */
void cDrmDevice::ExitGbm(void)
{
	if (m_pGbmSurface) {
		gbm_surface_destroy(m_pGbmSurface);
		m_pGbmSurface = nullptr;
	}

	if (m_pGbmDevice) {
		gbm_device_destroy(m_pGbmDevice);
		m_pGbmDevice = nullptr;
	}
}

PFNEGLGETPLATFORMDISPLAYEXTPROC get_platform_display = NULL;           ///< eglGetPlatformDisplayEXT() (from the EGL extension)
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC get_platform_surface = NULL;  ///< eglCreatePlatformWindowSurfaceEXT() (from the EGL extension)

/**
 * EGL context attributes: OpenGL/ES 2
 *
 * @ingroup drm
 */
static const EGLint context_attribute_list[] =
{
	EGL_CONTEXT_CLIENT_VERSION, 2,
	EGL_NONE
};

/**
 * Get a suitable EGLConfig
 *
 * @ingroup drm
 */
EGLConfig cDrmDevice::GetEGLConfig(void)
{
	EGLint config_attribute_list[] = {
		EGL_BUFFER_SIZE, 32,
		EGL_STENCIL_SIZE, EGL_DONT_CARE,
		EGL_DEPTH_SIZE, EGL_DONT_CARE,
		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
		EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
		EGL_NONE
	};
	EGLConfig *configs = nullptr;
	EGLint matched = 0;
	EGLint count = 0;
	EGL_CHECK(eglGetConfigs(m_eglDisplay, NULL, 0, &count));
	if (count < 1)
		LOGFATAL("drmdevice: %s: no EGL configs to choose from", __FUNCTION__);

	LOGDEBUG2(L_OPENGL, "drmdevice: %s: %d EGL configs found", __FUNCTION__, count);

	configs = (EGLConfig *)malloc(count * sizeof(*configs));
	if (!configs)
		LOGFATAL("drmdevice: %s: can't allocate space for EGL configs", __FUNCTION__);

	EGL_CHECK(eglChooseConfig(m_eglDisplay, config_attribute_list, configs, count, &matched));
	if (!matched) {
		free(configs);
		LOGFATAL("drmdevice: %s: no EGL configs with appropriate attributes", __FUNCTION__);
	}

	LOGDEBUG2(L_OPENGL, "drmdevice: %s: %d appropriate EGL configs found, which match attributes", __FUNCTION__, matched);

	EGLConfig chosen = NULL;
	for (int i = 0; i < matched; ++i) {
		EGLint gbm_format;
		EGL_CHECK(eglGetConfigAttrib(m_eglDisplay, configs[i], EGL_NATIVE_VISUAL_ID, &gbm_format));

		if (gbm_format == GBM_FORMAT_ARGB8888) {
			chosen = configs[i];
			break;
		}
	}

	free(configs);
	if (chosen == NULL)
		LOGFATAL("drmdevice: %s: no matching gbm config found", __FUNCTION__);

	return chosen;
}

/**
 * Init EGL context
 *
 * @retval 0       on success
 * @retval -1      on error
 */
int cDrmDevice::InitEGL(void)
{
	EGLint iMajorVersion, iMinorVersion;

	PFNEGLGETPLATFORMDISPLAYEXTPROC get_platform_display = (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
	assert(get_platform_display != NULL);
	PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC get_platform_surface = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC)eglGetProcAddress("eglCreatePlatformWindowSurfaceEXT");
	assert(get_platform_surface != NULL);

	EGL_CHECK(m_eglDisplay = get_platform_display(EGL_PLATFORM_GBM_KHR, m_pGbmDevice, NULL));
	if (!m_eglDisplay) {
		LOGERROR("drmdevice: %s: failed to get eglDisplay", __FUNCTION__);
		return -1;
	}

	if (!eglInitialize(m_eglDisplay, &iMajorVersion, &iMinorVersion)) {
		LOGERROR("drmdevice: %s: eglInitialize failed", __FUNCTION__);
		return -1;
	}

	LOGDEBUG2(L_OPENGL, "drmdevice: %s: Using display %p with EGL version %d.%d", __FUNCTION__, m_eglDisplay, iMajorVersion, iMinorVersion);
	EGL_CHECK(LOGDEBUG2(L_OPENGL, "  EGL Version: \"%s\"", eglQueryString(m_eglDisplay, EGL_VERSION)));
	EGL_CHECK(LOGDEBUG2(L_OPENGL, "  EGL Vendor: \"%s\"", eglQueryString(m_eglDisplay, EGL_VENDOR)));
	EGL_CHECK(LOGDEBUG2(L_OPENGL, "  EGL Extensions: \"%s\"", eglQueryString(m_eglDisplay, EGL_EXTENSIONS)));
	EGL_CHECK(LOGDEBUG2(L_OPENGL, "  EGL APIs: \"%s\"", eglQueryString(m_eglDisplay, EGL_CLIENT_APIS)));

	EGLConfig eglConfig = GetEGLConfig();

	EGL_CHECK(eglBindAPI(EGL_OPENGL_ES_API));
	EGL_CHECK(m_eglContext = eglCreateContext(m_eglDisplay, eglConfig, EGL_NO_CONTEXT, context_attribute_list));
	if (!m_eglContext) {
		LOGERROR("drmdevice: %s: failed to create eglContext", __FUNCTION__);
		return -1;
	}

	EGL_CHECK(m_eglSurface = get_platform_surface(m_eglDisplay, eglConfig, m_pGbmSurface, NULL));
	if (m_eglSurface == EGL_NO_SURFACE) {
		LOGERROR("drmdevice: %s: failed to create eglSurface", __FUNCTION__);
		return -1;
	}

	EGLint s_width, s_height;
	EGL_CHECK(eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &s_width));
	EGL_CHECK(eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_HEIGHT, &s_height));

	LOGDEBUG2(L_OPENGL, "drmdevice: %s: GLSurface %p on EGLDisplay %p for %d x %d BO created", __FUNCTION__, m_eglSurface, m_eglDisplay, s_width, s_height);

	m_glInitiated = true;
	LOGINFO("DRM Setup: EGL context initialized");

	return 0;
}

/**
 * Free the EGL surface, context and display
 *
 * Must be called before ExitGbm(): destroying the EGL surface also destroys
 * its gbm buffer objects (and their drm framebuffers).
 * The OpenGL thread must have released the context before.
 */
void cDrmDevice::ExitEGL(void)
{
	m_glInitiated = false;

	if (m_eglDisplay == EGL_NO_DISPLAY)
		return;

	eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);

	if (m_eglSurface != EGL_NO_SURFACE)
		eglDestroySurface(m_eglDisplay, m_eglSurface);

	if (m_eglContext != EGL_NO_CONTEXT)
		eglDestroyContext(m_eglDisplay, m_eglContext);

	eglTerminate(m_eglDisplay);

	m_eglSurface = EGL_NO_SURFACE;
	m_eglContext = EGL_NO_CONTEXT;
	m_eglDisplay = EGL_NO_DISPLAY;

	LOGDEBUG2(L_OPENGL, "drmdevice: %s: EGL context freed", __FUNCTION__);
}

/**
 * Callback function to destroy a drm buffer which stays in the gbm_bo's user data
 *
 * @ingroup drm
 */
static void drm_fb_destroy_callback(struct gbm_bo *bo, void *data)
{
	int drm_fd = gbm_device_get_fd(gbm_bo_get_device(bo));
	cDrmBuffer *buf = (cDrmBuffer *)data;

	if (buf->Id())
		drmModeRmFB(drm_fd, buf->Id());

	delete(buf);
}

/// @cond
// The multi plane functions of gbm are declared weak, so that the plugin also
// loads with an older libgbm. GetBufFromBo() checks, if they are available.
__attribute__ ((weak)) union gbm_bo_handle
gbm_bo_get_handle_for_plane(struct gbm_bo *bo, int plane);

__attribute__ ((weak)) int
gbm_bo_get_fd(struct gbm_bo *bo);

__attribute__ ((weak)) uint64_t
gbm_bo_get_modifier(struct gbm_bo *bo);

__attribute__ ((weak)) int
gbm_bo_get_plane_count(struct gbm_bo *bo);

__attribute__ ((weak)) uint32_t
gbm_bo_get_stride_for_plane(struct gbm_bo *bo, int plane);

__attribute__ ((weak)) uint32_t
gbm_bo_get_offset(struct gbm_bo *bo, int plane);
/// @endcond

/**
 * Get a drm buffer from a gbm buffer object
 *
 * @param bo        gbm buffer object
 *
 * @return          a drm buffer corresponding to the gbm buffer object
 */
cDrmBuffer *cDrmDevice::GetBufFromBo(struct gbm_bo *bo)
{
	cDrmBuffer *buf = (cDrmBuffer *)gbm_bo_get_user_data(bo);
	uint32_t mod_flags = 0;
	int ret = -1;

	// the buffer was already allocated
	if (buf)
		return buf;

	buf = new cDrmBuffer(m_fdDrm, gbm_bo_get_width(bo), gbm_bo_get_height(bo), gbm_bo_get_format(bo), bo);

	if (gbm_bo_get_handle_for_plane && gbm_bo_get_modifier &&
	    gbm_bo_get_plane_count && gbm_bo_get_stride_for_plane &&
	    gbm_bo_get_offset) {
		uint64_t modifiers[4] = {0};
		modifiers[0] = gbm_bo_get_modifier(bo);
		const int num_planes = gbm_bo_get_plane_count(bo);
		buf->SetNumPlanes(num_planes);
		for (int i = 0; i < num_planes; i++) {
			buf->SetHandle(i, gbm_bo_get_handle_for_plane(bo, i).u32);
			buf->SetPitch(i, gbm_bo_get_stride_for_plane(bo, i));
			buf->SetOffset(i, gbm_bo_get_offset(bo, i));
			modifiers[i] = modifiers[0];
			buf->SetSize(i, buf->Height() * buf->Pitch(i));
			LOGDEBUG2(L_DRM, "drmdevice: %s: %d: handle %d pitch %d, offset %d, size %d", __FUNCTION__, i, buf->PrimeHandle(i), buf->Pitch(i), buf->Offset(i), buf->Size(i));
		}
		buf->SetNumObjects(1);
		buf->SetObjectIndex(0, 0);
		buf->SetDmaBufHandle(gbm_bo_get_fd(bo));

		if (modifiers[0]) {
			mod_flags = DRM_MODE_FB_MODIFIERS;
			LOGDEBUG2(L_DRM, "drmdevice: %s: Using modifier %" PRIx64 "", __FUNCTION__, modifiers[0]);
		}

		uint32_t id;
		// Add FB
		ret = drmModeAddFB2WithModifiers(m_fdDrm, buf->Width(), buf->Height(), buf->PixFmt(),
			buf->PrimeHandle(), buf->Pitch(), buf->Offset(), modifiers, &id, mod_flags);
		buf->SetId(id);
	}

	if (ret) {
		if (mod_flags)
			LOGDEBUG2(L_DRM, "drmdevice: %s: Modifiers failed!", __FUNCTION__);

		buf->SetNumPlanes(1);
		uint32_t tmpHandle[4] = { gbm_bo_get_handle(bo).u32, 0, 0, 0};
		uint32_t tmpStride[4] = { gbm_bo_get_stride(bo), 0, 0, 0};
		uint32_t tmpSize[4]   = { buf->Height() * buf->Width() * buf->Pitch(0), 0, 0, 0};
		memcpy(buf->PrimeHandle(), tmpHandle, sizeof(tmpHandle));
		memcpy(buf->Pitch(), tmpStride, sizeof(tmpStride));
		memcpy(buf->Size(), tmpSize, sizeof(tmpSize));
		memset(buf->Offset(), 0, 16);
		buf->SetNumObjects(1);
		buf->SetObjectIndex(0, 0);
		buf->SetDmaBufHandle(gbm_bo_get_fd(bo));

		uint32_t id;
		ret = drmModeAddFB2(m_fdDrm, buf->Width(), buf->Height(), buf->PixFmt(),
			buf->PrimeHandle(), buf->Pitch(), buf->Offset(), &id, 0);
		buf->SetId(id);
	}

	if (ret) {
		LOGFATAL("drmdevice: %s: cannot create framebuffer (%d): %m", __FUNCTION__, errno);
		delete buf;
		return NULL;
	}

	uint32_t pixFmt = buf->PixFmt();
	LOGDEBUG2(L_DRM, "drmdevice: %s: New GL buffer %d x %d pix_fmt %4.4s fb_id %d", __FUNCTION__,
		buf->Width(), buf->Height(), (char *)&pixFmt, buf->Id());

	gbm_bo_set_user_data(bo, buf, drm_fb_destroy_callback);
	return buf;
}
#endif

/**
 * Find the CRTC_ID for the given encoder
 *
 * @param resources       drm resources
 * @param encoder         drm encoder
 *
 * @return                CRTC_ID
 *
 * @ingroup drm
 */
static int32_t FindCrtcForEncoder(const drmModeRes *resources, const drmModeEncoder *encoder)
{
	int i;

	for (i = 0; i < resources->count_crtcs; i++) {
		const uint32_t crtc_mask = 1 << i;
		const uint32_t crtc_id = resources->crtcs[i];
		if (encoder->possible_crtcs & crtc_mask) {
			return crtc_id;
		}
	}

	return -1;
}

/**
 * Find the CRTC_ID for the given connector
 *
 * @param resources       drm resources
 * @param connector       drm connector
 *
 * @return                CRTC_ID
 */
int32_t cDrmDevice::FindCrtcForConnector(const drmModeRes *resources, const drmModeConnector *connector)
{
	int i;

	for (i = 0; i < connector->count_encoders; i++) {
		const uint32_t encoder_id = connector->encoders[i];
		drmModeEncoder *encoder = drmModeGetEncoder(m_fdDrm, encoder_id);

		if (encoder) {
			const int32_t crtc_id = FindCrtcForEncoder(resources, encoder);
			drmModeFreeEncoder(encoder);
			if (crtc_id != -1) {
				return crtc_id;
			}
		}
	}

	return -1;
}

/**
 * Close the drm file handle
 */
void cDrmDevice::Close(void)
{
	LOGDEBUG2(L_DRM, "drmdevice: %s: closing fd %d", __FUNCTION__, m_fdDrm);
	drmDropMaster(m_fdDrm);

	close(m_fdDrm);
	m_fdDrm = -1;
}

/**
 * Add a drm property to an atomic modeset request
 *
 * @param ModeReq     atomic request object
 * @param objectID    drm object id
 * @param objectType  drm object type
 * @param propName    name of the drm property to be set
 * @param value       the value, the drm property should get
 *
 * @return            negative value on errors, otherwise the number of properties in the atomic request
 */
int cDrmDevice::SetPropertyRequest(drmModeAtomicReqPtr ModeReq,
	uint32_t objectID, uint32_t objectType,
	const char *propName, uint64_t value)
{
	uint32_t i;
	uint64_t id = 0;
	drmModePropertyPtr Prop;
	drmModeObjectPropertiesPtr objectProps =
		drmModeObjectGetProperties(m_fdDrm, objectID, objectType);

	if (!objectProps)
		return -EINVAL;

	for (i = 0; i < objectProps->count_props; i++) {
		if ((Prop = drmModeGetProperty(m_fdDrm, objectProps->props[i])) == NULL) {
			LOGDEBUG2(L_DRM, "drmdevice: %s: Unable to query property", __FUNCTION__);
			continue;
		}

		if (strcmp(propName, Prop->name) == 0) {
			id = Prop->prop_id;
			drmModeFreeProperty(Prop);
			break;
		}

		drmModeFreeProperty(Prop);
	}

	drmModeFreeObjectProperties(objectProps);

	// don't add an invalid property, the whole atomic commit would fail
	if (id == 0) {
		LOGDEBUG2(L_DRM, "drmdevice: %s Unable to find value for property \'%s\'.", __FUNCTION__, propName);
		return -EINVAL;
	}

	return drmModeAtomicAddProperty(ModeReq, objectID, id, value);
}

/**
 * Get a drm property value
 *
 * @param objectID      drm object ID
 * @param objectType    drm object type
 * @param propName      drm property name
 * @param[out] value    value for the requested property
 *
 * @retval 0            value was found
 * @retval -1           value was not found
 */
int cDrmDevice::GetPropertyValue(uint32_t objectID, uint32_t objectType, const char *propName, uint64_t *value)
{
	uint32_t i;
	int found = 0;
	drmModePropertyPtr Prop;
	drmModeObjectPropertiesPtr objectProps =
		drmModeObjectGetProperties(m_fdDrm, objectID, objectType);

	if (!objectProps)
		return -1;

	for (i = 0; i < objectProps->count_props; i++) {
		if ((Prop = drmModeGetProperty(m_fdDrm, objectProps->props[i])) == NULL) {
			LOGDEBUG2(L_DRM, "drmdevice: %s: Unable to query property", __FUNCTION__);
			continue;
		}

		if (strcmp(propName, Prop->name) == 0) {
			*value = objectProps->prop_values[i];
			found = 1;
		}

		drmModeFreeProperty(Prop);

		if (found)
			break;
	}

	drmModeFreeObjectProperties(objectProps);

	if (!found) {
		LOGDEBUG2(L_DRM, "drmdevice: %s: Unable to find value for property \'%s\'.", __FUNCTION__, propName);
		return -1;
	}

	return 0;
}

/**
 * Get a property ID
 *
 * @param objectID      drm object ID
 * @param objectType    drm object type
 * @param propName      drm property name
 *
 * @return the value if found, 0 otherwise
 */
uint32_t cDrmDevice::GetPropertyID(uint32_t objectID, uint32_t objectType, const char *propName)
{
	uint32_t i;
	int found = 0;
	int value = 0;

	drmModePropertyPtr Prop;
	drmModeObjectPropertiesPtr objectProps =
		drmModeObjectGetProperties(m_fdDrm, objectID, objectType);

	if (!objectProps)
		return 0;

	for (i = 0; i < objectProps->count_props; i++) {
		if ((Prop = drmModeGetProperty(m_fdDrm, objectProps->props[i])) == NULL) {
			LOGDEBUG2(L_DRM, "drmdevice: %s: Unable to query property", __FUNCTION__);
			continue;
		}

		if (strcmp(propName, Prop->name) == 0) {
			value = objectProps->props[i];
			found = 1;
		}

		drmModeFreeProperty(Prop);

		if (found)
			break;
	}

	drmModeFreeObjectProperties(objectProps);

	if (!found)
		LOGDEBUG2(L_DRM, "drmdevice: %s: Unable to find value for property \'%s\'.", __FUNCTION__, propName);

	return value;
}

/**
 * Save information of a CRTC
 */
void cDrmDevice::SaveCrtc(void)
{
	if (m_drmModeCrtcSaved)
		drmModeFreeCrtc(m_drmModeCrtcSaved);

	m_drmModeCrtcSaved = drmModeGetCrtc(m_fdDrm, m_crtcId);
}

/**
 * Restore information of a CRTC
 */
void cDrmDevice::RestoreCrtc(void)
{
	if (m_drmModeCrtcSaved) {
		drmModeSetCrtc(m_fdDrm, m_drmModeCrtcSaved->crtc_id, m_drmModeCrtcSaved->buffer_id,
			m_drmModeCrtcSaved->x, m_drmModeCrtcSaved->y, &m_connectorId, 1, &m_drmModeCrtcSaved->mode);
		drmModeFreeCrtc(m_drmModeCrtcSaved);
		m_drmModeCrtcSaved = nullptr;
	}
}

/**
 * Poll for a drm event
 *
 * @retval    0 if successful
 * @retval   -1 on error
 */
int cDrmDevice::HandleEvent(void)
{
	return drmHandleEvent(m_fdDrm, &m_drmEventCtx);
}

/**
 * Init the event context
 */
void cDrmDevice::InitEvent(void)
{
	memset(&m_drmEventCtx, 0, sizeof(m_drmEventCtx));
	m_drmEventCtx.version = 2;
}

/*
 * drmModeAtomic* wrapper functions
 *
 * The Set* functions add a property to an atomic modeset request,
 * they return a negative value on errors (see SetPropertyRequest()).
 */

/** Add the connector property "CRTC_ID" (the current crtc) to the request */
int cDrmDevice::SetConnectorCrtcId(drmModeAtomicReqPtr modeReq)
{
	return SetPropertyRequest(modeReq, m_connectorId, DRM_MODE_OBJECT_CONNECTOR, "CRTC_ID", m_crtcId);
}

/** Add the connector property "HDR_OUTPUT_METADATA" (blob id, 0 disables HDR) to the request */
int cDrmDevice::SetConnectorHdrOutputMetadata(drmModeAtomicReqPtr modeReq, uint32_t id)
{
	return SetPropertyRequest(modeReq, m_connectorId, DRM_MODE_OBJECT_CONNECTOR, "HDR_OUTPUT_METADATA", id);
}

/** Add the connector property "Colorspace" (see ::drmColorSpace) to the request */
int cDrmDevice::SetConnectorColorspace(drmModeAtomicReqPtr modeReq, uint32_t id)
{
	return SetPropertyRequest(modeReq, m_connectorId, DRM_MODE_OBJECT_CONNECTOR, "Colorspace", id);
}

/** Add the video plane property "COLOR_ENCODING" (see ::drmColorEncoding) to the request */
int cDrmDevice::SetVideoPlaneColorEncoding(drmModeAtomicReqPtr modeReq, uint32_t id)
{
	return SetPropertyRequest(modeReq, m_videoPlane.GetId(), DRM_MODE_OBJECT_PLANE, "COLOR_ENCODING", id);
}

/** Add the video plane property "COLOR_RANGE" (see ::drmColorRange) to the request */
int cDrmDevice::SetVideoPlaneColorRange(drmModeAtomicReqPtr modeReq, uint32_t id)
{
	return SetPropertyRequest(modeReq, m_videoPlane.GetId(), DRM_MODE_OBJECT_PLANE, "COLOR_RANGE", id);
}

/** Get the current value of the video plane property "COLOR_RANGE", returns 0 on success */
int cDrmDevice::GetVideoPlaneColorRange(uint64_t *value)
{
	return GetPropertyValue(m_videoPlane.GetId(), DRM_MODE_OBJECT_PLANE, "COLOR_RANGE", value);
}

/** Add the crtc property "MODE_ID" (blob id of the mode) to the request */
int cDrmDevice::SetCrtcModeId(drmModeAtomicReqPtr modeReq, uint32_t id)
{
	return SetPropertyRequest(modeReq, m_crtcId, DRM_MODE_OBJECT_CRTC, "MODE_ID", id);
}

/** Add the crtc property "ACTIVE" to the request */
int cDrmDevice::SetCrtcActive(drmModeAtomicReqPtr modeReq, uint32_t id)
{
	return SetPropertyRequest(modeReq, m_crtcId, DRM_MODE_OBJECT_CRTC, "ACTIVE", id);
}

/** Create a property blob of the current mode, returns 0 on success */
int cDrmDevice::CreateModeBlob(uint32_t *modeID)
{
	return drmModeCreatePropertyBlob(m_fdDrm, &m_drmModeInfo, sizeof(m_drmModeInfo), modeID);
}

/** Destroy a mode property blob, returns 0 on success */
int cDrmDevice::DestroyModeBlob(uint32_t modeID)
{
	return drmModeDestroyPropertyBlob(m_fdDrm, modeID);
}

/** Create a property blob of the HDR metadata, returns 0 on success */
int cDrmDevice::CreateHdrBlob(struct hdr_output_metadata *data, size_t size, uint32_t *blobID)
{
	int ret = drmModeCreatePropertyBlob(m_fdDrm, data, size, blobID);
	if (ret)
		LOGDEBUG2(L_DRM, "drmdevice: %s: failed to create hdr property blob: id %u, data %p (%zu) ret %d", __FUNCTION__, *blobID, (void *)data, size, ret);

	return ret;
}

/** Set the connector property "HDR_OUTPUT_METADATA" directly (without atomic request), returns 0 on success */
int cDrmDevice::SetConnectorHdrBlobProperty(uint32_t blobID)
{
	int ret = drmModeConnectorSetProperty(m_fdDrm, m_connectorId, m_hdrMetadata, blobID);
	if (ret)
		LOGDEBUG2(L_DRM, "drmdevice: %s: failed to set hdr property blob: blob id %d connector_id %d, m_hdrMetadata %d ret %d",
			__FUNCTION__, blobID, m_connectorId, m_hdrMetadata, ret);

	return ret;
}

/** Destroy a HDR metadata property blob, returns 0 on success */
int cDrmDevice::DestroyHdrBlob(uint32_t blobID)
{
	return drmModeDestroyPropertyBlob(m_fdDrm, blobID);
}