playercontext.cpp

Go to the documentation of this file.

#include <cmath>
#include <utility>
 
#include <QPainter>
 
#include "mythconfig.h"
 
#include "playercontext.h"
#include "mythplayer.h"
#include "remoteencoder.h"
#include "livetvchain.h"
#include "io/mythmediabuffer.h"
#include "playgroup.h"
#include "videoouttypes.h"
#include "storagegroup.h"
#include "mythcorecontext.h"
#include "videometadatautil.h"
#include "metadataimagehelper.h"
#include "mythlogging.h"
#include "DVD/mythdvdplayer.h"
#include "Bluray/mythbdplayer.h"
#include "channelutil.h"
#include "tv_play.h"
 
#define LOC QString("playCtx: ")
 
const uint PlayerContext::kSMExitTimeout     = 2000;
const uint PlayerContext::kMaxChannelHistory = 30;
 
PlayerContext::PlayerContext(QString inUseID) :
    m_recUsage(std::move(inUseID))
{
    m_lastSignalMsgTime.start();
    m_lastSignalMsgTime.addMSecs(-2 * (int)kSMExitTimeout);
}
 
PlayerContext::~PlayerContext()
{
    TeardownPlayer();
    m_nextState.clear();
}
 
void PlayerContext::TeardownPlayer(void)
{
    m_ffRewState = 0;
    m_ffRewIndex = 0;
    m_ffRewSpeed = 0;
    m_tsNormal   = 1.0F;
 
    SetPlayer(nullptr);
    SetRecorder(nullptr);
    SetRingBuffer(nullptr);
    SetTVChain(nullptr);
    SetPlayingInfo(nullptr);
}
 
void PlayerContext::SetInitialTVState(bool islivetv)
{
    TVState newState = kState_None;
    QString newPlaygroup("Default");
 
    LockPlayingInfo(__FILE__, __LINE__);
    if (islivetv)
    {
        SetTVChain(new LiveTVChain());
        newState = kState_WatchingLiveTV;
    }
    else if (m_playingInfo)
    {
        int overrecordseconds = gCoreContext->GetNumSetting("RecordOverTime");
        QDateTime curtime = MythDate::current();
        QDateTime recendts = m_playingInfo->GetRecordingEndTime()
            .addSecs(overrecordseconds);
 
        if (m_playingInfo->IsRecording())
        {
            newState = (curtime < recendts) ?
                kState_WatchingRecording : kState_WatchingPreRecorded;
        }
        else if (m_playingInfo->IsVideoDVD())
            newState = kState_WatchingDVD;
        else if (m_playingInfo->IsVideoBD())
            newState = kState_WatchingBD;
        else
            newState = kState_WatchingVideo;
 
        newPlaygroup = m_playingInfo->GetPlaybackGroup();
    }
    UnlockPlayingInfo(__FILE__, __LINE__);
 
    ChangeState(newState);
    SetPlayGroup(newPlaygroup);
}
 
bool PlayerContext::HasPlayer(void) const
{
    QMutexLocker locker(&m_deletePlayerLock);
    return m_player;
}
 
bool PlayerContext::IsPlayerErrored(void) const
{
    QMutexLocker locker(&m_deletePlayerLock);
    return m_player && m_player->IsErrored();
}
 
bool PlayerContext::IsPlayerPlaying(void) const
{
    QMutexLocker locker(&m_deletePlayerLock);
    return m_player && m_player->IsPlaying();
}
 
bool PlayerContext::HandlePlayerSpeedChangeFFRew(void)
{
    QMutexLocker locker(&m_deletePlayerLock);
    if ((m_ffRewState || m_ffRewSpeed) && m_player && m_player->AtNormalSpeed())
    {
        m_ffRewSpeed = 0;
        m_ffRewState = 0;
        m_ffRewIndex = TV::kInitFFRWSpeed;
        return true;
    }
    return false;
}
 
bool PlayerContext::HandlePlayerSpeedChangeEOF(void)
{
    QMutexLocker locker(&m_deletePlayerLock);
    if (m_player && (m_player->GetNextPlaySpeed() != m_tsNormal) &&
        m_player->AtNormalSpeed())
    {
        // Speed got changed in player since we are close to the end of file
        m_tsNormal = 1.0F;
        return true;
    }
    return false;
}
 
