softhddevice.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __SOFTHDDEVICE_H
#define __SOFTHDDEVICE_H
 
#if __cplusplus < 201703L
#error "C++17 or higher is required"
#endif
 
#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 "event.h"
#include "hardwaredevice.h"
#include "jittertracker.h"
#include "pes.h"
 
class cAudioDecoder;
class cDvbSpuDecoder;
class cPipHandler;
class cPipReceiver;
class cSpuDecoder;
class cSoftHdAudio;
class cSoftHdDevice;
class cSoftHdGrab;
class cSoftOsdProvider;
class cVideoRender;
class cVideoStream;
 
// State machine definitions
// Implementing C++17 visitor pattern
 
template<class... Ts>
struct overload : Ts... { using Ts::operator()...; };
template<class... Ts> overload(Ts...) -> overload<Ts...>;
 
enum State {
    STOP,
    BUFFERING,
    PLAY,
    TRICK_SPEED,
    DETACHED
};
 
inline const char* EventToString(const Event& e) {
    return std::visit(overload{
        [](const PlayEvent&) -> const char* { return "PlayEvent"; },
        [](const PauseEvent&) -> const char* { return "PauseEvent"; },
        [](const StopEvent&) -> const char* { return "StopEvent"; },
        [](const TrickSpeedEvent&) -> const char* { return "TrickSpeedEvent"; },
        [](const StillPictureEvent&) -> const char* { return "StillPictureEvent"; },
        [](const DetachEvent&) -> const char* { return "DetachEvent"; },
        [](const AttachEvent&) -> const char* { return "AttachEvent"; },
        [](const BufferUnderrunEvent& e) -> const char* { return e.type == AUDIO ? "BufferUnderrunEvent: Audio" : "BufferUnderrunEvent: Video"; },
        [](const BufferingThresholdReachedEvent&) -> const char* { return "BufferingThresholdReachedEvent"; },
        [](const ScheduleResyncAtPtsMsEvent&) -> const char* { return "ScheduleResyncAtPtsMsEvent"; },
        [](const ResyncEvent&) -> const char* { return "ResyncEvent"; },
        [](const DisplayChangeEvent&) -> const char* { return "DisplayChangeEvent"; },
    }, e);
}
 
inline const char* StateToString(State s) {
    switch(s) {
        case State::STOP: return "STOP";
        case State::BUFFERING: return "BUFFERING";
        case State::PLAY: return "PLAY";
        case State::TRICK_SPEED: return "TRICK_SPEED";
        case State::DETACHED: return "DETACHED";
    }
    return "Unknown";
}
 
enum PlaybackMode {
    NONE,
    AUDIO_AND_VIDEO,
    AUDIO_ONLY,
    VIDEO_ONLY
};
 
class cEventHandler : public cThread {
public:
    cEventHandler(cSoftHdDevice *);
    virtual ~cEventHandler(void);
 
    void AddEvent(Event);
protected:
    virtual void Action(void) override;
private:
    cSoftHdDevice *m_pDevice;         
    std::mutex m_mutex;               
    std::vector<Event> m_eventQueue;  
    IEventReceiver *m_pEventReceiver; 
};
 
class cSoftHdDevice : public cDevice, public IEventReceiver, public cStatus {
public:
    cSoftHdDevice(cSoftHdConfig *);
    virtual ~cSoftHdDevice(void);
 
    //
    // virtual cDevice
    //
protected:
    virtual void MakePrimaryDevice(bool);
    virtual void ChannelSwitch(const cDevice *, int, bool);
 
public:
    virtual cString DeviceName(void) const { return "softhddevice-drm-gles"; }
    virtual bool HasDecoder(void) const;
 
    // SPU facilities
    virtual cSpuDecoder * GetSpuDecoder(void);
 
    // player facilities
    virtual bool CanReplay(void) const;
    virtual bool SetPlayMode(ePlayMode);
    virtual int PlayVideo(const uchar *, int);
    virtual int PlayAudio(const uchar *, int, uchar);
    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);
 
    // 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 &);
 
    // track facilities
    virtual void SetAudioTrackDevice(eTrackType);
 
    // audio facilities
    virtual int GetAudioChannelDevice(void);
    virtual void SetAudioChannelDevice(int);
    virtual void SetVolumeDevice(int);
    virtual void SetDigitalAudioDevice(bool);
 
    //
    // wrapped by cPluginSoftHdDevice
    //
    bool Initialize(void);
    int Start(void);
    void Stop(void);
 
    //
    // cSoftHdDevice public methods
    //
    cSoftHdConfig *Config(void) { return m_pConfig; };
    cVideoStream *VideoStream(void) { return m_pVideoStream; };
    cVideoRender *Render(void) { return m_pRender; };
    cSoftHdAudio *Audio(void) { return m_pAudio; };
 
    void SetDisableDeint(void);
    void SetDecoderNeedsIFrame(void);
    void SetParseH264Dimensions(void);
    void SetDecoderFallbackToSw(bool);
    void SetEnableHdr(bool);
    void SetDisplayMode(int);
 
    // 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 IsBufferingThresholdReached(void);
    bool IsVideoOnlyPlayback(void) { return m_playbackMode == VIDEO_ONLY; };
 
    // pip 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);
 
    // pip functions
    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; };
 
private:
    static constexpr int MIN_BUFFER_FILL_LEVEL_THRESHOLD_MS = 450; 
 
    std::atomic<State> m_state = DETACHED;          
    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<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);
    void OnEventReceived(const Event&);
    void HandleStillPicture(const uchar *data, int size);
    void HandleDisplayModeChange(const sDrmMode &);
    int64_t GetFirstAudioPtsMsToPlay();
    int64_t GetFirstVideoPtsMsToPlay();
 
    int GetBufferFillLevelThresholdMs();
 
    // State machine
    void SetState(State);
    void OnEnteringState(State);
    void OnLeavingState(State);
};
 
#endif