encoderlink.cpp

Go to the documentation of this file.

// ANSI C++ headers
#include <chrono> // for milliseconds
#include <thread> // for sleep_for
#include <utility>
 
// QT headers
#include <QMap>                         // for QMap
 
// MythTV headers
#include "libmythbase/compat.h"
#include "libmythbase/mythcorecontext.h"
#include "libmythbase/mythdate.h"
#include "libmythbase/mythlogging.h"      // for LOG
#include "libmythbase/programinfo.h"      // for ProgramInfo
#include "libmythbase/referencecounter.h"
#include "libmythprotoserver/requesthandler/fileserverutil.h"
#include "libmythtv/inputinfo.h"          // for InputInfo
#include "libmythtv/tv_rec.h"
 
// MythBackend
#include "encoderlink.h"
#include "playbacksock.h"
 
#define LOC QString("EncoderLink(%1): ").arg(m_inputid)
#define LOC_ERR QString("EncoderLink(%1) Error: ").arg(m_inputid)
 
EncoderLink::EncoderLink(int inputid, PlaybackSock *lsock,
                         QString lhostname)
    : m_inputid(inputid), m_sock(lsock), m_hostname(std::move(lhostname)),
      m_sleepStatusTime(MythDate::current()),
      m_lastSleepTime(MythDate::current()),
      m_lastWakeTime(MythDate::current()),
      m_endRecordingTime(MythDate::current().addDays(-2)),
      m_startRecordingTime(m_endRecordingTime)
{
    HasSockAndIncrRef();
}
 
EncoderLink::EncoderLink(int inputid, TVRec *ltv)
    : m_inputid(inputid), m_tv(ltv), m_local(true),
      m_sleepStatusTime(MythDate::current()),
      m_lastSleepTime(MythDate::current()),
      m_lastWakeTime(MythDate::current()),
      m_endRecordingTime(MythDate::current().addDays(-2)),
      m_startRecordingTime(m_endRecordingTime)
{
}
 
EncoderLink::~EncoderLink(void)
{
    if (m_tv)
    {
        delete m_tv;
        m_tv = nullptr;
    }
    SetSocket(nullptr);
}
 
bool EncoderLink::HasSockAndIncrRef()
{
    QMutexLocker locker(&m_sockLock);
    if (m_sock)
    {
        m_sock->IncrRef();
        return true;
    }
    return false;
}
 
bool EncoderLink::HasSockAndDecrRef()
{
    QMutexLocker locker(&m_sockLock);
    if (m_sock)
    {
        m_sock->DecrRef();
        return true;
    }
    return false;
}
 
void EncoderLink::SetSocket(PlaybackSock *lsock)
{
    if (lsock)
    {
        lsock->IncrRef();
 
        if (gCoreContext->GetSettingOnHost("SleepCommand", m_hostname).isEmpty())
            SetSleepStatus(sStatus_Undefined);
        else
            SetSleepStatus(sStatus_Awake);
    }
    else
    {
        if (IsFallingAsleep())
            SetSleepStatus(sStatus_Asleep);
        else
            SetSleepStatus(sStatus_Undefined);
    }
 
    HasSockAndDecrRef();
    m_sock = lsock;
}
 
void EncoderLink::SetSleepStatus(SleepStatus newStatus)
{
    m_sleepStatus     = newStatus;
    m_sleepStatusTime = MythDate::current();
}
 
bool EncoderLink::IsBusy(InputInfo *busy_input, std::chrono::seconds time_buffer)
{
    if (m_local)
        return m_tv->IsBusy(busy_input, time_buffer);
 
    if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        return m_sock->IsBusy(m_inputid, busy_input, time_buffer);
    }
 
    return false;
}
 
bool EncoderLink::IsBusyRecording(void)
{
    bool retval = false;
 
    TVState state = GetState();
 
    if (state == kState_RecordingOnly || state == kState_WatchingRecording ||
        state == kState_WatchingLiveTV)
    {
        retval = true;
    }
 
    return retval;
}
 
TVState EncoderLink::GetState(void)
{
    TVState retval = kState_Error;
 
    if (!IsConnected())
        return retval;
 
    if (m_local)
        retval = m_tv->GetState();
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        retval = (TVState)m_sock->GetEncoderState(m_inputid);
    }
    else
    {
        LOG(VB_GENERAL, LOG_ERR, QString("Broken for input: %1")
            .arg(m_inputid));
    }
 
    return retval;
}
 
