encoderlink.cpp

Go to the documentation of this file.

// C++ headers
#include <iostream>
using namespace std;

// C headers
#include <unistd.h>

// MythTV headers
#include "mythcorecontext.h"
#include "encoderlink.h"
#include "playbacksock.h"
#include "tv_rec.h"
#include "mythmiscutil.h"
#include "previewgenerator.h"
#include "storagegroup.h"
#include "backendutil.h"
#include "compat.h"

#define LOC QString("EncoderLink(%1): ").arg(m_capturecardnum)
#define LOC_ERR QString("EncoderLink(%1) Error: ").arg(m_capturecardnum)

EncoderLink::EncoderLink(int capturecardnum, PlaybackSock *lsock,
                         QString lhostname)
    : m_capturecardnum(capturecardnum), sock(lsock), hostname(lhostname),
      freeDiskSpaceKB(-1), tv(NULL), local(false), locked(false),
      sleepStatus(sStatus_Undefined), chanid(0)
{
    endRecordingTime = QDateTime::currentDateTime().addDays(-2);
    startRecordingTime = endRecordingTime;

    sleepStatusTime = QDateTime::currentDateTime();
    lastSleepTime   = QDateTime::currentDateTime();
    lastWakeTime    = QDateTime::currentDateTime();

    if (sock)
        sock->UpRef();
}

EncoderLink::EncoderLink(int capturecardnum, TVRec *ltv)
    : m_capturecardnum(capturecardnum), sock(NULL),
      freeDiskSpaceKB(-1), tv(ltv), local(true), locked(false),
      sleepStatus(sStatus_Undefined), chanid(0)
{
    endRecordingTime = QDateTime::currentDateTime().addDays(-2);
    startRecordingTime = endRecordingTime;

    sleepStatusTime = QDateTime::currentDateTime();
    lastSleepTime   = QDateTime::currentDateTime();
    lastWakeTime    = QDateTime::currentDateTime();
}

EncoderLink::~EncoderLink(void)
{
    if (tv)
    {
        delete tv;
        tv = NULL;
    }
}

void EncoderLink::SetSocket(PlaybackSock *lsock)
{
    if (lsock)
    {
        lsock->UpRef();

        if (gCoreContext->GetSettingOnHost("SleepCommand", hostname).isEmpty())
            SetSleepStatus(sStatus_Undefined);
        else
            SetSleepStatus(sStatus_Awake);
    }
    else
    {
        if (IsFallingAsleep())
            SetSleepStatus(sStatus_Asleep);
        else
            SetSleepStatus(sStatus_Undefined);
    }

    if (sock)
        sock->DownRef();
    sock = lsock;
}

void EncoderLink::SetSleepStatus(SleepStatus newStatus)
{
    sleepStatus     = newStatus;
    sleepStatusTime = QDateTime::currentDateTime();
}