bool PlayerContext::IsRecorderErrored(void) const
{
    return m_recorder && m_recorder->GetErrorStatus();
}
 
void PlayerContext::StopPlaying(void) const
{
    if (m_player)
        m_player->StopPlaying();
}
 
void PlayerContext::UpdateTVChain(const QStringList &data)
{
    QMutexLocker locker(&m_deletePlayerLock);
    if (m_tvchain && m_player)
    {
        m_tvchain->ReloadAll(data);
        m_player->CheckTVChain();
    }
}
 
bool PlayerContext::ReloadTVChain(void)
{
    if (!m_tvchain)
        return false;
 
    m_tvchain->ReloadAll();
    ProgramInfo *pinfo = m_tvchain->GetProgramAt(-1);
    if (pinfo)
    {
        SetPlayingInfo(pinfo);
        delete pinfo;
        return true;
    }
    return false;
}
 
void PlayerContext::PushPreviousChannel(void)
{
    if (!m_tvchain)
        return;
 
    // Don't store more than kMaxChannelHistory channels. Remove the first item
    if (m_prevChan.size() >= kMaxChannelHistory)
        m_prevChan.pop_front();
 
    // This method builds the stack of previous channels
    QString curChan = m_tvchain->GetChannelName(-1);
    if (m_prevChan.empty() ||
        curChan != m_prevChan[m_prevChan.size() - 1])
    {
        const QString& chan = curChan;
        m_prevChan.push_back(chan);
    }
}
 
QString PlayerContext::PopPreviousChannel(void)
{
    if (m_prevChan.empty())
        return QString();
 
    QString curChan = m_tvchain->GetChannelName(-1);
    if ((curChan == m_prevChan.back()) && !m_prevChan.empty())
        m_prevChan.pop_back();
 
    if (m_prevChan.empty())
        return QString();
 
    QString chan = m_prevChan.back();
    m_prevChan.pop_back();
    // add the current channel back to the list, to allow easy flipping between
    // two channels using PREVCHAN
    PushPreviousChannel();
    return chan;
}
 
QString PlayerContext::GetPreviousChannel(void) const
{
    if (m_prevChan.empty())
        return QString();
 
    QString curChan = m_tvchain->GetChannelName(-1);
    QString preChan;
    if (curChan != m_prevChan.back() || m_prevChan.size() < 2)
        preChan = m_prevChan.back();
    else
        preChan = m_prevChan[m_prevChan.size()-2];
    return preChan;
}
 
void PlayerContext::LockPlayingInfo(const char *file, int line) const
{
#if 0
    LOG(VB_GENERAL, LOG_DEBUG, QString("LockPlayingInfo(%1,%2)")
            .arg(file).arg(line));
#else
    Q_UNUSED(file);
    Q_UNUSED(line);
#endif
    m_playingInfoLock.lock();
}
 
void PlayerContext::UnlockPlayingInfo(const char *file, int line) const
{
#if 0
    LOG(VB_GENERAL, LOG_DEBUG, QString("UnlockPlayingInfo(%1,%2)")
            .arg(file).arg(line));
#else
    Q_UNUSED(file);
    Q_UNUSED(line);
#endif
    m_playingInfoLock.unlock();
}
 
void PlayerContext::LockDeletePlayer(const char *file, int line) const
{
#if 0
    LOG(VB_GENERAL, LOG_DEBUG, QString("LockDeletePlayer(%1,%2)")
            .arg(file).arg(line));
#else
    Q_UNUSED(file);
    Q_UNUSED(line);
#endif
    m_deletePlayerLock.lock();
}
 
void PlayerContext::UnlockDeletePlayer(const char *file, int line) const
{
#if 0
    LOG(VB_GENERAL, LOG_DEBUG, QString("UnlockDeletePlayer(%1,%2)")
            .arg(file).arg(line));
#else
    Q_UNUSED(file);
    Q_UNUSED(line);
#endif
    m_deletePlayerLock.unlock();
}
 
void PlayerContext::LockState(void) const
{
    m_stateLock.lock();
}
 
void PlayerContext::UnlockState(void) const
{
    m_stateLock.unlock();
}
 
