Ticket #9726: 0006-libmythtv-Unicable-SCR-DIN-EN-50494.patch

mythtv/libs/libmythtv/diseqc.cpp

@@ -68 +68 @@
 #define DISEQC_CMD_WRITE_N0   0x38
 #define DISEQC_CMD_WRITE_N1   0x39
 #define DISEQC_CMD_WRITE_FREQ 0x58
+#define DISEQC_CMD_ODU        0x5A
+#define DISEQC_CMD_ODU_MDU    0x5C
 #define DISEQC_CMD_HALT       0x60
 #define DISEQC_CMD_LMT_OFF    0x63
 #define DISEQC_CMD_LMT_E      0x66
@@ -563 +565 @@
     return lnb;
 }
 
+/** \fn DiSEqCDevTree::FindSCR(const DiSEqCDevSettings&)
+ *  \brief Returns the SCR device object selected by the configuration chain.
+ *  \param settings Configuration chain in effect.
+ *  \return Pointer to SCR object if found, NULL otherwise.
+ */
+DiSEqCDevSCR *DiSEqCDevTree::FindSCR(const DiSEqCDevSettings &settings)
+{
+    DiSEqCDevDevice *node = m_root;
+    DiSEqCDevSCR    *scr  = NULL;
+
+    while (node)
+    {
+        scr = dynamic_cast<DiSEqCDevSCR*>(node);
+
+        if (scr)
+            break;
+
+        node = node->GetSelectedChild(settings);
+    }
+
+    return scr;
+}
+
 
 /** \fn DiSEqCDevTree::FindDevice(uint)
  *  \brief Returns a device by ID.
@@ -784 +809 @@
  *  \brief Represents a node in a DVB-S device network.
  */
 
-const DiSEqCDevDevice::TypeTable DiSEqCDevDevice::dvbdev_lookup[4] =
+const DiSEqCDevDevice::TypeTable DiSEqCDevDevice::dvbdev_lookup[5] =
 {
     { "switch",      kTypeSwitch },
     { "rotor",       kTypeRotor  },
+    { "scr",         kTypeSCR    },
     { "lnb",         kTypeLNB    },
     { QString::null, kTypeLNB    },
 };
@@ -891 +917 @@
             if (node)
                 node->SetDescription("Rotor");
             break;
+        case kTypeSCR:
+            node = new DiSEqCDevSCR(tree, dev_id);
+            if (node)
+                node->SetDescription("Unicable");
+                break;
         case kTypeLNB:
             node = new DiSEqCDevLNB(tree, dev_id);
             if (node)
@@ -2052 +2083 @@
 }
 
 ////////////////////////////////////////
