softhddevice.cpp

Go to the documentation of this file.

 
#ifndef __USE_GNU
#define __USE_GNU
#endif
 
#include <functional>
#include <mutex>
#include <variant>
#include <algorithm>
 
#include <assert.h>
#include <unistd.h>
 
#include <libintl.h>
 
#include <pthread.h>
#include <sys/types.h>
#include <sys/wait.h>
 
#include "softhddevice-drm-gles.h"
#include "softhdosd.h"
 
#include "softhddevice.h"
#include "logger.h"
 
extern "C" {
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavutil/timestamp.h>
 
}
#include "buf2rgb.h"
 
#include "iatomic.h"
#include "videostream.h"
#include "audio.h"
#include "videorender.h"
#include "codec_audio.h"
#include "codec_video.h"
#include "pes.h"
#include "misc.h"
#include "pipreceiver.h"
 
#define _(str) gettext(str)                    
#define _N(str) str                            
 
extern "C" uint8_t * CreateJpeg(uint8_t * image, int *size, int quality,
    int width, int height)
{
    return (uint8_t *) RgbToJpeg((uchar *) image, width, height, *size, quality);
}
 
#if defined(USE_JPEG) && JPEG_LIB_VERSION >= 80
uint8_t *CreateJpeg(uint8_t * image, int raw_size, int *size, int quality,
    int width, int height)
{
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
    JSAMPROW row_ptr[1];
    int rowStride;
    uint8_t *outbuf;
    long unsigned int outsize;
 
    outbuf = NULL;
    outsize = 0;
    cinfo.err = jpeg_std_error(&jerr);
    jpeg_create_compress(&cinfo);
    jpeg_mem_dest(&cinfo, &outbuf, &outsize);
 
    cinfo.image_width = width;
    cinfo.image_height = height;
    cinfo.input_components = raw_size / height / width;
    cinfo.in_color_space = JCS_RGB;
 
    jpeg_set_defaults(&cinfo);
    jpeg_set_quality(&cinfo, quality, TRUE);
    jpeg_start_compress(&cinfo, TRUE);
 
    rowStride = width * 3;
    while (cinfo.next_scanline < cinfo.image_height) {
        row_ptr[0] = &image[cinfo.next_scanline * rowStride];
        jpeg_write_scanlines(&cinfo, row_ptr, 1);
    }
 
    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
    *size = outsize;
 
    return outbuf;
}
#endif
 
/*****************************************************************************
 * cSoftHdDevice class
 ****************************************************************************/
 
cSoftHdDevice::cSoftHdDevice(cSoftHdConfig *config)
{
//  LOGDEBUG("device: %s:", __FUNCTION__);
 
    m_pSpuDecoder = new cDvbSpuDecoder();
    m_pConfig = config;
    m_pAudioDecoder = nullptr;
    m_audioChannelID = -1;
    m_pOsdProvider = nullptr;
    m_pipActive = false;
    m_pipUseAlt = m_pConfig->ConfigPipUseAlt;
}
 
cSoftHdDevice::~cSoftHdDevice(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    delete m_pSpuDecoder;
}
 
int cSoftHdDevice::Start(void)
{
    LOGDEBUG("device: %s", __FUNCTION__);
    OnEventReceived(AttachEvent{});
 
    return true;
}
 
void cSoftHdDevice::Stop(void)
{
    LOGDEBUG("device: %s", __FUNCTION__);
    OnEventReceived(DetachEvent{});
}
 
