videorender.cpp

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

/**
 * @file videorender.cpp
 * Video Renderer (Display)
 *
 * This file defines cVideoRender, which includes all methods to
 * bring the video and osd to display.
 *
 * @copyright 2009 - 2015 by Johns.  All Rights Reserved.
 * @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 <chrono>
#include <cinttypes>
#include <cstdint>
#include <mutex>
#include <vector>

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

extern "C" {
#include <libavcodec/avcodec.h>
#include <libavutil/hwcontext_drm.h>
}

#include <drm_fourcc.h>
#include <vdr/osd.h>
#include <vdr/thread.h>
#include <xf86drmMode.h>

#include "audio.h"
#include "config.h"
#include "drmdevice.h"
#include "drmhdr.h"
#include "grab.h"
#include "logger.h"
#include "misc.h"
#include "queue.h"
#include "softhddevice.h"
#include "statemachine.h"
#include "videorender.h"
#include "videostream.h"

/**
 * Create the video renderer
 *
 * @param device         pointer to cSoftHdDevice
 */
cVideoRender::cVideoRender(cSoftHdDevice *device)
	: cThread("softhd display"),
	  m_pDevice(device),
	  m_pAudio(m_pDevice->Audio()),
	  m_pConfig(m_pDevice->Config()),
	  m_grabOsd("OSD"),
	  m_grabVideo("VIDEO"),
	  m_grabPip("PIP"),
	  m_pDrmDevice(new cDrmDevice(this, m_pConfig)),
	  m_pHdrMetadata(this),
	  m_enableHdr(m_pConfig->ConfigVideoEnableHDR)
{
#ifdef USE_GLES
	m_disableOglOsd = m_pConfig->ConfigDisableOglOsd;
	m_bo = nullptr;
	m_pNextBo = nullptr;
	m_pOldBo = nullptr;
#endif
	m_timebase = av_make_q(1, 90000);
	SetPipSize(m_pConfig->ConfigPipUseAlt);
}

/**
 * Destroy the video renderer
 */
cVideoRender::~cVideoRender(void)
{
	LOGDEBUG2(L_DRM, "videorender: %s", __FUNCTION__);

	Stop();

	delete m_pDrmDevice;
}

/**
 * Clear (empty) the decoder to display queue
 */
void cVideoRender::ClearDecoderToDisplayQueue(void)
{
	m_drmBufferQueue.Clear();
	m_drmBufferPool.DestroyAllExcept(m_pCurrentlyDisplayed);

	if (m_pCurrentlyDisplayed)
		m_pCurrentlyDisplayed->SetDestroyAfterUse(true);
}

/**
 * Clear (empty) the decoder to display queue
 */
void cVideoRender::ClearPipDecoderToDisplayQueue(void)
{
	m_pipDrmBufferQueue.Clear();
	m_pipDrmBufferPool.DestroyAllExcept(nullptr);

	m_pCurrentlyPipDisplayed = nullptr;
}

/** @ingroup render */
struct sRect {
	uint64_t x;
	uint64_t y;
	uint64_t w;
	uint64_t h;
};

/**
 * Fits the video frame into a given area
 *
 * @param frame        AVFrame with frame dimensions and aspect ratio information
 * @param dispX        x offset of video area
 * @param dispY        y offset of video area
 * @param dispWidth    width of video area
 * @param dispHeight   height of video area
 *
 * @return             the new computed video area or the given area if no frame was given
 */
static sRect ComputeFittedRect(AVFrame *frame, uint64_t dispX, uint64_t dispY, uint64_t dispWidth, uint64_t dispHeight)
{
	if (!frame || dispWidth == 0 || dispHeight == 0)
		return { dispX, dispY, dispWidth, dispHeight };

	double frameWidth = frame->width > 0 ? frame->width : 1.0;
	double frameHeight = frame->height > 0 ? frame->height : 1.0;
	double frameSar = av_q2d(frame->sample_aspect_ratio) ? av_q2d(frame->sample_aspect_ratio) : 1.0;
	double dispAspect = static_cast<double>(dispWidth) / static_cast<double>(dispHeight);
	double frameAspect = frameWidth / frameHeight * frameSar;

	double picWidthD = dispWidth;
	double picHeightD = dispHeight;

	if (dispAspect > frameAspect) {
		// letterbox horizontally (frame narrower than display)
		picWidthD = dispHeight * frameAspect;
		if (picWidthD <= 0 || picWidthD > dispWidth)
			picWidthD = dispWidth;
	} else {
		// pillarbox vertically (frame wider than display)
		picHeightD = dispWidth / frameAspect;
		if (picHeightD <= 0 || picHeightD > dispHeight)
			picHeightD = dispHeight;
	}

	// round to the nearest pixel
	uint64_t picWidth = std::llround(std::max(0.0, picWidthD));
	uint64_t picHeight = std::llround(std::max(0.0, picHeightD));

	int64_t offsetX = static_cast<int64_t>(dispWidth) - static_cast<int64_t>(picWidth);
	int64_t offsetY = static_cast<int64_t>(dispHeight) - static_cast<int64_t>(picHeight);
	uint64_t posX = dispX + static_cast<uint64_t>(std::max<int64_t>(0, offsetX / 2));
	uint64_t posY = dispY + static_cast<uint64_t>(std::max<int64_t>(0, offsetY / 2));

	return { posX, posY, picWidth, picHeight };
}

/**
 * Create an hdr blob and set it for the connector
 *
 * @param hdrData   hdr metadata
 */
void cVideoRender::SetHdrBlob(struct hdr_output_metadata hdrData)
{
	uint32_t blobID = 0;
	if (m_pDrmDevice->CreateHdrBlob(&hdrData, sizeof(hdrData), &blobID)) {
		LOGERROR("videorender: %s: HDR: Failed to create hdr property blob.", __FUNCTION__);
	} else if (m_pDrmDevice->SetConnectorHdrBlobProperty(blobID)) {
		LOGERROR("videorender: %s: HDR: Failed to set hdr property", __FUNCTION__);
	}

	if (blobID)
		m_pDrmDevice->DestroyHdrBlob(blobID);

	if (!m_colorRangeStored) {
		uint64_t value;
		if (!m_pDrmDevice->GetVideoPlaneColorRange(&value)) {
			m_originalColorRange = static_cast<drmColorRange>(value);
			m_colorRangeStored = true;
		}
	}
}

/**
 * Set kms color space, color encoding and color range
 *
 * depending on the hdr data
 *
 * @param colorRange   color range to set
 */
void cVideoRender::SetColorSpace(drmColorRange colorRange)
{
	drmModeAtomicReqPtr modeReq;
	const uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;

	if (!(modeReq = m_pDrmDevice->ModeAtomicAlloc()))
		LOGFATAL("videorender: %s: cannot allocate atomic request (%d): %m", __FUNCTION__, errno);

	m_pDrmDevice->SetConnectorColorspace(modeReq, m_pHdrMetadata.GetColorPrimaries() == AVCOL_PRI_BT2020 ? COLORSPACE_BT2020_RGB : COLORSPACE_BT709_YCC);
	m_pDrmDevice->SetVideoPlaneColorEncoding(modeReq, m_pHdrMetadata.GetColorPrimaries() == AVCOL_PRI_BT2020 ? COLORENCODING_BT2020 : COLORENCODING_BT709);
	m_pDrmDevice->SetVideoPlaneColorRange(modeReq, colorRange);

	LOGDEBUG2(L_DRM, "videorender: %s: HDR: connector %d -> Colorspace %s", __FUNCTION__,
		m_pDrmDevice->ConnectorId(), m_pHdrMetadata.GetColorPrimaries() == AVCOL_PRI_BT2020 ? "BT2020_RGB" : "BT709_YCC");

	LOGDEBUG2(L_DRM, "videorender: %s: HDR: plane %d -> COLOR_ENCODING %s, COLOR_RANGE %s (Color %d)", __FUNCTION__,
		m_pDrmDevice->VideoPlane()->GetId(), m_pHdrMetadata.GetColorPrimaries() == AVCOL_PRI_BT2020 ? "YCBCR_BT20202" : "YCBCR_BT709",
		colorRange == COLORRANGE_FULL ? "full" : "limited", m_pHdrMetadata.GetColorPrimaries());

	if (m_pDrmDevice->ModeAtomicCommit(modeReq, flags, NULL) != 0) {
		m_pDrmDevice->ModeAtomicFree(modeReq);
		LOGFATAL("videorender: %s: cannot set atomic mode (%d): %m", __FUNCTION__, errno);
	}

	m_pDrmDevice->ModeAtomicFree(modeReq);

	m_hasDoneHdrModeset = true;
}

