softhddevice.cpp

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-or-later
 
#include <chrono>
#include <mutex>
#include <variant>
#include <libintl.h>
 
extern "C" {
#include <libavcodec/avcodec.h>
}
 
#include <vdr/dvbspu.h>
#include <vdr/skins.h>
#include <vdr/status.h>
#include <vdr/thread.h>
 
#include "audio.h"
#include "codec_audio.h"
#include "config.h"
#include "event.h"
#include "grab.h"
#include "hardwaredevice.h"
#include "jittertracker.h"
#include "logger.h"
#include "pes.h"
#include "pipreceiver.h"
#include "softhddevice.h"
#include "softhdosdprovider.h"
#include "videorender.h"
#include "videostream.h"
 
cSoftHdDevice::cSoftHdDevice(cSoftHdConfig *config)
    : m_pSpuDecoder(new cDvbSpuDecoder()),
      m_pConfig(config),
      m_pipUseAlt(m_pConfig->ConfigPipUseAlt)
{
//  LOGDEBUG("device: %s:", __FUNCTION__);
    m_pEventHandler = new cEventHandler(this);
 
    m_channelSwitchStartTime = std::chrono::steady_clock::now();
    m_dataReceivedTime = m_channelSwitchStartTime;
}
 
cSoftHdDevice::~cSoftHdDevice(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
 
    delete m_pEventHandler;
    delete m_pHardwareDevice;
    delete m_pSpuDecoder;
}
 
bool cSoftHdDevice::Initialize(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    m_pHardwareDevice = new cHardwareDevice(); // deleted in destructor
 
    return true;
}
 
int cSoftHdDevice::Start(void)
{
    LOGDEBUG("device: %s", __FUNCTION__);
    OnEventReceived(AttachEvent{});
 
    return true;
}
 
void cSoftHdDevice::Stop(void)
{
    LOGDEBUG("device: %s", __FUNCTION__);
    m_pPipHandler->Disable();
    OnEventReceived(DetachEvent{});
}
 
void cSoftHdDevice::FlushAudio(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    m_pAudioDecoder->FlushBuffers();
    m_pAudio->FlushBuffers();
    m_audioReassemblyBuffer.Reset();
}
 
void cSoftHdDevice::MakePrimaryDevice(bool on)
{
    LOGDEBUG("device: %s: %d", __FUNCTION__, on);
 
    if (on)
        m_pOsdProvider = new cSoftOsdProvider(this); // no need to delete it, VDR does it
 
    cDevice::MakePrimaryDevice(on);
}
 
void cSoftHdDevice::ChannelSwitch(const cDevice *device, int channelNum, bool liveView)
{
    if (device != cDevice::PrimaryDevice())
        return;
 
    if (!liveView)
        return;
 
    if (channelNum == 0)
        m_channelSwitchStartTime = std::chrono::steady_clock::now();
}
 
cSpuDecoder *cSoftHdDevice::GetSpuDecoder(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    if (!IsPrimaryDevice())
        return NULL;
 
    return m_pSpuDecoder;
}
 
bool cSoftHdDevice::HasDecoder(void) const
{
    bool hasDecoder = !IsDetached();
 
//  LOGDEBUG("device: %s: %d", __FUNCTION__, hasDecoder);
 
    return hasDecoder;
}
 
bool cSoftHdDevice::CanReplay(void) const
{
    bool canReplay = !IsDetached();
 
    LOGDEBUG("device: %s: %d", __FUNCTION__, canReplay);
 
    return canReplay;
}
 