void cSoftHdDevice::ClearAudio(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);
}
 
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();
    std::lock_guard<std::mutex> lock(m_mutex);
 
    LOGDEBUG("device: received %s", EventToString(event));
 
    if (m_state != DETACHED) {
        m_pRender->DisplayThreadHalt();
        m_pVideoStream->DecodingThreadHalt();
    }
 
    bool 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&) {
                    SetState(STOP);
                },
                [&invalid](const BufferUnderrunEvent&) { invalid(); },
                [&invalid](const BufferingThresholdReachedEvent&) { invalid(); },
                [&invalid](const PipEvent&) { invalid(); },
            }, event);
            needsResume = false;
            break;
        case State::STOP:
            std::visit(overload{
                [this](const PlayEvent&) {
                    m_pAudio->LazyInit();
                    SetState(BUFFERING);
                    m_pRender->ResetFrameCounter();
                    m_pVideoStream->ResetFilterThreadNeededCheck();
                },
                [&invalid](const PauseEvent&) { invalid(); },
                [&invalid](const StopEvent&) { invalid(); },
                [&invalid](const TrickSpeedEvent&) { invalid(); },
                [&invalid](const StillPictureEvent&) { invalid(); },
                [this, &needsResume](const DetachEvent&) {
                    HandlePip(PIPSTOP);
                    SetState(DETACHED);
                    needsResume = false;
                },
                [&invalid](const AttachEvent&) { invalid(); },
                [&invalid](const BufferUnderrunEvent&) { invalid(); },
                [&invalid](const BufferingThresholdReachedEvent&) { invalid(); },
                [this](const PipEvent& p) {
                    HandlePip(p.state);
                },
            }, 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.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->HasPts();
                    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 PipEvent& p) {
                    HandlePip(p.state);
                },
            }, event);
            break;
        case State::PLAY:
            std::visit(overload{
                [this](const PlayEvent&) {
                    // resume from pause
                    int audioBehindVideoByMs;
                    switch (m_playbackMode) {
                        case AUDIO_ONLY:
                            m_pAudio->SetPaused(false);
                            break;
                        case VIDEO_ONLY:
                            m_pRender->SetPlaybackPaused(false);
                            break;
                        case AUDIO_AND_VIDEO:
                            audioBehindVideoByMs = m_pRender->GetOutputPtsMs() - m_pAudio->GetOutputPtsMs() - m_pConfig->ConfigVideoAudioDelayMs;
                            if (audioBehindVideoByMs > 0) {
                                m_pAudio->DropSamplesOlderThanPtsMs(m_pAudio->GetOutputPtsMs() + audioBehindVideoByMs);
                                m_pAudio->SetPaused(false);
                            } else
                                m_pRender->SetScheduleAudioResume(true);
 
                            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&) {
                    m_pRender->SetPlaybackPaused(true);
                    m_pAudio->SetPaused(true);
                },
                [this](const StopEvent&) {
                    SetState(STOP);
                },
                [this](const TrickSpeedEvent& t) {
                    m_pRender->SetTrickSpeed(t.speed, t.forward);
                    SetState(TRICK_SPEED);
                },
                [this](const StillPictureEvent& s) {
                    HandleStillPicture(s.data, s.size);
                },
                [this, &needsResume](const DetachEvent&) {
                    HandlePip(PIPSTOP);
                    SetState(DETACHED);
                    needsResume = false;
                },
                [&invalid](const AttachEvent&) { invalid(); },
                [this](const BufferUnderrunEvent&) {
                    SetState(BUFFERING);
                },
                [&invalid](const BufferingThresholdReachedEvent&) {
                    // ignore
                },
                [this](const PipEvent& p) {
                    HandlePip(p.state);
                },
            }, 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);
                },
                [this](const StopEvent&) {
                    SetState(STOP);
                },
                [this](const TrickSpeedEvent& t) {
                    // resume from pause, or change trick speed direction/speed
                    m_pRender->SetTrickSpeed(t.speed, t.forward);
                    m_pRender->SetPlaybackPaused(false);
                 },
                [this](const StillPictureEvent& s) {
                    HandleStillPicture(s.data, s.size);
                },
                [this, &needsResume](const DetachEvent&) {
                    HandlePip(PIPSTOP);
                    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(); },
                [this](const PipEvent& p) {
                    HandlePip(p.state);
                },
            }, event);
            break;
        case State::STILL_PICTURE:
            std::visit(overload{
                [this](const PlayEvent&) {
                    SetState(PLAY);
                },
                [&invalid](const PauseEvent&) { invalid(); },
                [this](const StopEvent&) {
                    SetState(STOP);
                },
                [this](const TrickSpeedEvent& t) {
                    m_pRender->SetTrickSpeed(t.speed, t.forward);
                    SetState(TRICK_SPEED);
                },
                [this](const StillPictureEvent& s) {
                    HandleStillPicture(s.data, s.size);
                },
                [this, &needsResume](const DetachEvent&) {
                    HandlePip(PIPSTOP);
                    SetState(DETACHED);
                    needsResume = false;
                },
                [&invalid](const AttachEvent&) { invalid(); },
                [&invalid](const BufferUnderrunEvent&) { invalid(); },
                [&invalid](const BufferingThresholdReachedEvent&) { invalid(); },
                [this](const PipEvent& p) {
                    HandlePip(p.state);
                },
            }, event);
            break;
    }
 
    if (needsResume) {
        m_pVideoStream->DecodingThreadResume();
        m_pRender->DisplayThreadResume();
    }
 
    uint64_t stopStateChange = cTimeMs::Now();
    LOGDEBUG("device: state change done in %d ms", (int)(stopStateChange - startStateChange));
}
 