uint EncoderLink::GetFlags(void)
{
    uint retval = 0;
 
    if (!IsConnected())
        return retval;
 
    if (m_local)
        retval = m_tv->GetFlags();
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        retval = m_sock->GetEncoderState(m_inputid);
    }
    else
    {
        LOG(VB_GENERAL, LOG_ERR, LOC + "GetFlags failed");
    }
 
    return retval;
}
 
bool EncoderLink::IsRecording(const ProgramInfo *rec)
{
    return (rec->GetChanID() == m_chanid &&
            rec->GetRecordingStartTime() == m_startRecordingTime);
}
 
bool EncoderLink::MatchesRecording(const ProgramInfo *rec)
{
    bool retval = false;
    ProgramInfo *tvrec = nullptr;
 
    if (m_local)
    {
        while (kState_ChangingState == GetState())
            std::this_thread::sleep_for(100us);
 
        if (IsBusyRecording())
            tvrec = m_tv->GetRecording();
 
        if (tvrec)
        {
            retval = tvrec->IsSameRecording(*rec);
            delete tvrec;
        }
    }
    else
    {
        if (HasSockAndIncrRef())
        {
            ReferenceLocker rlocker(m_sock);
            retval = m_sock->EncoderIsRecording(m_inputid, rec);
        }
    }
 
    return retval;
}
 
void EncoderLink::RecordPending(const ProgramInfo *rec,
                                std::chrono::seconds secsleft,
                                bool hasLater)
{
    if (m_local)
        m_tv->RecordPending(rec, secsleft, hasLater);
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        m_sock->RecordPending(m_inputid, rec, secsleft, hasLater);
    }
}
 
bool EncoderLink::WouldConflict(const ProgramInfo *rec)
{
    if (!IsConnected())
        return true;
 
    if (rec->GetRecordingStartTime() < m_endRecordingTime)
        return true;
 
    return false;
}
 
bool EncoderLink::CheckFile(ProgramInfo *pginfo)
{
    if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        return m_sock->CheckFile(pginfo);
    }
    pginfo->SetPathname(GetPlaybackURL(pginfo));
    return pginfo->IsLocal();
}
 
long long EncoderLink::GetMaxBitrate()
{
    if (m_local)
        return m_tv->GetMaxBitrate();
    if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        return m_sock->GetMaxBitrate(m_inputid);
    }
 
    return -1;
}
 
std::chrono::milliseconds EncoderLink::SetSignalMonitoringRate(std::chrono::milliseconds rate, int notifyFrontend)
{
    if (m_local)
        return m_tv->SetSignalMonitoringRate(rate, notifyFrontend);
    if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        return m_sock->SetSignalMonitoringRate(m_inputid, rate,
                                             notifyFrontend);
    }
    return -1ms;
}
 
bool EncoderLink::GoToSleep(void)
{
    if (IsLocal() || !HasSockAndIncrRef())
        return false;
    ReferenceLocker rlocker(m_sock);
 
    m_lastSleepTime = MythDate::current();
 
    return m_sock->GoToSleep();
}
 
int EncoderLink::LockTuner()
{
    if (m_locked)
        return -2;
 
    m_locked = true;
    return m_inputid;
}
 
RecStatus::Type EncoderLink::StartRecording(ProgramInfo *rec)
{
    RecStatus::Type retval = RecStatus::Aborted;
 
    m_endRecordingTime = rec->GetRecordingEndTime();
    m_startRecordingTime = rec->GetRecordingStartTime();
    m_chanid = rec->GetChanID();
 
    if (m_local)
        retval = m_tv->StartRecording(rec);
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        retval = m_sock->StartRecording(m_inputid, rec);
    }
    else
    {
        LOG(VB_GENERAL, LOG_ERR,
            QString("Wanted to start recording on recorder %1,\n\t\t\t"
                    "but the backend is not there anymore\n")
                .arg(m_inputid));
    }
 
    if (retval != RecStatus::Recording &&
        retval != RecStatus::Tuning &&
        retval != RecStatus::Failing)
    {
        m_endRecordingTime = MythDate::current().addDays(-2);
        m_startRecordingTime = m_endRecordingTime;
        m_chanid = 0;
    }
 
    return retval;
}
 