void cSoftHdDevice::OnEventReceived(const Event& event)
{
    uint64_t startStateChange = cTimeMs::Now();
    LOGDEBUG("device: STATE MACHINE received %s", EventToString(event));
    bool needsResume = false;
 
#ifdef USE_GLES
    // Lock the GL thread before the state machine lock, because cmdCopyBufferToOutputFb() calls
    // cSoftHdDevice::OsdDrawARGB(), which itself locks the state machine mutex and we can end
    // up in a deadlock then.
    // We can safely unlock the thread again after the state change, because cSoftHdDevice::OsdDrawARGB()
    // always tests if we are in detached mode and this new state is probably set then.
    bool needsOglResume = false;
    if (m_pOsdProvider && m_state != DETACHED)
        needsOglResume = m_pOsdProvider->LockOpenGlThread();
#endif
 
    { // locked state machine context
    std::lock_guard<std::mutex> lock(m_mutex);
 
    if (m_state != DETACHED) {
        m_pRender->Halt();
        m_pVideoStream->Halt();
        needsResume = true;
    }
 
    auto invalid = [this, &event]() {
        LOGWARNING("device: Invalid event '%s' in state '%s' received", EventToString(event), StateToString(m_state));
    };
 
    switch (m_state) {
        case State::DETACHED:
            std::visit(overload{
                [&invalid](const PlayEvent&) { invalid(); },
                [&invalid](const PauseEvent&) { invalid(); },
                [&invalid](const StopEvent&) { invalid(); },
                [&invalid](const TrickSpeedEvent&) { invalid(); },
                [&invalid](const StillPictureEvent&) { invalid(); },
                [](const DetachEvent&) { /* ignore */ },
                [this](const AttachEvent&) {
                    if (!m_forceDetached)
                        SetState(STOP);
                },
                [&invalid](const BufferUnderrunEvent&) { invalid(); },
                [&invalid](const BufferingThresholdReachedEvent&) { invalid(); },
                [&invalid](const ScheduleResyncAtPtsMsEvent&) { invalid(); },
                [&invalid](const ResyncEvent&) { invalid(); },
                [&invalid](const DisplayChangeEvent&) { invalid(); },
            }, event);
            needsResume = false;
            break;
        case State::STOP:
            std::visit(overload{
                [this](const PlayEvent&) {
                    m_pAudio->LazyInit();
                    m_pAudio->SetVolume((m_volume * 1000) / 255);
                    SetState(BUFFERING);
                    m_pRender->ResetFrameCounter();
                    m_pVideoStream->ResetFilterThreadNeededCheck();
                },
                [&invalid](const PauseEvent&) { invalid(); },
                [&invalid](const StopEvent&) { invalid(); },
                [&invalid](const TrickSpeedEvent&) { invalid(); },
                [this](const StillPictureEvent& s) {
                    HandleStillPicture(s.data, s.size);
                },
                [this, &needsResume](const DetachEvent&) {
                    SetState(DETACHED);
                    needsResume = false;
                },
                [&invalid](const AttachEvent&) { invalid(); },
                [&invalid](const BufferUnderrunEvent&) { invalid(); },
                [&invalid](const BufferingThresholdReachedEvent&) { invalid(); },
                [&invalid](const ScheduleResyncAtPtsMsEvent&) { invalid(); },
                [&invalid](const ResyncEvent&) { invalid(); },
                [this](const DisplayChangeEvent& d) {
                    HandleDisplayModeChange(d.mode);
                },
            }, event);
            break;
        case State::BUFFERING:
            std::visit(overload{
                [this](const PlayEvent&) {
                    // ignore
                },
                [this](const PauseEvent&) {
                    // ignore
                },
                [this](const StopEvent&) {
                    SetState(STOP);
                },
                [this](const TrickSpeedEvent& t) {
                    // abort buffering and proceed with trick speed immediately, because trick speed shall be as fast and as demanded as possible
                    SetState(PLAY);
                    m_pRender->SetTrickSpeed(t.speed, t.active, t.forward);
                    SetState(TRICK_SPEED);
                },
                [this](const StillPictureEvent& s) {
                    HandleStillPicture(s.data, s.size);
                },
                [this, &needsResume](const DetachEvent&) {
                    SetState(DETACHED);
                    needsResume = false;
                },
                [&invalid](const AttachEvent&) { invalid(); },
                [&invalid](const BufferUnderrunEvent&) { invalid(); },
                [this](const BufferingThresholdReachedEvent&) {
                    bool receivedAudio = m_pAudio->HasInputPts();
                    bool receivedVideo = m_pVideoStream->HasInputPts();
 
                    if (receivedAudio && receivedVideo) {
                        m_playbackMode = AUDIO_AND_VIDEO;
                        int64_t firstAudioPtsMs = GetFirstAudioPtsMsToPlay();
                        int64_t firstVideoPtsMs = GetFirstVideoPtsMsToPlay();
                        // store the first PTSes beforehand, because dropping samples/frames will change the output of GetFirst*PtsMsToPlay()
                        m_pAudio->DropSamplesOlderThanPtsMs(firstAudioPtsMs);
                        m_pRender->SchedulePlaybackStartAtPtsMs(firstVideoPtsMs);
                    } else if (receivedAudio) {
                        LOGDEBUG("device: audio only detected");
                        m_playbackMode = AUDIO_ONLY;
                        m_pAudio->DropSamplesOlderThanPtsMs(m_pAudio->GetOutputPtsMs());
                    } else if (receivedVideo) {
                        LOGDEBUG("device: video only detected");
                        m_playbackMode = VIDEO_ONLY;
                        m_pRender->SchedulePlaybackStartAtPtsMs(m_pRender->GetOutputPtsMs());
                    } else
                        LOGFATAL("device: buffering threshold reached and no a/v available. This is a bug.");
 
                    SetState(PLAY);
                },
                [this](const ScheduleResyncAtPtsMsEvent& s) {
                    SetState(PLAY);
                    m_pRender->ScheduleResyncAtPtsMs(s.pts);
                },
                [&invalid](const ResyncEvent&) { invalid(); },
                [this](const DisplayChangeEvent& d) {
                    HandleDisplayModeChange(d.mode);
                },
            }, event);
            break;
        case State::PLAY:
            std::visit(overload{
                [this](const PlayEvent&) {
                    // resume from pause
                    int audioBehindVideoByMs;
                    switch (m_playbackMode) {
                        case AUDIO_ONLY:
                            m_pAudio->SetHwDelayBaseline();
                            m_pAudio->SetPaused(false);
                            break;
                        case AUDIO_AND_VIDEO:
                            audioBehindVideoByMs = m_pRender->GetOutputPtsMs() - m_pAudio->GetOutputPtsMs() - m_pConfig->ConfigVideoAudioDelayMs;
                            m_pAudio->SetHwDelayBaseline();
                            if (audioBehindVideoByMs > 0) {
                                m_pAudio->DropSamplesOlderThanPtsMs(m_pAudio->GetOutputPtsMs() + audioBehindVideoByMs);
                                m_pAudio->SetPaused(false);
                            } else
                                m_pRender->SetScheduleAudioResume(true);
 
                            // fallthrough
                        case VIDEO_ONLY:
                            m_pRender->SetStillpicture(false);
                            m_pRender->SetPlaybackPaused(false);
                            break;
                        case NONE:
                            LOGFATAL("device: play event in PLAY state with NONE playback mode. This is a bug.");
                            break;
                    }
                },
                [this](const PauseEvent&) {
                    if (m_playbackMode == AUDIO_AND_VIDEO)
                        m_pRender->ScheduleVideoPlaybackPauseAt(m_pAudio->GetOutputPtsMs() - m_pConfig->ConfigVideoAudioDelayMs);
                    else
                        m_pRender->SetPlaybackPaused(true);
 
                    m_pAudio->SetPaused(true);
                    m_pAudio->ResetHwDelayBaseline();
                },
                [this](const StopEvent&) {
                    SetState(STOP);
                },
                [this](const TrickSpeedEvent& t) {
                    m_pRender->SetTrickSpeed(t.speed, t.active, t.forward);
                    SetState(TRICK_SPEED);
                },
                [this](const StillPictureEvent& s) {
                    HandleStillPicture(s.data, s.size);
                },
                [this, &needsResume](const DetachEvent&) {
                    SetState(DETACHED);
                    needsResume = false;
                },
                [&invalid](const AttachEvent&) { invalid(); },
                [this](const BufferUnderrunEvent&) {
                    SetState(BUFFERING);
                },
                [&invalid](const BufferingThresholdReachedEvent&) {
                    // ignore
                },
                [this](const ScheduleResyncAtPtsMsEvent& s) {
                    m_pRender->ScheduleResyncAtPtsMs(s.pts);
                },
                [this](const ResyncEvent&) {
                    SetState(BUFFERING);
                },
                [this](const DisplayChangeEvent& d) {
                    HandleDisplayModeChange(d.mode);
                },
            }, event);
            break;
        case State::TRICK_SPEED:
            std::visit(overload{
                [this](const PlayEvent&) {
                    SetState(PLAY);
                },
                [this](const PauseEvent&) {
                    m_pRender->SetPlaybackPaused(true);
                    m_pAudio->SetPaused(true);
                    m_pAudio->ResetHwDelayBaseline();
                },
                [this](const StopEvent&) {
                    SetState(STOP);
                },
                [this](const TrickSpeedEvent& t) {
                    // resume from pause, or change trick speed direction/speed
                    m_pRender->SetTrickSpeed(t.speed, t.active, t.forward);
                    m_pRender->SetPlaybackPaused(false);
                },
                [this](const StillPictureEvent& s) {
                    HandleStillPicture(s.data, s.size);
                },
                [this, &needsResume](const DetachEvent&) {
                    SetState(DETACHED);
                    needsResume = false;
                },
                [&invalid](const AttachEvent&) { invalid(); },
                [this](const BufferUnderrunEvent&) {
                    // ignore during trick speed. Fast forward/reverse as fast and as demanded as possible
                },
                [&invalid](const BufferingThresholdReachedEvent&) { invalid(); },
                [&invalid](const ScheduleResyncAtPtsMsEvent&) { invalid(); },
                [&invalid](const ResyncEvent&) { invalid(); },
                [this](const DisplayChangeEvent& d) {
                    HandleDisplayModeChange(d.mode);
                },
            }, event);
            break;
    }
 
    if (needsResume) {
        m_pVideoStream->Resume();
        m_pRender->Resume();
    }
 
    } // end of locked state machine context
#ifdef USE_GLES
    if (m_pOsdProvider && needsOglResume)
        m_pOsdProvider->UnlockOpenGlThread();
#endif
 
    uint64_t stopStateChange = cTimeMs::Now();
    LOGDEBUG("device: STATE MACHINE state change done in %d ms", (int)(stopStateChange - startStateChange));
}
 
