device.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 "device.h"
#include "grab.h"
#include "hardwaredevice.h"
#include "jittertracker.h"
#include "logger.h"
#include "osdprovider.h"
#include "pes.h"
#include "pip.h"
#include "statemachine.h"
#include "videorender.h"
#include "videostream.h"
 
cOutputDevice::cOutputDevice(cDeviceConfig *config)
    : m_pConfig(config)
{
    m_pStateMachine = std::make_unique<cStateMachine>(this);
}
 
cOutputDevice::~cOutputDevice(void)
{
    if (!m_initialized)
        return;
 
    m_initialized = false; // not necessary, just for documentation
 
    delete m_pEventHandler;
    delete m_pHardwareDevice;
    delete m_pSpuDecoder;
}
 
/*********************************************************************
 * VDR cPlugin interface (wrapped by cPluginDrmDevice)
 ********************************************************************/
 
bool cOutputDevice::Initialize(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
 
    // the following are deleted in the destructor
    m_pSpuDecoder = new cDvbSpuDecoder();
    m_pHardwareDevice = new cHardwareDevice();
    m_pEventHandler = new cEventHandler(m_pStateMachine.get());
 
    auto channelSwitchStartTime = std::chrono::steady_clock::now();
    LOGGER->SetChannelSwitchStartTime(channelSwitchStartTime);
    LOGGER->SetChannelSwitchDataReceivedTime(channelSwitchStartTime);
 
    m_pipUseAlt = m_pConfig->ConfigPipUseAlt;
    m_channelSwitchMode = static_cast<ChannelSwitchMode>(m_pConfig->ConfigVideoChannelSwitchMode);
 
    m_initialized = true;
 
    return true;
}
 
int cOutputDevice::Start(void)
{
    LOGDEBUG("device: %s", __FUNCTION__);
    TriggerEvent(AttachEvent{});
 
    return true;
}
 
void cOutputDevice::Stop(void)
{
    LOGDEBUG("device: %s", __FUNCTION__);
    m_pPipHandler->Disable();
    TriggerEvent(DetachEvent{});
}
 
/*********************************************************************
 * VDR cDevice interface
 ********************************************************************/
 
void cOutputDevice::MakePrimaryDevice(bool on)
{
    LOGDEBUG("device: %s: %d", __FUNCTION__, on);
 
    if (on)
        m_pOsdProvider = new cDeviceOsdProvider(this); // no need to delete it, VDR does it
 
    cDevice::MakePrimaryDevice(on);
}
 
bool cOutputDevice::HasDecoder(void) const
{
    bool hasDecoder = !IsDetached();
 
//  LOGDEBUG("device: %s: %d", __FUNCTION__, hasDecoder);
 
    return hasDecoder;
}
 
cSpuDecoder *cOutputDevice::GetSpuDecoder(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    if (!IsPrimaryDevice())
        return NULL;
 
    return m_pSpuDecoder;
}
 
uchar *cOutputDevice::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;
}
 
void cOutputDevice::SetVideoDisplayFormat(eVideoDisplayFormat videoDisplayFormat)
{
    LOGDEBUG("device: %s: %d", __FUNCTION__, videoDisplayFormat);
 
    cDevice::SetVideoDisplayFormat(videoDisplayFormat);
}
 
void cOutputDevice::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 cOutputDevice::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 cOutputDevice::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 cOutputDevice::SetVolumeDevice(int volume)
{
    if (IsDetached())
        return;
 
    LOGDEBUG("device: %s: %d", __FUNCTION__, volume);
    m_volume = volume;
    m_pAudio->SetVolume((volume * 1000) / 255);
}
 
bool cOutputDevice::CanReplay(void) const
{
    bool canReplay = !IsDetached();
 
    LOGDEBUG("device: %s: %d", __FUNCTION__, canReplay);
 
    return canReplay;
}
 