/**
 * Restore color space, color encoding and color range
 * to BT709 and the original color range
 */
void cVideoRender::RestoreColorSpace(void)
{
	drmModeAtomicReqPtr modeReq;
	const uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;

	if (!(modeReq = m_pDrmDevice->ModeAtomicAlloc()))
		LOGFATAL("videorender: %s: cannot allocate atomic request (%d): %m", __FUNCTION__, errno);

	m_pDrmDevice->SetConnectorHdrOutputMetadata(modeReq, 0);
	m_pDrmDevice->SetConnectorColorspace(modeReq, COLORSPACE_BT709_YCC);
	m_pDrmDevice->SetVideoPlaneColorEncoding(modeReq, COLORENCODING_BT709);
	m_pDrmDevice->SetVideoPlaneColorRange(modeReq, m_colorRangeStored ? static_cast<uint64_t>(m_originalColorRange) : static_cast<uint64_t>(COLORRANGE_LIMITED));

	if (m_pDrmDevice->ModeAtomicCommit(modeReq, flags, NULL) != 0) {
		m_pDrmDevice->ModeAtomicFree(modeReq);
		LOGFATAL("videorender: %s: cannot set atomic mode (%d): %m", __FUNCTION__, errno);
	}

	m_pDrmDevice->ModeAtomicFree(modeReq);

	m_hasDoneHdrModeset = false;
	m_colorRangeStored = false;
}

/**
 * Modesetting for video
 *
 * @param[in] buf    drm video buffer to display
 *
 * @retval 1         no modesetting was done
 * @retval 0         modesetting was done
 */
int cVideoRender::SetVideoBuffer(cDrmBuffer *buf)
{
	if (!buf)
		return 1;

	AVFrame *frame = buf->frame;

	if (frame && m_enableHdr) {
		struct hdr_output_metadata hdrData;
		AVFrameSideData *sd1 = av_frame_get_side_data(frame, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA);
		AVFrameSideData *sd2 = av_frame_get_side_data(frame, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL);

		if (!m_pHdrMetadata.Build(&hdrData, frame->color_primaries, frame->color_trc, sd1, sd2)) {
			SetHdrBlob(hdrData);
			SetColorSpace(COLORRANGE_LIMITED);
		}
	}

	// set display dimensions as default
	uint64_t dispWidth = m_pDrmDevice->DisplayWidth();
	uint64_t dispHeight = m_pDrmDevice->DisplayHeight();
	uint64_t dispX = 0;
	uint64_t dispY = 0;

	cDrmPlane *videoPlane = m_pDrmDevice->VideoPlane();

	// get video size and position
	if (m_videoIsScaled) {
		dispWidth = m_videoRect.Width();
		dispHeight = m_videoRect.Height();
		dispX = m_videoRect.X();
		dispY = m_videoRect.Y();
	}

	// fit frame into display
	sRect fittedRect = ComputeFittedRect(frame, dispX, dispY, dispWidth, dispHeight);

	// now set the plane parameters
	videoPlane->SetParams(m_pDrmDevice->CrtcId(), buf->Id(),
		fittedRect.x, fittedRect.y, fittedRect.w, fittedRect.h,
		0, 0, buf->Width(), buf->Height());

	buf->SetSizeOnScreen(fittedRect.x, fittedRect.y, fittedRect.w, fittedRect.h); // remember for grab

	return 0;
}

/**
 * Modesetting for osd
 *
 * @retval 1     osd is not dirty, do nothing
 * @retval 0     osd modesetting was done
 */
int cVideoRender::SetOsdBuffer(drmModeAtomicReqPtr modeReq)
{
	if (!m_pBufOsd || !m_pBufOsd->IsDirty())
		return 1;

	cDrmPlane *videoPlane = m_pDrmDevice->VideoPlane();
	cDrmPlane *osdPlane = m_pDrmDevice->OsdPlane();

	// We had draw activity on the osd buffer
	if (m_pDrmDevice->UseZpos()) {
		videoPlane->SetZpos(m_osdShown ? m_pDrmDevice->ZposPrimary() : m_pDrmDevice->ZposOverlay());
		osdPlane->SetZpos(m_osdShown ? m_pDrmDevice->ZposOverlay() : m_pDrmDevice->ZposPrimary());
		videoPlane->SetPlaneZpos(modeReq);
		osdPlane->SetPlaneZpos(modeReq);

		LOGDEBUG2(L_DRM, "videorender: %s: SetPlaneZpos: video->plane_id %d -> zpos %" PRIu64 ", osd->plane_id %d -> zpos %" PRIu64 "", __FUNCTION__,
			videoPlane->GetId(), videoPlane->GetZpos(),
			osdPlane->GetId(), osdPlane->GetZpos());
	}

	uint64_t crtcW = m_osdShown ? m_pDrmDevice->DisplayWidth() : 0;
	uint64_t crtcH = m_osdShown ? m_pDrmDevice->DisplayHeight() : 0;
	uint64_t srcW = m_osdShown ? m_pBufOsd->Width() : 0;
	uint64_t srcH = m_osdShown ? m_pBufOsd->Height() : 0;

	// now set the plane parameters
	osdPlane->SetParams(m_pDrmDevice->CrtcId(), m_pBufOsd->Id(),
		0, 0, crtcW, crtcH,
		0, 0, srcW, srcH);

	m_pBufOsd->SetSizeOnScreen(0, 0, crtcW, crtcH); // remember for grab

	m_pBufOsd->MarkClean();
	return 0;
}

/**
 * Modesetting for pip
 *
 * @param[in] buf    drm video buffer to display
 *
 * @retval 1         no modesetting was done
 * @retval 0         modesetting was done
 */
int cVideoRender::SetPipBuffer(cDrmBuffer *buf)
{
	if (!buf || !m_pipActive || m_videoIsScaled)
		return 1;

	AVFrame *frame = buf->frame;

	// set display dimensions as default
	uint64_t dispWidth = m_pDrmDevice->DisplayWidth();
	uint64_t dispHeight = m_pDrmDevice->DisplayHeight();
	uint64_t dispX = 0;
	uint64_t dispY = 0;

	cDrmPlane *pipPlane = m_pDrmDevice->PipPlane();

	// Get video size and position
	if (m_videoIsScaled) {
		dispWidth = m_videoRect.Width();
		dispHeight = m_videoRect.Height();
		dispX = m_videoRect.X();
		dispY = m_videoRect.Y();
	}

	// fit frame into display
	sRect fittedRect = ComputeFittedRect(frame, dispX, dispY, dispWidth, dispHeight);

	// compute pip window with given scaling and positioning values from menu
	int64_t centerOffsetX = static_cast<int64_t>(dispWidth) - static_cast<int64_t>(fittedRect.w);
	int64_t centerOffsetY = static_cast<int64_t>(dispHeight) - static_cast<int64_t>(fittedRect.h);
	centerOffsetX = std::max<int64_t>(0, centerOffsetX / 2);
	centerOffsetY = std::max<int64_t>(0, centerOffsetY / 2);

	double crtcWD = fittedRect.w * m_pipScalePercent / 100.0;
	double crtcHD = fittedRect.h * m_pipScalePercent / 100.0;
	uint64_t crtcW = std::llround(crtcWD);
	uint64_t crtcH = std::llround(crtcHD);

	double spaceW = dispWidth - crtcW - centerOffsetX;
	double spaceH = dispHeight - crtcH - centerOffsetY;

	uint64_t crtcX = dispX + std::llround(spaceW * m_pipLeftPercent / 100.0 + centerOffsetX * m_pipScalePercent / 100.0);
	uint64_t crtcY = dispY + std::llround(spaceH * m_pipTopPercent / 100.0 + centerOffsetY * m_pipScalePercent / 100.0);

	// now set the plane parameters
	pipPlane->SetParams(m_pDrmDevice->CrtcId(), buf->Id(),
		crtcX, crtcY, crtcW, crtcH,
		0, 0, buf->Width(), buf->Height());

	buf->SetSizeOnScreen(crtcX, crtcY, crtcW, crtcH); // remember for grab

	return 0;
}

