pipreceiver.cpp

Go to the documentation of this file.

 
#include <vdr/remux.h>
#include <vdr/skins.h>
 
#include "event.h"
#include "logger.h"
#include "pipreceiver.h"
#include "softhddevice.h"
 
/*****************************************************************************
 * cPipReceiver class
 ****************************************************************************/
 
cPipReceiver::cPipReceiver(const cChannel *channel, cSoftHdDevice *device)
    : cReceiver(NULL, MINPRIORITY),
      m_pDevice(device)
{
    LOGDEBUG("pipreceiver: %s", __FUNCTION__);
    AddPid(channel->Vpid());
}
 
cPipReceiver::~cPipReceiver(void)
{
    LOGDEBUG("pipreceiver: %s", __FUNCTION__);
    Detach();
}
 
void cPipReceiver::Activate(bool on)
{
    LOGDEBUG("pipreceiver: %s %s", __FUNCTION__, on ? "on" : "off");
    m_pTsToPesVideo.Reset();
}
 
#define MAXRETRIES    20 // max. number of retries for a single TS packet
#define RETRYWAITMS    5 // time between two retries
#define ERRORDELTASEC 60 // seconds before reporting lost packages again
void cPipReceiver::Receive(const uchar *data, int size)
{
    for (int i = 0; i < MAXRETRIES; i++) {
        if (ParseTs(data, size) > 0)
            return;
        cCondWait::SleepMs(RETRYWAITMS);
    }
    m_numLostPackets++;
    if (cTimeMs::Now() - m_lastErrorReport > ERRORDELTASEC) {
        LOGWARNING("pipreceiver: %d TS packet(s) not accepted in pip stream", m_numLostPackets);
        m_numLostPackets = 0;
        m_lastErrorReport = cTimeMs::Now();
    }
}
 
int cPipReceiver::ParseTs(const uchar *data, int size)
{
    int played = 0;
 
    if (!data) {
        LOGWARNING("pipreceiver: %s null data received, reset pes buffer!", __FUNCTION__);
        m_pTsToPesVideo.Reset();
        return 0;
    }
 
    if (size < TS_SIZE) {
        LOGWARNING("pipreceiver: %s TS fragment received!", __FUNCTION__);
        return size;
    }
 
    while (size >= TS_SIZE) {
        if (int skipped = TS_SYNC(data, size)) {
            LOGWARNING("pipreceiver: %s TS stream not in sync!", __FUNCTION__);
            return played + skipped;
        }
 
        if (TsHasPayload(data)) {
            int payloadOffset = TsPayloadOffset(data);
            if (payloadOffset < TS_SIZE) {
                int w = PlayTs(data, TS_SIZE);
                if (w < 0)
                    return played ? played : w;
                if (w == 0)
                    break;
            }
        }
 
        played += TS_SIZE;
        size -= TS_SIZE;
        data += TS_SIZE;
    }
 
    return played;
}
 
int cPipReceiver::PlayTs(const uchar *data, int size)
{
    if (TsPayloadStart(data)) {
        int length;
        while (const uchar *pes = m_pTsToPesVideo.GetPes(length)) {
            int w = m_pDevice->PlayPipVideo(pes, length);
            if (w <= 0) {
                m_pTsToPesVideo.SetRepeatLast();
                return w;
            }
        }
        m_pTsToPesVideo.Reset();
    }
    m_pTsToPesVideo.PutTs(data, size);
 
    return size;
}
 
/*****************************************************************************
 * cPipHandler class
 ****************************************************************************/
 
cPipHandler::cPipHandler(cSoftHdDevice *device)
    : m_pDevice(device),
      m_pEventReceiver(device)
{
}
 
cPipHandler::~cPipHandler(void)
{
    Stop();
}
 
/*****************************************************************************
 * Handle events
 *
 * The following functions are called from within the state change and must
 * not trigger any new events. Otherwise we end up in a dead lock!
 ****************************************************************************/
 
void cPipHandler::HandleEvent(enum PipState event)
{
    switch (event) {
        case PIPSTART:
            HandleEnable(true);
            break;
        case PIPSTOP:
            HandleEnable(false);
            break;
        case PIPTOGGLE:
            HandleEnable(!m_active);
            break;
        case PIPCHANUP:
            HandleChannelChange(1);
            break;
        case PIPCHANDOWN:
            HandleChannelChange(-1);
            break;
        case PIPCHANSWAP:
            Stop();
            Start(0);
            break;
        case PIPSIZECHANGE:
            m_pDevice->SetRenderPipSize();
            break;
        case PIPSWAPPOSITION:
            m_pDevice->ToggleRenderPipPosition();
            m_pDevice->SetRenderPipSize();
            break;
        default:
            break;
    }
}
 