void cSoftHdDevice::OnEnteringState(State state) {
    switch (state) {
        case BUFFERING:
            m_pAudio->ResetHwDelayBaseline();
            // nothing
            break;
        case PLAY:
            if (m_playbackMode != VIDEO_ONLY)
                m_pAudio->SetPaused(false);
 
            if (m_playbackMode != AUDIO_ONLY) {
                m_pVideoStream->SetDeinterlacerDeactivated(false);
                m_pRender->SetStillpicture(false);
                m_pRender->SetPlaybackPaused(false);
            }
            break;
        case TRICK_SPEED:
            // The filter thread needs to be restarted for interlaced streams to be rendered without deinterlacer in trick speed mode. It is started lazily.
            m_pVideoStream->CancelFilterThread();
            m_pRender->SetPlaybackPaused(false);
            m_pVideoStream->SetDeinterlacerDeactivated(true);
            m_pRender->ResetBufferReuseStrategy();
            break;
        case STOP:
            FlushAudio();
 
            m_pVideoStream->CancelFilterThread();
            m_pRender->DisplayBlackFrame();
            m_pRender->Reset();
            m_playbackMode = NONE;
 
            m_videoReassemblyBuffer.Reset();
            m_pVideoStream->ClearVdrCoreToDecoderQueue();
            m_pRender->ClearDecoderToDisplayQueue();
            m_pRender->ResetDecodingStrategy();
            m_pRender->ResetBufferReuseStrategy();
            m_pVideoStream->CloseDecoder();
            m_audioJitterTracker.Reset();
            m_videoJitterTracker.Reset();
 
            break;
        case DETACHED:
            delete m_pPipHandler;
            m_pPipHandler = nullptr;
 
            // resume the previously stopped threads
            m_pVideoStream->Resume();
            m_pRender->Resume();
 
            // now do the detach
            m_pPipStream->Exit();
            delete m_pPipStream;
 
#ifdef USE_GLES
            // The opengl thread was probably locked before cmdCopyBufferToOutputFb().
            // 1) set running to false
            // 2) continue the thread (which will skip the waiting cmd->Execute())
            // 3) do the real thread cancel and cleanup
            // We need to keep this order to prevent a deadlock!
            m_pOsdProvider->RequestStopOpenGlThread();
            m_pOsdProvider->UnlockOpenGlThread();
            m_pOsdProvider->StopOpenGlThread();
#endif
            m_pRender->Exit(); // render must be stopped before videostream!
            m_pVideoStream->Exit();
            m_pAudio->Exit(); // audio must be stopped after renderer!
 
            delete m_pAudioDecoder; // includes a Close()
            delete m_pVideoStream;
            delete m_pGrab;
            delete m_pRender;
            delete m_pAudio;
 
            break;
    }
}
 
void cSoftHdDevice::OnLeavingState(State state) {
    switch (state) {
        case PLAY:
            m_pRender->SchedulePlaybackStartAtPtsMs(AV_NOPTS_VALUE);
            m_pRender->SetPlaybackPaused(true);
            m_pAudio->SetPaused(true);
            m_pAudio->ResetHwDelayBaseline();
            break;
        case BUFFERING:
            m_pAudio->SetHwDelayBaseline();
            m_pRender->SetDisplayOneFrameThenPause(false);
            break;
        case TRICK_SPEED:
            // The filter thread needs to be restarted for interlaced streams to be rendered with deinterlacer again. It is started lazily.
            m_pVideoStream->CancelFilterThread();
            m_pRender->SetTrickSpeed(0, false, false);
            m_pRender->ResetFrameCounter();
            m_pVideoStream->ResetFilterThreadNeededCheck();
            m_pVideoStream->SetDeinterlacerDeactivated(false);
            m_pRender->SetPlaybackPaused(true);
            m_pRender->ResetBufferReuseStrategy();
            m_pVideoStream->ResetTrickSpeedFramesSentCounter();
            break;
        case STOP:
            m_receivedAudio = false;
            m_receivedVideo = false;
            m_receivedValidAudio = false;
            m_receivedValidVideo = false;
            break;
        case DETACHED:
            m_pAudio = new cSoftHdAudio(this);
            m_pRender = new cVideoRender(this);
            m_pGrab = new cSoftHdGrab(m_pRender);
            m_pVideoStream = new cMainVideoStream(m_pRender, m_pHardwareDevice->GetQuirks(), m_pRender->GetMainOutputBuffer(), m_pConfig, std::bind(&cVideoRender::PushMainFrame, m_pRender, std::placeholders::_1));
            m_pAudioDecoder = new cAudioDecoder(m_pAudio);
            m_pRender->Init(); // starts display thread
            m_pVideoStream->StartDecoder(); // starts decoding thread
            m_pPipStream = new cPipVideoStream(m_pRender, m_pHardwareDevice->GetQuirks(), m_pRender->GetPipOutputBuffer(), m_pConfig, std::bind(&cVideoRender::PushPipFrame, m_pRender, std::placeholders::_1));
            m_pPipStream->StartDecoder(); // starts decoding thread
            m_pPipHandler = new cPipHandler(this);
            // Audio is init lazily (includes starting thread)
 
            break;
    }
}
 
void cSoftHdDevice::SetState(State newState)
{
    if (m_state != newState) {
        LOGDEBUG("device: Preparing to leave state %s", StateToString(m_state));
        OnLeavingState(m_state);
        LOGDEBUG("device: Changing state %s -> %s", StateToString(m_state), StateToString(newState));
        m_state = newState;
        OnEnteringState(m_state);
        LOGDEBUG("device: State changed to %s", StateToString(m_state));
    }
}
 