/**
 * Commit the frame to the hardware
 *
 * @param buf        video drm buffer
 *
 * @retval 0         modesetting and commit was done, need to process outstanding DRM events
 * @retval -1        no modesetting and commit was done
 */
int cVideoRender::CommitBuffer(cDrmBuffer *buf, cDrmBuffer *pip)
{
	enum modeSetLevel {
		MODESET_OSD   = (1 << 0),
		MODESET_VIDEO = (1 << 1),
		MODESET_PIP   = (1 << 2)
	};

	int modeSet = 0;
	cDrmPlane *videoPlane = m_pDrmDevice->VideoPlane();
	cDrmPlane *osdPlane = m_pDrmDevice->OsdPlane();
	cDrmPlane *pipPlane = m_pDrmDevice->PipPlane();
	drmModeAtomicReqPtr modeReq;
	uint32_t flags = DRM_MODE_PAGE_FLIP_EVENT;

	if (!(modeReq = m_pDrmDevice->ModeAtomicAlloc())) {
		LOGERROR("videorender: %s: cannot allocate atomic request (%d): %m", __FUNCTION__, errno);
		return -1;
	}

	// handle the video plane
	// If no new video is available, set the old buffer again, if available.
	// This is necessary to recognize a size-change in SetVideoBuffer().
	// Though this is not expensive, maybe we should only call that, if size really changed.
	if (!SetVideoBuffer(buf) || !SetVideoBuffer(m_pCurrentlyDisplayed)) {
		videoPlane->SetPlane(modeReq);
		modeSet |= MODESET_VIDEO;
//		LOGDEBUG2(L_DRM, "videorender: %s: SetPlane Video (fb = %" PRIu64 ")", __FUNCTION__, videoPlane->GetFbId());
	}

	// handle the pip plane
	if (pipPlane->GetId()) {
		if (!SetPipBuffer(pip) || !SetPipBuffer(m_pCurrentlyPipDisplayed))
			pipPlane->SetPlane(modeReq);
		else
			pipPlane->ClearPlane(modeReq);

		modeSet |= MODESET_PIP;
	}

	// handle the osd plane
	if (!SetOsdBuffer(modeReq)) {
		osdPlane->SetPlane(modeReq);
		modeSet |= MODESET_OSD;
//		LOGDEBUG2(L_DRM, "videorender: %s: SetPlane OSD %d (fb = %" PRIu64 ")", __FUNCTION__, m_osdShown, osdPlane->GetFbId());
	}

	// return without an atomic commit (no video frame and osd activity)
	if (!modeSet) {
		m_pDrmDevice->ModeAtomicFree(modeReq);
		return -1;
	}

	// do the atomic commit
	if (m_pDrmDevice->ModeAtomicCommit(modeReq, flags, NULL) != 0) {
		if (modeSet & MODESET_OSD)
			osdPlane->DumpParameters("osd");
		if (modeSet & MODESET_VIDEO)
			videoPlane->DumpParameters("video");
		if (modeSet & MODESET_PIP)
			pipPlane->DumpParameters("pip");

		m_pDrmDevice->ModeAtomicFree(modeReq);
		LOGERROR("videorender: %s: page flip failed (%d): %m", __FUNCTION__, errno);
		return -1;
	}

	m_pDrmDevice->ModeAtomicFree(modeReq);

	return 0;
}

/**
 * Log A/V sync debug message
 *
 * @param audioPtsMs               audio pts
 * @param videoPtsMs               video pts
 * @param audioBehindVideoByMs     audio is behind video by this many ms
 */
void cVideoRender::LogDroppedDuped(int64_t audioPtsMs, int64_t videoPtsMs, int audioBehindVideoByMs)
{
	bool logDropDup = true;

	if (audioBehindVideoByMs > AV_SYNC_THRESHOLD_AUDIO_BEHIND_VIDEO_MS)
		m_framesDuped++;
	else if (audioBehindVideoByMs < -AV_SYNC_THRESHOLD_AUDIO_AHEAD_VIDEO_MS)
		m_framesDropped++;
	else
		logDropDup = false;

	LOGDEBUG2(L_AV_SYNC, "%s (%d|%d|%d) Pkts %d Frames %d Rb %d bytes (%dms) PTS: in %s a %s v %s user delay %dms hw delay %dms diff %dms",
		(logDropDup && (audioBehindVideoByMs > 0)) ? "Frame duped" : (logDropDup ? "Frame dropped" : "Frames:"),
		m_framesDropped,
		m_framesDuped,
		m_startCounter,
		m_pDevice->VideoStream()->GetAvPacketsFilled(),
		m_drmBufferQueue.Size(),
		m_pAudio->GetUsedRingbufferBytes(),
		m_pAudio->GetUsedRingbufferMs(),
		Timestamp2String(m_pAudio->GetInputPtsMs(), 1),
		Timestamp2String(audioPtsMs, 1),
		Timestamp2String(videoPtsMs, 1),
		m_pDevice->GetVideoAudioDelayMs(),
		m_pAudio->GetHardwareOutputDelayMs(),
		audioBehindVideoByMs);
}

/**
 * Get frame flags
 *
 * @param frame       AVFrame
 *
 * @return            FRAME_FLAG_TRICKSPEED or FRAME_FLAG_STILLPICTURE
 */
int cVideoRender::GetFrameFlags(AVFrame *frame)
{
	if (!frame || !frame->opaque_ref)
		return 0;

	int *frameFlags = (int *)frame->opaque_ref->data;
	return *frameFlags;
}

/**
 * Set frame flags
 *
 * @param frame     AVFrame
 * @param flags     FRAME_FLAG_TRICKSPEED and/or FRAME_FLAG_STILLPICTURE
 */
void cVideoRender::SetFrameFlags(AVFrame *frame, int flags)
{
	int *frameFlags;
	if (!frame->opaque_ref) {
		frame->opaque_ref = av_buffer_allocz(sizeof(*frameFlags));
		if (!frame->opaque_ref) {
			LOGFATAL("videorender: %s: cannot allocate private frame data", __FUNCTION__);
		}
	}

	frameFlags = (int *)frame->opaque_ref->data;
	*frameFlags = flags;
}

/**
 * Do the pageflip
 *
 * @param buf       drm buffer
 * @param pipBuf    drm pip buffer
 * @return          true if page flip was done
 */
bool cVideoRender::PageFlip(cDrmBuffer *buf, cDrmBuffer *pipBuf)
{
	if (CommitBuffer(buf, pipBuf) < 0) {
		// no modesetting was done
		if (buf && buf->frame)
			av_frame_free(&buf->frame);
		if (pipBuf && pipBuf->frame)
			av_frame_free(&pipBuf->frame);

		return false;
	} else {
		if (m_pDrmDevice->HandleEvent() != 0)
			LOGERROR("threads: display thread: drmHandleEvent failed!");

		m_flipCounter++;

		// now, that we had a successful commit, set the STC if we have a frame. Skip if only the OSD was updated.
		if (buf && buf->frame) {
			if (buf->frame->pts != AV_NOPTS_VALUE)
				SetVideoClock(buf->frame->pts);

			LOGDEBUG2(L_PACKET, "videorender: %s: ID %d:                 PTS %s", __FUNCTION__, buf->Id(), Timestamp2String(buf->frame->pts, 90));
		}

		return true;
	}
}

/*****************************************************************************
 * Thread
 ****************************************************************************/