RecStatus::Type EncoderLink::GetRecordingStatus(void)
{
    RecStatus::Type retval = RecStatus::Aborted;
 
    if (m_local)
        retval = m_tv->GetRecordingStatus();
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        retval = m_sock->GetRecordingStatus(m_inputid);
    }
    else
    {
        LOG(VB_GENERAL, LOG_ERR,
            QString("Wanted to get status on recorder %1,\n\t\t\t"
                    "but the backend is not there anymore\n")
                .arg(m_inputid));
    }
 
    if (retval != RecStatus::Recording &&
        retval != RecStatus::Tuning &&
        retval != RecStatus::Failing)
    {
        m_endRecordingTime = MythDate::current().addDays(-2);
        m_startRecordingTime = m_endRecordingTime;
        m_chanid = 0;
    }
 
    return retval;
}
 
ProgramInfo *EncoderLink::GetRecording(void)
{
    ProgramInfo *info = nullptr;
 
    if (m_local)
        info = m_tv->GetRecording();
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        info = m_sock->GetRecording(m_inputid);
    }
 
    return info;
}
 
void EncoderLink::StopRecording(bool killFile)
{
    m_endRecordingTime = MythDate::current().addDays(-2);
    m_startRecordingTime = m_endRecordingTime;
    m_chanid = 0;
 
    if (m_local)
    {
        m_tv->StopRecording(killFile);
        return;
    }
}
 
void EncoderLink::FinishRecording(void)
{
    if (m_local)
    {
        m_tv->FinishRecording();
        return;
    }
    m_endRecordingTime = MythDate::current().addDays(-2);
}
 
bool EncoderLink::IsReallyRecording(void)
{
    if (m_local)
        return m_tv->IsReallyRecording();
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: IsReallyRecording");
    return false;
}
 
float EncoderLink::GetFramerate(void)
{
    if (m_local)
        return m_tv->GetFramerate();
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetFramerate");
    return -1;
}
 
long long EncoderLink::GetFramesWritten(void)
{
    if (m_local)
        return m_tv->GetFramesWritten();
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetFramesWritten");
    return -1;
}
 
long long EncoderLink::GetFilePosition(void)
{
    if (m_local)
        return m_tv->GetFilePosition();
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetFilePosition");
    return -1;
}
 
int64_t EncoderLink::GetKeyframePosition(uint64_t desired)
{
    if (m_local)
        return m_tv->GetKeyframePosition(desired);
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetKeyframePosition");
    return -1;
}
 
bool EncoderLink::GetKeyframePositions(
    int64_t start, int64_t end, frm_pos_map_t &map)
{
    if (!m_local)
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: GetKeyframePositions");
        return false;
    }
 
    return m_tv->GetKeyframePositions(start, end, map);
}
 
bool EncoderLink::GetKeyframeDurations(
    int64_t start, int64_t end, frm_pos_map_t &map)
{
    if (!m_local)
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: GetKeyframeDurations");
        return false;
    }
 
    return m_tv->GetKeyframeDurations(start, end, map);
}
 
void EncoderLink::FrontendReady(void)
{
    if (m_local)
        m_tv->FrontendReady();
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: FrontendReady");
}
 
void EncoderLink::CancelNextRecording(bool cancel)
{
    if (m_local)
        m_tv->CancelNextRecording(cancel);
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        m_sock->CancelNextRecording(m_inputid, cancel);
    }
}
 
void EncoderLink::SpawnLiveTV(LiveTVChain *chain, bool pip, QString startchan)
{
    if (m_local)
        m_tv->SpawnLiveTV(chain, pip, std::move(startchan));
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SpawnLiveTV");
}
 
QString EncoderLink::GetChainID(void)
{
    if (m_local)
        return m_tv->GetChainID();
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SpawnLiveTV");
    return "";
}
 
void EncoderLink::StopLiveTV(void)
{
    if (m_local)
        m_tv->StopLiveTV();
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: StopLiveTV");
}
 
void EncoderLink::PauseRecorder(void)
{
    if (m_local)
        m_tv->PauseRecorder();
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: PauseRecorder");
}
 
void EncoderLink::SetLiveRecording(int recording)
{
    if (m_local)
        m_tv->SetLiveRecording(recording);
    else
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: SetLiveRecording");
}
 
void EncoderLink::SetNextLiveTVDir(const QString& dir)
{
    if (m_local)
        m_tv->SetNextLiveTVDir(dir);
    else if (HasSockAndIncrRef())
    {
        ReferenceLocker rlocker(m_sock);
        m_sock->SetNextLiveTVDir(m_inputid, dir);
    }
}
 
