videorender.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __VIDEORENDER_H
#define __VIDEORENDER_H
 
#include <atomic>
#include <cstdint>
#include <mutex>
#include <vector>
 
#include <xf86drmMode.h>
 
extern "C" {
#include <libavutil/frame.h>
#include <libavutil/hwcontext_drm.h>
}
 
#ifdef USE_GLES
#include <gbm.h>
#include <EGL/egl.h>
#endif
 
#include <vdr/osd.h>
#include <vdr/thread.h>
 
#include "config.h"
#include "drmbuffer.h"
#ifdef USE_GLES
#include "drmdevice.h"
#endif
#include "drmhdr.h"
#include "event.h"
#include "grab.h"
#include "misc.h"
#include "queue.h"
 
#ifndef USE_GLES
class cDrmDevice;
#endif
class cSoftHdDevice;
class cSoftHdAudio;
 
enum drmColorSpace {
    COLORSPACE_BT709_YCC = 2,
    COLORSPACE_BT2020_RGB = 9
};
 
enum drmColorEncoding {
    COLORENCODING_BT709 = 1,
    COLORENCODING_BT2020 = 2
};
 
enum drmColorRange {
    COLORRANGE_LIMITED = 0,
    COLORRANGE_FULL = 1
};
 
class cBufferStrategy {
public:
    virtual ~cBufferStrategy() = default;
    virtual cDrmBuffer *GetBuffer(cDrmBufferPool *, AVDRMFrameDescriptor *) = 0;
};
 
class cBufferStrategyUseOnce : public cBufferStrategy {
public:
    cDrmBuffer *GetBuffer(cDrmBufferPool *, AVDRMFrameDescriptor *) override;
};
 
class cBufferStrategyReuseHardware : public cBufferStrategy {
public:
    cDrmBuffer *GetBuffer(cDrmBufferPool *, AVDRMFrameDescriptor *) override;
};
 
class cBufferStrategyReuseSoftware : public cBufferStrategy {
public:
    cDrmBuffer *GetBuffer(cDrmBufferPool *, AVDRMFrameDescriptor *) override;
};
 
class cDecodingStrategy {
public:
    virtual ~cDecodingStrategy() = default;
    virtual AVFrame *PrepareDrmBuffer(cDrmBuffer *, int, AVFrame *) = 0;
};
 
class cDecodingStrategySoftware : public cDecodingStrategy {
public:
    AVFrame *PrepareDrmBuffer(cDrmBuffer *, int, AVFrame *) override;
};
 
class cDecodingStrategyHardware : public cDecodingStrategy {
public:
    AVFrame *PrepareDrmBuffer(cDrmBuffer *, int, AVFrame *) override;
};
 
class cVideoRender : public cThread {
public:
    cVideoRender(cSoftHdDevice *);
    ~cVideoRender(void);
 
    void Init(void);
    void ReInitDisplayMode(void);
    void Exit(void);
    void Stop(void);
    void Halt(void) { m_mutex.lock(); };
    void Resume(void) { m_mutex.unlock(); };
 
    void SetVideoOutputPosition(const cRect &);
    void SetOsdSize(int, int);
    void SetScreenSize(int, int, double, bool);
    void SetDisplayMode(int);
    bool CanHandleMode(sDrmMode *);
    int64_t GetVideoClock(void) { return m_pts; };
    void GetStats(int *, int *, int *);
    void ResetFrameCounter(void);
    void Reset();
    void SetPlaybackPaused(bool pause) { m_videoPlaybackPaused = pause; };
    void SetScheduleAudioResume(bool resume) { m_resumeAudioScheduled = resume; };
    void ScheduleVideoPlaybackPauseAt(int64_t ptsMs) { m_videoPlaybackPauseScheduledAt = ptsMs; };
 
    void ProcessEvents(void);
    void ResetBufferReuseStrategy() { delete m_bufferReuseStrategy; m_bufferReuseStrategy = nullptr; };
    void ResetDecodingStrategy() { delete m_decodingStrategy; m_decodingStrategy = nullptr; };
    void ResetPipBufferReuseStrategy() { delete m_pipBufferReuseStrategy; m_pipBufferReuseStrategy = nullptr; };
    void ResetPipDecodingStrategy() { delete m_pipDecodingStrategy; m_pipDecodingStrategy = nullptr; };
 