/**
 * Thread loop, which tries to display frames and processes events
 */
void cVideoRender::Action(void)
{
	LOGDEBUG("videorender: display thread started");
	while(Running()) {
		m_mutex.lock();

		bool scheduleImmediately = DisplayFrame();

		m_mutex.unlock();

		ProcessEvents();

		if (scheduleImmediately)
			usleep(100); // yield thread. give control also to threads with lower priority.
		else
			usleep(1000);
	}
	LOGDEBUG("videorender: display thread stopped");
}

/**
 * Stop the thread
 */
void cVideoRender::Stop(void)
{
	if (!Active())
		return;

	LOGDEBUG("videorender: stopping display thread");
	Cancel(2);
}

/**
 * Do the AV Sync
 *
 * @param audioPtsMs               audio pts
 * @param videoPtsMs               video pts
 *
 * @return true if the frame should be dropped, false otherwise
 */
bool cVideoRender::FrameDropNecessary(int64_t audioPtsMs, int64_t videoPtsMs)
{
	int audioBehindVideoByMs = videoPtsMs - audioPtsMs - m_pDevice->GetVideoAudioDelayMs();

	bool skipSync = m_scheduleResyncAtPtsMs != AV_NOPTS_VALUE;

	// resync, if the video pts reaches the scheduled resync pts
	// skip the resync, if the difference between the resync-pts and the current video pts is greater
	// than the AV_RESYNC_BORDER_MS to sort out false positives
	if (m_scheduleResyncAtPtsMs != AV_NOPTS_VALUE && m_scheduleResyncAtPtsMs <= videoPtsMs) {
		if (std::abs(PtsToMs(m_scheduleResyncAtPtsMs) - PtsToMs(videoPtsMs)) <= m_pAudio->GetAvResyncBorderMs()) {
			LOGDEBUG2(L_AV_SYNC, "videorender: resync schedule arrived at %s, current audio pts %s video pts %s",
				Timestamp2String(m_scheduleResyncAtPtsMs, 1), Timestamp2String(audioPtsMs, 1), Timestamp2String(videoPtsMs, 1));
			m_eventQueue.push_back(ResyncEvent{});
		}
		m_scheduleResyncAtPtsMs = AV_NOPTS_VALUE;
	}

	// Pause was scheduled and we reached this pts now
	if (m_videoPlaybackPauseScheduledAt != AV_NOPTS_VALUE && m_videoPlaybackPauseScheduledAt < videoPtsMs) {
		LOGDEBUG2(L_AV_SYNC, "videorender: %s: pause was scheduled at %s)!", __FUNCTION__, Timestamp2String(videoPtsMs, 1));
		m_videoPlaybackPauseScheduledAt = AV_NOPTS_VALUE;
		m_displayOneFrameThenPause = true;
	// Resuming audio from pause was scheduled audio needs to catch up video
	} else if (m_resumeAudioScheduled && audioBehindVideoByMs >= 0 && !skipSync) {
		LOGDEBUG2(L_AV_SYNC, "videorender: resuming audio playback: video %s, audio %s", Timestamp2String(videoPtsMs, 1), Timestamp2String(audioPtsMs, 1));
		m_pAudio->SetPaused(false);
		m_resumeAudioScheduled = false;
	// Duplicate frame
	} else if (audioBehindVideoByMs > AV_SYNC_THRESHOLD_AUDIO_BEHIND_VIDEO_MS &&
	           !skipSync && !m_pAudio->IsPaused()) {
		LogDroppedDuped(audioPtsMs, videoPtsMs, audioBehindVideoByMs);
		m_framePresentationCounter++; // display the current video frame one period longer
	// Drop frame - max every second frame. Otherwise, the buffer gets drained immediately, if multiple frames in a row are dropped.
	} else if (audioBehindVideoByMs < -AV_SYNC_THRESHOLD_AUDIO_AHEAD_VIDEO_MS &&
	           !m_lastFrameWasDropped && !skipSync && !m_pAudio->IsPaused()) {
		LogDroppedDuped(audioPtsMs, videoPtsMs, audioBehindVideoByMs);
		m_framePresentationCounter--; // skip this pageflip
		m_lastFrameWasDropped = true;

		return true;
	}

//	LogDroppedDuped(audioPtsMs, videoPtsMs, audioBehindVideoByMs);

	// log AV diff for the first 10 frames and every 10 seconds
//	if (m_startCounter < 10 || m_startCounter % 500 == 0)
//		LOGDEBUG2(L_AV_SYNC, "drop %d, dup %d, total %d audio %s video %s Delay %dms kernel buffer delay %dms diff %dms",
//		m_framesDropped, m_framesDuped, m_startCounter,
//		Timestamp2String(audioPtsMs, 1), Timestamp2String(videoPtsMs, 1),
//		m_pDevice->GetVideoAudioDelayMs(), m_pAudio->GetHardwareOutputDelayMs(), audioBehindVideoByMs);

	m_startCounter++;

	return false;
}

/**
 * Display the frame (video and/or osd)
 *
 * @return true if it shall be scheduled immediately again
 */
bool cVideoRender::DisplayFrame(void)
{
	bool frameTick = m_flipCounter % m_framesPerFlipCycle == 0;

	if (m_pDevice->IsBufferingThresholdReached())
		m_eventQueue.push_back(BufferingThresholdReachedEvent{});

	bool skipBufferUnderrunCheck = m_videoPlaybackPaused ||
	                               m_displayOneFrameThenPause ||
	                               m_videoPlaybackPauseScheduledAt != AV_NOPTS_VALUE ||
	                               m_pDevice->IsVideoOnlyPlayback() ||
	                               IsTrickSpeed() ||
	                               IsStillpicture() ||
	                               m_pDevice->IsDraining() ||
	                               m_schedulePlaybackStartAtPtsMs != AV_NOPTS_VALUE;
	if (m_pDevice->VideoStream()->GetAvPacketsFilled() == 0 && !skipBufferUnderrunCheck)
		m_eventQueue.push_back(BufferUnderrunEvent{VIDEO});

	cDrmBuffer *drmBuffer = nullptr;
	if ((!m_videoPlaybackPaused || m_schedulePlaybackStartAtPtsMs != AV_NOPTS_VALUE) && m_framePresentationCounter == 0 && frameTick)
		drmBuffer = m_drmBufferQueue.Peek();

	cDrmBuffer *pipBuffer = m_pipDrmBufferQueue.Pop();

	bool pageFlipDone = false;
	if (drmBuffer) {
		if (m_framePresentationCounter == 0) {
			if (m_pCurrentlyDisplayed) {
				int64_t interFrameGapMs = std::abs(PtsToMs(drmBuffer->frame->pts - m_pCurrentlyDisplayed->frame->pts));
				m_framePresentationCounter = GetFramePresentationCount(interFrameGapMs);
			} else
				m_framePresentationCounter = 1;
		}

		if (m_schedulePlaybackStartAtPtsMs != AV_NOPTS_VALUE) {
			// check if playback shall start
			if (PtsToMs(drmBuffer->frame->pts) < m_schedulePlaybackStartAtPtsMs) {
				drmBuffer->PresentationFinished();
				m_drmBufferQueue.Pop();
				return true;
			} else {
				m_schedulePlaybackStartAtPtsMs = AV_NOPTS_VALUE;
				m_videoPlaybackPaused = false;
			}
		} else if (!m_displayOneFrameThenPause && !IsStillpicture()) {
			// A/V sync
			int64_t audioPtsMs = m_pAudio->GetHardwareOutputPtsMs();
			int64_t videoPtsMs = PtsToMs(drmBuffer->frame->pts);
			if (audioPtsMs != AV_NOPTS_VALUE && FrameDropNecessary(audioPtsMs, videoPtsMs)) {
				// drop frame
				drmBuffer->PresentationFinished();
				if (pipBuffer)
					pipBuffer->PresentationFinished();
				m_drmBufferQueue.Pop();
				return true;
			}

			if (m_videoPlaybackPaused || IsTrickSpeed())
				m_pAudio->DropSamplesOlderThanPtsMs(drmBuffer->frame->pts * 1000 * av_q2d(m_timebase));
		}

		pageFlipDone = PageFlip(drmBuffer, pipBuffer);

		// log channel switch duration
		if (m_pDevice->Transferring() && ((m_startCounter == 0 && m_displayOneFrameThenPause) || m_startCounter == 1)) {
			auto now = std::chrono::steady_clock::now();
			auto channelSwitchDurationMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_pDevice->GetChannelSwitchStartTime()).count();
			auto durationSinceFirstPacketMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_pDevice->GetChannelSwitchFirstPacketTime()).count();

			if (m_startCounter == 0) {
				LOGDEBUG("first frame displayed %dms after channel switch, %dms after first packet was received", channelSwitchDurationMs, durationSinceFirstPacketMs);
			} else {
				if (m_pConfig->ConfigShowChannelSwitchDurationMessage)
					Skins.Message(mtInfo, cString::sprintf(tr("channel switch done in %ldms (%ldms)"), channelSwitchDurationMs, durationSinceFirstPacketMs));
				LOGDEBUG("playback start fired %dms after channel switch, %dms after first packet was received", channelSwitchDurationMs, durationSinceFirstPacketMs);
			}
		}

		if (m_displayOneFrameThenPause) {
			m_videoPlaybackPaused = true;
			m_displayOneFrameThenPause = false;
		}

		if (m_pCurrentlyDisplayed)
			m_pCurrentlyDisplayed->PresentationFinished();

		m_lastFrameWasDropped = false;
		m_pCurrentlyDisplayed = drmBuffer;

		m_drmBufferQueue.Pop();
	} else if (m_pCurrentlyDisplayed && !m_videoPlaybackPaused) {
		// display the current frame again in trick speed mode or for A/V syncing
		pageFlipDone = PageFlip(m_pCurrentlyDisplayed, pipBuffer);
	} else if ((m_pBufOsd && m_pBufOsd->IsDirty()) || pipBuffer) {
		pageFlipDone = PageFlip(NULL, pipBuffer);
	}

	if (pipBuffer) {
		if (m_pCurrentlyPipDisplayed && m_pCurrentlyPipDisplayed != pipBuffer)
			m_pCurrentlyPipDisplayed->PresentationFinished();

		m_pCurrentlyPipDisplayed = pipBuffer;
	}

	if (m_framePresentationCounter > 0)
		m_framePresentationCounter--;

	CreateGrabBuffers(!m_videoIsScaled);

	return pageFlipDone;
}