int cPipHandler::Start(int channelNum)
{
    if (!channelNum)
        channelNum = m_pDevice->CurrentChannel();
 
    LOCK_CHANNELS_READ;
    const cChannel *channel;
    cDevice *device;
    cPipReceiver *receiver;
 
    if (channelNum && (channel = Channels->GetByNumber(channelNum)) &&
       (device = m_pDevice->GetDevice(channel, 0, false, false))) {
        Stop();
        device->SwitchChannel(channel, false);
        receiver = new cPipReceiver(channel, m_pDevice);
        device->AttachReceiver(receiver);
        m_pPipReceiver = receiver;
        m_pPipChannel = channel;
        m_pipChannelNum = channelNum;
 
        LOGDEBUG("piphandler: %s: New receiver for channel (%d) %s", __FUNCTION__, channel->Number(), channel->Name());
 
        m_active = true;
        return 0;
    }
 
    LOGERROR("piphandler: %s: No receiver for channel num %d available", __FUNCTION__, channelNum);
    return -1;
}
 
void cPipHandler::Stop(void)
{
    m_active = false;
 
    if (!m_pPipReceiver)
        return;
 
    LOGDEBUG("piphandler: %s: deleting receiver for channel (%d) %s", __FUNCTION__, m_pPipChannel->Number(), m_pPipChannel->Name());
 
    m_pDevice->ResetPipStream();
 
    delete m_pPipReceiver;
    m_pPipReceiver = nullptr;
    m_pPipChannel = nullptr;
}
 
void cPipHandler::HandleEnable(bool on)
{
    if (on && m_active) {
        LOGDEBUG("piphandler: %s: pip is already enabled", __FUNCTION__);
    } else if (on && !m_active) {
        LOGDEBUG("piphandler: %s: enabling pip (channel %d)", __FUNCTION__, m_pipChannelNum);
        if (!Start(0))
            m_pDevice->SetRenderPipActive(true);
    } else if (!on && !m_active) {
        LOGDEBUG("piphandler: %s: pip is already disabled", __FUNCTION__);
    } else if (!on && m_active){
        LOGDEBUG("piphandler: %s: disabling pip", __FUNCTION__);
        m_pDevice->SetRenderPipActive(false);
        Stop();
    }
}
 
void cPipHandler::HandleChannelChange(int direction)
{
    if (!m_active)
        return;
 
    const cChannel *channel;
    const cChannel *first;
 
    channel = m_pPipChannel;
    first = channel;
 
    Stop();
 
    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) {
                Start(channel->Number());
                return;
        }
 
        if (channel == first) {
            Skins.Message(mtError, tr("Channel not available!"));
            break;
        }
    }
}
 
/*****************************************************************************
 * Trigger events
 *
 * These (public) functions are wrapped by cSoftHdDevice and can be called
 * to trigger a pip event.
 ****************************************************************************/
 
void cPipHandler::Enable(void)
{
    if (m_active)
        return;
 
    m_pEventReceiver->OnEventReceived(PipEvent{PIPSTART});
}
 
void cPipHandler::Disable(void)
{
    if (!m_active)
        return;
 
    m_pEventReceiver->OnEventReceived(PipEvent{PIPSTOP});
}
 
void cPipHandler::Toggle(void)
{
    m_pEventReceiver->OnEventReceived(PipEvent{PIPTOGGLE});
}
 
void cPipHandler::ChannelChange(int direction)
{
    if (!m_active)
        return;
 
    if (direction > 0)
        m_pEventReceiver->OnEventReceived(PipEvent{PIPCHANUP});
    else
        m_pEventReceiver->OnEventReceived(PipEvent{PIPCHANDOWN});
}
 
void cPipHandler::ChannelSwap(bool closePip)
{
    if (!m_active)
        return;
 
    const cChannel *channel = m_pPipChannel;
    if (!channel)
        return;
 
    if (closePip)
        m_pEventReceiver->OnEventReceived(PipEvent{PIPSTOP});
    else
        m_pEventReceiver->OnEventReceived(PipEvent{PIPCHANSWAP}); // resets the pip channel to the current channel
 
    LOCK_CHANNELS_READ;
    LOGDEBUG("piphandler: %s: switch main stream to %d", __FUNCTION__, channel->Number());
    Channels->SwitchTo(channel->Number());
}
 
void cPipHandler::SetSize(void)
{
    m_pEventReceiver->OnEventReceived(PipEvent{PIPSIZECHANGE});
}
 
void cPipHandler::SwapPosition(void)
{
    m_pEventReceiver->OnEventReceived(PipEvent{PIPSWAPPOSITION});
}