bool cOutputDevice::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) {
        TriggerEvent(AttachEvent{});
        m_externalPlayerActive = false;
    }
 
    auto now = std::chrono::steady_clock::now();
    auto durationSinceChannelSwitchMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - LOGGER->GetChannelSwitchStartTime()).count();
 
    SetDrain(false);
 
    switch (play_mode) {
    case pmNone:
        TriggerEvent(StopEvent{});
        break;
    case pmAudioVideo:
    case pmAudioOnly:
    case pmAudioOnlyBlack:
    case pmVideoOnly:
        m_logPlaybackStart = true;
        LOGDEBUG2(L_AV_SYNC, "TRACE: +%5dms SetPlayMode()", durationSinceChannelSwitchMs);
        TriggerEvent(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();
        TriggerEvent(DetachEvent{});
        m_externalPlayerActive = true;
        break;
    default:
        LOGERROR("device: %s: playmode not supported %d", play_mode);
        return false;
        break;
    }
 
    return true;
}
 
int cOutputDevice::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;
 
    // Special audio-only trickspeed handling:
    // Advance the pts and block the thread depending on the pts difference and trickspeed factor.
    // Don't forward any data to the hardware, because audio is muted anyway.
    bool slowForward = m_pAudio->IsForwardTrickSpeed() && m_pAudio->IsSlowTrickSpeed();
    if (m_playbackMode == AUDIO_ONLY && m_pStateMachine->GetState() == State::TRICK_SPEED && !slowForward) {
        cPesAudio pesPacket((const uint8_t*)data, size);
        if (pesPacket.IsValid() && pesPacket.GetPts() != AV_NOPTS_VALUE)
            m_pAudio->AdvanceTrickSpeedPts(pesPacket.GetPts());
 
        return size;
    }
 
    if (m_pAudio->IsBufferFull())
        return 0;
 
    cPesAudio pesPacket((const uint8_t*)data, size);
 
    if (!pesPacket.IsValid()) {
        m_audioReassemblyBuffer.Reset();
 
        return size;
    }
 
    if (!m_receivedValidAudio) {
        auto now = std::chrono::steady_clock::now();
        auto durationSinceChannelSwitchMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - LOGGER->GetChannelSwitchStartTime()).count();
        LOGDEBUG2(L_AV_SYNC, "TRACE: +%5dms PlayAudio() first valid audio data", durationSinceChannelSwitchMs);
 
        if (!m_receivedValidVideo)
            LOGGER->SetChannelSwitchDataReceivedTime(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());
 
    // fire playback start, if all buffers reached the threshold fill levels
    if (CheckPlaybackStartConditions())
        TriggerEvent(BufferingThresholdReachedEvent{});
 
    // unpause audio, if the fast channel switch mode wants it to be started,
    // the audio buffer reached the threshold and we are in live tv mode
    if (CheckAudioPlaybackStartConditions())
        m_pAudio->SetPaused(false);
 
    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;
}
 
int cOutputDevice::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);
}
 
int64_t cOutputDevice::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:
            bool slowForward = m_pAudio->IsForwardTrickSpeed() && m_pAudio->IsSlowTrickSpeed();
            if (m_pStateMachine->GetState() == State::TRICK_SPEED && !slowForward)
                return m_pAudio->GetTrickSpeedPtsTimebaseUnits();
 
            return m_pAudio->GetHardwareOutputPtsTimebaseUnits();
    }
 
    abort();
}
 
cRect cOutputDevice::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 cOutputDevice::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 cOutputDevice::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;
    }
 
    TriggerEvent(TrickSpeedEvent{normalizedSpeed, speed != 0, forward});
}
 
void cOutputDevice::Clear(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    cDevice::Clear();
 
    if (IsDetached())
        return;
 
    m_pRender->Halt();
    m_pVideoStream->Halt();
 
    SetDrain(false);
 
    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);
    m_pAudio->ResetHwDelayBaseline();
    FlushAudio();
 
    m_pStateMachine->ChangeState(BUFFERING);
 
    m_pRender->Resume();
    m_pVideoStream->Resume();
}
 
void cOutputDevice::Play(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    cDevice::Play();
 
    TriggerEvent(PlayEvent{});
}
 