QString EncoderLink::GetInput(void) const
{
    if (m_local)
        return m_tv->GetInput();
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetInput");
    return {};
}
 
QString EncoderLink::SetInput(QString input)
{
    if (m_local)
        return m_tv->SetInput(std::move(input));
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SetInput");
    return {};
}
 
void EncoderLink::ToggleChannelFavorite(const QString& changroup)
{
    if (m_local)
        m_tv->ToggleChannelFavorite(changroup);
    else
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: ToggleChannelFavorite");
}
 
void EncoderLink::ChangeChannel(ChannelChangeDirection channeldirection)
{
    if (m_local)
        m_tv->ChangeChannel(channeldirection);
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: ChangeChannel");
}
 
void EncoderLink::SetChannel(const QString &name)
{
    if (m_local)
        m_tv->SetChannel(name);
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SetChannel");
}
 
int EncoderLink::GetPictureAttribute(PictureAttribute attr)
{
    if (!m_local)
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: GetPictureAttribute");
        return -1;
    }
 
    return m_tv->GetPictureAttribute(attr);
}
 
int EncoderLink::ChangePictureAttribute(PictureAdjustType type,
                                        PictureAttribute  attr,
                                        bool              direction)
{
    if (!m_local)
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: ChangePictureAttribute");
        return -1;
    }
 
    return m_tv->ChangePictureAttribute(type, attr, direction);
}
 
bool EncoderLink::CheckChannel(const QString &name)
{
    if (m_local)
        return m_tv->CheckChannel(name);
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: CheckChannel");
    return false;
}
 
bool EncoderLink::ShouldSwitchToAnotherInput(const QString &channelid)
{
    if (m_local)
        return m_tv->ShouldSwitchToAnotherInput(channelid);
 
    LOG(VB_GENERAL, LOG_ERR,
        "Should be local only query: ShouldSwitchToAnotherInput");
    return false;
}
 
bool EncoderLink::CheckChannelPrefix(
    const QString &prefix,
    uint          &complete_valid_channel_on_rec,
    bool          &is_extra_char_useful,
    QString       &needed_spacer)
{
    if (m_local)
    {
        return m_tv->CheckChannelPrefix(
            prefix, complete_valid_channel_on_rec,
            is_extra_char_useful, needed_spacer);
    }
 
    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: CheckChannelPrefix");
    complete_valid_channel_on_rec    = 0;
    is_extra_char_useful             = false;
    needed_spacer                    = "";
    return false;
}
 
void EncoderLink::GetNextProgram(BrowseDirection direction,
                                 QString &title,       QString &subtitle,
                                 QString &desc,        QString &category,
                                 QString &starttime,   QString &endtime,
                                 QString &callsign,    QString &iconpath,
                                 QString &channelname, uint    &_chanid,
                                 QString &seriesid,    QString &programid)
{
    if (m_local)
    {
        m_tv->GetNextProgram(direction,
                           title, subtitle, desc, category, starttime,
                           endtime, callsign, iconpath, channelname,
                           _chanid, seriesid, programid);
    }
    else
    {
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetNextProgram");
    }
}
 
bool EncoderLink::GetChannelInfo(uint &chanid, uint &sourceid,
                                 QString &callsign, QString &channum,
                                 QString &channame, QString &xmltv) const
{
    if (!m_local)
    {
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetChannelInfo");
        return false;
    }
 
    return m_tv->GetChannelInfo(chanid, sourceid,
                              callsign, channum, channame, xmltv);
}
 
bool EncoderLink::SetChannelInfo(uint chanid, uint sourceid,
                                 const QString& oldchannum,
                                 const QString& callsign, const QString& channum,
                                 const QString& channame, const QString& xmltv)
{
    if (!m_local)
    {
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SetChannelInfo");
        return false;
    }
 
    return m_tv->SetChannelInfo(chanid, sourceid, oldchannum,
                                callsign, channum,
                                channame, xmltv);
}
 
bool EncoderLink::AddChildInput(uint childid)
{
    if (m_local)
    {
        LOG(VB_GENERAL, LOG_ERR, LOC + "Called on local recorder");
        return false;
    }
 
    bool retval = m_sock->AddChildInput(childid);
    return retval;
}
 
/* vim: set expandtab tabstop=4 shiftwidth=4: */