bool EncoderLink::IsBusy(TunedInputInfo *busy_input, int time_buffer)
{
    if (local)
        return tv->IsBusy(busy_input, time_buffer);

    if (sock)
        return sock->IsBusy(m_capturecardnum, 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 (local)
        retval = tv->GetState();
    else if (sock)
        retval = (TVState)sock->GetEncoderState(m_capturecardnum);
    else
        LOG(VB_GENERAL, LOG_ERR, QString("Broken for card: %1")
            .arg(m_capturecardnum));

    return retval;
}

uint EncoderLink::GetFlags(void) const
{
    uint retval = 0;

    if (!IsConnected())
        return retval;

    if (local)
        retval = tv->GetFlags();
    else if (sock)
        retval = sock->GetEncoderState(m_capturecardnum);
    else
        LOG(VB_GENERAL, LOG_ERR, LOC + "GetFlags failed");

    return retval;
}

bool EncoderLink::IsRecording(const ProgramInfo *rec)
{
    return (rec->GetChanID() == chanid &&
            rec->GetRecordingStartTime() == startRecordingTime);
}

bool EncoderLink::MatchesRecording(const ProgramInfo *rec)
{
    bool retval = false;
    ProgramInfo *tvrec = NULL;

    if (local)
    {
        while (kState_ChangingState == GetState())
            usleep(100);

        if (IsBusyRecording())
            tvrec = tv->GetRecording();

        if (tvrec)
        {
            retval = tvrec->IsSameRecording(*rec);
            delete tvrec;
        }
    }
    else
    {
        if (sock)
            retval = sock->EncoderIsRecording(m_capturecardnum, rec);
    }

    return retval;
}

void EncoderLink::RecordPending(const ProgramInfo *rec, int secsleft,
                                bool hasLater)
{
    if (local)
        tv->RecordPending(rec, secsleft, hasLater);
    else if (sock)
        sock->RecordPending(m_capturecardnum, rec, secsleft, hasLater);
}

bool EncoderLink::WouldConflict(const ProgramInfo *rec)
{
    if (!IsConnected())
        return true;

    if (rec->GetRecordingStartTime() < endRecordingTime)
        return true;

    return false;
}

bool EncoderLink::CheckFile(ProgramInfo *pginfo)
{
    if (sock)
        return sock->CheckFile(pginfo);

    pginfo->SetPathname(GetPlaybackURL(pginfo));
    return pginfo->IsLocal();
}

void EncoderLink::GetDiskSpace(QStringList &o_strlist)
{
    if (sock)
        sock->GetDiskSpace(o_strlist);
}

long long EncoderLink::GetMaxBitrate()
{
    if (local)
        return tv->GetMaxBitrate();
    else if (sock)
        return sock->GetMaxBitrate(m_capturecardnum);

    return -1;
}

int EncoderLink::SetSignalMonitoringRate(int rate, int notifyFrontend)
{
    if (local)
        return tv->SetSignalMonitoringRate(rate, notifyFrontend);
    else if (sock)
        return sock->SetSignalMonitoringRate(m_capturecardnum, rate,
                                             notifyFrontend);
    return -1;
}

bool EncoderLink::GoToSleep(void)
{
    if (IsLocal() || !sock)
        return false;

    lastSleepTime = QDateTime::currentDateTime();

    return sock->GoToSleep();
}

int EncoderLink::LockTuner()
{
    if (locked)
        return -2;

    locked = true;
    return m_capturecardnum;
}

RecStatusType EncoderLink::StartRecording(const ProgramInfo *rec)
{
    RecStatusType retval = rsAborted;

    endRecordingTime = rec->GetRecordingEndTime();
    startRecordingTime = rec->GetRecordingStartTime();
    chanid = rec->GetChanID();

    if (local)
        retval = tv->StartRecording(rec);
    else if (sock)
        retval = sock->StartRecording(m_capturecardnum, 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_capturecardnum));

    if (retval != rsRecording && retval != rsTuning)
    {
        endRecordingTime = QDateTime::currentDateTime().addDays(-2);
        startRecordingTime = endRecordingTime;
        chanid = 0;
    }

    return retval;
}

RecStatusType EncoderLink::GetRecordingStatus(void)
{
    RecStatusType retval = rsAborted;

    if (local)
        retval = tv->GetRecordingStatus();
    else if (sock)
        retval = sock->GetRecordingStatus(m_capturecardnum);
    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_capturecardnum));

    if (retval != rsRecording && retval != rsTuning)
    {
        endRecordingTime = QDateTime::currentDateTime().addDays(-2);
        startRecordingTime = endRecordingTime;
        chanid = 0;
    }

    return retval;
}

ProgramInfo *EncoderLink::GetRecording(void)
{
    ProgramInfo *info = NULL;

    if (local)
        info = tv->GetRecording();
    else if (sock)
        info = sock->GetRecording(m_capturecardnum);

    return info;
}

void EncoderLink::StopRecording(bool killFile)
{
    endRecordingTime = QDateTime::currentDateTime().addDays(-2);
    startRecordingTime = endRecordingTime;
    chanid = 0;

    if (local)
    {
        tv->StopRecording(killFile);
        return;
    }
}

void EncoderLink::FinishRecording(void)
{
    if (local)
    {
        tv->FinishRecording();
        return;
    }
    else
    {
        endRecordingTime = QDateTime::currentDateTime().addDays(-2);
    }
}

bool EncoderLink::IsReallyRecording(void)
{
    if (local)
        return tv->IsReallyRecording();

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: IsReallyRecording");
    return false;
}

float EncoderLink::GetFramerate(void)
{
    if (local)
        return tv->GetFramerate();

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetFramerate");
    return -1;
}

long long EncoderLink::GetFramesWritten(void)
{
    if (local)
        return tv->GetFramesWritten();

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetFramesWritten");
    return -1;
}

long long EncoderLink::GetFilePosition(void)
{
    if (local)
        return tv->GetFilePosition();

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetFilePosition");
    return -1;
}

int64_t EncoderLink::GetKeyframePosition(uint64_t desired)
{
    if (local)
        return 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 (!local)
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: GetKeyframePositions");
        return false;
    }

    return tv->GetKeyframePositions(start, end, map);
}

void EncoderLink::FrontendReady(void)
{
    if (local)
        tv->FrontendReady();
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: FrontendReady");
}