void cOutputDevice::Freeze(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    cDevice::Freeze();
 
    TriggerEvent(PauseEvent{});
}
 
void cOutputDevice::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;
    }
 
    TriggerEvent(StillPictureEvent{data, size});
}
 
bool cOutputDevice::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 cOutputDevice::Flush(int timeoutMs)
{
    if (IsDetached())
        return true;
 
//  LOGDEBUG("device: %s: timeout %d ms", __FUNCTION__, timeoutMs);
 
    const auto buffersEmpty = [&]() {
        return m_playbackMode == AUDIO_ONLY
            ? m_pAudio->IsBufferEmpty()
            : m_pVideoStream->BuffersEmpty();
    };
 
    const cTimeMs timeout(timeoutMs);
    while (!buffersEmpty() && !timeout.TimedOut())
        cCondWait::SleepMs(std::min(5, timeoutMs));
 
    return buffersEmpty();
}
 
#if APIVERSNUM >= 30014
bool cOutputDevice::DrainDevice(void)
{
    if (IsDetached())
        return true;
 
    // enter drain mode once
    if (!m_draining) {
        if (!m_videoReassemblyBuffer.IsEmpty())
            m_pVideoStream->PushAvPacket(m_videoReassemblyBuffer.PopAvPacket());
 
        if (!m_pVideoStream->Drain())
            return false;
 
        SetDrain(true);
    }
 
    const auto buffersEmpty = [&]() {
        return m_playbackMode == AUDIO_ONLY
            ? m_pAudio->IsBufferEmpty()
            : m_pVideoStream->BuffersEmpty();
    };
 
    if (!buffersEmpty())
        return false;
 
    LOGDEBUG("device: %s: drained, buffers are empty", __FUNCTION__);
    SetDrain(false);
 
    return true;
}
#endif
 
/*********************************************************************
 * VDR cStatus interface
 ********************************************************************/
 
void cOutputDevice::ChannelSwitch(const cDevice *device, int channelNum, bool liveView)
{
    if (device != cDevice::PrimaryDevice() || !liveView || channelNum != 0)
        return;
 
    auto now = std::chrono::steady_clock::now();
    LOGGER->SetChannelSwitchStartTime(now);
    LOGDEBUG2(L_AV_SYNC, "TRACE: channel switch");
}
 
void cOutputDevice::Replaying([[maybe_unused]]const cControl *control,
                              [[maybe_unused]]const char *name,
                              [[maybe_unused]]const char *filenameDevice,
                              bool on)
{
    if (!on)
        return;
 
    auto now = std::chrono::steady_clock::now();
    LOGGER->SetChannelSwitchStartTime(now);
    LOGDEBUG2(L_AV_SYNC, "TRACE: replay start");
}
 
/*********************************************************************
 * cOutputDevice public API - playback, display, decoder control
 ********************************************************************/
 
void cOutputDevice::SetDisableDeint(void)
{
    if (m_pVideoStream)
        m_pVideoStream->DisableDeint(m_pConfig->ConfigDisableDeint);
}
 
 
void cOutputDevice::SetDecoderFallbackToSw(bool enable)
{
    if (!m_pVideoStream)
        return;
 
    if (enable)
        m_pVideoStream->SetDecoderFallbackToSwNumPkts(m_pConfig->ConfigDecoderFallbackToSwNumPkts);
    else
        m_pVideoStream->SetDecoderFallbackToSwNumPkts(0);
}
 
void cOutputDevice::SetEnableHdr(bool enable)
{
    m_pRender->SetEnableHdr(enable);
};
 
void cOutputDevice::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});
    }
}
 
