device.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef __DRMDEVICE_OUTPUT_DEVICE_H
#define __DRMDEVICE_OUTPUT_DEVICE_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 cAudioStream;
class cDeviceOsdProvider;
class cDvbSpuDecoder;
class cGrabber;
class cOutputDevice;
class cPipHandler;
class cPipReceiver;
class cSpuDecoder;
class cStateMachine;
class cVideoRender;
class cVideoStream;
 
enum PlaybackMode {
    NONE,
    AUDIO_AND_VIDEO,
    AUDIO_ONLY,
    VIDEO_ONLY
};
 
class cOutputDevice : public cDevice, public cStatus {
public:
    cOutputDevice(cDeviceConfig *);
    virtual ~cOutputDevice(void);
 
    //
    // VDR cPlugin interface (wrapped by cPluginDrmDevice)
    //
    bool Initialize(void);
    int Start(void);
    void Stop(void);
 
    //
    // VDR cDevice interface
    //
protected:
    virtual void MakePrimaryDevice(bool);
public:
    virtual cString DeviceName(void) const { return "drmdevice"; }
    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 DrainDevice(void);
#endif
 
    //
    // VDR cStatus interface
    //
protected:
    virtual void ChannelSwitch(const cDevice *, int, bool);
    virtual void Replaying(const cControl *, const char *, const char *, bool);
 
    //
    // cOutputDevice public API
    //
public:
    cDeviceConfig *Config(void) { return m_pConfig; };
    cVideoStream *VideoStream(void) { return m_pVideoStream; };
    cVideoRender *Render(void) { return m_pRender; };
    cAudioStream *Audio(void) { return m_pAudio; };
 
    // Playback, display and decoder
    void SetDisableDeint(void);
    void SetDecoderFallbackToSw(bool);
    void SetEnableHdr(bool);
    void SetChannelSwitchMode(ChannelSwitchMode mode) { m_channelSwitchMode = mode; };
    void SetDisplayMode(int);
    bool FastChannelSwitchAudioInTransferMode(void) { return m_channelSwitchMode == CHANNEL_SWITCH_FAST_AUDIO && Transferring(); };
    bool FastChannelSwitchInTransferMode(void) { return m_channelSwitchMode != CHANNEL_SWITCH_AVSYNC && Transferring(); };
    bool CheckPlaybackStartConditions(void);
    bool CheckAudioPlaybackStartConditions(void);
    bool IsVideoOnlyPlayback(void) { return m_playbackMode == VIDEO_ONLY; };
    bool IsAudioOnlyPlayback(void) { return m_playbackMode == AUDIO_ONLY; };
 
    // Osd
#ifdef USE_GLES
    int MaxSizeGPUImageCache(void);
    int OglOsdIsDisabled(void);
    void SetDisableOglOsd(void);
    void SetEnableOglOsd(void);
#endif
    void OsdClose(void);
    void OsdDraw(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 *);
 
    // 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;                  
    cDeviceConfig *m_pConfig;                       
    cVideoRender *m_pRender;                        
    cVideoStream *m_pVideoStream;                   
    cAudioStream *m_pAudio;                         
    cAudioDecoder *m_pAudioDecoder = nullptr;       
    cDeviceOsdProvider *m_pOsdProvider = nullptr;   
    cHardwareDevice *m_pHardwareDevice;             
    cEventHandler *m_pEventHandler;                 
    cReassemblyBufferVideo m_videoReassemblyBuffer; 
    cReassemblyBufferAudio m_audioReassemblyBuffer; 
    cJitterTracker m_audioJitterTracker{"audio"};   
    cJitterTracker m_videoJitterTracker{"video"};   
    std::atomic<ChannelSwitchMode> m_channelSwitchMode = CHANNEL_SWITCH_AVSYNC; 
    bool m_logPlaybackStart = true;
 
    std::atomic<PlaybackMode> m_playbackMode = NONE; 
    int m_audioChannelID = -1;       
    cGrabber *m_pGrab;               
 
    cVideoStream *m_pPipStream;      
    cReassemblyBufferVideo m_pipReassemblyBuffer; 
    cPipHandler *m_pPipHandler = nullptr; 
    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();
    void SetDrain(bool);
};
 
#endif