videorender.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: 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"
 
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);
}
 
cVideoRender::~cVideoRender(void)
{
    LOGDEBUG2(L_DRM, "videorender: %s", __FUNCTION__);
 
    Stop();
 
    delete m_pDrmDevice;
}
 
void cVideoRender::ClearDecoderToDisplayQueue(void)
{
    m_drmBufferQueue.Clear();
    m_drmBufferPool.DestroyAllExcept(m_pCurrentlyDisplayed);
 
    if (m_pCurrentlyDisplayed)
        m_pCurrentlyDisplayed->SetDestroyAfterUse(true);
}
 
void cVideoRender::ClearPipDecoderToDisplayQueue(void)
{
    m_pipDrmBufferQueue.Clear();
    m_pipDrmBufferPool.DestroyAllExcept(nullptr);
 
    m_pCurrentlyPipDisplayed = nullptr;
}
 
struct sRect {
    uint64_t x;
    uint64_t y;
    uint64_t w;
    uint64_t h;
};
 
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 };
}
 
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;
        }
    }
}
 
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;
}
 
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;
}
 
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;
}
 
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;
}
 
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;
}
 
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;
}
 
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);
}
 
int cVideoRender::GetFrameFlags(AVFrame *frame)
{
    if (!frame || !frame->opaque_ref)
        return 0;
 
    int *frameFlags = (int *)frame->opaque_ref->data;
    return *frameFlags;
}
 
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;
}
 
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
 ****************************************************************************/
 
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");
}
 
void cVideoRender::Stop(void)
{
    if (!Active())
        return;
 
    LOGDEBUG("videorender: stopping display thread");
    Cancel(2);
}
 
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;
}
 
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;
}
 
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;
    }
}
 
int64_t cVideoRender::PtsToMs(int64_t pts)
{
    std::lock_guard<std::mutex> lock(m_timebaseMutex);
 
    return pts * 1000 * av_q2d(m_timebase);
}
 
int cVideoRender::DrmHandleEvent(void)
{
    return m_pDrmDevice->HandleEvent();
}
 
bool cVideoRender::CanHandleHdr(void)
{
    return m_pDrmDevice->CanHandleHdr();
}
 
/*****************************************************************************
 * 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))
 
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;
}
 
static void ReleaseFrame( __attribute__ ((unused)) void *opaque, uint8_t *data)
{
    AVDRMFrameDescriptor *primedata = (AVDRMFrameDescriptor *)data;
 
    av_free(primedata);
}
 
bool cVideoRender::IsOutputBufferFull(void)
{
    return m_drmBufferQueue.IsFull();
}
 
void cVideoRender::PushMainFrame(AVFrame *frame)
{
    PushFrame(frame, IsTrickSpeed(), m_bufferReuseStrategy, m_decodingStrategy, &m_drmBufferQueue, &m_drmBufferPool, true);
}
 
void cVideoRender::PushPipFrame(AVFrame *frame)
{
    PushFrame(frame, false, m_pipBufferReuseStrategy, m_pipDecodingStrategy, &m_pipDrmBufferQueue, &m_pipDrmBufferPool, false);
}
 
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);
}
 
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);
}
 
void cVideoRender::ResetFrameCounter(void)
{
    m_startCounter = 0;
    LOGDEBUG("videorender: %s: reset m_startCounter %d TrickSpeed %d", __FUNCTION__, m_startCounter, IsTrickSpeed());
}
 
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;
}
 
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;
}
 
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
 ****************************************************************************/
 
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;
}
 
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();
}
 
void cVideoRender::ClearGrabBuffers(void)
{
    std::lock_guard<std::mutex> lock(m_grabMutex);
 
    m_grabOsd.Clear();
    m_grabVideo.Clear();
    m_grabPip.Clear();
}
 
void cVideoRender::GetStats(int *duped, int *dropped, int *counter)
{
    *duped = m_framesDuped;
    *dropped = m_framesDropped;
    *counter = m_startCounter;
}
 
/*****************************************************************************
 * Setup and initialization
 ****************************************************************************/
 
void cVideoRender::SetOsdSize(int width, int height)
{
    m_pDevice->SetOsdSize(width, height);
}
 
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;
}
 
void cVideoRender::SetDisplayMode(int idx)
{
    m_pDevice->SetDisplayMode(idx);
}
 
bool cVideoRender::CanHandleMode(sDrmMode *mode)
{
    return m_pDrmDevice->CanHandleMode(mode);
}
 
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();
}
 
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);
}
 
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;
}
 
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
}
 
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();
}
 
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" : "");
}
 
void cVideoRender::ProcessEvents(void)
{
    for (Event event : m_eventQueue)
        m_pDevice->TriggerEvent(event);
 
    m_eventQueue.clear();
}
 
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;
}