bool cOutputDevice::CheckPlaybackStartConditions()
{
    if (m_pStateMachine->GetState() == PLAY && m_playbackMode == AUDIO_ONLY && m_receivedVideo) {
        TriggerEvent(ResyncEvent{});
        return false;
    }
 
    if (m_pStateMachine->GetState() != 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;
 
    const int64_t bufferFillLevelThresholdMs = GetBufferFillLevelThresholdMs();
 
    if (audioOnly && m_pAudio->GetInputPtsMs() - m_pAudio->GetOutputPtsMs() > bufferFillLevelThresholdMs) {
        LOGDEBUG("device: %s: Detected audio only", __FUNCTION__);
        return true;
    }
 
    if (videoOnly && videoHasOutputPts && m_pVideoStream->GetInputPtsMs() - m_pRender->GetOutputPtsMs() > bufferFillLevelThresholdMs) {
        LOGDEBUG("device: %s: Detected video only", __FUNCTION__);
        return true;
    }
 
    // In audio/video mode we need valid PTS values for both streams and a video frame must have reached the output buffer.
    if (!audioHasInputPts || !videoHasInputPts || !videoHasOutputPts)
        return false;
 
    const int64_t syncedAudioBufferFillLevelMs = m_pAudio->GetInputPtsMs() - GetFirstAudioPtsMsToPlay();
    const int64_t syncedVideoBufferFillLevelMs = m_pVideoStream->GetInputPtsMs() - GetFirstVideoPtsMsToPlay();
    const bool renderBufferIsFilled = m_pRender->IsOutputBufferFull();
 
    bool videoBufferReachedThreshold = syncedVideoBufferFillLevelMs > bufferFillLevelThresholdMs;
    bool audioBufferReachedThreshold = syncedAudioBufferFillLevelMs > bufferFillLevelThresholdMs;
 
    const bool videoIsReady = renderBufferIsFilled && videoBufferReachedThreshold;
    const bool audioIsReady = audioBufferReachedThreshold || !m_pAudio->IsPaused();
 
    // used for diagnostics:
    // both audio and video have reached their buffering thresholds, but playback may
    // still be waiting for audio/video sync
    const bool allBuffersReachedThreshold = videoIsReady && audioBufferReachedThreshold;
 
    // in CHANNEL_SWITCH_FAST_AUDIO mode audio was started already,
    // do not start video until audio has caught up with the video pts
    const int64_t audioBehindVideoMs = m_pRender->GetOutputPtsMs() - m_pAudio->GetOutputPtsMs() - GetVideoAudioDelayMs();
    bool videoPlaybackMayStart = !FastChannelSwitchAudioInTransferMode() || audioBehindVideoMs <= m_pRender->GetAudioBehindVideoStartThresholdMs();
 
    if (videoIsReady && audioIsReady && videoPlaybackMayStart) {
        auto now = std::chrono::steady_clock::now();
        auto durationSinceChannelSwitchMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - LOGGER->GetChannelSwitchStartTime()).count();
        LOGDEBUG2(L_AV_SYNC, "TRACE: +%5dms firing BufferingThresholdReached - PTS: %s (a), %s (v) -> diff %dms - buffer fill levels: %ldms (a) %ldms (v) render queue %d",
            durationSinceChannelSwitchMs,
            Timestamp2StringMs(m_pAudio->GetOutputPtsMs()),
            Timestamp2StringMs(m_pRender->GetOutputPtsMs()),
            audioBehindVideoMs,
            syncedAudioBufferFillLevelMs,
            syncedVideoBufferFillLevelMs,
            m_pRender->GetFramesFilled());
 
        return true;
    }
 
    if (allBuffersReachedThreshold && m_logPlaybackStart) {
        auto now = std::chrono::steady_clock::now();
        auto durationSinceChannelSwitchMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - LOGGER->GetChannelSwitchStartTime()).count();
        LOGDEBUG2(L_AV_SYNC, "TRACE: +%5dms BufferingThresholdReached, video waits for audio - PTS: %s (a), %s (v) -> diff %dms - buffer fill levels: %ldms (a) %ldms (v) render queue %d",
            durationSinceChannelSwitchMs,
            Timestamp2StringMs(m_pAudio->GetOutputPtsMs()),
            Timestamp2StringMs(m_pRender->GetOutputPtsMs()),
            audioBehindVideoMs,
            syncedAudioBufferFillLevelMs,
            syncedVideoBufferFillLevelMs,
            m_pRender->GetFramesFilled());
        m_logPlaybackStart = false;
    }
 
    return false;
}
 