+
+/** \class DiSEqCDevSCR
+ *  \brief Unicable / SCR Class.
+ */
+
+const DiSEqCDevDevice::TypeTable DiSEqCDevSCR::SCRPositionTable[3] =
+{
+    { "A",            kTypeScrPosA },
+    { "B",            kTypeScrPosB },
+    { QString::null,  kTypeScrPosA },
+};
+
+DiSEqCDevSCR::DiSEqCDevSCR(DiSEqCDevTree &tree, uint devid)
+    : DiSEqCDevDevice(tree, devid)
+    , m_scr_userband(0)
+    , m_scr_frequency(1400)
+    , m_scr_pin(-1)
+    , m_child(0)
+{
+    Reset();
+}
+
+DiSEqCDevSCR::~DiSEqCDevSCR()
+{
+    if (m_child)
+        delete m_child;
+}
+
+void DiSEqCDevSCR::Reset(void)
+{
+    if (m_child)
+        m_child->Reset();
+}
+
+bool DiSEqCDevSCR::Execute(const DiSEqCDevSettings &settings, const DTVMultiplex &tuning)
+{
+    // retrieve LNB info
+    DiSEqCDevLNB *lnb = m_tree.FindLNB(settings);
+    if (!lnb)
+    {
+        LOG(VB_GENERAL, LOG_ERR, LOC + "SCR: No LNB for this configuration!");
+        return false;
+    }
+
+    bool     high_band  = lnb->IsHighBand(tuning);
+    bool     horizontal = lnb->IsHorizontal(tuning);
+    uint32_t frequency  = lnb->GetIntermediateFrequency(settings, tuning);
+    uint t = (frequency / 1000 + m_scr_frequency + 2) / 4 - 350;
+
+    // retrieve position settings
+    dvbdev_pos_t scr_position = (dvbdev_pos_t) settings.GetValue(GetDeviceID());
+
+    // check parameters
+    if (m_scr_userband > 8)
+    {
+        LOG(VB_GENERAL, LOG_INFO, QString("SCR: Userband ID=%1 is out of standard range!")
+        .arg(m_scr_userband));
+    }
+
+    if (t >= 1024)
+    {
+        LOG(VB_GENERAL, LOG_ERR, LOC + "SCR: T out of range!");
+        return false;
+    }
+
+    LOG(VB_GENERAL, LOG_INFO, QString("SCR: Tuning to %1kHz, %2, %3 using UB=%4, FREQ=%5MHz, POS=%6%7")
+            .arg(tuning.frequency)
+            .arg(high_band ? "HiBand" : "LoBand")
+            .arg(horizontal ? "H" : "V")
+            .arg(m_scr_userband)
+            .arg(m_scr_frequency)
+            .arg((scr_position) ? "B" : "A")
+            .arg((m_scr_pin >= 0 && m_scr_pin <= 255) ?
+                     QString(", PIN=%1").arg(m_scr_pin) : QString("")));
+
+    // build command
+    unsigned char data[3];
+    data[0] = t >> 8 | m_scr_userband << 5;
+    data[1] = t & 0x00FF;
+
+    if (high_band)
+        data[0] |= (1 << 2);
+
+    if (horizontal)
+        data[0] |= (1 << 3);
+
+    if (scr_position)
+        data[0] |= (1 << 4);
+
+    // send command
+    if (m_scr_pin >= 0 && m_scr_pin <= 255)
+    {
+        data[2] = m_scr_pin;
+        return SendCommand(DISEQC_CMD_ODU_MDU, m_repeat, 3, data);
+    } else {
+        return SendCommand(DISEQC_CMD_ODU, m_repeat, 2, data);
+    }
+}
+
+bool DiSEqCDevSCR::PowerOff(void) const
+{
+    // check parameters
+    if (m_scr_userband > 8)
+    {
+        LOG(VB_GENERAL, LOG_INFO, QString("SCR: Userband ID=%1 is out of standard range!")
+        .arg(m_scr_userband));
+    }
+
+    LOG(VB_CHANNEL, LOG_INFO, LOC + QString("SCR: Power off UB=%1%7")
+            .arg(m_scr_userband)
+            .arg((m_scr_pin >= 0 && m_scr_pin <= 255)
+                 ? QString(", PIN=%1").arg(m_scr_pin)
+                 : QString("")));
+
+    // build command
+    unsigned char data[3];
+    data[0] = (uint8_t) (m_scr_userband << 5);
+    data[1] = 0x00;
+
+    // send command
+    if (m_scr_pin >= 0 && m_scr_pin <= 255)
+    {
+        data[2] = m_scr_pin;
+        return SendCommand(DISEQC_CMD_ODU_MDU, m_repeat, 3, data);
+    } else {
+        return SendCommand(DISEQC_CMD_ODU, m_repeat, 2, data);
+    }
+}
+
+bool DiSEqCDevSCR::SendCommand(uint cmd, uint repeats, uint data_len,
+                               unsigned char *data) const
+{
+    (void) repeats;
+
+    // power on bus
+    if (!m_tree.SetVoltage(SEC_VOLTAGE_18))
+        return false;
+    usleep(DISEQC_LONG_WAIT);
+
+    // send command
+    bool ret = m_tree.SendCommand(DISEQC_ADR_SW_ALL, cmd, repeats, data_len, data);
+
+    // power off bus
+    if (!m_tree.SetVoltage(SEC_VOLTAGE_13))
+        return false;
+
+    return ret;
+}
+
+uint DiSEqCDevSCR::GetVoltage(const DiSEqCDevSettings &settings,
+                              const DTVMultiplex      &tuning) const
+{
+    return SEC_VOLTAGE_13;
+}
+
+uint32_t DiSEqCDevSCR::GetIntermediateFrequency(const uint32_t frequency) const
+{
+    uint t = (frequency / 1000 + m_scr_frequency + 2) / 4 - 350;
+    return ((t + 350) * 4) * 1000 - frequency;
+}
+
+bool DiSEqCDevSCR::Load(void)
+{
+    // populate scr parameters from db
+    MSqlQuery query(MSqlQuery::InitCon());
+    query.prepare(
+        "SELECT scr_userband,    scr_frequency, "
+        "       scr_pin,         cmd_repeat "
+        "FROM diseqc_tree "
+        "WHERE diseqcid = :DEVID");
+    query.bindValue(":DEVID", GetDeviceID());
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("DiSEqCDevSCR::Load 1", query);
+        return false;
+    }
+    else if (query.next())
+    {
+        m_scr_userband  = query.value(0).toUInt();
+        m_scr_frequency = query.value(1).toUInt();
+        m_scr_pin       = query.value(2).toInt();
+        m_repeat        = query.value(3).toUInt();
+    }
+
+    // load children from db
+    if (m_child)
+    {
+        delete m_child;
+        m_child = NULL;
+    }
+
+    query.prepare(
+        "SELECT diseqcid "
+        "FROM diseqc_tree "
+        "WHERE parentid = :DEVID");
+    query.bindValue(":DEVID", GetDeviceID());
+
+    if (!query.exec() || !query.isActive())
+    {
+        MythDB::DBError("DiSEqCDevSCR::Load 2", query);
+        return false;
+    }
+    else if (query.next())
+    {
+        uint child_dev_id = query.value(0).toUInt();
+        SetChild(0, CreateById(m_tree, child_dev_id));
+    }
+
+    return true;
+}
+
+bool DiSEqCDevSCR::Store(void) const
+{
+    MSqlQuery query(MSqlQuery::InitCon());
+
+    // insert new or update old
+    if (IsRealDeviceID())
+    {
+        query.prepare(
+            "UPDATE diseqc_tree "
+            "SET parentid        = :PARENT,  "
+            "    ordinal         = :ORDINAL, "
+            "    type            = 'scr',    "
+            "    description     = :DESC,    "
+            "    scr_userband    = :USERBAND, "
+            "    scr_frequency   = :FREQUENCY, "
+            "    scr_pin         = :PIN, "
+            "    cmd_repeat      = :REPEAT   "
+            "WHERE diseqcid = :DEVID");
+        query.bindValue(":DEVID",   GetDeviceID());
+    }
+    else
+    {
+        query.prepare(
+            "INSERT INTO diseqc_tree"
+            " ( parentid,      ordinal,         type, "
+            "   description,   scr_userband,    scr_frequency, "
+            "   scr_pin,       cmd_repeat) "
+            "VALUES "
+            " (:PARENT,       :ORDINAL,         'scr', "
+            "  :DESC,         :USERBAND,        :FREQUENCY,"
+            "  :PIN,          :REPEAT) ");
+    }
+
+    if (m_parent)
+        query.bindValue(":PARENT", m_parent->GetDeviceID());
+
+    query.bindValue(":ORDINAL",   m_ordinal);
+    query.bindValue(":DESC",      GetDescription());
+    query.bindValue(":USERBAND",  m_scr_userband);
+    query.bindValue(":FREQUENCY", m_scr_frequency);
+    query.bindValue(":PIN",       m_scr_pin);
+    query.bindValue(":REPEAT",    m_repeat);
+
+    // update dev_id
+    if (!query.exec())
+    {
+        MythDB::DBError("DiSEqCDevSCR::Store", query);
+        return false;
+    }
+
+    // figure out devid if we did an insert
+    if (!IsRealDeviceID())
+        SetDeviceID(query.lastInsertId().toUInt());
+
+    // chain to child
+    if (m_child)
+        return m_child->Store();
+
+    return true;
+}
+
+bool DiSEqCDevSCR::SetChild(uint ordinal, DiSEqCDevDevice *device)
+{
+    if (ordinal)
+        return false;
+
+    DiSEqCDevDevice *old_child = m_child;
+    m_child = NULL;
+    if (old_child)
+        delete old_child;
+
+    m_child = device;
+    if (m_child)
+    {
+        m_child->SetOrdinal(ordinal);
+        m_child->SetParent(this);
+    }
+
+    return true;
+}
+
+////////////////////////////////////////
 
 /** \class DiSEqCDevLNB
  *  \brief LNB Class.

mythtv/libs/libmythtv/diseqc.h

@@ -27 +27 @@
 class DiSEqCDevDevice;
 class DiSEqCDevRotor;
 class DiSEqCDevLNB;
+class DiSEqCDevSCR;
 
 typedef QMap<uint, double>         uint_to_dbl_t;
 typedef QMap<double, uint>         dbl_to_uint_t;
@@ -85 +86 @@
 
     DiSEqCDevRotor  *FindRotor(const DiSEqCDevSettings &settings, uint index = 0);
     DiSEqCDevLNB    *FindLNB(const DiSEqCDevSettings &settings);
+    DiSEqCDevSCR    *FindSCR(const DiSEqCDevSettings &settings);
     DiSEqCDevDevice *FindDevice(uint dev_id);
 
     /** \brief Retrieves the root node in the tree. */
