softhddevice.h

// SPDX-License-Identifier: AGPL-3.0-or-later

/**
 * @file softhddevice.h
 * Output Device Header File
 *
 * @copyright 2011 - 2015 by Johns.  All Rights Reserved.
 * @copyright 2025 - 2026 by Andreas Baierl. All Rights Reserved.
 *
 * @license{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;

/**
 * Output Device Implementation
 * @defgroup device Device
 */

/**
 * @addtogroup device
 * @{
 */

// 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 PipEvent&) -> const char* { return "PipEvent"; },
		[](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
};

/** @} */

/**
 * Event handler thread
 *
 * Queues events and sends them to cSoftHdDevice as the final event receiver
 */
class cEventHandler : public cThread {
public:
	cEventHandler(cSoftHdDevice *);
	virtual ~cEventHandler(void);

	void AddEvent(Event);
protected:
	virtual void Action(void) override;
private:
	cSoftHdDevice *m_pDevice;         ///< pointer to device
	std::mutex m_mutex;               ///< queue mutex
	std::vector<Event> m_eventQueue;  ///< event fifo queue
	IEventReceiver *m_pEventReceiver; ///< pointer to event receiver
};

/**
 * Output Device Implementation
 *
 * @ingroup device
 */
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; ///< min buffering threshold in ms

	std::atomic<State> m_state = DETACHED; ///< current plugin state, normal plugin start sets detached state
	std::mutex m_eventMutex;         ///< mutex to protect event queue
	bool m_needsMakePrimary = false;
	cDvbSpuDecoder *m_pSpuDecoder;                  ///< pointer to spu decoder
	cSoftHdConfig *m_pConfig;                       ///< pointer to cSoftHdConfig object
	cVideoRender *m_pRender;                        ///< pointer to cVideoRender object
	cVideoStream *m_pVideoStream;                   ///< pointer to main video stream
	cSoftHdAudio *m_pAudio;                         ///< pointer to cSoftHdAudio object
	cAudioDecoder *m_pAudioDecoder = nullptr;       ///< pointer to cAudioDecoder object
	cSoftOsdProvider *m_pOsdProvider = nullptr;     ///< pointer to cSoftOsdProvider object
	cHardwareDevice *m_pHardwareDevice;             ///< pointer to hardware device description
	cEventHandler *m_pEventHandler;                 ///< event handler thread
	cReassemblyBufferVideo m_videoReassemblyBuffer; ///< video pes reassembly buffer
	cReassemblyBufferAudio m_audioReassemblyBuffer; ///< audio pes reassembly buffer
	cJitterTracker m_audioJitterTracker{"audio"};   ///< audio jitter tracker
	cJitterTracker m_videoJitterTracker{"video"};   ///< video jitter tracker
	std::chrono::steady_clock::time_point m_channelSwitchStartTime; ///< timestamp, when VDR triggered a channel switch
	std::chrono::steady_clock::time_point m_dataReceivedTime;       ///< timestamp, when the first audio or video data after a channel switch arrives in Play*()

	std::atomic<PlaybackMode> m_playbackMode = NONE; ///< current playback mode
	int m_audioChannelID = -1;       ///< current audio channel ID
	cSoftHdGrab *m_pGrab;            ///< pointer to grabber object

	cVideoStream *m_pPipStream;      ///< pointer to pip video stream
	cReassemblyBufferVideo m_pipReassemblyBuffer; ///< pip pes reassembly buffer
	cPipHandler *m_pPipHandler = nullptr; ///< pointer to pip handler
	mutable std::mutex m_mutex;      ///< mutex to lock the state machine
	std::mutex m_sizeMutex;          ///< mutex to lock screen size (which is accessed by different threads)
	std::atomic<bool> m_receivedAudio = false; ///< flag if audio packets have been received
	std::atomic<bool> m_receivedVideo = false; ///< flag if video packets have been received
	std::atomic<bool> m_receivedValidAudio = false; ///< flag if valid audio packets have been received
	std::atomic<bool> m_receivedValidVideo = false; ///< flag if valid video packets have been received
	bool m_pipUseAlt;                ///< use alternative pip position
	bool m_drmCanDisplayPip = true;  ///< true, if the drm device is able to display a pip video
	bool m_disablePip = false;       ///< true, if pip was disabled by the user
	int m_volume = 0;                ///< track the volume in the device (for attach)

	int m_osdWidth;
	int m_osdHeight;
	int m_screenWidth;
	int m_screenHeight;

	bool m_forceDetached = false; ///< start the plugin in detached state
	bool m_externalPlayerActive = false; ///< true, if we detached for an external player

	int PlayVideoInternal(cVideoStream *, cReassemblyBufferVideo *, const uchar *, int, 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