bool cSoftHdDevice::SetPlayMode(ePlayMode play_mode)
{
    LOGDEBUG("device: %s: %d", __FUNCTION__, play_mode);
 
    // A new play mode arrived, attach first if we did detach because of an external player
    if (m_externalPlayerActive) {
        OnEventReceived(AttachEvent{});
        m_externalPlayerActive = false;
    }
 
    switch (play_mode) {
    case pmNone:
        OnEventReceived(StopEvent{});
        break;
    case pmAudioVideo:
    case pmAudioOnly:
    case pmAudioOnlyBlack:
    case pmVideoOnly:
        OnEventReceived(PlayEvent{});
        break;
    case pmExtern_THIS_SHOULD_BE_AVOIDED:
        // External players like mpv (vdr-plugin-mpv) want to acquire DRM/ALSA
        // so we release it here and set a flag. As soon as the next SetPlayMode arrives
        // we then can attach again before changing to the new playmode.
        m_pPipHandler->Disable();
        OnEventReceived(DetachEvent{});
        m_externalPlayerActive = true;
        break;
    default:
        LOGERROR("device: %s: playmode not supported %d", play_mode);
        return false;
        break;
    }
 
    return true;
}
 
int64_t cSoftHdDevice::GetSTC(void)
{
    if (IsDetached())
        return AV_NOPTS_VALUE;
 
    switch (m_playbackMode) {
        case NONE:
            return AV_NOPTS_VALUE;
        case AUDIO_AND_VIDEO:
        case VIDEO_ONLY:
            return m_pRender->GetVideoClock();
        case AUDIO_ONLY:
            return m_pAudio->GetHardwareOutputPtsTimebaseUnits();
    }
 
    abort();
}
 
void cSoftHdDevice::TrickSpeed(int speed, bool forward)
{
    LOGDEBUG("device: %s: %d %s", __FUNCTION__, speed, forward ? "forward" : "backward");
 
    // This normalizes the VDR frame displaying count into a factor, representing how fast/slow the playback shall be.
    // For example, a factor of 2.0 means twice as fast as normal, a factor of 0.5 means half as fast as normal (slow-mo).
    // This is necessary because VDR sends only I-frames during trickspeed, but the distance between I-frames depends on the encoding parameters.
    // Therefore, we send a normalized factor for the further components, which then calculate the necessary frame displaying count by considering the distance between I-frames.
 
    double normalizedSpeed = 1;
    static constexpr double MAX_SPEED = 3;
 
    // these are arbitrary values, which feel just right
    static constexpr double FAST_TRICKSPEED_FACTOR = 5; // the higher the factor, the faster the fast forward/reverse
    static constexpr double SLOW_FORWARD_FACTOR = 2; // the higher the factor, the slower the slow-mo
 
    // Fastest speed in reverse slow-mo is the original speed. Slower speeds are too slow, because of the already low frame rate.
    static constexpr double SLOW_REVERSE_FACTOR = 1;
 
    // speed of the trickspeed (VDR's magic frame displaying count)
    switch (speed) {
        case 6:
        case 8:
        case 63:
            normalizedSpeed = 1; // slowest (both, in fast trickspeed and slow-mo)
            break;
        case 3:
        case 4:
        case 48:
            normalizedSpeed = 2;
            break;
        case 1:
        case 2:
        case 24:
            normalizedSpeed = 3; // fastest (both, in fast trickspeed and slow-mo)
            break;
    }
 
    // figure out if VDR demands slow-mo or fast trickspeed
    double tmp;
    switch (speed) {
        case 8:
        case 4:
        case 2:
        case 63:
        case 48:
        case 24:
            // slow-mo
            tmp = (MAX_SPEED + 1) - normalizedSpeed;
 
            if (forward)
                tmp *= SLOW_FORWARD_FACTOR;
            else
                tmp *= SLOW_REVERSE_FACTOR;
 
            normalizedSpeed = 1 / tmp;
        break;
        default:
            // fast trickspeed
            normalizedSpeed *= FAST_TRICKSPEED_FACTOR;
        break;
    }
 
    OnEventReceived(TrickSpeedEvent{normalizedSpeed, speed != 0, forward});
}
 
void cSoftHdDevice::Clear(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    cDevice::Clear();
 
    if (IsDetached())
        return;
 
    m_pRender->Halt();
    m_pVideoStream->Halt();
 
    m_pRender->SetDisplayOneFrameThenPause(true);
    m_pVideoStream->CancelFilterThread();
 
    m_videoReassemblyBuffer.Reset();
    m_pVideoStream->ClearVdrCoreToDecoderQueue();
    m_pRender->ClearDecoderToDisplayQueue();
 
    if (m_playbackMode == AUDIO_AND_VIDEO || m_playbackMode == VIDEO_ONLY)
        m_pVideoStream->FlushDecoder();
 
    m_pRender->Reset();
 
    m_pAudio->SetPaused(true);
    FlushAudio();
 
    SetState(BUFFERING);
 
    m_pRender->Resume();
    m_pVideoStream->Resume();
}
 
void cSoftHdDevice::Play(void)
{
    cDevice::Play();
 
    OnEventReceived(PlayEvent{});
}
 
void cSoftHdDevice::Freeze(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    cDevice::Freeze();
 
    OnEventReceived(PauseEvent{});
}
 
void cSoftHdDevice::StillPicture(const uchar *data, int size)
{
    LOGDEBUG("device: %s: %s %p %d", __FUNCTION__, data[0] == 0x47 ? "ts" : "pes", data, size);
 
    if (data[0] == 0x47) {      // ts sync byte
        cDevice::StillPicture(data, size);
        return;
    }
 
    OnEventReceived(StillPictureEvent{data, size});
}
 
void cSoftHdDevice::HandleStillPicture(const uchar *data, int size)
{
    m_pRender->SetPlaybackPaused(false);
    m_pVideoStream->SetDeinterlacerDeactivated(true);
 
    // skip BufferUnderrunEvent{VIDEO} in renderer
    m_pRender->SetStillpicture(true);
 
    const uchar *currentPacketStart = data;
    while (currentPacketStart < data + size) {
        cPesVideo pesPacket((const uint8_t*)currentPacketStart, size - (currentPacketStart - data));
 
        if (pesPacket.IsValid())
            PlayVideoInternal(m_pVideoStream, &m_videoReassemblyBuffer, currentPacketStart, pesPacket.GetPacketLength(), false, true);
        else {
            LOGWARNING("device: %s: invalid PES packet", __FUNCTION__);
            break;
        }
 
        currentPacketStart += pesPacket.GetPacketLength();
    }
 
    m_pVideoStream->PushAvPacket(m_videoReassemblyBuffer.PopAvPacket());
    m_pVideoStream->ResetInputPts(); // stillpicture shouldn't trigger having video data
    m_pVideoStream->Flush();
}
 
