softhddevice.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __SOFTHDDEVICE_H
#define __SOFTHDDEVICE_H
 
#include <atomic>
#include <mutex>
 
extern "C"
{
#include <libavcodec/avcodec.h>
}
 
#include <vdr/device.h>
#include <vdr/osd.h>
#include <vdr/status.h>
#include <vdr/thread.h>
 
#include "config.h"
#include "hardwaredevice.h"
#include "jittertracker.h"
#include "pes.h"
#include "statemachine.h"
 
class cAudioDecoder;
class cDvbSpuDecoder;
class cPipHandler;
class cPipReceiver;
class cSpuDecoder;
class cSoftHdAudio;
class cSoftHdDevice;
class cSoftHdGrab;
class cSoftOsdProvider;
class cStateMachine;
class cVideoRender;
class cVideoStream;
 
enum PlaybackMode {
    NONE,
    AUDIO_AND_VIDEO,
    AUDIO_ONLY,
    VIDEO_ONLY
};
 
class cSoftHdDevice : public cDevice, public cStatus {
public:
    cSoftHdDevice(cSoftHdConfig *);
    virtual ~cSoftHdDevice(void);
 
    //
    // VDR cPlugin interface (wrapped by cPluginSoftHdDevice)
    //
    bool Initialize(void);
    int Start(void);
    void Stop(void);
 
    //
    // VDR cDevice interface
    //
protected:
    virtual void MakePrimaryDevice(bool);
public:
    virtual cString DeviceName(void) const { return "softhddevice-drm-gles"; }
    virtual bool HasDecoder(void) const;
 
    // SPU facilities
    virtual cSpuDecoder * GetSpuDecoder(void);
 
    // Image grab facilities
    virtual uchar *GrabImage(int &, bool, int, int, int);
 
    // Video format facilities
    virtual void SetVideoDisplayFormat(eVideoDisplayFormat);
    virtual void SetVideoFormat(bool);
    virtual void GetVideoSize(int &, int &, double &);
    virtual void GetOsdSize(int &, int &, double &);
 
    // Audio facilities
protected:
    virtual void SetVolumeDevice(int);
 
    // Player facilities
    virtual bool CanReplay(void) const;
    virtual bool SetPlayMode(ePlayMode);
    virtual int PlayVideo(const uchar *, int);
    virtual int PlayAudio(const uchar *, int, uchar);
public:
    virtual int64_t GetSTC(void);
    virtual cRect CanScaleVideo(const cRect &, int taCenter);
    virtual void ScaleVideo(const cRect & = cRect::Null);
    virtual void TrickSpeed(int, bool);
    virtual void Clear(void);
    virtual void Play(void);
    virtual void Freeze(void);
    virtual void StillPicture(const uchar *, int);
    virtual bool Poll(cPoller &, int = 0);
    virtual bool Flush(int = 0);
#if APIVERSNUM >= 30014
    virtual bool Drain(void);
#endif
 
    //
    // VDR cStatus interface
    //
protected:
    virtual void ChannelSwitch(const cDevice *, int, bool);
 
    //
    // cSoftHdDevice public API
    //
public:
    cSoftHdConfig *Config(void) { return m_pConfig; };
    cVideoStream *VideoStream(void) { return m_pVideoStream; };
    cVideoRender *Render(void) { return m_pRender; };
    cSoftHdAudio *Audio(void) { return m_pAudio; };
 
    // Playback, display and decoder
    void SetDisableDeint(void);
    void SetDecoderNeedsIFrame(void);
    void SetParseH264Dimensions(void);
    void SetDecoderFallbackToSw(bool);
    void SetEnableHdr(bool);
    void SetChannelSwitchMode(ChannelSwitchMode mode) { m_channelSwitchMode = mode; };
    void SetDisplayMode(int);
    bool IsBufferingThresholdReached(void);
    bool IsAudioBufferingThresholdReached(void);
    bool IsVideoOnlyPlayback(void) { return m_playbackMode == VIDEO_ONLY; };
 
    // Osd
#ifdef USE_GLES
    int MaxSizeGPUImageCache(void);
    int OglOsdIsDisabled(void);
    void SetDisableOglOsd(void);
    void SetEnableOglOsd(void);
#endif
    void OsdClose(void);
    void OsdDrawARGB(int, int, int, int, int, const uint8_t *, int, int);
    void SetOsdSize(int, int);
    void SetScreenSize(int, int);
 
    // Audio
    int GetVideoAudioDelayMs(void) { return m_pConfig->ConfigVideoAudioDelayMs; };
    int GetMinBufferFillLevelThresholdMs(void) { return MIN_BUFFER_FILL_LEVEL_THRESHOLD_MS; };
    void SetPassthroughMask(int);
    void ResetChannelId(void);
 
    // Logging, statistics
    void GetStats(int *, int *, int *);
    std::chrono::steady_clock::time_point GetChannelSwitchStartTime(void) { return m_channelSwitchStartTime; };
    std::chrono::steady_clock::time_point GetChannelSwitchFirstPacketTime(void) { return m_dataReceivedTime; };
 