bool cOutputDevice::CheckAudioPlaybackStartConditions()
{
    if (m_pStateMachine->GetState() != BUFFERING)
        return false;
 
    if (!FastChannelSwitchAudioInTransferMode())
        return false;
 
    if (!m_pAudio->IsPaused())
        return false;
 
    bool audioHasInputPts = m_pAudio->HasInputPts();
    bool videoHasInputPts = m_pVideoStream->HasInputPts();
    bool videoHasOutputPts = m_pRender->GetVideoClock() != AV_NOPTS_VALUE;
 
    // only start audio playback if the device also received and presented video already
    // -> video is always first
    if (!audioHasInputPts || !videoHasInputPts || !videoHasOutputPts)
        return false;
 
    int64_t audioBufferFillLevelMs = m_pAudio->GetInputPtsMs() - m_pAudio->GetOutputPtsMs();
 
    // the needed audio threshold fill level wasn't reached yet
    if (audioBufferFillLevelMs < GetBufferFillLevelThresholdMs())
        return false;
 
    // drop audio data here, if the buffer fill level exceeds the threshold
    // - otherwise a later playback start is unneccessarily delayed when all buffers
    // reached their threshold but the rest of the audio data has still to be played out ...
    int64_t bufferSurplus = audioBufferFillLevelMs - GetBufferFillLevelThresholdMs();
    m_pAudio->DropSamplesOlderThanPtsMs(m_pAudio->GetOutputPtsMs() + bufferSurplus);
 
    // get new buffer filllevel for correct log message, because frames have been dropped in the meantime
    int64_t newAudioBufferFillLevelMs = m_pAudio->GetInputPtsMs() - m_pAudio->GetOutputPtsMs();
 
    const int64_t audioBehindVideoMs = m_pRender->GetOutputPtsMs() - m_pAudio->GetOutputPtsMs() - GetVideoAudioDelayMs();
 
    auto now = std::chrono::steady_clock::now();
    auto durationSinceChannelSwitchMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - LOGGER->GetChannelSwitchStartTime()).count();
    LOGDEBUG2(L_AV_SYNC, "TRACE: +%5dms firing AudioBufferingThresholdReached, threshold %dms - PTS: %s (a), %s (v) -> diff %dms - audio buffer: %ldms -> %ldms",
        durationSinceChannelSwitchMs,
        GetBufferFillLevelThresholdMs(),
        Timestamp2StringMs(m_pAudio->GetOutputPtsMs()),
        Timestamp2StringMs(m_pRender->GetOutputPtsMs()),
        audioBehindVideoMs,
        audioBufferFillLevelMs,
        newAudioBufferFillLevelMs);
 
    return true;
}
 
/*********************************************************************
 * cOutputDevice public API - osd control
 ********************************************************************/
 
#ifdef USE_GLES
int cOutputDevice::MaxSizeGPUImageCache(void)
{
    return m_pConfig->ConfigMaxSizeGPUImageCache;
};
 
int cOutputDevice::OglOsdIsDisabled(void)
{
    return m_pConfig->ConfigDisableOglOsd;
};
 
void cOutputDevice::SetDisableOglOsd(void)
{
    m_pConfig->ConfigDisableOglOsd = 1;
    if (m_pRender)
        m_pRender->DisableOglOsd();
}
 
void cOutputDevice::SetEnableOglOsd(void)
{
    m_pConfig->ConfigDisableOglOsd = 0;
    if (m_pRender)
        m_pRender->EnableOglOsd();
}
#endif
 
void cOutputDevice::OsdClose(void)
{
    if (IsDetached())
        return;
 
    m_pRender->OsdClear();
}
 
void cOutputDevice::OsdDraw(int xi, int yi, int height, int width, int pitch,
    const uint8_t * argb, int x, int y)
{
    if (IsDetached())
        return;
 
    m_pRender->OsdDraw(xi, yi, height, width, pitch, argb, x, y);
}
 