bool cSoftHdDevice::Poll(__attribute__ ((unused)) cPoller & poller, int timeoutMs)
{
//  LOGDEBUG("device: %s: timeout %d", __FUNCTION__, timeout_ms);
    if (IsDetached())
        return true;
 
    if (!m_pAudio->IsBufferFull() && !m_pVideoStream->IsInputBufferFull())
        return true;
 
    usleep(timeoutMs * 1000);
 
    return false;
}
 
bool cSoftHdDevice::Flush(int timeoutMs)
{
    if (IsDetached())
        return true;
 
    LOGDEBUG("device: %s: timeout %d ms", __FUNCTION__, timeoutMs);
    if (m_pVideoStream->GetAvPacketsFilled()) {
        if (timeoutMs) {            // let display thread work
            usleep(timeoutMs * 1000);
        }
        return !m_pVideoStream->GetAvPacketsFilled();
    }
 
    return true;
}
 
void cSoftHdDevice::SetVideoDisplayFormat(eVideoDisplayFormat videoDisplayFormat)
{
    LOGDEBUG("device: %s: %d", __FUNCTION__, videoDisplayFormat);
 
    cDevice::SetVideoDisplayFormat(videoDisplayFormat);
}
 
void cSoftHdDevice::SetVideoFormat(bool videoFormat16_9)
{
    LOGDEBUG("device: %s: %d", __FUNCTION__, videoFormat16_9);
 
    // FIXME: 4:3 / 16:9 video format not supported.
    SetVideoDisplayFormat(eVideoDisplayFormat(Setup.VideoDisplayFormat));
}
 
void cSoftHdDevice::GetVideoSize(int &width, int &height, double &aspectRatio)
{
//  LOGDEBUG("device: %s: %d x %d @ %f", __FUNCTION__, *width, *height, *aspectRatio);
 
    if (IsDetached()) { // return default values according to vdr docs
        width = 0;
        height = 0;
        aspectRatio = 1.0;
        return;
    }
 
    m_pVideoStream->GetVideoSize(&width, &height, &aspectRatio);
}
 
void cSoftHdDevice::GetOsdSize(int &width, int &height, double &aspectRatio)
{
    if (IsDetached()) { // hardcode to 1920x1080 in detached state
        width = 1920;
        height = 1080;
        aspectRatio = (double)width / (double)height;
        return;
    }
 
    std::lock_guard<std::mutex> lock(m_sizeMutex);
    width = m_osdWidth;
    height = m_osdHeight;
    aspectRatio = (double)width / (double)height;
}
 
void cSoftHdDevice::SetOsdSize(int width, int height)
{
    std::lock_guard<std::mutex> lock(m_sizeMutex);
    m_osdWidth = width;
    m_osdHeight = height;
}
 
void cSoftHdDevice::SetScreenSize(int width, int height)
{
    std::lock_guard<std::mutex> lock(m_sizeMutex);
    m_screenWidth = width;
    m_screenHeight = height;
}
 
static void PrintStreamData(const uchar *payload)
{
    LOGDEBUG2(L_CODEC, "Stream: %02X%02X%02X | %02X | %02X%02X | %02X%02X%02X | %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X %02X%02X%02X%02X",
        payload[0],
        payload[1],
        payload[2],
        payload[3],
        payload[4],
        payload[5],
        payload[6],
        payload[7],
        payload[8],
        payload[9],
        payload[10],
        payload[11],
        payload[12],
        payload[13],
        payload[14],
        payload[15],
        payload[16],
        payload[17],
        payload[18],
        payload[19],
        payload[20],
        payload[21],
        payload[22],
        payload[23],
        payload[24]
    );
}
 
int cSoftHdDevice::PlayAudio(const uchar *data, int size, uchar id)
{
//  LOGDEBUG("device: %s: %p %p %d %d", __FUNCTION__, this, data, size, id);
    if (IsDetached())
        return size;
 
    m_receivedAudio = true;
 
    if (m_pAudio->IsBufferFull())
        return 0;
 
    cPesAudio pesPacket((const uint8_t*)data, size);
 
    if (!pesPacket.IsValid()) {
        m_audioReassemblyBuffer.Reset();
 
        return size;
    }
 
    if (!m_receivedValidAudio && Transferring()) {
        auto now = std::chrono::steady_clock::now();
        auto timeUntilFirstPacketReceived = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_channelSwitchStartTime).count();
        LOGDEBUG("device: first valid audio packet arrives %dms after channel switch was triggered", timeUntilFirstPacketReceived);
 
        if (!m_receivedValidVideo)
            m_dataReceivedTime = now;
    }
    m_receivedValidAudio = true;
 
    if (Transferring()) { // compensation is only necessary with live streams
        m_pAudio->ClockDriftCompensation();
        m_audioJitterTracker.PacketReceived();
        m_pConfig->StatMaxShortTermAudioJitterMs = m_audioJitterTracker.GetShortTermMaxJitterMs();
        m_pConfig->StatMaxLongTermAudioJitterMs = m_audioJitterTracker.GetLongTermMaxJitterMs();
    }
 
    if (m_audioChannelID != id) {
        m_audioChannelID = id;
        m_audioReassemblyBuffer.Reset();
        m_pAudioDecoder->Close();
        LOGDEBUG("device: %s: new channel id 0x%02X", __FUNCTION__, m_audioChannelID);
    }
 
    m_audioReassemblyBuffer.Push(pesPacket.GetPayload(), pesPacket.GetPayloadSize(), pesPacket.GetPts());
 
    if (IsBufferingThresholdReached())
        OnEventReceived(BufferingThresholdReachedEvent{});
 
    AVPacket *avpkt;
    do {
        if (!(avpkt = m_audioReassemblyBuffer.PopAvPacket()))
            break;
 
        if (m_pAudioDecoder->GetCodecId() == AV_CODEC_ID_NONE && m_audioReassemblyBuffer.GetCodec() != AV_CODEC_ID_NONE) {
            // The playback has just started
            m_pAudioDecoder->Close();
            m_pAudioDecoder->Open(m_audioReassemblyBuffer.GetCodec());
        }
 
        m_pAudioDecoder->Decode(avpkt);
        AVPacket *copy = avpkt;
        av_packet_free(&copy);
    } while (avpkt != nullptr);
 
    return size;
}
 
void cSoftHdDevice::SetAudioTrackDevice( __attribute__ ((unused)) eTrackType type)
{
    //LOGDEBUG("device: %s:", __FUNCTION__);
}
 
void cSoftHdDevice::SetDigitalAudioDevice( __attribute__ ((unused)) bool on)
{
    //LOGDEBUG("device: %s: %s", __FUNCTION__, on ? "true" : "false");
}
 
void cSoftHdDevice::SetAudioChannelDevice( __attribute__ ((unused))
    int audio_channel)
{
    //LOGDEBUG("device: %s: %d", __FUNCTION__, audio_channel);
}
 