/**
 * Display a black video frame
 */
void cVideoRender::DisplayBlackFrame(void)
{
	LOGDEBUG2(L_DRM, "videorender: %s: closing, set a black FB", __FUNCTION__);

	PageFlip(&m_bufBlack, NULL);

	if (m_pCurrentlyDisplayed) {
		av_frame_free(&m_pCurrentlyDisplayed->frame);
		m_pCurrentlyDisplayed->Destroy();
		m_pCurrentlyDisplayed = nullptr;
	}
}

/**
 * Convert a PTS to milliseconds
 */
int64_t cVideoRender::PtsToMs(int64_t pts)
{
	std::lock_guard<std::mutex> lock(m_timebaseMutex);

	return pts * 1000 * av_q2d(m_timebase);
}

/**
 * Wrapper for drmHandleEvent()
 */
int cVideoRender::DrmHandleEvent(void)
{
	return m_pDrmDevice->HandleEvent();
}

/**
 * Return true, if the device can handle HDR
 */
bool cVideoRender::CanHandleHdr(void)
{
	return m_pDrmDevice->CanHandleHdr();
}

/*****************************************************************************
 * OSD
 ****************************************************************************/

/**
 * Clear the OSD (draw an empty/ transparent OSD)
 */
void cVideoRender::OsdClear(void)
{
#ifdef USE_GLES
	if (m_disableOglOsd) {
		memset((void *)m_pBufOsd->Plane(0), 0,
			(size_t)(m_pBufOsd->Pitch(0) * m_pBufOsd->Height()));
	} else {
		cDrmBuffer *buf;

		EGL_CHECK(eglSwapBuffers(m_pDrmDevice->EglDisplay(), m_pDrmDevice->EglSurface()));
		m_pNextBo = gbm_surface_lock_front_buffer(m_pDrmDevice->GbmSurface());
		assert(m_pNextBo);

		buf = m_pDrmDevice->GetBufFromBo(m_pNextBo);
		if (!buf) {
			LOGERROR("videorender: %s: Failed to get GL buffer", __FUNCTION__);
			return;
		}

		m_pBufOsd = buf;

		// release old buffer for writing again
		if (m_bo)
			gbm_surface_release_buffer(m_pDrmDevice->GbmSurface(), m_bo);

		// rotate bos and create and keep bo as m_pOldBo to make it free'able
		m_pOldBo = m_bo;
		m_bo = m_pNextBo;

		LOGDEBUG2(L_OPENGL, "videorender: %s: eglSwapBuffers m_eglDisplay %p eglSurface %p (%i x %i, %i)", __FUNCTION__, m_pDrmDevice->EglDisplay(), m_pDrmDevice->EglSurface(), buf->Width(), buf->Height(), buf->Pitch(0));
	}
#else
	memset((void *)m_pBufOsd->Plane(0), 0,
		(size_t)(m_pBufOsd->Pitch(0) * m_pBufOsd->Height()));
#endif

	m_pBufOsd->MarkDirty();
	m_osdShown = false;
}

#define MIN(a, b) ((a) < (b) ? (a) : (b))

/**
 * Draw an OSD ARGB image.
 *
 * @param xi         x-coordinate in argb image
 * @param yi         y-coordinate in argb image
 * @param height     height in pixel in argb image
 * @param width      width in pixel in argb image
 * @param pitch      pitch of argb image
 * @param argb       32bit ARGB image data
 * @param x          x-coordinate on screen of argb image
 * @param y          y-coordinate on screen of argb image
 */
void cVideoRender::OsdDrawARGB(int xi, int yi,
                               int width, int height, int pitch,
                               const uint8_t * argb, int x, int y)
{
#ifdef USE_GLES
	if (m_disableOglOsd) {
		LOGDEBUG2(L_OSD, "videorender: %s: width %d height %d pitch %d argb %p x %d y %d pitch buf %d xi %d yi %d", __FUNCTION__,
			width, height, pitch, argb, x, y, m_pBufOsd->Pitch(0), xi, yi);
		for (int i = 0; i < height; ++i) {
			memcpy(m_pBufOsd->Plane(0) + x * 4 + (i + y) * m_pBufOsd->Pitch(0),
				argb + i * pitch, MIN((size_t)pitch, m_pBufOsd->Pitch(0)));
		}
	} else {
		cDrmBuffer *buf;

		EGL_CHECK(eglSwapBuffers(m_pDrmDevice->EglDisplay(), m_pDrmDevice->EglSurface()));
		m_pNextBo = gbm_surface_lock_front_buffer(m_pDrmDevice->GbmSurface());
		assert(m_pNextBo);

		buf = m_pDrmDevice->GetBufFromBo(m_pNextBo);
		if (!buf) {
			LOGERROR("videorender: %s: Failed to get GL buffer", __FUNCTION__);
			return;
		}

		m_pBufOsd = buf;

		// release old buffer for writing again
		if (m_bo)
			gbm_surface_release_buffer(m_pDrmDevice->GbmSurface(), m_bo);

		// rotate bos and create and keep bo as m_pOldBo to make it free'able
		m_pOldBo = m_bo;
		m_bo = m_pNextBo;

		LOGDEBUG2(L_OPENGL, "videorender: %s: eglSwapBuffers eglDisplay %p eglSurface %p (%i x %i, %i)", __FUNCTION__, m_pDrmDevice->EglDisplay(), m_pDrmDevice->EglSurface(), buf->Width(), buf->Height(), buf->Pitch(0));
	}
#else
	// suppress unused variable warnings ...
	(void) xi;
	(void) yi;
	(void) width;

	for (int i = 0; i < height; ++i) {
		memcpy(m_pBufOsd->Plane(0) + x * 4 + (i + y) * m_pBufOsd->Pitch(0),
			argb + i * pitch, (size_t)pitch);
	}
#endif
	m_pBufOsd->MarkDirty();
	m_osdShown = true;
}

