dvbchannel.h

Go to the documentation of this file.

// -*- Mode: c++ -*-
/*
 *  Copyright (C) Kenneth Aafloy 2003
 *
 *  Copyright notice is in dvbchannel.cpp of the MythTV project.
 */

#ifndef DVBCHANNEL_H
#define DVBCHANNEL_H

#include <QObject>
#include <QString>
#include <QMap>

#include "mythcontext.h"
#include "mythdbcon.h"
#include "dtvchannel.h"
#include "dtvconfparserhelpers.h" // for DTVTunerType
#include "streamlisteners.h"
#include "diseqc.h"

class TVRec;
class DVBCam;
class DVBRecorder;
class DVBChannel;

typedef QMap<const DVBChannel*,bool> IsOpenMap;

class DVBChannel : public DTVChannel
{
  public:
    DVBChannel(const QString &device, TVRec *parent = nullptr);
    ~DVBChannel();

    bool Open(void) override // ChannelBase
        { return Open(this); }
    void Close(void) override // ChannelBase
        { Close(this); }

    bool Init(QString &startchannel, bool setchan) override; // ChannelBase

    // Sets
    void SetPMT(const ProgramMapTable*);
    void SetTimeOffset(double offset);
    void SetSlowTuning(uint how_slow_in_ms)
        { m_tuning_delay = how_slow_in_ms; }

    // Gets
    bool IsOpen(void) const override; // ChannelBase
    int  GetFd(void) const  override // ChannelBase
        { return m_fd_frontend; }
    bool IsTuningParamsProbeSupported(void) const;

    QString GetDevice(void) const override // ChannelBase
        { return m_device; }
    QString GetCardNum(void)            const { return m_device; };
    QString GetFrontendName(void)       const { return m_frontend_name; }
    bool IsMaster(void)                 const override; // DTVChannel
    bool HasCRCBug(void)                const { return m_has_crc_bug; }
    uint GetMinSignalMonitorDelay(void) const { return m_sigmon_delay; }
    const DiSEqCDevRotor *GetRotor(void) const;

    bool HasLock(bool *ok = nullptr) const;
    double GetSignalStrength(bool *ok = nullptr) const;
    double GetSNR(bool *ok = nullptr) const;
    double GetBitErrorRate(bool *ok = nullptr) const;
    double GetUncorrectedBlockCount(bool *ok = nullptr) const;

    // Commands
    bool SwitchToInput(int newcapchannel, bool setstarting);
    using DTVChannel::Tune;
    bool Tune(const DTVMultiplex &tuning) override; // DTVChannel
    bool Tune(const DTVMultiplex &tuning,
              bool force_reset = false, bool same_input = false);
    bool Retune(void) override; // ChannelBase

    bool ProbeTuningParams(DTVMultiplex &tuning) const;

  private:
    bool Open(DVBChannel*);
    void Close(DVBChannel*);

    int  GetChanID(void) const override; // ChannelBase

    void CheckOptions(DTVMultiplex &t) const override; // DTVChannel
    void CheckFrequency(uint64_t frequency) const;
    bool CheckModulation(DTVModulation modulation) const;
    bool CheckCodeRate(DTVCodeRate rate) const;

    typedef DVBChannel* DVBChannelP;
    DVBChannel *GetMasterLock(void);
    static void ReturnMasterLock(DVBChannelP &dvbm);

    typedef const DVBChannel* DVBChannelCP;
    const DVBChannel *GetMasterLock(void) const;
    static void ReturnMasterLock(DVBChannelCP &dvbm);

    double GetSignalStrengthDVBv5(bool *ok) const;
    double GetSNRDVBv5(bool *ok) const;
    double GetBitErrorRateDVBv5(bool *ok) const;
    double GetUncorrectedBlockCountDVBv5(bool *ok) const;

  private:
    IsOpenMap         m_is_open;

    // Data
    DiSEqCDev         m_diseqc_dev;
    DiSEqCDevSettings m_diseqc_settings;
    DiSEqCDevTree    *m_diseqc_tree         {nullptr};
    DVBCam           *m_dvbcam              {nullptr};

    // Device info
    QString           m_frontend_name;
    uint64_t          m_capabilities        {0};
    uint64_t          m_ext_modulations     {0};
    uint64_t          m_frequency_minimum   {0};
    uint64_t          m_frequency_maximum   {0};
    uint              m_symbol_rate_minimum {0};
    uint              m_symbol_rate_maximum {0};

    // Tuning State
    mutable QMutex    m_tune_lock;
    mutable QMutex    m_hw_lock             {QMutex::Recursive};
    DTVMultiplex      m_desired_tuning;
    DTVMultiplex      m_prev_tuning;

    uint              m_last_lnb_dev_id     {(uint)~0x0};

    uint              m_tuning_delay        {0};
    uint              m_sigmon_delay        {25};
    bool              m_first_tune          {true};

    // Other State
    int               m_fd_frontend         {-1};
    QString           m_device;      
    bool              m_has_crc_bug         {false};

    static QDateTime  s_last_tuning;
    QMutex            m_tune_delay_lock;
};

#endif