int cSoftHdDevice::GetAudioChannelDevice(void)
{
    //LOGDEBUG("device: %s:", __FUNCTION__);
    return 0;
}
 
void cSoftHdDevice::SetVolumeDevice(int volume)
{
    if (IsDetached())
        return;
 
    LOGDEBUG("device: %s: %d", __FUNCTION__, volume);
    m_volume = volume;
    m_pAudio->SetVolume((volume * 1000) / 255);
}
 
int cSoftHdDevice::PlayVideo(const uchar *data, int size)
{
//  LOGDEBUG("device: %s: %p %d", __FUNCTION__, data, size);
    if (IsDetached())
        return size;
 
    m_receivedVideo = true;
 
    return PlayVideoInternal(m_pVideoStream, &m_videoReassemblyBuffer, data, size, Transferring(), true);
}
 
int cSoftHdDevice::PlayPipVideo(const uchar *data, int size)
{
//  LOGDEBUG("device: %s: %p %d", __FUNCTION__, data, size);
 
    // This is a bit hacky:
    // Because we do no sync with the pip stream, we simply drop data
    // if the input buffer is full -> this prevents us from having a buffer overflow
    // caused by the pip stream.
    if (m_pPipStream->IsInputBufferFull())
        return size;
 
    return PlayVideoInternal(m_pPipStream, &m_pipReassemblyBuffer, data, size, false, false);
}
 
int cSoftHdDevice::PlayVideoInternal(cVideoStream *stream, cReassemblyBufferVideo *buffer, const uchar *data, int size, bool trackJitter, bool mainStream)
{
    // LOGDEBUG("device: %s: %p %d %s", __FUNCTION__, data, size, mainStream ? "video" : "pip");
 
    if (stream->IsInputBufferFull())
        return 0;
 
    cPesVideo pesPacket((const uint8_t*)data, size);
 
    if (!pesPacket.IsValid()) {
        buffer->Reset();
 
        return size;
    }
 
    if (mainStream) {
        if (!m_receivedValidVideo && Transferring()) {
            auto now = std::chrono::steady_clock::now();
            auto timeUntilFirstPacketReceived = std::chrono::duration_cast<std::chrono::milliseconds>(now - m_channelSwitchStartTime).count();
            LOGDEBUG("device: first valid video packet arrives %dms after channel switch was triggered", timeUntilFirstPacketReceived);
 
            if (!m_receivedValidAudio)
                m_dataReceivedTime = now;
 
        }
        m_receivedValidVideo = true;
    }
 
    if (trackJitter) {
        m_videoJitterTracker.PacketReceived();
        m_pConfig->StatMaxShortTermVideoJitterMs = m_videoJitterTracker.GetShortTermMaxJitterMs();
        m_pConfig->StatMaxLongTermVideoJitterMs = m_videoJitterTracker.GetLongTermMaxJitterMs();
    }
 
    if (stream->GetCodecId() == AV_CODEC_ID_NONE) {
        // The playback has just started
        if (!pesPacket.HasPts() || !buffer->ParseCodecHeader(pesPacket.GetPayload(), pesPacket.GetPayloadSize())) {
            // received the middle of fragmented data, wait for the next PES packets with the start of a new frame
            return size;
        }
 
        PrintStreamData(data);
        buffer->Push(pesPacket.GetPayload(), pesPacket.GetPayloadSize(), pesPacket.GetPts());
 
        stream->Open(buffer->GetCodec());
    } else {
        int payloadOffset = 0;
        if (pesPacket.HasPts() && !buffer->IsEmpty()) {
            // received the first fragment of a new frame, finish the current reassembly buffer into an AVPacket
            stream->PushAvPacket(buffer->PopAvPacket());
 
            // populate the cleared buffer with the next frame
            if (buffer->HasLeadingZero(pesPacket.GetPayload(), pesPacket.GetPayloadSize()))
                payloadOffset = 1; // H.264/HEVC streams may have a leading zero byte before the start code
        }
 
        buffer->Push(pesPacket.GetPayload() + payloadOffset, pesPacket.GetPayloadSize() - payloadOffset, pesPacket.GetPts());
    }
 
    return size;
}
 
int cSoftHdDevice::GetBufferFillLevelThresholdMs() {
    return MIN_BUFFER_FILL_LEVEL_THRESHOLD_MS + m_pConfig->ConfigAdditionalBufferLengthMs;
}
 
bool cSoftHdDevice::IsBufferingThresholdReached()
{
    if (m_state != BUFFERING)
        return false;
 
    bool audioHasInputPts = m_pAudio->HasInputPts();
    bool videoHasInputPts = m_pVideoStream->HasInputPts();
    bool videoHasOutputPts = m_pRender->GetOutputPtsMs() != AV_NOPTS_VALUE;
 
    // Assume audio only or video only if no PES fragment from the other stream has been received, while the buffering threshold of the other stream is reached.
    // Check for buffer fill level only if at least one PES packet was reassembled and pushed to the respective decoder.
    bool audioOnly = audioHasInputPts && !videoHasInputPts && m_receivedAudio && !m_receivedVideo;
    bool videoOnly = !audioHasInputPts && videoHasInputPts && !m_receivedAudio && m_receivedVideo;
 
    if        (audioOnly &&                      m_pAudio->GetInputPtsMs() - m_pAudio->GetOutputPtsMs() > GetBufferFillLevelThresholdMs()) {
        LOGDEBUG("device: %s: Detected audio only", __FUNCTION__);
        return true;
    } else if (videoOnly && videoHasOutputPts && m_pVideoStream->GetInputPtsMs() - m_pRender->GetOutputPtsMs() > GetBufferFillLevelThresholdMs()) {
        LOGDEBUG("device: %s: Detected video only", __FUNCTION__);
        return true;
    } else if (!audioHasInputPts || !videoHasInputPts || !videoHasOutputPts)
        return false; // Either no video or no audio received, yet. Or, video didn't make it to the output buffer, yet.
 
    int64_t syncedAudioBufferFillLevelMs = m_pAudio->GetInputPtsMs() - GetFirstAudioPtsMsToPlay();
    int64_t syncedVideoBufferFillLevelMs = m_pVideoStream->GetInputPtsMs() - GetFirstVideoPtsMsToPlay();
 
    bool reached = m_pRender->IsOutputBufferFull() && // video decoder output buffer (audio hardware output buffer is negligible)
        syncedVideoBufferFillLevelMs > GetBufferFillLevelThresholdMs() && // video decoder input buffer
        syncedAudioBufferFillLevelMs > GetBufferFillLevelThresholdMs(); // audio decoder output buffer
 
    if (reached) {
        LOGDEBUG2(L_AV_SYNC, "First received PTS: %s (audio), %s (video) buffer fill levels: %ldms (audio) %ldms (video)",
            Timestamp2String(m_pAudio->GetOutputPtsMs(), 1),
            Timestamp2String(m_pRender->GetOutputPtsMs(), 1),
            syncedAudioBufferFillLevelMs,
            syncedVideoBufferFillLevelMs);
    }
 
    return reached;
}
 
