encoderlink.h

Go to the documentation of this file.

#ifndef ENCODERLINK_H_
#define ENCODERLINK_H_
 
// C++ headers
#include <utility>
#include <vector>                       // for vector
 
// QT headers
#include <QDateTime>                    // for QDateTime
#include <QMutex>                       // for QMutex
#include <QString>                      // for QString
 
#include "libmythtv/recordingstatus.h"
#include "libmythtv/tv.h"               // for SleepStatus, etc
#include "libmythtv/videoouttypes.h"    // for PictureAttribute
 
class TVRec;
class PlaybackSock;
class LiveTVChain;
class InputInfo;
class ProgramInfo;
 
class EncoderLink
{
  public:
    EncoderLink(int inputid, PlaybackSock *lsock, QString lhostname);
    EncoderLink(int inputid, TVRec *ltv);
 
   ~EncoderLink();
 
    void SetSocket(PlaybackSock *lsock);
    PlaybackSock *GetSocket(void) { return m_sock; }
 
    void SetSleepStatus(SleepStatus newStatus);
    QDateTime GetSleepStatusTime(void) const { return m_sleepStatusTime; }
    QDateTime GetLastSleepTime(void) const { return m_lastSleepTime; }
    void SetLastWakeTime(QDateTime newTime) { m_lastWakeTime = std::move(newTime); }
    QDateTime GetLastWakeTime(void) const { return m_lastWakeTime; }
 
    QString GetHostName(void) const { return m_hostname; }
    bool IsLocal(void) const { return m_local; }
    bool IsConnected(void) const { return (IsLocal() || m_sock!=nullptr); }
    bool IsAwake(void) const { return (m_sleepStatus == sStatus_Awake); }
    bool IsAsleep(void) const { return (m_sleepStatus & sStatus_Asleep) != 0; }
    bool IsWaking(void) const { return (m_sleepStatus == sStatus_Waking); }
    bool IsFallingAsleep(void) const
                        { return (m_sleepStatus == sStatus_FallingAsleep); }
    bool CanSleep(void) const { return (m_sleepStatus != sStatus_Undefined); }
 
    SleepStatus GetSleepStatus(void) const { return (m_sleepStatus); }
 
    int GetInputID(void) const { return m_inputid; }
    TVRec *GetTVRec(void) { return m_tv; }
 
    bool GoToSleep(void);
    int LockTuner(void);
    void FreeTuner(void) { m_locked = false; }
    bool IsTunerLocked(void) const { return m_locked; }
 
    bool CheckFile(ProgramInfo *pginfo);
    long long GetMaxBitrate(void);
    std::chrono::milliseconds SetSignalMonitoringRate(std::chrono::milliseconds rate, int notifyFrontend);
 
    bool IsBusy(InputInfo *busy_input = nullptr, std::chrono::seconds time_buffer = 5s);
    bool IsBusyRecording(void);
 
    TVState GetState();
    uint GetFlags(void);
    bool IsRecording(const ProgramInfo *rec); // scheduler call only.
 
    bool MatchesRecording(const ProgramInfo *rec);
    void RecordPending(const ProgramInfo *rec, std::chrono::seconds secsleft, bool hasLater);
    RecStatus::Type StartRecording(ProgramInfo *rec);
    RecStatus::Type GetRecordingStatus(void);
    void StopRecording(bool killFile = false);
    void FinishRecording(void);
    void FrontendReady(void);
    void CancelNextRecording(bool cancel);
    bool WouldConflict(const ProgramInfo *rec);
 
    bool IsReallyRecording(void);
    ProgramInfo *GetRecording(void);
    float GetFramerate(void);
    long long GetFramesWritten(void);
    long long GetFilePosition(void);
    int64_t GetKeyframePosition(uint64_t desired);
    bool GetKeyframePositions(int64_t start, int64_t end, frm_pos_map_t &map);
    bool GetKeyframeDurations(int64_t start, int64_t end, frm_pos_map_t &map);
    void SpawnLiveTV(LiveTVChain *chain, bool pip, QString startchan);
    QString GetChainID(void);
    void StopLiveTV(void);
    void PauseRecorder(void);
    void SetLiveRecording(int recording);
    void SetNextLiveTVDir(const QString& dir);
    QString GetInput(void) const;
    QString SetInput(QString input);
    void ToggleChannelFavorite(const QString &changroup);
    void ChangeChannel(ChannelChangeDirection channeldirection);
    void SetChannel(const QString &name);
    int  GetPictureAttribute(PictureAttribute attr);
    int  ChangePictureAttribute(PictureAdjustType type,
                                PictureAttribute  attr,
                                bool              direction);
    bool CheckChannel(const QString &name);
    bool ShouldSwitchToAnotherInput(const QString &channelid);
    bool CheckChannelPrefix(const QString &prefix, uint &complete_valid_channel_on_rec,
                            bool &is_extra_char_useful, QString &needed_spacer);
    void 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);
    bool GetChannelInfo(uint &chanid, uint &sourceid,
                        QString &callsign, QString &channum,
                        QString &channame, QString &xmltv) const;
    bool SetChannelInfo(uint chanid, uint sourceid,
                        const QString& oldchannum,
                        const QString& callsign, const QString& channum,
                        const QString& channame, const QString& xmltv);
 
    bool AddChildInput(uint childid);
 
  private:
    bool HasSockAndIncrRef();
    bool HasSockAndDecrRef();
 
    int m_inputid;
 
    PlaybackSock *m_sock           {nullptr};
    QMutex m_sockLock;
    QString m_hostname;
 
    TVRec *m_tv                    {nullptr};
 
    bool m_local                   {false};
    bool m_locked                  {false};
 
    SleepStatus m_sleepStatus      {sStatus_Undefined};
    QDateTime m_sleepStatusTime;
    QDateTime m_lastSleepTime;
    QDateTime m_lastWakeTime;
 
    QDateTime m_endRecordingTime;
    QDateTime m_startRecordingTime;
    uint      m_chanid             {0};
};
 
#endif