bool PlayerContext::InStateChange(void) const
{
    if (!m_stateLock.tryLock())
        return true;
    bool inStateChange = !m_nextState.empty();
    m_stateLock.unlock();
    return inStateChange;
}
 
void PlayerContext::ChangeState(TVState newState)
{
    QMutexLocker locker(&m_stateLock);
    m_nextState.enqueue(newState);
}
 
TVState PlayerContext::DequeueNextState(void)
{
    QMutexLocker locker(&m_stateLock);
    return m_nextState.dequeue();
}
 
void PlayerContext::ForceNextStateNone(void)
{
    QMutexLocker locker(&m_stateLock);
    m_nextState.clear();
    m_nextState.push_back(kState_None);
}
 
TVState PlayerContext::GetState(void) const
{
    QMutexLocker locker(&m_stateLock);
    return m_playingState;
}
 
bool PlayerContext::GetPlayingInfoMap(InfoMap &infoMap) const
{
    bool loaded = false;
    LockPlayingInfo(__FILE__, __LINE__);
    if (m_playingInfo)
    {
        m_playingInfo->ToMap(infoMap);
        infoMap["tvstate"]  = StateToString(m_playingState);
        infoMap["iconpath"] = ChannelUtil::GetIcon(m_playingInfo->GetChanID());
        if ((m_playingInfo->IsVideoFile() || m_playingInfo->IsVideoDVD() ||
            m_playingInfo->IsVideoBD()) && m_playingInfo->GetPathname() !=
            m_playingInfo->GetBasename())
        {
            infoMap["coverartpath"] = VideoMetaDataUtil::GetArtPath(
                m_playingInfo->GetPathname(), "Coverart");
            infoMap["fanartpath"] = VideoMetaDataUtil::GetArtPath(
                m_playingInfo->GetPathname(), "Fanart");
            infoMap["bannerpath"] = VideoMetaDataUtil::GetArtPath(
                m_playingInfo->GetPathname(), "Banners");
            infoMap["screenshotpath"] = VideoMetaDataUtil::GetArtPath(
                m_playingInfo->GetPathname(), "Screenshots");
        }
        else
        {
            ArtworkMap artmap = GetArtwork(m_playingInfo->GetInetRef(),
                                           m_playingInfo->GetSeason());
            infoMap["coverartpath"] =
                artmap.value(kArtworkCoverart).url;
            infoMap["fanartpath"] =
                artmap.value(kArtworkFanart).url;
            infoMap["bannerpath"] =
                artmap.value(kArtworkBanner).url;
            infoMap["screenshotpath"] =
                artmap.value(kArtworkScreenshot).url;
        }
        loaded = true;
    }
    UnlockPlayingInfo(__FILE__, __LINE__);
    return loaded;
}
 
bool PlayerContext::IsSameProgram(const ProgramInfo &p) const
{
    bool ret = false;
    LockPlayingInfo(__FILE__, __LINE__);
    if (m_playingInfo)
        ret = m_playingInfo->IsSameProgram(p);
    UnlockPlayingInfo(__FILE__, __LINE__);
    return ret;
}
 
QString PlayerContext::GetFilters(const QString &baseFilters) const
{
    QString filters     = baseFilters;
    QString chanFilters;
 
    if (gCoreContext->IsDatabaseIgnored())
        return baseFilters;
 
    LockPlayingInfo(__FILE__, __LINE__);
    if (m_playingInfo) // Recordings have this info already.
        chanFilters = m_playingInfo->GetChannelPlaybackFilters();
    UnlockPlayingInfo(__FILE__, __LINE__);
 
    if (!chanFilters.isEmpty())
    {
        if ((chanFilters[0] != '+'))
        {
            filters = chanFilters;
        }
        else
        {
            if (!filters.isEmpty() && (!filters.endsWith(",")))
                filters += ",";
 
            filters += chanFilters.midRef(1);
        }
    }
 
    LOG(VB_CHANNEL, LOG_INFO, LOC +
        QString("Output filters for this channel are: '%1'")
                    .arg(filters));
 
    return filters;
}
 