    // OSD
    void OsdClear(void);
    void OsdDrawARGB(int, int, int, int, int, const uint8_t *, int, int);
 
    // TrickSpeed/ Stillpicture
    void SetTrickSpeed(double, bool, bool);
    bool IsTrickSpeed(void) { return m_trickspeed; };
    bool IsForwardTrickspeed(void) { return m_forwardTrickspeed; };
    void SetStillpicture(bool active) { m_stillpicture = active; };
    bool IsStillpicture(void) { return m_stillpicture; };
 
    // Grab
    int TriggerGrab(void);
    void ClearGrabBuffers(void);
    cGrabBuffer *GetGrabbedVideoBuffer(void) { return &m_grabVideo; };
    cGrabBuffer *GetGrabbedOsdBuffer(void) { return &m_grabOsd; };
    cGrabBuffer *GetGrabbedPipBuffer(void) { return &m_grabPip; };
 
    // DRM
    int DrmHandleEvent(void);
    bool CanHandleHdr(void);
    void SetEnableHdr(bool enable) { m_enableHdr = enable; };
 
    // Frame and buffer
    bool DisplayFrame();
    int GetFramesFilled(void) { return m_drmBufferQueue.Size(); };
    void PushMainFrame(AVFrame *);
    void PushPipFrame(AVFrame *);
    int64_t GetOutputPtsMs(void);
    void DisplayBlackFrame(void);
    void ClearDecoderToDisplayQueue(void);
    bool IsOutputBufferFull(void);
    void SetDisplayOneFrameThenPause(bool pause) { m_displayOneFrameThenPause = pause; };
    void SchedulePlaybackStartAtPtsMs(int64_t ptsMs) { m_schedulePlaybackStartAtPtsMs = ptsMs; };
    void ScheduleResyncAtPtsMs(int64_t ptsMs) { m_scheduleResyncAtPtsMs = ptsMs; };
    cQueue<cDrmBuffer> *GetMainOutputBuffer(void) { return &m_drmBufferQueue; };
    cQueue<cDrmBuffer> *GetPipOutputBuffer(void) { return &m_pipDrmBufferQueue; };
 
#ifdef USE_GLES
    // GLES
    void DisableOglOsd(void) { m_disableOglOsd = true; };
    void EnableOglOsd(void) { m_disableOglOsd = false; };
    bool OglOsdDisabled(void) { return m_disableOglOsd; };
    EGLSurface EglSurface(void) { return m_pDrmDevice->EglSurface(); };
    EGLDisplay EglDisplay(void) { return m_pDrmDevice->EglDisplay(); };
    EGLContext EglContext(void) { return m_pDrmDevice->EglContext(); };
    int GlInitiated(void) { return m_pDrmDevice->GlInitiated(); };
#endif
 
    // PIP
    void SetPipActive(bool on) { m_pipActive = on; };
    void ClearPipDecoderToDisplayQueue(void);
    void SetPipSize(bool);
 
protected:
    virtual void Action(void);
 
private:
    cSoftHdDevice *m_pDevice;           
    cSoftHdAudio *m_pAudio;             
    cSoftHdConfig *m_pConfig;           
    std::mutex m_mutex;                 
    std::vector<Event> m_eventQueue;    
    std::atomic<double> m_refreshRateHz; 
 
    cQueue<cDrmBuffer> m_drmBufferQueue{VIDEO_SURFACES_MAX};     
    cQueue<cDrmBuffer> m_pipDrmBufferQueue{VIDEO_SURFACES_MAX};  
    std::atomic<double> m_trickspeedFactor = 0;      
    std::atomic<bool> m_trickspeed = false;          
    std::atomic<bool> m_forwardTrickspeed = true;    
    std::atomic<bool> m_stillpicture = false;        
    std::atomic<int> m_framePresentationCounter = 0; 
    int m_numWrongProgressive;          
 
    std::atomic<bool> m_startgrab = false; 
    cCondVar m_grabCond;                
    cGrabBuffer m_grabOsd;              
    cGrabBuffer m_grabVideo;            
    cGrabBuffer m_grabPip;              
 