int64_t cSoftHdDevice::GetFirstAudioPtsMsToPlay()
{
    int64_t ret = std::max(m_pRender->GetOutputPtsMs(), m_pAudio->GetOutputPtsMs());
 
    if (m_pConfig->ConfigVideoAudioDelayMs < 0)
        ret -= m_pConfig->ConfigVideoAudioDelayMs;
 
    return ret;
}
 
int64_t cSoftHdDevice::GetFirstVideoPtsMsToPlay()
{
    int64_t ret = std::max(m_pRender->GetOutputPtsMs(), m_pAudio->GetOutputPtsMs());
 
    if (m_pConfig->ConfigVideoAudioDelayMs > 0)
        ret += m_pConfig->ConfigVideoAudioDelayMs;
 
    return ret;
}
 
uchar *cSoftHdDevice::GrabImage(int &size, bool jpeg, int quality, int width, int height)
{
    if (!width || !height) {
        LOGWARNING("device: %s: width or height is 0 - skip!", __FUNCTION__);
        return nullptr;
    }
 
    if (IsDetached())
        return nullptr;
 
    if (m_pGrab->IsActive()) {
        LOGWARNING("device: %s: wait for the last grab to be finished - skip!", __FUNCTION__);
        return nullptr;
    }
 
    LOGDEBUG2(L_GRAB, "device: %s: %d, %d, %d, %dx%d", __FUNCTION__, size, jpeg, quality, width, height);
 
    if (!m_pGrab->Start(jpeg, quality, width, height, m_screenWidth, m_screenHeight))
        return nullptr;
 
    if (!m_pGrab->ProcessGrab())
        return nullptr;
 
    size = m_pGrab->Size();
    uchar *result = m_pGrab->Image();
 
    m_pGrab->Finish();
 
    return result;
}
 
cRect cSoftHdDevice::CanScaleVideo(const cRect & rect, __attribute__ ((unused)) int alignment)
{
    if (m_screenWidth == m_osdWidth && m_screenHeight == m_osdHeight)
        return rect;
 
    double scaleFactor = std::min((double)m_screenWidth / m_osdWidth, (double)m_screenHeight / m_osdHeight);
    int width  = std::lround(scaleFactor * rect.Width());
    int height = std::lround(scaleFactor * rect.Height());
    int x      = std::lround(scaleFactor * rect.X());
    int y      = std::lround(scaleFactor * rect.Y());
 
    x = std::max(0, x);
    y = std::max(0, y);
    if (x + width > m_screenWidth)
        width = m_screenWidth - x;
    if (y + height > m_screenHeight)
        height = m_screenHeight - y;
 
    if (width <= 0 || height <= 0)
        return cRect::Null;
 
    LOGDEBUG2(L_DRM, "device: %s: scale rect %dx%d-%d|%d -> %dx%d-%d|%d", __FUNCTION__,
        rect.Width(), rect.Height(), rect.X(), rect.Y(), width, height, x, y);
 
    return cRect(x, y, width, height);
}
 
void cSoftHdDevice::ScaleVideo(const cRect & rect)
{
    if (IsDetached())
        return;
 
    LOGDEBUG2(L_OSD, "device: %s: %dx%d%+d%+d",
        __FUNCTION__, rect.Width(), rect.Height(), rect.X(), rect.Y());
 
    if (m_pRender)
        m_pRender->SetVideoOutputPosition(rect);
}
 
void cSoftHdDevice::OsdClose(void)
{
    if (IsDetached())
        return;
 
    m_pRender->OsdClear();
}
 
void cSoftHdDevice::OsdDrawARGB(int xi, int yi, int height, int width, int pitch,
    const uint8_t * argb, int x, int y)
{
    if (IsDetached())
        return;
 
    m_pRender->OsdDrawARGB(xi, yi, height, width, pitch, argb, x, y);
}
 
#ifdef USE_GLES
int cSoftHdDevice::MaxSizeGPUImageCache(void)
{
    return m_pConfig->ConfigMaxSizeGPUImageCache;
};
 
int cSoftHdDevice::OglOsdIsDisabled(void)
{
    return m_pConfig->ConfigDisableOglOsd;
};
 
void cSoftHdDevice::SetDisableOglOsd(void)
{
    m_pConfig->ConfigDisableOglOsd = 1;
    if (m_pRender)
        m_pRender->DisableOglOsd();
}
 
void cSoftHdDevice::SetEnableOglOsd(void)
{
    m_pConfig->ConfigDisableOglOsd = 0;
    if (m_pRender)
        m_pRender->EnableOglOsd();
}
 
#endif
 
void cSoftHdDevice::SetDisableDeint(void)
{
    if (m_pVideoStream)
        m_pVideoStream->DisableDeint(m_pConfig->ConfigDisableDeint);
}
 
void cSoftHdDevice::SetDecoderNeedsIFrame(void)
{
    if (m_pVideoStream)
        m_pVideoStream->SetStartDecodingWithIFrame(m_pConfig->ConfigDecoderNeedsIFrame);
}
 
void cSoftHdDevice::SetParseH264Dimensions(void)
{
    if (m_pVideoStream)
        m_pVideoStream->SetParseH264Dimensions(m_pConfig->ConfigParseH264Dimensions);
}
 
void cSoftHdDevice::SetDecoderFallbackToSw(bool enable)
{
    if (!m_pVideoStream)
        return;
 
    if (enable)
        m_pVideoStream->SetDecoderFallbackToSwNumPkts(m_pConfig->ConfigDecoderFallbackToSwNumPkts);
    else
        m_pVideoStream->SetDecoderFallbackToSwNumPkts(0);
}
 
void cSoftHdDevice::SetPassthroughMask(int mask)
{
    m_pAudio->SetPassthroughMask(mask);
    if (m_pAudioDecoder)
        m_pAudioDecoder->SetPassthroughMask(mask);
}
 
void cSoftHdDevice::ResetChannelId(void)
{
    LOGDEBUG("%s:", __FUNCTION__);
    m_audioChannelID = -1;
}
 
void cSoftHdDevice::GetStats(int *duped, int *dropped, int *counter)
{
    *duped = 0;
    *dropped = 0;
    *counter = 0;
    if (m_pRender) {
        m_pRender->GetStats(duped, dropped, counter);
    }
}
 
/*****************************************************************************
 * media player functions
 ****************************************************************************/
 