void cOutputDevice::SetOsdSize(int width, int height)
{
    std::lock_guard<std::mutex> lock(m_sizeMutex);
    m_osdWidth = width;
    m_osdHeight = height;
}
 
void cOutputDevice::SetScreenSize(int width, int height)
{
    std::lock_guard<std::mutex> lock(m_sizeMutex);
    m_screenWidth = width;
    m_screenHeight = height;
}
 
/*********************************************************************
 * cOutputDevice public API - audio control
 ********************************************************************/
 
void cOutputDevice::SetPassthroughMask(int mask)
{
    m_pAudio->SetPassthroughMask(mask);
    if (m_pAudioDecoder)
        m_pAudioDecoder->SetPassthroughMask(mask);
}
 
void cOutputDevice::ResetChannelId(void)
{
    LOGDEBUG("%s:", __FUNCTION__);
    m_audioChannelID = -1;
}
 
/*********************************************************************
 * cOutputDevice public API - logging, statistics
 ********************************************************************/
 
void cOutputDevice::GetStats(int *duped, int *dropped, int *counter)
{
    *duped = 0;
    *dropped = 0;
    *counter = 0;
    if (m_pRender) {
        m_pRender->GetStats(duped, dropped, counter);
    }
}
 
/*********************************************************************
 * cOutputDevice public API - mediaplayer
 ********************************************************************/
 
void cOutputDevice::SetAudioCodec(enum AVCodecID codecId, AVCodecParameters * par, AVRational timebase)
{
    m_pAudioDecoder->Open(codecId, par, timebase);
}
 
void cOutputDevice::SetVideoCodec(enum AVCodecID codecId, AVCodecParameters * par, AVRational timebase)
{
    m_pVideoStream->Open(codecId, par, timebase);
}
 
int cOutputDevice::PlayAudioPkts(AVPacket * pkt)
{
    if (m_pAudio->LazyInit())
        LOGFATAL("%s: audio init failed, abort!", __FUNCTION__);
 
    if (m_pAudio->IsBufferFull())
        return 0;
 
    m_pAudioDecoder->Decode(pkt);
    return 1;
}
 
int cOutputDevice::PlayVideoPkts(AVPacket * pkt)
{
    if (m_pAudio->LazyInit())
        LOGFATAL("%s: audio init failed, abort!", __FUNCTION__);
 
    if (m_pVideoStream->GetAvPacketsFilled() >= (size_t)m_pVideoStream->GetVideoPacketMax() - 10)
        return 0;
 
    m_pVideoStream->PushAvPacket(pkt);
 
    return 1;
}
 
/*********************************************************************
 * cOutputDevice public API - detach/ attach
 ********************************************************************/
 
void cOutputDevice::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();
    TriggerEvent(DetachEvent{});
}
 
void cOutputDevice::Attach(void)
{
    m_forceDetached = false;
 
    if (m_needsMakePrimary) {
        MakePrimaryDevice(true);
        m_needsMakePrimary = false;
    }
 
    TriggerEvent(AttachEvent{});
}
 
bool cOutputDevice::IsDetached(void) const
{
    auto lock = m_pStateMachine->Lock();
 
    return m_pStateMachine->GetState() == State::DETACHED;
}
 
/*********************************************************************
 * cOutputDevice public API - pip
 ********************************************************************/
 
int cOutputDevice::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);
}
 