QString PlayerContext::GetPlayMessage(void) const
{
    QString mesg = QObject::tr("Play");
    if (m_tsNormal != 1.0F)
    {
        if (m_tsNormal == 0.5F)
            mesg += QString(" 1/2x");
        else if (0.32F < m_tsNormal && m_tsNormal < 0.34F)
            mesg += QString(" 1/3x");
        else if (m_tsNormal == 0.25F)
            mesg += QString(" 1/4x");
        else if (m_tsNormal == 0.125F)
            mesg += QString(" 1/8x");
        else if (m_tsNormal == 0.0625F)
            mesg += QString(" 1/16x");
        else
            mesg += QString(" %1x").arg(m_tsNormal);
    }
 
    return mesg;
}
 
void PlayerContext::SetPlayer(MythPlayer *newplayer)
{
    QMutexLocker locker(&m_deletePlayerLock);
    if (m_player)
    {
        StopPlaying();
        delete m_player;
    }
    m_player = newplayer;
}
 
void PlayerContext::SetRecorder(RemoteEncoder *rec)
{
    if (m_recorder)
    {
        delete m_recorder;
        m_recorder = nullptr;
    }
 
    if (rec)
    {
        m_recorder = rec;
        m_lastCardid = m_recorder->GetRecorderNumber();
    }
}
 
void PlayerContext::SetTVChain(LiveTVChain *chain)
{
    if (m_tvchain)
    {
        m_tvchain->DestroyChain();
        m_tvchain->DecrRef();
        m_tvchain = nullptr;
    }
 
    m_tvchain = chain;
 
    if (m_tvchain)
        m_tvchain->InitializeNewChain(gCoreContext->GetHostName());
}
 
void PlayerContext::SetRingBuffer(MythMediaBuffer *Buffer)
{
    if (m_buffer)
    {
        delete m_buffer;
        m_buffer = nullptr;
    }
 
    m_buffer = Buffer;
}
 
void PlayerContext::SetPlayingInfo(const ProgramInfo *info)
{
    bool ignoreDB = gCoreContext->IsDatabaseIgnored();
 
    QMutexLocker locker(&m_playingInfoLock);
 
    if (m_playingInfo)
    {
        if (!ignoreDB)
            m_playingInfo->MarkAsInUse(false, m_recUsage);
        delete m_playingInfo;
        m_playingInfo = nullptr;
    }
 
    if (info)
    {
        m_playingInfo = new ProgramInfo(*info);
        if (!ignoreDB)
            m_playingInfo->MarkAsInUse(true, m_recUsage);
        m_playingLen = m_playingInfo->GetSecondsInRecording();
    }
}
 
void PlayerContext::SetPlayGroup(const QString &group)
{
    m_fftime       = PlayGroup::GetSetting(group, "skipahead", 30);
    m_rewtime      = PlayGroup::GetSetting(group, "skipback", 5);
    m_jumptime     = PlayGroup::GetSetting(group, "jump", 10);
    m_tsNormal     = PlayGroup::GetSetting(group, "timestretch", 100) * 0.01F;
    m_tsAlt        = (m_tsNormal == 1.0F) ? 1.5F : 1.0F;
}
 
void PlayerContext::SetPseudoLiveTV(
    const ProgramInfo *pi, PseudoState new_state)
{
    ProgramInfo *old_rec = m_pseudoLiveTVRec;
    ProgramInfo *new_rec = nullptr;
 
    if (pi)
    {
        new_rec = new ProgramInfo(*pi);
        QString msg = QString("Wants to record: %1 %2 %3 %4")
            .arg(new_rec->GetTitle()).arg(new_rec->GetChanNum())
            .arg(new_rec->GetRecordingStartTime(MythDate::ISODate))
            .arg(new_rec->GetRecordingEndTime(MythDate::ISODate));
        LOG(VB_PLAYBACK, LOG_INFO, LOC + msg);
    }
 
    m_pseudoLiveTVRec   = new_rec;
    m_pseudoLiveTVState = new_state;
 
    if (old_rec)
    {
        QString msg = QString("Done recording: %1 %2 %3 %4")
            .arg(old_rec->GetTitle()).arg(old_rec->GetChanNum())
            .arg(old_rec->GetRecordingStartTime(MythDate::ISODate))
            .arg(old_rec->GetRecordingEndTime(MythDate::ISODate));
        LOG(VB_PLAYBACK, LOG_INFO, LOC + msg);
        delete old_rec;
    }
}