void cSoftHdDevice::SetAudioCodec(enum AVCodecID codecId, AVCodecParameters * par, AVRational timebase)
{
    m_pAudioDecoder->Open(codecId, par, timebase);
}
 
void cSoftHdDevice::SetVideoCodec(enum AVCodecID codecId, AVCodecParameters * par, AVRational timebase)
{
    m_pVideoStream->Open(codecId, par, timebase);
}
 
int cSoftHdDevice::PlayAudioPkts(AVPacket * pkt)
{
    m_pAudio->LazyInit();
 
    if (m_pAudio->IsBufferFull())
        return 0;
 
    m_pAudioDecoder->Decode(pkt);
    return 1;
}
 
int cSoftHdDevice::PlayVideoPkts(AVPacket * pkt)
{
    m_pAudio->LazyInit();
 
    if (m_pVideoStream->GetAvPacketsFilled() >= (size_t)m_pVideoStream->GetVideoPacketMax() - 10)
        return 0;
 
    m_pVideoStream->PushAvPacket(pkt);
 
    return 1;
}
 
/*****************************************************************************
 * Detach and attach functionality
 ****************************************************************************/
 
void cSoftHdDevice::Detach(void)
{
    if (cDevice::Replaying()) {
        LOGDEBUG("device: %s: Device is replaying, stop replay first", __FUNCTION__);
        StopReplay();
    }
 
    if (IsPrimaryDevice(false)) {
        m_needsMakePrimary = true;
        MakePrimaryDevice(false);
    }
 
    m_pPipHandler->Disable();
    OnEventReceived(DetachEvent{});
}
 
void cSoftHdDevice::Attach(void)
{
    m_forceDetached = false;
 
    if (m_needsMakePrimary) {
        MakePrimaryDevice(true);
        m_needsMakePrimary = false;
    }
 
    OnEventReceived(AttachEvent{});
}
 
bool cSoftHdDevice::IsDetached(void) const
{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_state == State::DETACHED;
}
 
/*****************************************************************************
 * PiP functionality
 ****************************************************************************/
 
void cSoftHdDevice::ResetPipStream(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
 
    m_pPipStream->Halt();
 
    m_pPipStream->CancelFilterThread();
    m_pipReassemblyBuffer.Reset();
    m_pPipStream->ClearVdrCoreToDecoderQueue();
    m_pPipStream->CloseDecoder();
 
    m_pRender->Halt();
 
    m_pRender->ClearPipDecoderToDisplayQueue();
    m_pRender->ResetPipDecodingStrategy();
    m_pRender->ResetPipBufferReuseStrategy();
 
    m_pRender->Resume();
    m_pPipStream->Resume();
}
 
bool cSoftHdDevice::PipIsEnabled(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_pPipHandler->IsEnabled();
}
 
/*
 * Wrapper functions for cVideoRender and cPipHandler
 */
void cSoftHdDevice::SetRenderPipSize(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_pRender->Halt();
    m_pRender->SetPipSize(m_pipUseAlt);
    m_pRender->Resume();
};
 
void cSoftHdDevice::SetRenderPipActive(bool active)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_pRender->Halt();
    m_pRender->SetPipActive(active);
    m_pRender->Resume();
};
 
void cSoftHdDevice::PipEnable(void) { m_pPipHandler->Enable(); };
void cSoftHdDevice::PipDisable(void) { m_pPipHandler->Disable(); };
void cSoftHdDevice::PipToggle(void) { m_pPipHandler->Toggle(); };
void cSoftHdDevice::PipChannelChange(int dir) { m_pPipHandler->ChannelChange(dir); };
void cSoftHdDevice::PipChannelSwap(bool closePip) { m_pPipHandler->ChannelSwap(closePip); };
void cSoftHdDevice::PipSwapPosition(void) { m_pPipHandler->SwapPosition(); };
void cSoftHdDevice::PipSetSize(void) { m_pPipHandler->SetSize(); };
 
void cSoftHdDevice::SetEnableHdr(bool enable) { m_pRender->SetEnableHdr(enable); };
 
void cSoftHdDevice::SetDisplayMode(int idx)
{
    sDrmMode *mode = &m_pConfig->AutoDetectedDrmMode;
 
    if (idx == CONFIG_DISPLAY_MODE_FOLLOW_VIDEO ||
        idx == CONFIG_DISPLAY_MODE_FOLLOW_VIDEO_INTERLACED) {
        mode = &m_pConfig->CurrentVideoDrmMode;
        if (!mode->width || !m_pRender->CanHandleMode(mode))
            mode = &m_pConfig->AutoDetectedDrmMode;
    } else if (idx >= CONFIG_DISPLAY_MODE_MANUAL)
        mode = &m_pConfig->CollectedDrmModes[idx - CONFIG_DISPLAY_MODE_MANUAL];
 
    // Check, if the requested mode differs from the current one at all
    if (!m_pConfig->CompareCurrentMode(mode)) {
        LOGDEBUG("Add display mode change event to %s mode %dx%d@%.2f%s",
             idx == CONFIG_DISPLAY_MODE_DEFAULT ? "default" :
            (idx == CONFIG_DISPLAY_MODE_FOLLOW_VIDEO ? "follow video" :
            (idx == CONFIG_DISPLAY_MODE_FOLLOW_VIDEO_INTERLACED ? "follow video interlaced" :
             "fixed")),
            mode->width, mode->height, mode->refreshRateHz, mode->interlaced ? "i" : "");
        m_pEventHandler->AddEvent(DisplayChangeEvent{*mode});
    }
}
 
void cSoftHdDevice::HandleDisplayModeChange(const sDrmMode &mode)
{
    LOGDEBUG("Set display mode: %dx%d@%.2f%s",
        mode.width,
        mode.height,
        mode.refreshRateHz,
        mode.interlaced ? "i" : "");
 
    m_pConfig->RequestedDrmMode = mode;
    m_pRender->ReInitDisplayMode();
}
 
cEventHandler::cEventHandler(cSoftHdDevice *device)
    : cThread("event handler"),
      m_pDevice(device),
      m_pEventReceiver(device)
{
    Start();
}
 
cEventHandler::~cEventHandler(void)
{
    Cancel(2);
}
 
void cEventHandler::Action(void)
{
    LOGDEBUG("device: event queue handler thread started");
 
    while (Running()) {
        std::vector<Event> local;
        {
            std::lock_guard<std::mutex> lock(m_mutex);
            local.swap(m_eventQueue);
        }
 
        for (auto &event : local)
            m_pEventReceiver->OnEventReceived(event);
 
        usleep(10000);
 
    }
 
    LOGDEBUG("device: event queue handler thread stopped");
}
 
void cEventHandler::AddEvent(Event event)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    m_eventQueue.push_back(event);
}