videorender.h

Go to the documentation of this file.

 
#ifndef __VIDEORENDER_H
#define __VIDEORENDER_H
 
#include <atomic>
#include <vector>
 
#include <xf86drm.h>
#include <xf86drmMode.h>
 
extern "C" {
#include <libavutil/hwcontext_drm.h>
}
 
#ifdef USE_GLES
#include <gbm.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <EGL/eglplatform.h>
#include "glhelpers.h"
 
/* Hack:
 * xlib.h via eglplatform.h: #define Status int
 * X.h via eglplatform.h: #define CurrentTime 0L
 *
 * revert it, because it conflicts with vdr variables.
 */
#undef Status
#undef CurrentTime
#endif
 
#include <atomic>
 
#include "logger.h"
#include "iatomic.h"
#include "softhddevice.h"
#include "videostream.h"
#include "drmbuffer.h"
#include "drmdevice.h"
#include "threads.h"
#include "grab.h"
#include "drmplane.h"
#include "config.h"
#include "event.h"
#include "queue.h"
 
// Hardware quirks, that are set depending on the hardware used
#define QUIRK_NO_HW_DEINT               1 << 0     
#define QUIRK_CODEC_FLUSH_WORKAROUND    1 << 1     
#define QUIRK_CODEC_NEEDS_EXT_INIT      1 << 2     
#define QUIRK_CODEC_SKIP_FIRST_FRAMES   1 << 3     
#define QUIRK_CODEC_SKIP_NUM_FRAMES     2          
#define QUIRK_CODEC_DISABLE_MPEG_HW     1 << 4     
#define QUIRK_CODEC_DISABLE_H264_HW     1 << 5     
 
#define AV_SYNC_THRESHOLD_AUDIO_BEHIND_VIDEO_MS 35 
#define AV_SYNC_THRESHOLD_AUDIO_AHEAD_VIDEO_MS 5   
 
class cDrmDevice;
 
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:
    cVideoRender(cSoftHdDevice *);
    virtual ~cVideoRender(void);
 
    void Init(void);
    void Exit(void);
 
    void SetVideoOutputPosition(const cRect &);
    void SetScreenSize(int, int, uint32_t);
    int64_t GetVideoClock(void);
    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 ProcessEvents(void);
    void ResetBufferReuseStrategy() { delete m_bufferReuseStrategy; m_bufferReuseStrategy = nullptr; };
    void ResetDecodingStrategy() { delete m_decodingStrategy; m_decodingStrategy = nullptr; };
 
    // OSD
    void OsdClear(void);
    void OsdDrawARGB(int, int, int, int, int, const uint8_t *, int, int);
 
    // TrickSpeed
    void SetTrickSpeed(int, int);
    int GetTrickSpeed(void);
    int GetTrickForward(void);
 
    // Grab
    int TriggerGrab(void);
    void ConvertVideoBufToRgb(void);
    void ConvertOsdBufToRgb(void);
    void ConvertPipBufToRgb(void);
    void ClearGrab(void);
    cSoftHdGrab *GetGrab(int *, int *, int *, int *, int *, int);
 
    // Threads
    void ExitDisplayThread(void);
    void DisplayThreadHalt(void) { m_pDisplayThread->Halt(); };
    void DisplayThreadResume(void) { m_pDisplayThread->Resume(); };
 
    // DRM
    int DrmHandleEvent(void);
 
    // 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; };
    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; };
    bool IsPipActive(void) { return m_pipActive; };
    void ClearPipDecoderToDisplayQueue(void);
    void SetPipSize(bool);
 
private:
    cSoftHdDevice *m_pDevice;           
    cSoftHdAudio *m_pAudio;             
    cSoftHdConfig *m_pConfig;           
    cDisplayThread *m_pDisplayThread;   
    cMutex m_trickspeedMutex;           
    cMutex m_videoClockMutex;           
    std::vector<Event> m_eventQueue;    
 
    cQueue<cDrmBuffer> m_drmBufferQueue{VIDEO_SURFACES_MAX};     
    cQueue<cDrmBuffer> m_pipDrmBufferQueue{VIDEO_SURFACES_MAX};  
    int m_trickSpeed;                   
    bool m_trickForward;                
    int m_framePresentationCounter = 0; 
    int m_numWrongProgressive;          
 
    bool m_startgrab;                   
    cCondVar m_grabCond;                
    cSoftHdGrab m_grabOsd;              
    cSoftHdGrab m_grabVideo;            
    cSoftHdGrab m_grabPip;              
    cRect m_lastVideoGrab;              
    cRect m_lastPipGrab;                
 
    int m_startCounter;                 
    int m_framesDuped = 0;              
    int m_framesDropped = 0;            
    bool m_lastFrameWasDropped = false; 
    AVRational m_timebase;              
    cMutex m_timebaseMutex;             
    int64_t m_pts = AV_NOPTS_VALUE;     
 
    cRect m_videoRect;                  
    bool m_videoIsScaled;               
    int m_pipScalePercent;              
    int m_pipLeftPercent;               
    int m_pipTopPercent;                
 
    cDrmDevice *m_pDrmDevice;           
    cDrmBuffer *m_pBufOsd;              
    cDrmBuffer m_bufBlack;              
    cDrmBuffer *m_pCurrentlyDisplayed = nullptr;    
    cDrmBuffer *m_pCurrentlyPipDisplayed = nullptr; 
    bool m_osdShown;                    
    std::atomic<bool> m_videoPlaybackPaused = true;                       
    std::atomic<bool> m_resumeAudioScheduled = false;                     
    std::atomic<bool> m_displayOneFrameThenPause = false;                 
    std::atomic<int64_t> m_schedulePlaybackStartAtPtsMs = 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;     
 
#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);
    bool PageFlip(cDrmBuffer *, cDrmBuffer *);
    void SetVideoBuffer(cDrmBuffer *);
    int SetOsdBuffer(drmModeAtomicReqPtr);
    void SetPipBuffer(cDrmBuffer *);
    int CommitBuffer(cDrmBuffer *, cDrmBuffer *);
    void Grab(cDrmBuffer *, cDrmBuffer *);
    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 *);
};
 
#endif