doxygen/encoderlink_8h_source.html

#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 "libmythbase/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);

    void GetDiskSpace(QStringList &o_strlist);

    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