    constexpr static int AV_SYNC_THRESHOLD_AUDIO_BEHIND_VIDEO_MS = 20; 
    constexpr static int AV_SYNC_THRESHOLD_AUDIO_AHEAD_VIDEO_MS  = 20; 
    int m_startCounter = 0;             
    int m_framesDuped = 0;              
    int m_framesDropped = 0;            
    bool m_lastFrameWasDropped = false; 
    AVRational m_timebase;              
    std::mutex m_timebaseMutex;         
    std::atomic<int64_t> m_pts = AV_NOPTS_VALUE; 
    std::mutex m_grabMutex;             
 
    cRect m_videoRect;                  
    bool m_videoIsScaled = false;       
    int m_pipScalePercent;              
    int m_pipLeftPercent;               
    int m_pipTopPercent;                
 
    cDrmDevice *m_pDrmDevice;           
    cDrmBuffer *m_pBufOsd = nullptr;    
    cDrmBuffer m_bufBlack;              
    cDrmBuffer *m_pCurrentlyDisplayed = nullptr;    
    cDrmBuffer *m_pCurrentlyPipDisplayed = nullptr; 
    bool m_osdShown = false;            
    std::atomic<bool> m_videoPlaybackPaused = true;                       
    std::atomic<bool> m_resumeAudioScheduled = false;                     
    std::atomic<int64_t> m_videoPlaybackPauseScheduledAt = AV_NOPTS_VALUE; 
    std::atomic<bool> m_displayOneFrameThenPause = false;                 
    std::atomic<int64_t> m_schedulePlaybackStartAtPtsMs = AV_NOPTS_VALUE; 
    std::atomic<int64_t> m_scheduleResyncAtPtsMs = AV_NOPTS_VALUE;        
 
    IEventReceiver *m_pEventReceiver;                                     
    cDrmBufferPool m_drmBufferPool;                                       
    cDrmBufferPool m_pipDrmBufferPool;                                    
    std::atomic<cBufferStrategy *> m_bufferReuseStrategy = nullptr;       
    std::atomic<cBufferStrategy *> m_pipBufferReuseStrategy = nullptr;    
    std::atomic<cDecodingStrategy *> m_decodingStrategy = nullptr;        
    std::atomic<cDecodingStrategy *> m_pipDecodingStrategy = nullptr;     
    int m_framesPerFlipCycle = 1;                                         
    int m_flipCounter = 0;                                                
 
    cHdrMetadata m_pHdrMetadata;                             
    bool m_hasDoneHdrModeset = false;                        
    std::atomic<bool> m_enableHdr = false;                   
    drmColorRange m_originalColorRange = COLORRANGE_LIMITED; 
    bool m_colorRangeStored = false;                         
 
#ifdef USE_GLES
    bool m_disableOglOsd;                      
    struct gbm_bo *m_bo;                       
    struct gbm_bo *m_pOldBo;                   
    struct gbm_bo *m_pNextBo;                  
#endif
 
    std::atomic<bool> m_pipActive = false;     
 
    int GetFrameFlags(AVFrame *);
    void SetFrameFlags(AVFrame *, int);
    void SetVideoClock(int64_t pts) { m_pts = pts; };
    bool PageFlip(cDrmBuffer *, cDrmBuffer *);
    int SetVideoBuffer(cDrmBuffer *);
    int SetOsdBuffer(drmModeAtomicReqPtr);
    int SetPipBuffer(cDrmBuffer *);
    int CommitBuffer(cDrmBuffer *, cDrmBuffer *);
    void InitBuffers(void);
    void DeleteBuffers(void);
    void CreateGrabBuffers(bool);
    bool FrameDropNecessary(int64_t, int64_t);
    void LogDroppedDuped(int64_t, int64_t, int);
    int64_t PtsToMs(int64_t);
    void PushFrame(AVFrame *, bool, std::atomic<cBufferStrategy*> &, std::atomic<cDecodingStrategy*> &, cQueue<cDrmBuffer> *, cDrmBufferPool *, bool);
    int GetFramePresentationCount(int64_t);
    void SetHdrBlob(struct hdr_output_metadata);
    void SetColorSpace(drmColorRange);
    void RestoreColorSpace(void);
};
 
#endif