@@ -142 +144 @@
     virtual bool Store(void) const = 0;
 
     // Sets
-    enum dvbdev_t { kTypeSwitch = 0, kTypeRotor = 1, kTypeLNB = 2, };
+    enum dvbdev_t
+    {
+        kTypeSwitch = 0,
+        kTypeRotor = 1,
+        kTypeSCR = 2,
+        kTypeLNB = 3,
+    };
     void SetDeviceType(dvbdev_t type)        { m_dev_type = type;    }
     void SetParent(DiSEqCDevDevice* parent)  { m_parent   = parent;  }
     void SetOrdinal(uint ordinal)            { m_ordinal  = ordinal; }
@@ -201 +209 @@
                                    const TypeTable *table);
 
   private:
-    static const TypeTable dvbdev_lookup[4];
+    static const TypeTable dvbdev_lookup[5];
 };
 
 class DiSEqCDevSwitch : public DiSEqCDevDevice
@@ -359 +367 @@
     static const TypeTable RotorTypeTable[3];
 };
 
+class DiSEqCDevSCR : public DiSEqCDevDevice
+{
+  public:
+    DiSEqCDevSCR(DiSEqCDevTree &tree, uint devid);
+    ~DiSEqCDevSCR();
+
+    // Commands
+    virtual void Reset(void);
+    virtual bool Execute(const DiSEqCDevSettings&, const DTVMultiplex&);
+    bool         PowerOff(void) const;
+    virtual bool Load(void);
+    virtual bool Store(void) const;
+
+    // Sets
+    enum dvbdev_pos_t
+    {
+        kTypeScrPosA               = 0,
+        kTypeScrPosB               = 1,
+    };
+    void SetUserBand(uint userband)        { m_scr_userband  = userband;   }
+    void SetFrequency(uint freq)           { m_scr_frequency = freq;       }
+    void SetPIN(int pin)                   { m_scr_pin       = pin;        }
+    virtual bool SetChild(uint ordinal, DiSEqCDevDevice* device);
+
+    // Gets
+    uint         GetUserBand(void) const   { return m_scr_userband;        }
+    uint         GetFrequency(void) const  { return m_scr_frequency;       }
+    int          GetPIN(void) const        { return m_scr_pin;             }
+    virtual uint GetChildCount(void) const { return 1;                     }
+    virtual bool IsCommandNeeded(const DiSEqCDevSettings&,
+                                 const DTVMultiplex&) const { return false; }
+    virtual uint GetVoltage(const DiSEqCDevSettings&,
+                            const DTVMultiplex&) const;
+    uint32_t     GetIntermediateFrequency(const uint32_t frequency) const;
+
+    // Non-const Gets
+    virtual DiSEqCDevDevice *GetSelectedChild(const DiSEqCDevSettings&) const
+                                            { return m_child;              }
+    virtual DiSEqCDevDevice *GetChild(uint) { return m_child;              }
+
+    // statics
+    static QString SCRPositionToString(dvbdev_pos_t pos)
+        { return TableToString((uint)pos, SCRPositionTable); }
+
+    static dvbdev_pos_t SCRPositionFromString(const QString &pos)
+        { return (dvbdev_pos_t) TableFromString(pos, SCRPositionTable); }
+
+  protected:
+    bool         SendCommand(uint cmd, uint repeats, uint data_len = 0,
+                             unsigned char *data = NULL) const;
+
+  private:
+    uint         m_scr_userband;  /* 0-7 */
+    uint         m_scr_frequency;
+    int          m_scr_pin;       /* 0-255, -1=disabled */
+
+    DiSEqCDevDevice *m_child;
+
+    static const TypeTable SCRPositionTable[3];
+};
+
 class DiSEqCDevLNB : public DiSEqCDevDevice
 {
   public:

mythtv/libs/libmythtv/diseqcsettings.cpp

@@ -49 +49 @@
                      QString::number((uint) DiSEqCDevDevice::kTypeSwitch));
         addSelection(DeviceTree::tr("Rotor"),
                      QString::number((uint) DiSEqCDevDevice::kTypeRotor));
