playercontext.h

Go to the documentation of this file.

#ifndef PLAYER_CONTEXT_H
#define PLAYER_CONTEXT_H
 
#include <vector>
#include <deque>
 
// Qt headers
#include <QWidget>
#include <QString>
#if QT_VERSION < QT_VERSION_CHECK(5,14,0)
#include <QMutex>
#else
#include <QRecursiveMutex>
#endif
#include <QHash>
#include <QRect>
#include <QObject>
#include <QDateTime>
 
// MythTV headers
#include "libmythbase/mythdate.h"
#include "libmythbase/mythdeque.h"
#include "libmythbase/mythtimer.h"
#include "libmythbase/mythtypes.h"
#include "libmythtv/mythtvexp.h"
#include "libmythtv/tv.h"
#include "libmythtv/videoouttypes.h"
 
class TV;
class RemoteEncoder;
class MythPlayer;
class MythMediaBuffer;
class ProgramInfo;
class LiveTVChain;
class QPainter;
class MythMainWindow;
 
struct osdInfo
{
    InfoMap             text;
    QHash<QString,int>  values;
};
 
enum PseudoState
{
    kPseudoNormalLiveTV  = 0,
    kPseudoChangeChannel = 1,
    kPseudoRecording     = 2,
};
 
using StringDeque = std::deque<QString>;
 
class MTV_PUBLIC PlayerContext
{
  public:
    explicit PlayerContext(QString inUseID = QString("Unknown"));
    ~PlayerContext();
 
    // Actions
    void TeardownPlayer(void);
    void StopPlaying(void) const;
    void UpdateTVChain(const QStringList &data = QStringList());
    bool ReloadTVChain(void);
    void    PushPreviousChannel(void);
    QString PopPreviousChannel(void);
 
    void ChangeState(TVState newState);
    void ForceNextStateNone(void);
    TVState DequeueNextState(void);
 
    bool HandlePlayerSpeedChangeFFRew(void);
    bool HandlePlayerSpeedChangeEOF(void);
 
    // Locking
    void LockState(void) const;
    void UnlockState(void) const;
 
    void LockPlayingInfo(const char *file, int line) const;
    void UnlockPlayingInfo(const char *file, int line) const;
 
    void LockDeletePlayer(const char *file, int line) const;
    void UnlockDeletePlayer(const char *file, int line) const;
 
    // Sets
    void SetInitialTVState(bool islivetv);
    void SetPlayer(MythPlayer *newplayer);
    void SetRecorder(RemoteEncoder *rec);
    void SetTVChain(LiveTVChain *chain);
    void SetRingBuffer(MythMediaBuffer *Buffer);
    void SetPlayingInfo(const ProgramInfo *info);
    void SetPlayGroup(const QString &group);
    void SetPseudoLiveTV(const ProgramInfo *pi, PseudoState new_state);
    void SetPlayerChangingBuffers(bool val) { m_playerUnsafe = val; }
 
    // Gets
    QString  GetPreviousChannel(void) const;
    uint     GetCardID(void) const { return m_lastCardid; }
    QString  GetFilters(const QString &baseFilters) const;
    QString  GetPlayMessage(void) const;
    TVState  GetState(void) const;
    bool     GetPlayingInfoMap(InfoMap &infoMap) const;
 
    // Boolean Gets
    bool IsPlayerChangingBuffers(void) const { return m_playerUnsafe; }
    bool HasPlayer(void) const;
    bool IsPlayerErrored(void) const;
    bool IsPlayerPlaying(void) const;
    bool IsRecorderErrored(void) const;
    bool InStateChange(void) const;
    bool IsErrored(void) const { return m_errored; }
    bool IsSameProgram(const ProgramInfo &p) const;
 
  public:
    QString             m_recUsage;
    MythPlayer         *m_player             {nullptr};
    volatile bool       m_playerUnsafe       {false};
    RemoteEncoder      *m_recorder           {nullptr};
    LiveTVChain        *m_tvchain            {nullptr};
    MythMediaBuffer    *m_buffer             {nullptr};
    ProgramInfo        *m_playingInfo        {nullptr}; 
    std::chrono::seconds m_playingLen        {0s};  
    QDateTime           m_playingRecStart;
    int                 m_lastCardid         {-1}; 
    int                 m_ffRewState         {0};
    int                 m_ffRewIndex         {0};
    int                 m_ffRewSpeed         {0};
    TVState             m_playingState       {kState_None};
 
    bool                m_errored            {false};
 
    // Previous channel functionality state variables
    StringDeque         m_prevChan; 
 
    // Recording to play next, after LiveTV
    ProgramInfo        *m_pseudoLiveTVRec    {nullptr};
    PseudoState         m_pseudoLiveTVState  {kPseudoNormalLiveTV};
 
    std::chrono::seconds  m_fftime           {0s};
    std::chrono::seconds  m_rewtime          {0s};
    std::chrono::minutes  m_jumptime         {0min};
    float               m_tsNormal           {1.0F};
    float               m_tsAlt              {1.5F};
 
#if QT_VERSION < QT_VERSION_CHECK(5,14,0)
    mutable QMutex      m_playingInfoLock    {QMutex::Recursive};
    mutable QMutex      m_deletePlayerLock   {QMutex::Recursive};
    mutable QMutex      m_stateLock          {QMutex::Recursive};
#else
    mutable QRecursiveMutex  m_playingInfoLock;
    mutable QRecursiveMutex  m_deletePlayerLock;
    mutable QRecursiveMutex  m_stateLock;
#endif
 
    // Signal info
    mutable QStringList m_lastSignalMsg;
    mutable MythTimer   m_lastSignalMsgTime;
    mutable InfoMap     m_lastSignalUIInfo;
    mutable MythTimer   m_lastSignalUIInfoTime;
 
    // tv state related
    MythDeque<TVState>  m_nextState;
 
    static constexpr std::chrono::milliseconds kSMExitTimeout { 2s };
    static constexpr uint kMaxChannelHistory { 30 };
};
 
#endif // PLAYER_CONTEXT_H