/**
 * Callback free primedata if av_buffer is unreferenced
 */
static void ReleaseFrame( __attribute__ ((unused)) void *opaque, uint8_t *data)
{
	AVDRMFrameDescriptor *primedata = (AVDRMFrameDescriptor *)data;

	av_free(primedata);
}

/**
 * Check, if the main render output buffer is full.
 *
 * @retval true     render output buffer is full
 */
bool cVideoRender::IsOutputBufferFull(void)
{
	return m_drmBufferQueue.IsFull();
}

/**
 * Push a main frame into the render ringbuffer
 */
void cVideoRender::PushMainFrame(AVFrame *frame)
{
	PushFrame(frame, IsTrickSpeed(), m_bufferReuseStrategy, m_decodingStrategy, &m_drmBufferQueue, &m_drmBufferPool, true);
}

/**
 * Push a PiP frame into the render ringbuffer
 */
void cVideoRender::PushPipFrame(AVFrame *frame)
{
	PushFrame(frame, false, m_pipBufferReuseStrategy, m_pipDecodingStrategy, &m_pipDrmBufferQueue, &m_pipDrmBufferPool, false);
}

/**
 * Push the frame into the render ringbuffer
 */
void cVideoRender::PushFrame(
	AVFrame *frame,
	bool trickspeed,
	std::atomic<cBufferStrategy*> &bufferReuseStrategy,
	std::atomic<cDecodingStrategy*> &decodingStrategy,
	cQueue<cDrmBuffer>* drmBufferQueue,
	cDrmBufferPool *drmBufferPool,
	bool mainFrame)
{
	if (bufferReuseStrategy == nullptr) {
		if (trickspeed)
			bufferReuseStrategy = new cBufferStrategyUseOnce();
		else if (frame->format == AV_PIX_FMT_DRM_PRIME)
			bufferReuseStrategy = new cBufferStrategyReuseHardware();
		else
			bufferReuseStrategy = new cBufferStrategyReuseSoftware();
	}

	if (decodingStrategy == nullptr) {
		if (frame->format == AV_PIX_FMT_DRM_PRIME)
			decodingStrategy = new cDecodingStrategyHardware();
		else
			decodingStrategy = new cDecodingStrategySoftware();
	}

	// Store the PTS of the first frame to be presented. The first frame might not have a valid PTS, if gone through a HW deinterlacer.
	//
	// @note: This is the only place outside of the display thread, where the video pts is set
	// (except setting it to AV_NOPTS_VALUE in cSofthdDevice::Clear() and ChangeState(STOP))
	// We only store here, if the stream recently started and the clock wasn't set already in the display thread

	if (mainFrame && GetVideoClock() == AV_NOPTS_VALUE && frame->pts != AV_NOPTS_VALUE)
		SetVideoClock(frame->pts);

	AVDRMFrameDescriptor *primedata = (AVDRMFrameDescriptor *)frame->data[0];
	cDrmBuffer *buf = bufferReuseStrategy.load()->GetBuffer(drmBufferPool, primedata);

	if (!buf)
		LOGFATAL("videorender: %s: no free DRM buffer found. This is a bug.", __FUNCTION__);

	frame = decodingStrategy.load()->PrepareDrmBuffer(buf, m_pDrmDevice->Fd(), frame);

	buf->frame = frame;
	buf->SetPresentationPending(true);

	drmBufferQueue->Push(buf);
}

/**
 * Get the output PTS in milliseconds
 *
 * Returns the presentation timestamp of the next frame to be displayed.
 *
 * @return PTS in milliseconds
 */
int64_t cVideoRender::GetOutputPtsMs(void)
{
	if (GetVideoClock() == AV_NOPTS_VALUE)
		return AV_NOPTS_VALUE;

	std::lock_guard<std::mutex> lock(m_timebaseMutex);

	return GetVideoClock() * 1000 * av_q2d(m_timebase);
}

/**
 * Send start condition to video thread
 */
void cVideoRender::ResetFrameCounter(void)
{
	m_startCounter = 0;
	LOGDEBUG("videorender: %s: reset m_startCounter %d TrickSpeed %d", __FUNCTION__, m_startCounter, IsTrickSpeed());
}

/**
 * Reset the renderer
 */
void cVideoRender::Reset(void)
{
	m_startCounter = 0;
	m_framesDuped = 0;
	m_framesDropped = 0;
	m_numWrongProgressive = 0;
	SetVideoClock(AV_NOPTS_VALUE);
	m_flipCounter = 0;

	delete m_decodingStrategy;
	m_decodingStrategy = nullptr;
}

/**
 * Set the trickspeed parameters
 *
 * @param speed         trick speed value from VDR (0 = normal)
 * @param active        true if trickspeed is active
 * @param forward       true if forward trick speed, false if backward
 */
void cVideoRender::SetTrickSpeed(double speed, bool active, bool forward)
{
	LOGDEBUG2(L_TRICK, "videorender: %s: set trick speed %.3f %s %s", __FUNCTION__, speed, speed > 1.0 ? "fast" : "slow", forward ? "forward" : "backward");
	m_framePresentationCounter = 1;
	m_trickspeedFactor = speed;
	m_trickspeed = active;
	m_forwardTrickspeed = forward;
}

/**
 * Get the number of times the current frame shall be presented in trickspeed mode.
 * This is calculated based on the inter-frame gap (distance between each I-frame VDR sends us during trickspeed), the refresh rate of the output device, and the trickspeed speed.
 *
 * @param interFrameGapMs      inter-frame gap in ms
 * @retval                     number of times the current frame shall be presented
 */
int cVideoRender::GetFramePresentationCount(int64_t interFrameGapMs)
{
	if (!IsTrickSpeed())
		return 1;

	// Calculate the expected number of display refreshes for this frame
	double interFrameGapSec = interFrameGapMs / 1000.0;
	double refreshPeriodSec = 1.0 / m_refreshRateHz;
	int displayCount = std::max(1, static_cast<int>(std::round(interFrameGapSec / refreshPeriodSec / m_trickspeedFactor)));

	return displayCount;
}

/*****************************************************************************
 * Grabbing
 ****************************************************************************/

/**
 * Trigger a screen grab
 *
 * @retval 0     on success, grab was triggered
 * @retval 1     on timeout, grab was not triggered
 */
int cVideoRender::TriggerGrab(void)
{
	int timeoutMs = 500;
	cMutex mutex;
	mutex.Lock();
	m_startgrab = true;
	int err = 0;

	if (!m_grabCond.TimedWait(mutex, timeoutMs)) {
		LOGWARNING("videorender: %s: timed out after %dms", __FUNCTION__, timeoutMs);
		err = 1;
	}

	std::lock_guard<std::mutex> lock(m_grabMutex);
	m_startgrab = false;

	return err;
}

/**
 * Copy current video, osd and pip buffers to dedicated grabbing buffers
 *
 * @param grabPip   true, if the pip buffer should be grabbed
 */
void cVideoRender::CreateGrabBuffers(bool grabPip)
{
	std::lock_guard<std::mutex> lock(m_grabMutex);

	if (!m_startgrab)
		return;

	if (m_pBufOsd && m_osdShown) {
		LOGDEBUG2(L_GRAB, "videorender: %s: Trigger osd grab arrived", __FUNCTION__);
		m_grabOsd.Set(m_pBufOsd);
	}

	cDrmBuffer *pbuf = m_pCurrentlyDisplayed ? m_pCurrentlyDisplayed : nullptr;
	if (pbuf) {
		LOGDEBUG2(L_GRAB, "videorender: %s: Trigger video grab arrived", __FUNCTION__);
		m_grabVideo.Set(pbuf);
	}

	cDrmBuffer *pipBuf = m_pCurrentlyPipDisplayed ? m_pCurrentlyPipDisplayed : nullptr;
	if (pipBuf && grabPip) {
		LOGDEBUG2(L_GRAB, "videorender: %s: Trigger pip grab arrived", __FUNCTION__);
		m_grabPip.Set(pipBuf);
	}

	m_grabCond.Broadcast();
}