void cOutputDevice::ResetPipStream(void)
{
    auto lock = m_pStateMachine->Lock();
 
    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 cOutputDevice::PipIsEnabled(void)
{
    auto lock = m_pStateMachine->Lock();
 
    return m_pPipHandler->IsEnabled();
}
 
void cOutputDevice::PipEnable(void) { m_pPipHandler->Enable(); };
void cOutputDevice::PipDisable(void) { m_pPipHandler->Disable(); };
void cOutputDevice::PipToggle(void) { m_pPipHandler->Toggle(); };
void cOutputDevice::PipChannelChange(int dir) { m_pPipHandler->ChannelChange(dir); };
void cOutputDevice::PipChannelSwap(bool closePip) { m_pPipHandler->ChannelSwap(closePip); };
void cOutputDevice::PipSwapPosition(void) { m_pPipHandler->SwapPosition(); };
void cOutputDevice::PipSetSize(void) { m_pPipHandler->SetSize(); };
 
/*
 * Wrapper functions for cVideoRender and cPipHandler
 */
void cOutputDevice::SetRenderPipSize(void)
{
    auto lock = m_pStateMachine->Lock();
 
    m_pRender->Halt();
    m_pRender->SetPipSize(m_pipUseAlt);
    m_pRender->Resume();
};
 
void cOutputDevice::SetRenderPipActive(bool active)
{
    auto lock = m_pStateMachine->Lock();
 
    m_pRender->Halt();
    m_pRender->SetPipActive(active);
    m_pRender->Resume();
};
 
/*********************************************************************
 * cOutputDevice private functions
 ********************************************************************/
 
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 cOutputDevice::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) {
            auto now = std::chrono::steady_clock::now();
            auto durationSinceChannelSwitchMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - LOGGER->GetChannelSwitchStartTime()).count();
            LOGDEBUG2(L_AV_SYNC, "TRACE: +%5dms PlayVideo() first valid video data", durationSinceChannelSwitchMs);
 
            if (!m_receivedValidAudio)
                LOGGER->SetChannelSwitchDataReceivedTime(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;
        }
 
        auto now = std::chrono::steady_clock::now();
        auto durationSinceChannelSwitchMs = std::chrono::duration_cast<std::chrono::milliseconds>(now - LOGGER->GetChannelSwitchStartTime()).count();
        LOGDEBUG2(L_AV_SYNC, "TRACE: +%5dms PlayVideo() first decodeable video packet", durationSinceChannelSwitchMs);
 
        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;
}
 
void cOutputDevice::FlushAudio(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    m_pAudioDecoder->FlushBuffers();
    m_pAudio->FlushBuffers();
    m_audioReassemblyBuffer.Reset();
}
 
void cOutputDevice::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->Drain();
}
 
void cOutputDevice::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();
}
 
int64_t cOutputDevice::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 cOutputDevice::GetFirstVideoPtsMsToPlay()
{
    int64_t ret = std::max(m_pRender->GetOutputPtsMs(), m_pAudio->GetOutputPtsMs());
 
    if (m_pConfig->ConfigVideoAudioDelayMs > 0)
        ret += m_pConfig->ConfigVideoAudioDelayMs;
 
    return ret;
}
 
int cOutputDevice::GetBufferFillLevelThresholdMs() {
    return MIN_BUFFER_FILL_LEVEL_THRESHOLD_MS + m_pConfig->ConfigAdditionalBufferLengthMs;
}
 
void cOutputDevice::SetDrain(bool on)
{
    LOGDEBUG("device: %s: %s draining", __FUNCTION__, on ? "start" : "stop");
    m_draining = on;
}
 
/*********************************************************************
 * cOutputDevice state transitioning functions
 ********************************************************************/
 
void cOutputDevice::TriggerEvent(const Event &event)
{
    m_pStateMachine->OnEventReceived(event);
}
 