void cSoftHdDevice::OnEnteringState(State state) {
    switch (state) {
        case BUFFERING:
            // nothing
            break;
        case PLAY:
            if (m_playbackMode == AUDIO_ONLY)
                m_pAudio->SetPaused(false);
            else {
                m_pAudio->SetPaused(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:
            ClearAudio();
 
            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();
 
            break;
        case STILL_PICTURE:
            m_pRender->SetPlaybackPaused(false);
            m_pVideoStream->SetDeinterlacerDeactivated(true);
            break;
        case DETACHED:
            // resume the previously stopped threads
            m_pVideoStream->DecodingThreadResume();
            m_pRender->DisplayThreadResume();
 
            // now do the detach
            m_pPipStream->Exit();
            delete m_pPipStream;
 
            m_pRender->Exit(); // render must be stopped before videostream!
            m_pVideoStream->Exit();
            m_pAudio->Exit(); // audio must be stopped after renderer!
#ifdef USE_GLES
            m_pOsdProvider->StopOpenGlThread();
#endif
            delete m_pAudioDecoder; // includes a Close()
            delete m_pVideoStream;
            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);
            break;
        case BUFFERING:
            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, 1);
            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;
            break;
        case STILL_PICTURE:
            m_pVideoStream->SetDeinterlacerDeactivated(false);
            m_pRender->SetPlaybackPaused(true);
            break;
        case DETACHED:
            m_pAudio = new cSoftHdAudio(this);
            m_pRender = new cVideoRender(this);
            m_pVideoStream = new cVideoStream(m_pRender, m_pRender->GetMainOutputBuffer(), m_pConfig, "main", 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 cVideoStream(m_pRender, m_pRender->GetPipOutputBuffer(), m_pConfig, "PIP", std::bind(&cVideoRender::PushPipFrame, m_pRender, std::placeholders::_1));
            m_pPipStream->StartDecoder(); // starts decoding thread
            // 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);
 
    switch (play_mode) {
    case pmNone:
        OnEventReceived(StopEvent{});
        break;
    case pmAudioVideo:
    case pmAudioOnly:
    case pmAudioOnlyBlack:
    case pmVideoOnly:
        OnEventReceived(PlayEvent{});
        break;
    default:
        LOGERROR("device: %s: playmode not supported %d", play_mode);
        return 0;
        break;
    }
 
    return 1;
}
 
int64_t cSoftHdDevice::GetSTC(void)
{
    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");
 
    OnEventReceived(TrickSpeedEvent{speed, forward});
}
 
void cSoftHdDevice::Clear(void)
{
    LOGDEBUG("device: %s:", __FUNCTION__);
    cDevice::Clear();
 
    if (IsDetached())
        return;
 
    m_pRender->DisplayThreadHalt();
    m_pVideoStream->DecodingThreadHalt();
 
    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);
    ClearAudio();
 
    SetState(BUFFERING);
 
    m_pRender->DisplayThreadResume();
    m_pVideoStream->DecodingThreadResume();
}
 
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)
{
    SetState(STILL_PICTURE);
 
    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());
        else {
            LOGWARNING("device: %s: invalid PES packet", __FUNCTION__);
            break;
        }
 
        currentPacketStart += pesPacket.GetPacketLength();
    }
 
    m_pVideoStream->PushAvPacket(m_videoReassemblyBuffer.PopAvPacket());
    m_pVideoStream->Flush();
}
 