/**
 * Clear the grab drm buffers
 */
void cVideoRender::ClearGrabBuffers(void)
{
	std::lock_guard<std::mutex> lock(m_grabMutex);

	m_grabOsd.Clear();
	m_grabVideo.Clear();
	m_grabPip.Clear();
}

/**
 * Get some rendering statistics
 *
 * @param[out] duped      number of duplicated frames
 * @param[out] dropped    number of dropped frames
 * @param[out] counter    number of decoded frames
 */
void cVideoRender::GetStats(int *duped, int *dropped, int *counter)
{
	*duped = m_framesDuped;
	*dropped = m_framesDropped;
	*counter = m_startCounter;
}

/*****************************************************************************
 * Setup and initialization
 ****************************************************************************/

/**
 * Wrapper to set the osd size in the device
 *
 * @param width           osd width
 * @param height          osd height
 */
void cVideoRender::SetOsdSize(int width, int height)
{
	m_pDevice->SetOsdSize(width, height);
}

/**
 * Wrapper to set the screen size in the device
 *
 * @param width           screen width
 * @param height          screen height
 * @param refreshRateHz   screen refresh rate in Hz
 * @param interlaced      true, if this is an interlaced screen mode
 */
void cVideoRender::SetScreenSize(int width, int height, double refreshRateHz, bool interlaced)
{
	m_refreshRateHz = refreshRateHz;
	m_pDevice->SetScreenSize(width, height);
	m_framesPerFlipCycle = interlaced ? 2 : 1;
	m_flipCounter = 0;
}

/**
 * Wrapper to set the display mode
 *
 * @param idx      idx in the setup menu display mode array
 */
void cVideoRender::SetDisplayMode(int idx)
{
	m_pDevice->SetDisplayMode(idx);
}

/**
 * Wrapper to check, if drm can handle the display mode
 *
 * @param mode      display mode
 */
bool cVideoRender::CanHandleMode(sDrmMode *mode)
{
	return m_pDrmDevice->CanHandleMode(mode);
}

/**
 * Init the osd and black buffer
 *
 * The osd buffer is only created in non-GLES mode
 *
 * Size of the black buffer: Initial (default) display size
 * Size of the osd buffer:   User requested size (if set as commandline arg) or initial (default) display size
 */
void cVideoRender::InitBuffers(void)
{
	// osd fb
#ifndef USE_GLES
	if (!m_pBufOsd)
		m_pBufOsd = new cDrmBuffer();

	m_pBufOsd->Setup(m_pDrmDevice->Fd(), m_pDrmDevice->OsdWidth(), m_pDrmDevice->OsdHeight(), DRM_FORMAT_ARGB8888, NULL, false);
#else
	if (m_disableOglOsd) {
		if (!m_pBufOsd)
			m_pBufOsd = new cDrmBuffer();

		m_pBufOsd->Setup(m_pDrmDevice->Fd(), m_pDrmDevice->OsdWidth(), m_pDrmDevice->OsdHeight(), DRM_FORMAT_ARGB8888, NULL, false);
	}
#endif

	// black fb
	LOGDEBUG2(L_DRM, "videorender: %s: Try to create a black FB", __FUNCTION__);
	m_bufBlack.Setup(m_pDrmDevice->Fd(), m_pDrmDevice->DisplayWidth(), m_pDrmDevice->DisplayHeight(), DRM_FORMAT_NV12, NULL, false);
	m_bufBlack.FillBlack();
}

/**
 * Re-Initialize the drm device with current display mode settings
 */
void cVideoRender::ReInitDisplayMode(void)
{
	if (m_pDrmDevice->ReInit())
		LOGFATAL("videorender: %s: Init drm device failed", __FUNCTION__);

	drmModeAtomicReqPtr modeReq;
	const uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;
	uint32_t modeID = 0;

	if (m_pDrmDevice->CreateModeBlob(&modeID) != 0)
		LOGFATAL("videorender: %s: Failed to create mode property blob.", __FUNCTION__);
	if (!(modeReq = m_pDrmDevice->ModeAtomicAlloc())) {
		m_pDrmDevice->DestroyModeBlob(modeID);
		LOGFATAL("videorender: %s: cannot allocate atomic request (%d): %m", __FUNCTION__, errno);
	}

	m_pDrmDevice->SetCrtcModeId(modeReq, modeID);
	m_pDrmDevice->SetConnectorCrtcId(modeReq);

	if (m_pDrmDevice->ModeAtomicCommit(modeReq, flags, NULL) != 0) {
		m_pDrmDevice->ModeAtomicFree(modeReq);
		m_pDrmDevice->DestroyModeBlob(modeID);
		LOGFATAL("videorender: %s: cannot set atomic mode (%d): %m", __FUNCTION__, errno);
	}

	m_pDrmDevice->ModeAtomicFree(modeReq);
	m_pDrmDevice->DestroyModeBlob(modeID);
}

/**
 * Initialize the renderer
 *
 * @retval 0 on success
 * @retval -1 on error
 */
int cVideoRender::Init(void)
{
	if (m_pDrmDevice->Init()) {
		LOGERROR("videorender: %s: Init drm device failed", __FUNCTION__);
		return -1;
	}

#ifdef USE_GLES
	if (!m_disableOglOsd && (m_pDrmDevice->InitGbm() || m_pDrmDevice->InitEGL())) {
		LOGERROR("videorender: %s: Init failed", __FUNCTION__);
		Exit();
		return -1;
	}
#endif

	m_pDevice->SetDrmCanDisplayPip(m_pDrmDevice->HasPipPlane());

	cDrmPlane *videoPlane = m_pDrmDevice->VideoPlane();
	cDrmPlane *osdPlane = m_pDrmDevice->OsdPlane();

	InitBuffers();

	// save actual modesetting
	m_pDrmDevice->SaveCrtc();

	drmModeAtomicReqPtr modeReq;
	const uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;
	uint32_t modeID = 0;

	if (m_pDrmDevice->CreateModeBlob(&modeID) != 0)
		LOGFATAL("videorender: %s: Failed to create mode property blob.", __FUNCTION__);
	if (!(modeReq = m_pDrmDevice->ModeAtomicAlloc())) {
		m_pDrmDevice->DestroyModeBlob(modeID);
		LOGFATAL("videorender: %s: cannot allocate atomic request (%d): %m", __FUNCTION__, errno);
	}

	m_pDrmDevice->SetCrtcModeId(modeReq, modeID);
	m_pDrmDevice->SetConnectorCrtcId(modeReq);
	m_pDrmDevice->SetCrtcActive(modeReq, 1);

	// Osd plane
	// We don't have the m_pBufOsd for OpenGL yet, so we can't set anything. Set src and FbId later when osd was drawn,
	// but initially move the OSD behind the VIDEO
#ifndef USE_GLES
	osdPlane->SetParams(m_pDrmDevice->CrtcId(), m_pBufOsd->Id(),
		0, 0, m_pDrmDevice->DisplayWidth(), m_pDrmDevice->DisplayHeight(),
		0, 0, m_pBufOsd->Width(), m_pBufOsd->Height());

	osdPlane->SetPlane(modeReq);
#else
	if (m_disableOglOsd) {
		osdPlane->SetParams(m_pDrmDevice->CrtcId(), m_pBufOsd->Id(),
			0, 0, m_pDrmDevice->DisplayWidth(), m_pDrmDevice->DisplayHeight(),
			0, 0, m_pBufOsd->Width(), m_pBufOsd->Height());

		osdPlane->SetPlane(modeReq);
	}
#endif
	if (m_pDrmDevice->UseZpos()) {
		videoPlane->SetZpos(m_pDrmDevice->ZposOverlay());
		videoPlane->SetPlaneZpos(modeReq);
#ifdef USE_GLES
		osdPlane->SetZpos(m_pDrmDevice->ZposPrimary());
		osdPlane->SetPlaneZpos(modeReq);
#endif
	}

	// Black buffer for video plane
	videoPlane->SetParams(m_pDrmDevice->CrtcId(), m_bufBlack.Id(),
		0, 0, m_pDrmDevice->DisplayWidth(), m_pDrmDevice->DisplayHeight(),
		0, 0, m_bufBlack.Width(), m_bufBlack.Height());

	videoPlane->SetPlane(modeReq);

	if (m_pDrmDevice->ModeAtomicCommit(modeReq, flags, NULL) != 0) {
#ifndef USE_GLES
		osdPlane->DumpParameters("osd");
#endif
		videoPlane->DumpParameters("video");

		m_pDrmDevice->DestroyModeBlob(modeID);
		m_pDrmDevice->ModeAtomicFree(modeReq);
		LOGFATAL("videorender: %s: cannot set atomic mode (%d): %m", __FUNCTION__, errno);
	}

	m_pDrmDevice->DestroyModeBlob(modeID);
	m_pDrmDevice->ModeAtomicFree(modeReq);

	m_osdShown = false;

	// init variables page flip
	m_pDrmDevice->InitEvent();

	Start();

	return 0;
}