    // Mediaplayer
    void SetAudioCodec(enum AVCodecID, AVCodecParameters *, AVRational);
    void SetVideoCodec(enum AVCodecID, AVCodecParameters *, AVRational);
    int PlayAudioPkts(AVPacket *);
    int PlayVideoPkts(AVPacket *);
 
    // Detach/ attach
    void Detach(void);
    void Attach(void);
    bool IsDetached(void) const;
    void ResetOsdProvider(void) { m_pOsdProvider = nullptr; }
    bool IsOsdProviderSet(void) const { return m_pOsdProvider != nullptr; }
    void SetStartDetached(void) { m_forceDetached = true; };
    bool IsDraining(void) { return m_draining; };
 
    // Pip
    int PlayPipVideo(const uchar *, int);
    void SetDrmCanDisplayPip(bool canDisplay) { m_drmCanDisplayPip = canDisplay; };
    bool UsePip(void) { return m_drmCanDisplayPip && !m_disablePip && m_pPipHandler; };
    void ResetPipStream(void);
    void ToggleRenderPipPosition(void) { m_pipUseAlt = !m_pipUseAlt; };
    // wrapper functions
    void SetDisablePip(void) { m_disablePip = true; };
    bool PipIsEnabled(void);
    void PipEnable(void);
    void PipDisable(void);
    void PipToggle(void);
    void PipChannelChange(int);
    void PipChannelSwap(bool);
    void PipSwapPosition(void);
    void PipSetSize(void);
    void SetRenderPipSize(void);
    void SetRenderPipActive(bool);
 
    // state transitioning functions
    void TriggerEvent(const Event&);
 
    void LeaveState(State);
    void EnterState(State);
    void HandleStillPicture(const uchar *data, int size);
    void HandleDisplayModeChange(const sDrmMode &);
    void HaltVideoThreads(void);
    void ResumeVideoThreads(void);
#ifdef USE_GLES
    bool HaltOpenGlThread(void);
    void ResumeOpenGlThread(void);
#endif
    bool IsDetachForced(void);
    void SetDetachForced(void) { m_forceDetached = true; };
    int InitAudio(bool);
    void ResetVideoFilter(void);
    void SetTrickSpeed(double, bool, bool);
    bool SchedulePlaybackStart(void);
    void ScheduleResyncAtPtsMs(int64_t);
    void ResumeFromPause(void);
    void PausePlayback(bool);
    void ResumePlayback(void);
 
private:
    static constexpr int MIN_BUFFER_FILL_LEVEL_THRESHOLD_MS = 450; 
 
    std::unique_ptr<cStateMachine> m_pStateMachine;
 
    bool m_initialized = false;                     
    std::atomic<bool> m_draining = false;           
    std::mutex m_eventMutex;                        
    bool m_needsMakePrimary = false;                
    cDvbSpuDecoder *m_pSpuDecoder;                  
    cSoftHdConfig *m_pConfig;                       
    cVideoRender *m_pRender;                        
    cVideoStream *m_pVideoStream;                   
    cSoftHdAudio *m_pAudio;                         
    cAudioDecoder *m_pAudioDecoder = nullptr;       
    cSoftOsdProvider *m_pOsdProvider = nullptr;     
    cHardwareDevice *m_pHardwareDevice;             
    cEventHandler *m_pEventHandler;                 
    cReassemblyBufferVideo m_videoReassemblyBuffer; 
    cReassemblyBufferAudio m_audioReassemblyBuffer; 
    cJitterTracker m_audioJitterTracker{"audio"};   
    cJitterTracker m_videoJitterTracker{"video"};   
    std::chrono::steady_clock::time_point m_channelSwitchStartTime; 
    std::chrono::steady_clock::time_point m_dataReceivedTime;       
    std::atomic<ChannelSwitchMode> m_channelSwitchMode = CHANNEL_SWITCH_AVSYNC; 
 
    std::atomic<PlaybackMode> m_playbackMode = NONE; 
    int m_audioChannelID = -1;       
    cSoftHdGrab *m_pGrab;            
 
    cVideoStream *m_pPipStream;      
    cReassemblyBufferVideo m_pipReassemblyBuffer; 
    cPipHandler *m_pPipHandler = nullptr; 
    mutable std::mutex m_mutex;      
    std::mutex m_sizeMutex;          
    std::atomic<bool> m_receivedAudio = false; 
    std::atomic<bool> m_receivedVideo = false; 
    std::atomic<bool> m_receivedValidAudio = false; 
    std::atomic<bool> m_receivedValidVideo = false; 
    bool m_pipUseAlt;                
    bool m_drmCanDisplayPip = true;  
    bool m_disablePip = false;       
    int m_volume = 0;                
 
    int m_osdWidth;
    int m_osdHeight;
    int m_screenWidth;
    int m_screenHeight;
 
    bool m_forceDetached = false; 
    bool m_externalPlayerActive = false; 
 
    int PlayVideoInternal(cVideoStream *, cReassemblyBufferVideo *, const uchar *, int, bool, bool);
    void FlushAudio(void);
    int64_t GetFirstAudioPtsMsToPlay();
    int64_t GetFirstVideoPtsMsToPlay();
    int GetBufferFillLevelThresholdMs();
};
 
#endif