void cOutputDevice::LeaveState(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_pAudio->SetTrickSpeed(0, false, false);
            m_pRender->ResetFrameCounter();
            m_pRender->ClearDecoderToDisplayQueue();
            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 cAudioStream(this);
            m_pRender = new cVideoRender(this);
            m_pGrab = new cGrabber(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);
            int err = m_pRender->Init(); // starts display thread
            if (err < 0) { // drm init failed -> force detached mode
                delete m_pAudioDecoder;
                delete m_pVideoStream;
                delete m_pGrab;
                delete m_pRender;
                delete m_pAudio;
                LOGERROR("device: display init failed -> start in detached mode");
                m_forceDetached = true;
                break;
            }
            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 cOutputDevice::EnterState(State state)
{
    switch (state) {
        case BUFFERING:
            m_pAudio->ResetHwDelayBaseline();
            if (FastChannelSwitchInTransferMode()) {
                m_pRender->SetPlaybackPaused(false);
                m_pRender->SetDisplayOneFrameThenPause(true);
            }
            break;
        case PLAY:
            // revert the video playback start release which was done in BUFFERING if we are audio-only
            if (m_playbackMode == AUDIO_ONLY && FastChannelSwitchInTransferMode()) {
                m_pRender->SetPlaybackPaused(true);
                m_pRender->SetDisplayOneFrameThenPause(false);
            }
 
            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();
            m_pAudio->ResetTrickSpeedPts();
            break;
        case STOP:
            if (m_forceDetached) {
                m_pStateMachine->SetState(DETACHED);
                break;
            }
 
            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 cOutputDevice::HaltVideoThreads(void)
{
    m_pRender->Halt();
    m_pVideoStream->Halt();
}
 
void cOutputDevice::ResumeVideoThreads(void)
{
    m_pVideoStream->Resume();
    m_pRender->Resume();
}
 
#ifdef USE_GLES
bool cOutputDevice::HaltOpenGlThread(void)
{
    return m_pOsdProvider && m_pOsdProvider->LockOpenGlThread();
}
 
void cOutputDevice::ResumeOpenGlThread(void)
{
    if (m_pOsdProvider)
        m_pOsdProvider->UnlockOpenGlThread();
}
#endif
 
bool cOutputDevice::IsDetachForced(void)
{
    return m_forceDetached;
}
 
int cOutputDevice::InitAudio(bool setVolume)
{
    if (m_pAudio->LazyInit())
        return -1;
 
    if (setVolume)
        m_pAudio->SetVolume((m_volume * 1000) / 255);
 
    return 0;
}
 
void cOutputDevice::ResetVideoFilter(void)
{
    m_pRender->ResetFrameCounter();
    m_pVideoStream->ResetFilterThreadNeededCheck();
}
 
void cOutputDevice::SetTrickSpeed(double speed, bool active, bool forward)
{
    m_pRender->SetTrickSpeed(speed, active, forward);
    m_pAudio->SetTrickSpeed(speed, active, forward);
}
 
bool cOutputDevice::SchedulePlaybackStart(void)
{
    bool receivedAudio = m_pAudio->HasInputPts();
    bool receivedVideo = m_pVideoStream->HasInputPts();
 
    if (receivedAudio && receivedVideo) {
        m_playbackMode = AUDIO_AND_VIDEO;
        // store the first PTSes beforehand, because dropping samples/frames will change the output of GetFirst*PtsMsToPlay()
        int64_t firstAudioPtsMs = GetFirstAudioPtsMsToPlay();
        int64_t firstVideoPtsMs = GetFirstVideoPtsMsToPlay();
 
        // don't drop old audio, if we want to wait for it in fast channel switch mode including audio playback
        if (!FastChannelSwitchAudioInTransferMode())
            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 {
        // Sometimes a DeviceClear() can jump in between signalling the ThresholdReachedEvent
        // and progressing it, e.g. the video thread signals the ThresholdReached, VDR sends a DeviceClear()
        // and OnEventReceived wants to process the ThresholdReachedEvent with empty buffers.
        LOGDEBUG("device: buffering threshold reached and no a/v available, keep BUFFERING state");
        return false;
    }
 
    return true;
}
 
void cOutputDevice::ScheduleResyncAtPtsMs(int64_t pts)
{
    m_pRender->ScheduleResyncAtPtsMs(pts);
}
 
void cOutputDevice::ResumeFromPause(void)
{
    // 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("STATE MACHINE: play event in PLAY state with NONE playback mode. This is a bug.");
            break;
    }
}
 
void cOutputDevice::PausePlayback(bool schedulePause)
{
    if (schedulePause && 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();
}
 
void cOutputDevice::ResumePlayback(void)
{
    m_pRender->SetPlaybackPaused(false);
}