/**
 * Delete the osd and black buffer
 *
 * The GBM bo (GLES OSD) are also destroyed here
 */
void cVideoRender::DeleteBuffers(void)
{
	m_bufBlack.Destroy();
#ifdef USE_GLES
	if (m_disableOglOsd) {
		if (m_pBufOsd) {
			m_pBufOsd->Destroy();
			delete m_pBufOsd;
		}
	} else {
		if (m_pNextBo)
			gbm_bo_destroy(m_pNextBo);
		if (m_pOldBo)
			gbm_bo_destroy(m_pOldBo);
	}
#else
	if (m_pBufOsd) {
		m_pBufOsd->Destroy();
		delete m_pBufOsd;
	}
#endif
}

/**
 * Exit and cleanup the renderer
 */
void cVideoRender::Exit(void)
{
	LOGDEBUG("videorender: %s", __FUNCTION__);

	Reset();
	Stop();

	// restore saved CRTC configuration
	m_pDrmDevice->RestoreCrtc();

	if (m_hasDoneHdrModeset)
		RestoreColorSpace();

	m_pDrmDevice->VideoPlane()->FreeProperties();
	m_pDrmDevice->OsdPlane()->FreeProperties();

	DeleteBuffers();

#ifdef USE_GLES
	if (!m_disableOglOsd)
		m_pDrmDevice->ExitGbm();
#endif

	m_pDrmDevice->Close();
}

/**
 * Set size and position of the video on the screen
 *
 * @param rect         a cRect, where the video should be rendered in
 */
void cVideoRender::SetVideoOutputPosition(const cRect &rect)
{
	m_videoRect.Set(rect.Point(), rect.Size());

	if (m_videoRect.IsEmpty())
		m_videoIsScaled = false;
	else
		m_videoIsScaled = true;

	LOGDEBUG("videorender: %s: %d %d %d %d%s", __FUNCTION__, rect.X(), rect.Y(), rect.Width(), rect.Height(), m_videoIsScaled ? ", video is scaled" : "");
}

/**
 * Process queued events and forward to event receiver
 */
void cVideoRender::ProcessEvents(void)
{
	for (Event event : m_eventQueue)
		m_pDevice->TriggerEvent(event);

	m_eventQueue.clear();
}

/**
 * Set the size and position of the pip window
 *
 * @param useAlt       true, if the alternative position and size (see setup menu) should be used
 */
void cVideoRender::SetPipSize(bool useAlt)
{
	if (useAlt) {
		m_pipScalePercent = m_pConfig->ConfigPipAltScalePercent;
		m_pipLeftPercent = m_pConfig->ConfigPipAltLeftPercent;
		m_pipTopPercent = m_pConfig->ConfigPipAltTopPercent;
	} else {
		m_pipScalePercent = m_pConfig->ConfigPipScalePercent;
		m_pipLeftPercent = m_pConfig->ConfigPipLeftPercent;
		m_pipTopPercent = m_pConfig->ConfigPipTopPercent;
	}
}

/*****************************************************************************
 * Buffer reuse strategy: use-once
 ****************************************************************************/
cDrmBuffer *cBufferStrategyUseOnce::GetBuffer(cDrmBufferPool *pool, AVDRMFrameDescriptor *)
{
	cDrmBuffer *buf = pool->FindUninitilized();

	if (buf)
		buf->SetDestroyAfterUse(true);

	return buf;
}

/*****************************************************************************
 * Buffer reuse strategy: reuse
 ****************************************************************************/
cDrmBuffer *cBufferStrategyReuseHardware::GetBuffer(cDrmBufferPool *pool, AVDRMFrameDescriptor *primedata)
{
	cDrmBuffer *buf = pool->FindByDmaBufHandle(primedata->objects[0].fd);

	if (buf)
		return buf;
	else
		return pool->FindUninitilized();
}

cDrmBuffer *cBufferStrategyReuseSoftware::GetBuffer(cDrmBufferPool *pool, AVDRMFrameDescriptor *)
{
	cDrmBuffer *buf = pool->FindNoPresentationPending();

	if (buf)
		return buf;
	else
		return pool->FindUninitilized();
}

/*****************************************************************************
 * Decoding strategy: software
 ****************************************************************************/
AVFrame *cDecodingStrategySoftware::PrepareDrmBuffer(cDrmBuffer *buf, int drmDeviceFd, AVFrame *inframe)
{
	if (!buf->IsDirty()) {
		buf->Setup(drmDeviceFd, inframe->width, inframe->height, DRM_FORMAT_NV12, nullptr, true);

		int dmaBufHandle;
		if (drmPrimeHandleToFD(drmDeviceFd, buf->PrimeHandle(0), DRM_CLOEXEC | DRM_RDWR, &dmaBufHandle))
			LOGFATAL("videorender: %s: Failed to retrieve the Prime FD (%d): %m", __FUNCTION__, errno);

		buf->SetDmaBufHandle(dmaBufHandle);
	}

	for (int i = 0; i < inframe->height; ++i)
		memcpy(buf->Plane(0) + i * buf->Pitch(0), inframe->data[0] + i * inframe->linesize[0], inframe->linesize[0]);

	for (int i = 0; i < inframe->height / 2; ++i)
		memcpy(buf->Plane(1) + i * buf->Pitch(1), inframe->data[1] + i * inframe->linesize[1], inframe->linesize[1]);

	AVFrame *frame = av_frame_alloc();
	frame->pts = inframe->pts;
	frame->width = inframe->width;
	frame->height = inframe->height;
	frame->format = AV_PIX_FMT_DRM_PRIME;
	frame->sample_aspect_ratio = inframe->sample_aspect_ratio;

	frame->format = AV_PIX_FMT_DRM_PRIME;
	AVDRMFrameDescriptor *primedata = (AVDRMFrameDescriptor *)av_mallocz(sizeof(AVDRMFrameDescriptor));
	primedata->objects[0].fd = buf->DmaBufHandle();
	frame->data[0] = (uint8_t *)primedata;
	frame->buf[0] = av_buffer_create((uint8_t *)primedata, sizeof(*primedata), ReleaseFrame, NULL, AV_BUFFER_FLAG_READONLY);

	av_frame_free(&inframe);

	return frame;
}

/*****************************************************************************
 * Decoding strategy: hardware
 ****************************************************************************/
AVFrame *cDecodingStrategyHardware::PrepareDrmBuffer(cDrmBuffer *buf, int drmDeviceFd, AVFrame *frame)
{
	if (!buf->IsDirty()) {
		AVDRMFrameDescriptor *primedata = (AVDRMFrameDescriptor *)frame->data[0];
		buf->Setup(drmDeviceFd, frame->width, frame->height, 0, primedata, false);
	}

	return frame;
}