+        addSelection(DeviceTree::tr("Unicable"),
+                     QString::number((uint) DiSEqCDevDevice::kTypeSCR));
         addSelection(DeviceTree::tr("LNB"),
                      QString::number((uint) DiSEqCDevDevice::kTypeLNB));
     }
@@ -558 +560 @@
     config.Save();
 }
 
+//////////////////////////////////////// SCRUserBandSetting
+
+class SCRUserBandSetting : public SpinBoxSetting, public Storage
+{
+  public:
+    SCRUserBandSetting(DiSEqCDevSCR &scr) :
+        SpinBoxSetting(this, 0, 8, 1), m_scr(scr)
+    {
+        setLabel(DeviceTree::tr("Userband"));
+        setHelpText(DeviceTree::tr("Unicable userband ID (0-7) or sometimes (1-8)"));
+    }
+
+    virtual void Load(void)
+    {
+        setValue(m_scr.GetUserBand());
+    }
+
+    virtual void Save(void)
+    {
+        m_scr.SetUserBand(intValue());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
+//////////////////////////////////////// SCRFrequencySetting
+
+class SCRFrequencySetting : public LineEditSetting, public Storage
+{
+  public:
+    SCRFrequencySetting(DiSEqCDevSCR &scr) : LineEditSetting(this), m_scr(scr)
+    {
+        setLabel(DeviceTree::tr("Frequency (MHz)"));
+        setHelpText(DeviceTree::tr("Unicable userband frequency (usually 1210, 1420, 1680 and 2040 MHz)"));
+    }
+
+    virtual void Load(void)
+    {
+        setValue(QString::number(m_scr.GetFrequency()));
+    }
+
+    virtual void Save(void)
+    {
+        m_scr.SetFrequency(getValue().toUInt());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
+//////////////////////////////////////// SCRPINSetting
+
+class SCRPINSetting : public LineEditSetting, public Storage
+{
+  public:
+    SCRPINSetting(DiSEqCDevSCR &scr) : LineEditSetting(this), m_scr(scr)
+    {
+        setLabel(DeviceTree::tr("PIN code"));
+        setHelpText(DeviceTree::tr("Unicable PIN code (-1 disabled, 0 - 255)"));
+    }
+
+    virtual void Load(void)
+    {
+        setValue(QString::number(m_scr.GetPIN()));
+    }
+
+    virtual void Save(void)
+    {
+        m_scr.SetPIN(getValue().toInt());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
+//////////////////////////////////////// SCRConfig
+
+SCRConfig::SCRConfig(DiSEqCDevSCR &scr) : m_scr(scr)
+{
+    ConfigurationGroup *group =
+        new VerticalConfigurationGroup(false, false);
+    group->setLabel(DeviceTree::tr("Unicable Configuration"));
+
+    group->addChild(new SCRUserBandSetting(scr));
+    group->addChild(new SCRFrequencySetting(scr));
+    group->addChild(new SCRPINSetting(scr));
+    group->addChild(new DeviceRepeatSetting(scr));
+
+    addChild(group);
+}
+
 //////////////////////////////////////// LnbPresetSetting
 
 class lnb_preset
@@ -948 +1048 @@
         }
         break;
 
+        case DiSEqCDevDevice::kTypeSCR:
+        {
+            DiSEqCDevSCR *scr = dynamic_cast<DiSEqCDevSCR*>(dev);
+            if (scr)
+            {
+                SCRConfig config(*scr);
+                changed = (config.exec() == MythDialog::Accepted);
+            }
+        }
+        break;
+
         case DiSEqCDevDevice::kTypeLNB:
         {
             DiSEqCDevLNB *lnb = dynamic_cast<DiSEqCDevLNB*>(dev);
@@ -977 +1088 @@
     MythListBox *list = new MythListBox(popup);
     list->insertItem(tr("Switch"));
     list->insertItem(tr("Rotor"));
+    list->insertItem(tr("Unicable"));
     list->insertItem(tr("LNB"));
     list->setCurrentRow(0, QItemSelectionModel::Select);
 
@@ -1263 +1375 @@
     DiSEqCDevSettings    &m_settings;
 };
 
+//////////////////////////////////////// SCRPositionSetting
+
+class SCRPositionSetting : public ComboBoxSetting, public Storage
+{
+  public:
+    SCRPositionSetting(DiSEqCDevDevice &node, DiSEqCDevSettings &settings)
+        : ComboBoxSetting(this), m_node(node), m_settings(settings)
+    {
+        setLabel("Position");
+        setHelpText(DeviceTree::tr("Unicable satellite position (A/B)"));
+        addSelection(DiSEqCDevSCR::SCRPositionToString(DiSEqCDevSCR::kTypeScrPosA),
+                     QString::number((uint)DiSEqCDevSCR::kTypeScrPosA), true);
+        addSelection(DiSEqCDevSCR::SCRPositionToString(DiSEqCDevSCR::kTypeScrPosB),
+                     QString::number((uint)DiSEqCDevSCR::kTypeScrPosB), false);
+    }
+
+    virtual void Load(void)
+    {
+        double value = m_settings.GetValue(m_node.GetDeviceID());
+        setValue(getValueIndex(QString::number((uint)value)));
+    }
+
+    virtual void Save(void)
+    {
+        m_settings.SetValue(m_node.GetDeviceID(), getValue().toDouble());
+    }
+
+    virtual void Save(QString /*destination*/) { }
+
+  private:
+    DiSEqCDevDevice      &m_node;
+    DiSEqCDevSettings    &m_settings;
+};
+
 //////////////////////////////////////// DTVDeviceConfigGroup
 
 DTVDeviceConfigGroup::DTVDeviceConfigGroup(
@@ -1305 +1451 @@
                 setting = new USALSRotorSetting(*node, m_settings);
             break;
         }
+        case DiSEqCDevDevice::kTypeSCR:
+        {
+            setting = new SCRPositionSetting(*node, m_settings);
+            break;
+        }
         default:
             break;
     }
@@ -1379 +1530 @@
     DISEQC_POSITIONER_X_SWITCH_2   = 9,
     DISEQC_SW21                    = 10,
     DISEQC_SW64                    = 11,
+    DISEQC_SCR                     = 12,
 };
 
 // import old diseqc configuration into tree
@@ -1548 +1700 @@
                 break;
             }
 
+            case DISEQC_SCR:
+            {
+                // SCR + LNB
+                root = DiSEqCDevDevice::CreateByType(
+                    tree, DiSEqCDevDevice::kTypeSCR);
+                DiSEqCDevSCR *scr = dynamic_cast<DiSEqCDevSCR*>(root);
+                if (scr)
+                {
+                    add_lnbs = 1;
+                }
+                break;
+            }
+
             default:
             {
                 LOG(VB_GENERAL, LOG_ERR, "Unknown DiSEqC device type " +
@@ -1614 +1779 @@
 
                 case DISEQC_POSITIONER_1_2:
                 case DISEQC_POSITIONER_X:
+                case DISEQC_SCR:
                     lnb = dynamic_cast<DiSEqCDevLNB*>(root->GetChild(0));
                     set.SetValue(root->GetDeviceID(), pos);
                     break;

mythtv/libs/libmythtv/diseqcsettings.h

@@ -73 +73 @@
     TransButtonSetting *m_pos;
 };
 
+class SCRConfig : public QObject, public ConfigurationWizard
+{
+    Q_OBJECT
+
+  public:
+    SCRConfig(DiSEqCDevSCR &scr);
+
+  private:
+    DiSEqCDevSCR &m_scr;
+};
+
 class LNBTypeSetting;
 class LNBLOFSwitchSetting;
 class LNBLOFLowSetting;

mythtv/libs/libmythtv/dvbchannel.cpp

@@ -712 +712 @@
         intermediate_freq = lnb->GetIntermediateFrequency(
             diseqc_settings, tuning);
 
+        // retrieve scr intermediate frequency
+        DiSEqCDevSCR *scr = diseqc_tree->FindSCR(diseqc_settings);
+        if (lnb && scr)
+        {
+            intermediate_freq = scr->GetIntermediateFrequency(intermediate_freq);
+        }
+
         // if card can auto-FEC, use it -- sometimes NITs are inaccurate
         if (capabilities & FE_CAN_FEC_AUTO)
             can_fec_auto = true;