void EncoderLink::CancelNextRecording(bool cancel)
{
    if (local)
        tv->CancelNextRecording(cancel);
    else
        sock->CancelNextRecording(m_capturecardnum, cancel);
}

void EncoderLink::SpawnLiveTV(LiveTVChain *chain, bool pip, QString startchan)
{
    if (local)
        tv->SpawnLiveTV(chain, pip, startchan);
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SpawnLiveTV");
}

QString EncoderLink::GetChainID(void)
{
    if (local)
        return tv->GetChainID();

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SpawnLiveTV");
    return "";
}

void EncoderLink::StopLiveTV(void)
{
    if (local)
        tv->StopLiveTV();
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: StopLiveTV");
}

void EncoderLink::PauseRecorder(void)
{
    if (local)
        tv->PauseRecorder();
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: PauseRecorder");
}

void EncoderLink::SetLiveRecording(int recording)
{
    if (local)
        tv->SetLiveRecording(recording);
    else
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: SetLiveRecording");
}

void EncoderLink::SetNextLiveTVDir(QString dir)
{
    if (local)
        tv->SetNextLiveTVDir(dir);
    else
        sock->SetNextLiveTVDir(m_capturecardnum, dir);
}

vector<InputInfo> EncoderLink::GetFreeInputs(
    const vector<uint> &excluded_cardids) const
{
    vector<InputInfo> list;

    if (local)
        list = tv->GetFreeInputs(excluded_cardids);
    else
        list = sock->GetFreeInputs(m_capturecardnum, excluded_cardids);

    return list;
}

QString EncoderLink::GetInput(void) const
{
    if (local)
        return tv->GetInput();

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetInput");
    return QString();
}

QString EncoderLink::SetInput(QString input)
{
    if (local)
        return tv->SetInput(input);

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SetInput");
    return QString();
}

void EncoderLink::ToggleChannelFavorite(QString changroup)
{
    if (local)
        tv->ToggleChannelFavorite(changroup);
    else
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: ToggleChannelFavorite");
}

void EncoderLink::ChangeChannel(ChannelChangeDirection channeldirection)
{
    if (local)
        tv->ChangeChannel(channeldirection);
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: ChangeChannel");
}

void EncoderLink::SetChannel(const QString &name)
{
    if (local)
        tv->SetChannel(name);
    else
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SetChannel");
}

int EncoderLink::GetPictureAttribute(PictureAttribute attr)
{
    if (!local)
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: GetPictureAttribute");
        return -1;
    }

    return tv->GetPictureAttribute(attr);
}

int EncoderLink::ChangePictureAttribute(PictureAdjustType type,
                                        PictureAttribute  attr,
                                        bool              direction)
{
    if (!local)
    {
        LOG(VB_GENERAL, LOG_ERR,
            "Should be local only query: ChangePictureAttribute");
        return -1;
    }

    return tv->ChangePictureAttribute(type, attr, direction);
}

bool EncoderLink::CheckChannel(const QString &name)
{
    if (local)
        return tv->CheckChannel(name);

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: CheckChannel");
    return false;
}

bool EncoderLink::ShouldSwitchToAnotherCard(const QString &channelid)
{
    if (local)
        return tv->ShouldSwitchToAnotherCard(channelid);

    LOG(VB_GENERAL, LOG_ERR,
        "Should be local only query: ShouldSwitchToAnotherCard");
    return false;
}

bool EncoderLink::CheckChannelPrefix(
    const QString &prefix,
    uint          &is_complete_valid_channel_on_rec,
    bool          &is_extra_char_useful,
    QString       &needed_spacer)
{
    if (local)
    {
        return tv->CheckChannelPrefix(
            prefix, is_complete_valid_channel_on_rec,
            is_extra_char_useful, needed_spacer);
    }

    LOG(VB_GENERAL, LOG_ERR, "Should be local only query: CheckChannelPrefix");
    is_complete_valid_channel_on_rec = false;
    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 (local)
    {
        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 (!local)
    {
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: GetChannelInfo");
        return false;
    }

    return tv->GetChannelInfo(chanid, sourceid,
                              callsign, channum, channame, xmltv);
}

bool EncoderLink::SetChannelInfo(uint chanid, uint sourceid,
                                 QString oldchannum,
                                 QString callsign, QString channum,
                                 QString channame, QString xmltv)
{
    if (!local)
    {
        LOG(VB_GENERAL, LOG_ERR, "Should be local only query: SetChannelInfo");
        return false;
    }

    return tv->SetChannelInfo(chanid, sourceid, oldchannum,
                              callsign, channum, channame, xmltv);
}

/* vim: set expandtab tabstop=4 shiftwidth=4: */