bool cSoftHdDevice::Poll(__attribute__ ((unused)) cPoller & poller, int timeoutMs)
{
//  LOGDEBUG("device: %s: timeout %d", __FUNCTION__, timeout_ms);
 
    if (!m_pAudio->IsBufferFull() && !m_pVideoStream->IsInputBufferFull())
        return true;
 
    usleep(timeoutMs * 1000);
 
    return false;
}
 
bool cSoftHdDevice::Flush(int timeout)
{
    if (IsDetached())
        return true;
 
    LOGDEBUG("device: %s: timeout %d ms", __FUNCTION__, timeout);
    if (m_pVideoStream->GetAvPacketsFilled()) {
        if (timeout) {          // let display thread work
            usleep(timeout * 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_screenWidth;
    height = m_screenHeight;
    aspectRatio = (double)width / (double)height;
}
 
void cSoftHdDevice::SetScreenSize(int width, int height, uint32_t refreshRate)
{
    std::lock_guard<std::mutex> lock(m_sizeMutex);
    m_screenWidth = width;
    m_screenHeight = height;
    m_screenRefreshRate = refreshRate;
}
 
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);
 
    m_receivedAudio = true;
 
    if (m_pAudio->IsBufferFull())
        return 0;
 
    cPesAudio pesPacket((const uint8_t*)data, size);
 
    if (!pesPacket.IsValid()) {
        m_audioReassemblyBuffer.Reset();
 
        return size;
    }
 
    // static int64_t lastPts = AV_NOPTS_VALUE;
    // LOGINFO("PlayAudio: PTS %s diff %s", Timestamp2String(pesPacket.GetPts(), 90), lastPts != AV_NOPTS_VALUE && pesPacket.HasPts() ? Timestamp2String(pesPacket.GetPts() - lastPts, 90) : "N/A");
    // lastPts = pesPacket.GetPts();
 
    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 {
        avpkt = m_audioReassemblyBuffer.PopAvPacket();
 
        if (avpkt) {
            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_pAudio->SetVolume((volume * 1000) / 255);
}
 
int cSoftHdDevice::PlayVideo(const uchar *data, int size)
{
//  LOGDEBUG("device: %s: %p %d", __FUNCTION__, data, size);
    return PlayVideoInternal(m_pVideoStream, &m_videoReassemblyBuffer, data, size);
}
 
int cSoftHdDevice::PlayPipVideo(const uchar *data, int size)
{
//  LOGDEBUG("device: %s: %p %d", __FUNCTION__, data, size);
    return PlayVideoInternal(m_pPipStream, &m_pipReassemblyBuffer, data, size);
}
 
int cSoftHdDevice::PlayVideoInternal(cVideoStream *stream, cReassemblyBufferVideo *buffer, const uchar *data, int size)
{
    // LOGDEBUG("device: %s: %p %d", __FUNCTION__, data, size);
 
    m_receivedVideo = true;
 
    if (stream->IsInputBufferFull())
        return 0;
 
    cPesVideo pesPacket((const uint8_t*)data, size);
 
    if (!pesPacket.IsValid()) {
        buffer->Reset();
 
        return size;
    }
 
    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;
}
 
bool cSoftHdDevice::IsBufferingThresholdReached()
{
    if (m_state != BUFFERING)
        return false;
 
    bool audioHasPts = m_pAudio->HasPts();
    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 = audioHasPts && !videoHasInputPts && m_receivedAudio && !m_receivedVideo;
    bool videoOnly = !audioHasPts && videoHasInputPts && !m_receivedAudio && m_receivedVideo;
 
    if ((audioOnly &&                      m_pAudio->GetInputPtsMs()       - m_pAudio->GetOutputPtsMs()  > GetBufferFillLevelThresholdMs()) ||
        (videoOnly && videoHasOutputPts && m_pVideoStream->GetInputPtsMs() - m_pRender->GetOutputPtsMs() > GetBufferFillLevelThresholdMs())) {
        LOGDEBUG("device: %s: Detected audio or video only", __FUNCTION__);
        return true;
    } else if (!audioHasPts || !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 (IsDetached())
        return NULL;
 
    if (m_grabActive) {
        LOGWARNING("device: %s: wait for the last grab to be finished - skip!", __FUNCTION__);
        return NULL;
    }
 
    if (!width || !height) {
        LOGERROR("device: %s: Width or height must be not 0!", __FUNCTION__);
        return NULL;
    }
 
    if (quality < 0) {  // caller should care, but fix it
        quality = 95;
    }
 
    LOGDEBUG2(L_GRAB, "device: %s: %d, %d, %d, %dx%d", __FUNCTION__, size, jpeg, quality, width, height);
 
    // 1. Trigger grab in render thread and wait for the buffers to be cloned
    m_grabActive = true;
    // TriggerGrab does wait and return 0, if buffers are available,
    // otherwise it returns != 0, if we ran into a timeout
    if (m_pRender->TriggerGrab()) {
        m_pRender->ClearGrab();
        m_grabActive = false;
        return NULL;
    }
 
    // 2. Convert the buffers to rgb and free the cloned buffers afterwards
    m_pRender->ConvertOsdBufToRgb();
    m_pRender->ConvertVideoBufToRgb();
    m_pRender->ConvertPipBufToRgb();
 
    // 3. get screen dimensions
    int screenWidth = 0;
    int screenHeight = 0;
    double aspectRatio = 0.0f;
    GetOsdSize(screenWidth, screenHeight, aspectRatio);
 
    int screenSize = screenWidth * screenHeight * 3; // we want a RGB24
 
    // 4. set grab dimensions
    int grabWidth = width > 0 ? width : screenWidth;
    int grabHeight = height > 0 ? height : screenHeight;
 
    int videoSize = 0;                // data size of the grabbed video
    int videoWidth = screenWidth;     // width of the grabbed video
    int videoHeight = screenHeight;   // height of the grabbed video
    int videoX = 0, videoY = 0;      // x, y of the grabbed video
 
    // 5. fetch video data
    // Video comes as RGB, width and height is original screen dimension (video is maybe scaled)
    cSoftHdGrab *videoGrab = m_pRender->GetGrab(&videoSize, &videoWidth, &videoHeight, &videoX, &videoY, 0);
    uint8_t *video = NULL;
    if (videoGrab->GetSize())
        video = videoGrab->GetData();
    if (!video) {
        LOGDEBUG2(L_GRAB, "device: %s: video is NULL, create black screen!", __FUNCTION__);
        video = (uint8_t *)calloc(1, screenSize);
    }
 
    int pipSize = 0;                // data size of the grabbed pip video
    int pipWidth = screenWidth;     // width of the grabbed pip video
    int pipHeight = screenHeight;   // height of the grabbed pip video
    int pipX = 0, pipY = 0;        // x, y of the grabbed pip video
 
    // 6. fetch pip data
    // Pip video comes as RGB, width and height is original screen dimension (video is maybe scaled)
    cSoftHdGrab *pipGrab = m_pRender->GetGrab(&pipSize, &pipWidth, &pipHeight, &pipX, &pipY, 2);
    uint8_t *pip = NULL;
    if (pipGrab->GetSize())
        pip = pipGrab->GetData();
    if (!pip)
        LOGDEBUG2(L_GRAB, "device: %s: pip is NULL, skip it", __FUNCTION__);
 
    // 7. fetch osd data
    // OSD comes as ARGB, width and height is original screen dimension (osd is always fullscreen)
    cSoftHdGrab *osdGrab = m_pRender->GetGrab(NULL, NULL, NULL, NULL, NULL, 1);
    uint8_t *osd = NULL;
    if (osdGrab->GetSize())
        osd = osdGrab->GetData();;
    if (!osd)
        LOGDEBUG2(L_GRAB, "device: %s: osd is NULL, skip it", __FUNCTION__);
 
    int ret;
    uint8_t *videoResult = NULL;
    // 8. blit the video into a full black screen if scaled
    if (videoWidth != screenWidth || videoHeight != screenHeight || videoX != 0 || videoY != 0) {
        videoResult = (uint8_t *)calloc(1, screenSize);
        ret = BlitVideo(videoResult, video, screenWidth, screenHeight, videoX, videoY, videoWidth, videoHeight);
        if (ret) {
            free(videoResult);
            free(video);
            return NULL;
        }
        free(video);
    } else {
        videoResult = video;
    }
 
    // 9. blit the pip video into the main video if available
    if (pip) {
        ret = BlitVideo(videoResult, pip, screenWidth, screenHeight, pipX, pipY, pipWidth, pipHeight);
        if (ret) {
            free(videoResult);
            free(pip);
            return NULL;
        }
        free(pip);
    }
 
    // 10. alphablend fullscreen video with osd if available
    uint8_t *result;
    if (!osd) {
        result = videoResult;
    } else {
        result = (uint8_t *)malloc(screenSize);
        AlphaBlend(result, osd, videoResult, screenWidth, screenHeight);
        free(videoResult);
        free(osd);
    }
 
    // 11. scale result to requested size width + height, if it differs from fullscreen
    int scaledSize = screenSize;
    uint8_t *scaledResult;
    if (screenWidth != grabWidth || screenHeight != grabHeight) {
        scaledResult = ScaleRgb24(result, &scaledSize, screenWidth, screenHeight, grabWidth, grabHeight);
        free(result);
    } else {
        scaledResult = result;
    }
 
    // 12. make jpeg or pnm
    uint8_t *grabbedImage;
    if (jpeg) {
        grabbedImage = CreateJpeg(scaledResult, &size, quality, grabWidth, grabHeight);
    } else {  // add header to raw data
        char buf[64];
        int n = snprintf(buf, sizeof(buf), "P6\n%d\n%d\n255\n", grabWidth, grabHeight);
        grabbedImage = (uint8_t *)malloc(scaledSize + n);
        memcpy(grabbedImage, buf, n);
        memcpy(grabbedImage + n, scaledResult, scaledSize);
        size = scaledSize + n;
    }
    free(scaledResult);
    LOGDEBUG2(L_GRAB, "device: %s: finished %s image (%dx%d, quality %d) at %p (size %d)", __FUNCTION__, jpeg ? "jpg" : "pnm", grabWidth, grabHeight, jpeg ? quality : 0, grabbedImage, size);
 
    m_grabActive = false;
    return grabbedImage;
}
 
cRect cSoftHdDevice::CanScaleVideo(const cRect & rect, __attribute__ ((unused)) int alignment)
{
    return rect;
}
 
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);
}
 
const char *cSoftHdDevice::CommandLineHelp(void)
{
    return "  -a device\taudio device (fe. alsa: hw:0,0)\n"
           "  -p device\taudio device for pass-through (hw:0,1)\n"
           "  -c channel\taudio mixer channel name (fe. PCM)\n"
           "  -d resolution\tdisplay resolution (fe. 1920x1080@50)\n"
#ifdef USE_GLES
           "  -w workaround\tenable/disable workarounds\n"
           "\tdisable-ogl-osd disable openGL osd\n"
#endif
           "\n";
}
 
int cSoftHdDevice::ProcessArgs(int argc, char *argv[])
{
    //
    //  Parse arguments.
    //
 
    for (;;) {
#ifdef USE_GLES
        switch (getopt(argc, argv, "-a:c:p:d:w:")) {
#else
        switch (getopt(argc, argv, "-a:c:p:d:")) {
#endif
        case 'a':           // audio device for pcm
            m_pConfig->ConfigAudioPCMDevice = optarg;
            continue;
        case 'c':           // channel of audio mixer
            m_pConfig->ConfigAudioMixerChannel = optarg;
            continue;
        case 'p':           // pass-through audio device
            m_pConfig->ConfigAudioPassthroughDevice = optarg;
            continue;
        case 'd':           // set display output
            m_pConfig->ConfigDisplayResolution = optarg;
            continue;
#ifdef USE_GLES
        case 'w':           // workarounds
            if (!strcasecmp("disable-ogl-osd", optarg)) {
                SetDisableOglOsd();
            } else {
                fprintf(stderr, _("Workaround '%s' unsupported\n"),
                optarg);
                return 0;
            }
            continue;
#endif
        case EOF:
            break;
        case '-':
            fprintf(stderr, _("We need no long options\n"));
            return 0;
        case ':':
            fprintf(stderr, _("Missing argument for option '%c'\n"), optopt);
            return 0;
        default:
            fprintf(stderr, _("Unknown option '%c'\n"), optopt);
            return 0;
        }
        break;
    }
 
    while (optind < argc) {
        fprintf(stderr, _("Unhandled argument '%s'\n"), argv[optind++]);
    }
 
    return 1;
}
 
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
#ifdef WRITE_PNG
char cSoftHdDevice::WritePngs(void)
{
    return m_pConfig->ConfigWritePngs;
};
#endif
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::SetPassthrough(int mask)
{
    m_pAudio->SetPassthrough(mask);
    if (m_pAudioDecoder)
        m_pAudioDecoder->SetPassthrough(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()) {
//      LOGERROR("device: %s: m_pAudio->GetFreeBytes() < AUDIO_MIN_BUFFER_FREE!", __FUNCTION__);
        return 0;
    }
    m_pAudioDecoder->Decode(pkt);
    return 1;
}
 
int cSoftHdDevice::PlayVideoPkts(AVPacket * pkt)
{
    m_pAudio->LazyInit();
 
    if (m_pVideoStream->GetAvPacketsFilled() >= VIDEO_PACKET_MAX - 10) {
        return 0;
    }
 
    m_pVideoStream->PushAvPacket(pkt);
 
    return 1;
}
 
void cSoftHdDevice::Detach(void)
{
    if (Replaying()) {
        LOGDEBUG("device: %s: Device is replaying, stop replay first", __FUNCTION__);
        StopReplay();
    }
 
    if (IsPrimaryDevice(false)) {
        m_needsMakePrimary = true;
        MakePrimaryDevice(false);
    }
 
    OnEventReceived(DetachEvent{});
}
 
void cSoftHdDevice::Attach(void)
{
    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;
}
 
int cSoftHdDevice::GetBufferFillLevelThresholdMs() {
    return MIN_BUFFER_FILL_LEVEL_THRESHOLD_MS + m_pConfig->ConfigAdditionalBufferLengthMs;
}
 
void cSoftHdDevice::PipEnable(void)
{
    OnEventReceived(PipEvent{PIPSTART});
}
 
void cSoftHdDevice::PipDisable(void)
{
    OnEventReceived(PipEvent{PIPSTOP});
}
 
void cSoftHdDevice::PipToggle(void)
{
    OnEventReceived(PipEvent{PIPTOGGLE});
}
 
bool cSoftHdDevice::PipIsEnabled(void)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_pipActive;
}
 
void cSoftHdDevice::PipChannelChange(int direction)
{
    if (direction > 0)
        OnEventReceived(PipEvent{PIPCHANUP});
    else
        OnEventReceived(PipEvent{PIPCHANDOWN});
}
 
void cSoftHdDevice::PipChannelSwap(void)
{
    const cChannel *channel = m_pPipChannel;
    if (!channel)
        return;
 
    OnEventReceived(PipEvent{PIPCHANSWAP}); // resets the pip channel to the current channel
 
    if (channel) {
        LOCK_CHANNELS_READ;
        LOGDEBUG("pip: %s: switch main stream to %d", __FUNCTION__, channel->Number());
        Channels->SwitchTo(channel->Number());
    }
}
 
void cSoftHdDevice::PipSetSize(void)
{
    OnEventReceived(PipEvent{PIPSIZECHANGE});
}
 
void cSoftHdDevice::PipSwapPosition(void)
{
    OnEventReceived(PipEvent{PIPSWAPPOSITION});
}
 
void cSoftHdDevice::HandlePip(enum PipState event)
{
    switch (event) {
        case PIPSTART:
            SetEnablePip(true);
            break;
        case PIPSTOP:
            SetEnablePip(false);
            break;
        case PIPTOGGLE:
            TogglePip();
            break;
        case PIPCHANUP:
            ChangePipChannel(1);
            break;
        case PIPCHANDOWN:
            ChangePipChannel(-1);
            break;
        case PIPCHANSWAP:
            ResetPipChannel();
            break;
        case PIPSIZECHANGE:
            SetPipSize();
            break;
        case PIPSWAPPOSITION:
            SwapPipPosition();
            break;
        default:
            break;
    }
}
 
void cSoftHdDevice::SetEnablePip(bool on)
{
    if (m_pipActive && on) {
        LOGDEBUG("device: %s: pip is already enabled", __FUNCTION__);
        return;
    }
 
    if (!m_pipActive && !on) {
        LOGDEBUG("device: %s: pip is already disabled", __FUNCTION__);
        return;
    }
 
    if (!m_pipActive) {
        LOGDEBUG("device: %s: enabling pip (channel %d)", __FUNCTION__, m_pipChannelNum);
        NewPip(m_pipChannelNum);
        m_pRender->SetPipActive(true);
    } else {
        LOGDEBUG("device: %s: disabling pip", __FUNCTION__);
        m_pRender->SetPipActive(false);
        DelPip();
    }
 
    m_pipActive = on;
}
 
void cSoftHdDevice::TogglePip(void)
{
    SetEnablePip(!m_pipActive);
}
 
void cSoftHdDevice::ChangePipChannel(int direction)
{
    if (!m_pipActive)
        return;
 
    const cChannel *channel;
    const cChannel *first;
 
    channel = m_pPipChannel;
    first = channel;
 
    DelPip();
 
    LOCK_CHANNELS_READ;
    while (channel) {
        bool ndr;
        cDevice *device;
 
        channel = direction > 0 ? Channels->Next(channel) : Channels->Prev(channel);
        if (!channel && Setup.ChannelsWrap)
            channel = direction > 0 ? Channels->First() : Channels->Last();
 
        if (channel && !channel->GroupSep() && (device = cDevice::GetDevice(channel, 0, false, true)) &&
            device->ProvidesChannel(channel, 0, &ndr) && !ndr) {
                NewPip(channel->Number());
                return;
        }
 
        if (channel == first) {
            Skins.Message(mtError, tr("Channel not available!"));
            break;
        }
    }
}
 
void cSoftHdDevice::ResetPipChannel(void)
{
    if (!m_pipActive)
        return;
 
    DelPip();
    NewPip(0);
}
 
void cSoftHdDevice::SetPipSize(void)
{
    m_pRender->SetPipSize(m_pipUseAlt);
}
 
void cSoftHdDevice::SwapPipPosition(void)
{
    m_pipUseAlt = !m_pipUseAlt;
    m_pRender->SetPipSize(m_pipUseAlt);
}
 
void cSoftHdDevice::DelPip(void)
{
    if (!m_pPipReceiver)
        return;
 
    LOGDEBUG("pip: %s: deleting receiver for channel (%d) %s", __FUNCTION__, m_pPipChannel->Number(), m_pPipChannel->Name());
 
    m_pPipStream->DecodingThreadHalt();
    m_pPipStream->CancelFilterThread();
    m_pipReassemblyBuffer.Reset();
    m_pPipStream->ClearVdrCoreToDecoderQueue();
    m_pRender->ClearPipDecoderToDisplayQueue();
    m_pPipStream->CloseDecoder();
    m_pPipStream->DecodingThreadResume();
 
    delete m_pPipReceiver;
    m_pPipReceiver = nullptr;
    m_pPipChannel = nullptr;
}
 
void cSoftHdDevice::NewPip(int channelNum)
{
    if (!channelNum)
        channelNum = CurrentChannel();
 
    LOCK_CHANNELS_READ;
    const cChannel *channel;
    cDevice *device;
    cPipReceiver *receiver;
 
    if (channelNum && (channel = Channels->GetByNumber(channelNum)) &&
       (device = GetDevice(channel, 0, false, false))) {
        DelPip();
        device->SwitchChannel(channel, false);
        receiver = new cPipReceiver(channel, this);
        device->AttachReceiver(receiver);
        m_pPipReceiver = receiver;
        m_pPipChannel = channel;
        m_pipChannelNum = channelNum;
 
        LOGDEBUG("pip: %s: New receiver for channel (%d) %s", __FUNCTION__, channel->Number(), channel->Name());
    }
}