Ticket #13339: hdhr-locking-pooling-4.patch

mythtv/libs/libmythtv/cardutil.cpp

@@ -540 +540 @@
                                  .arg((result_list[i].ip_addr>> 8) & 0xFF)
                                  .arg((result_list[i].ip_addr>> 0) & 0xFF);
 
-            for (int tuner = 0; tuner < result_list[i].tuner_count; tuner++)
+            QString hwmodel = "";
+            hdhomerun_device_t *device = hdhomerun_device_create(
+                result_list[i].device_id, 0, 0, nullptr);
+            if (device)
             {
-                QString hdhrdev = id.toUpper() + " " + ip + " " +
-                                  QString("%1").arg(tuner);
-                devs.push_back(hdhrdev);
+                hwmodel = hdhomerun_device_get_hw_model_str(device);
+                hdhomerun_device_destroy(device);
             }
+
+            QString hdhrdev = id.toUpper() + " " + ip + " " + hwmodel;
+            devs.push_back(hdhrdev);
         }
     }
 #endif // USING_HDHOMERUN
@@ -1396 +1401 @@
 {
     QString name = host + '|' + device;
     if (type == "FREEBOX" || type == "IMPORT" ||
-        type == "DEMO"    || type == "EXTERNAL")
+        type == "DEMO"    || type == "EXTERNAL" ||
+        type == "HDHOMERUN")
         name += QString("|%1").arg(inputid);
     return CreateInputGroup(name);
 }

mythtv/libs/libmythtv/recorders/channelbase.cpp

@@ -805 +805 @@
     {
         if (channel &&
             ((genOpt.inputtype == "DVB" && dvbOpt.dvb_on_demand) ||
+             genOpt.inputtype == "HDHOMERUN" ||
              CardUtil::IsV4L(genOpt.inputtype)))
         {
             channel->Close();
@@ -835 +836 @@
 
     return !m_externalChanger.isEmpty();
 }
+
+int ChannelBase::GetMajorID(void)
+{
+    return m_pParent ? m_pParent->GetMajorId() : m_inputid;
+}

mythtv/libs/libmythtv/recorders/channelbase.h

@@ -100 +100 @@
     // \brief Set inputid for scanning
     void SetInputID(uint _inputid) { m_inputid = _inputid; }
 
+    // \brief Get major input ID
+    int GetMajorID(void);
+
     static ChannelBase *CreateChannel(
         TVRec                    *tv_rec,
         const GeneralDBOptions   &genOpt,

mythtv/libs/libmythtv/recorders/hdhrchannel.cpp

@@ -59 +59 @@
     if (IsOpen())
         return true;
 
-    _stream_handler = HDHRStreamHandler::Get(_device_id, GetInputID());
+    _stream_handler = HDHRStreamHandler::Get(GetDevice(), GetInputID(),
+                                             GetMajorID());
 
     _tuner_types = _stream_handler->GetTunerTypes();
     tunerType = (_tuner_types.empty()) ?
@@ -86 +87 @@
 
 bool HDHRChannel::EnterPowerSavingMode(void)
 {
-    if (IsOpen())
-        return _stream_handler->EnterPowerSavingMode();
-    else
-        return true;
+    Close();
+    return true;
 }
 
 bool HDHRChannel::IsOpen(void) const

mythtv/libs/libmythtv/recorders/hdhrrecorder.cpp

@@ -36 +36 @@
     ResetForNewFile();
 
     _stream_handler = HDHRStreamHandler::Get(_channel->GetDevice(),
-                                     (tvrec ? tvrec->GetInputId() : -1));
+                                             _channel->GetInputID(),
+                                             _channel->GetMajorID());
 
     LOG(VB_RECORD, LOG_INFO, LOC + "HDHR opened successfully");
 

mythtv/libs/libmythtv/recorders/hdhrsignalmonitor.cpp

@@ -51 +51 @@
 
     AddFlags(kSigMon_WaitForSig);
 
-    streamHandler = HDHRStreamHandler::Get(channel->GetDevice(), inputid);
+    streamHandler = HDHRStreamHandler::Get(channel->GetDevice(),
+                                           channel->GetInputID(),
+                                           channel->GetMajorID());
 }
 
 /** \fn HDHRSignalMonitor::~HDHRSignalMonitor()

mythtv/libs/libmythtv/recorders/hdhrstreamhandler.cpp

@@ -21 +21 @@
 
 #define LOC      QString("HDHRSH[%1](%2): ").arg(_inputid).arg(_device)
 
-QMap<QString,HDHRStreamHandler*> HDHRStreamHandler::_handlers;
-QMap<QString,uint>               HDHRStreamHandler::_handlers_refcnt;
+QMap<int,HDHRStreamHandler*>     HDHRStreamHandler::_handlers;
+QMap<int,uint>                   HDHRStreamHandler::_handlers_refcnt;
 QMutex                           HDHRStreamHandler::_handlers_lock;
 
 HDHRStreamHandler *HDHRStreamHandler::Get(const QString &devname,
-                                          int inputid)
+                                          int inputid, int majorid)
 {
     QMutexLocker locker(&_handlers_lock);
 
-    QString devkey = devname.toUpper();
-
-    QMap<QString,HDHRStreamHandler*>::iterator it = _handlers.find(devkey);
+    QMap<int,HDHRStreamHandler*>::iterator it = _handlers.find(majorid);
 
     if (it == _handlers.end())
     {
-        HDHRStreamHandler *newhandler = new HDHRStreamHandler(devkey, inputid);
+        HDHRStreamHandler *newhandler = new HDHRStreamHandler(devname, inputid,
+                                                              majorid);
         newhandler->Open();
-        _handlers[devkey] = newhandler;
-        _handlers_refcnt[devkey] = 1;
+        _handlers[majorid] = newhandler;
+        _handlers_refcnt[majorid] = 1;
 
         LOG(VB_RECORD, LOG_INFO,
             QString("HDHRSH[%1]: Creating new stream handler %2 for %3")
-            .arg(inputid).arg(devkey).arg(devname));
+            .arg(inputid).arg(majorid).arg(devname));
     }
     else
     {
-        _handlers_refcnt[devkey]++;
-        uint rcount = _handlers_refcnt[devkey];
+        _handlers_refcnt[majorid]++;
+        uint rcount = _handlers_refcnt[majorid];
         LOG(VB_RECORD, LOG_INFO,
             QString("HDHRSH[%1]: Using existing stream handler %2 for %3")
-            .arg(inputid).arg(devkey)
+            .arg(inputid).arg(majorid)
             .arg(devname) + QString(" (%1 in use)").arg(rcount));
     }
 
-    return _handlers[devkey];
+    return _handlers[majorid];
 }
 
 void HDHRStreamHandler::Return(HDHRStreamHandler * & ref, int inputid)
 {
     QMutexLocker locker(&_handlers_lock);
 
-    QString devname = ref->_device;
+    int majorid = ref->_majorid;
 
-    QMap<QString,uint>::iterator rit = _handlers_refcnt.find(devname);
+    QMap<int,uint>::iterator rit = _handlers_refcnt.find(majorid);
     if (rit == _handlers_refcnt.end())
         return;
 
-    QMap<QString,HDHRStreamHandler*>::iterator it = _handlers.find(devname);
+    QMap<int,HDHRStreamHandler*>::iterator it = _handlers.find(majorid);
     if (*rit > 1)
     {
         ref = nullptr;
@@ -79 +78 @@
     if ((it != _handlers.end()) && (*it == ref))
     {
         LOG(VB_RECORD, LOG_INFO, QString("HDHRSH[%1]: Closing handler for %2")
-            .arg(inputid).arg(devname));
+            .arg(inputid).arg(majorid));
         ref->Close();
         delete *it;
         _handlers.erase(it);
@@ -88 +87 @@
     {
         LOG(VB_GENERAL, LOG_ERR,
             QString("HDHRSH[%1] Error: Couldn't find handler for %2")
-            .arg(inputid).arg(devname));
+            .arg(inputid).arg(majorid));
     }
 
     _handlers_refcnt.erase(rit);
     ref = nullptr;
 }
 
-HDHRStreamHandler::HDHRStreamHandler(const QString &device, int inputid)
+HDHRStreamHandler::HDHRStreamHandler(const QString &device, int inputid,
+                                     int majorid)
     : StreamHandler(device, inputid)
     , _hdhomerun_device(nullptr)
     , _tuner(-1)
     , _tune_mode(hdhrTuneModeNone)
+    , _majorid(majorid)
     , _hdhr_lock(QMutex::Recursive)
 {
     setObjectName("HDHRStreamHandler");
@@ -110 +111 @@
  */
 void HDHRStreamHandler::run(void)
 {
-    int tunerLock = 0;
-    char *error = nullptr;
-
     RunProlog();
-    /* Get a tuner lock */
-    tunerLock = hdhomerun_device_tuner_lockkey_request(_hdhomerun_device, &error);
-    if(tunerLock < 1)
-    {
-        LOG(VB_GENERAL, LOG_ERR, LOC +
-            QString("Get tuner lock failed. Aborting. Error: %1").arg(error));
-        _error = true;
-        RunEpilog();
-        return;
-    }
+
     /* Create TS socket. */
     if (!hdhomerun_device_stream_start(_hdhomerun_device))
     {
@@ -221 +210 @@
 
     LOG(VB_RECORD, LOG_INFO, LOC + "RunTS(): " + "end");
 
-    if(tunerLock == 1)
-    {
-        LOG(VB_RECORD, LOG_INFO, LOC + "Release tuner lock.");
-        hdhomerun_device_tuner_lockkey_release(_hdhomerun_device);
-    }
-
     SetRunning(false, false, false);
+
     RunEpilog();
 }
 
@@ -361 +345 @@
     if (_hdhomerun_device)
     {
         TuneChannel("none");
-        hdhomerun_device_destroy(_hdhomerun_device);
+        hdhomerun_device_tuner_lockkey_release(_hdhomerun_device);
         _hdhomerun_device = nullptr;
     }
+    if (_device_selector)
+    {
+        hdhomerun_device_selector_destroy(_device_selector, true);
+        _device_selector = nullptr;
+    }
 }
 
 bool HDHRStreamHandler::Connect(void)
 {
-    _hdhomerun_device = hdhomerun_device_create_from_str(
-        _device.toLocal8Bit().constData(), nullptr);
-
-    if (!_hdhomerun_device)
+    _device_selector = hdhomerun_device_selector_create(nullptr);
+    if (!_device_selector)
     {
-        LOG(VB_GENERAL, LOG_ERR, LOC + "Unable to create hdhomerun object");
+        LOG(VB_GENERAL, LOG_ERR, LOC + "Unable to create device selector");
         return false;
     }
 
-    _tuner = hdhomerun_device_get_tuner(_hdhomerun_device);
+    QStringList devices = _device.split(",");
+    for (int i = 0; i < devices.size(); ++i)
+    {
+        QByteArray ba = devices[i].toUtf8();
+        int n = hdhomerun_device_selector_load_from_str(
+            _device_selector, ba.data());
+        LOG(VB_GENERAL, LOG_INFO, LOC + QString("Added %1 devices from %3")
+            .arg(n).arg(devices[i]));
+    }
 
-    if (hdhomerun_device_get_local_machine_addr(_hdhomerun_device) == 0)
+    _hdhomerun_device = hdhomerun_device_selector_choose_and_lock(
+        _device_selector, nullptr);
+    if (!_hdhomerun_device)
     {
-        LOG(VB_GENERAL, LOG_ERR, LOC + "Unable to connect to device");
+        LOG(VB_GENERAL, LOG_ERR, LOC +
+            QString("Unable to find a free device"));
+        hdhomerun_device_selector_destroy(_device_selector, true);
+        _device_selector = nullptr;
         return false;
     }
 
-    LOG(VB_RECORD, LOG_INFO, LOC + "Successfully connected to device");
-    return true;
-}
+    _tuner = hdhomerun_device_get_tuner(_hdhomerun_device);
 
-bool HDHRStreamHandler::EnterPowerSavingMode(void)
-{
-    QMutexLocker locker(&_listener_lock);
+    LOG(VB_GENERAL, LOG_INFO, LOC +
+        QString("Connected to device(%1)")
+        .arg(hdhomerun_device_get_name(_hdhomerun_device)));
 
-    if (!_stream_data_list.empty())
-    {
-        LOG(VB_RECORD, LOG_INFO, LOC +
-            "Ignoring request - video streaming active");
-        return false;
-    }
-    else
-    {
-        locker.unlock(); // _listener_lock
-        return TuneChannel("none");
-    }
+    return true;
 }
 
 QString HDHRStreamHandler::TunerGet(

mythtv/libs/libmythtv/recorders/hdhrstreamhandler.h

@@ -30 +30 @@
 #endif
 #else
 struct hdhomerun_device_t { int dummy; };
+struct hdhomerun_device_selector_t { int dummy; };
 #endif
 
 enum HDHRTuneMode {
@@ -49 +50 @@
 class HDHRStreamHandler : public StreamHandler
 {
   public:
-    static HDHRStreamHandler *Get(const QString &devicename, int inputid);
+    static HDHRStreamHandler *Get(const QString &devicename, int inputid,
+                                  int majorid);
     static void Return(HDHRStreamHandler * & ref, int inputid);
 
     void AddListener(MPEGStreamData *data,
@@ -68 +70 @@
     bool TuneChannel(const QString &chanid);
     bool TuneProgram(uint mpeg_prog_num);
     bool TuneVChannel(const QString &vchn);
-    bool EnterPowerSavingMode(void);
 
   private:
-    explicit HDHRStreamHandler(const QString &, int inputid);
+    explicit HDHRStreamHandler(const QString &, int inputid, int majorid);
 
     bool Connect(void);
 
@@ -91 +92 @@
 
   private:
     hdhomerun_device_t     *_hdhomerun_device;
+    hdhomerun_device_selector_t *_device_selector;
     int                     _tuner;
     vector<DTVTunerType>    _tuner_types;
     HDHRTuneMode            _tune_mode; // debug self check
+    int                     _majorid;
 
     mutable QMutex          _hdhr_lock;
 
     // for implementing Get & Return
     static QMutex                            _handlers_lock;
-    static QMap<QString, HDHRStreamHandler*> _handlers;
-    static QMap<QString, uint>               _handlers_refcnt;
+    static QMap<int, HDHRStreamHandler*>     _handlers;
+    static QMap<int, uint>                   _handlers_refcnt;
 };
 
 #endif // _HDHRSTREAMHANDLER_H_

mythtv/libs/libmythtv/tv_rec.h

@@ -240 +240 @@
     /// \brief Returns the inputid
     uint GetInputId(void) { return inputid; }
     uint GetParentId(void) { return parentid; }
+    uint GetMajorId(void) { return parentid ? parentid : inputid; }
     /// \brief Returns true is "errored" is true, false otherwise.
     bool IsErrored(void)  const { return HasFlags(kFlagErrored); }
 

mythtv/libs/libmythtv/videosource.cpp

@@ -1383 +1383 @@
 // HDHomeRun Configuration
 // -----------------------
 
-HDHomeRunIP::HDHomeRunIP()
+HDHomeRunDeviceID::HDHomeRunDeviceID(const CaptureCard &parent,
+                                     HDHomeRunConfigurationGroup &_group) :
+    MythUITextEditSetting(
+        new CaptureCardDBStorage(this, parent, "videodevice")),
+    group(_group)
 {
-    setLabel(QObject::tr("IP Address"));
-    setEnabled(false);
-    connect(this, SIGNAL(valueChanged( const QString&)),
-            this, SLOT(  UpdateDevices(const QString&)));
-    _oldValue="";
-};
-
-void HDHomeRunIP::setEnabled(bool e)
-{
-    MythUITextEditSetting::setEnabled(e);
-    if (e)
-    {
-        if (!_oldValue.isEmpty())
-            setValue(_oldValue);
-        emit NewIP(getValue());
-    }
-    else
-    {
-        _oldValue = getValue();
-        _oldValue.detach();
-    }
-}
-
-void HDHomeRunIP::UpdateDevices(const QString &v)
-{
-   if (isEnabled())
-   {
-#if 0
-       LOG(VB_GENERAL, LOG_DEBUG, QString("Emitting NewIP(%1)").arg(v));
-#endif
-       emit NewIP(v);
-   }
-}
-
-HDHomeRunTunerIndex::HDHomeRunTunerIndex()
-{
-    setLabel(QObject::tr("Tuner"));
-    setEnabled(false);
-    connect(this, SIGNAL(valueChanged( const QString&)),
-            this, SLOT(  UpdateDevices(const QString&)));
-    _oldValue = "";
+    setVisible(false);
 };
 
-void HDHomeRunTunerIndex::setEnabled(bool e)
-{
-    MythUITextEditSetting::setEnabled(e);
-    if (e) {
-        if (!_oldValue.isEmpty())
-            setValue(_oldValue);
-        emit NewTuner(getValue());
-    }
-    else
-    {
-        _oldValue = getValue();
-    }
-}
-
-void HDHomeRunTunerIndex::UpdateDevices(const QString &v)
-{
-   if (isEnabled())
-   {
-#if 0
-       LOG(VB_GENERAL, LOG_DEBUG, QString("Emitting NewTuner(%1)").arg(v));
-#endif
-       emit NewTuner(v);
-   }
-}
-
-HDHomeRunDeviceID::HDHomeRunDeviceID(const CaptureCard &parent) :
-    MythUITextEditSetting(new CaptureCardDBStorage(this, parent, "videodevice"))
-{
-    setLabel(tr("Device ID"));
-    setHelpText(tr("Device ID of HDHomeRun device"));
-    setEnabled(false);
-}
-
-void HDHomeRunDeviceID::SetIP(const QString &ip)
-{
-#if 0
-    LOG(VB_GENERAL, LOG_DEBUG, QString("Setting IP to %1").arg(ip));
-#endif
-    _ip = ip;
-    setValue(QString("%1-%2").arg(_ip).arg(_tuner));
-#if 0
-    LOG(VB_GENERAL, LOG_DEBUG, QString("Done Setting IP to %1").arg(ip));
-#endif
-}
-
-void HDHomeRunDeviceID::SetTuner(const QString &tuner)
-{
-#if 0
-    LOG(VB_GENERAL, LOG_DEBUG, QString("Setting Tuner to %1").arg(tuner));
-#endif
-    _tuner = tuner;
-    setValue(QString("%1-%2").arg(_ip).arg(_tuner));
-#if 0
-    LOG(VB_GENERAL, LOG_DEBUG, QString("Done Setting Tuner to %1").arg(tuner));
-#endif
-}
-
-void HDHomeRunDeviceID::SetOverrideDeviceID(const QString &deviceid)
-{
-    _overridedeviceid = deviceid;
-    setValue(deviceid);
-}
-
 void HDHomeRunDeviceID::Load(void)
 {
-    GetStorage()->Load();
-    if (!_overridedeviceid.isEmpty())
-    {
-        setValue(_overridedeviceid);
-        _overridedeviceid.clear();
-    }
-}
-
-HDHomeRunDeviceIDList::HDHomeRunDeviceIDList(
-    HDHomeRunDeviceID   *deviceid,
-    StandardSetting     *desc,
-    HDHomeRunIP         *cardip,
-    HDHomeRunTunerIndex *cardtuner,
-    HDHomeRunDeviceList *devicelist,
-    const CaptureCard &parent) :
-    _deviceid(deviceid),
-    _desc(desc),
-    _cardip(cardip),
-    _cardtuner(cardtuner),
-    _devicelist(devicelist),
-    m_parent(parent)
-{
-    setLabel(QObject::tr("Available devices"));
-    setHelpText(
-        QObject::tr(
-            "Device ID and Tuner Number of available HDHomeRun devices."));
-
-    connect(this, SIGNAL(valueChanged( const QString&)),
-            this, SLOT(  UpdateDevices(const QString&)));
-
-    _oldValue = "";
-};
-
-/// \brief Adds all available device-tuner combinations to list
-/// If current is >= 0 it will be considered available even
-/// if no device exists for it on the network
-void HDHomeRunDeviceIDList::fillSelections(const QString &cur)
-{
-    clearSelections();
-
-    vector<QString> devs;
-    QMap<QString, bool> in_use;
-
-    QString current = cur;
-
-#if 0
-    LOG(VB_GENERAL, LOG_DEBUG, QString("Filling List, current = '%1'")
-            .arg(current));
-#endif
-
-    HDHomeRunDeviceList::iterator it = _devicelist->begin();
-    for (; it != _devicelist->end(); ++it)
-    {
-        if ((*it).discovered)
-        {
-            devs.push_back(it.key());
-            in_use[it.key()] = (*it).inuse;
-        }
-    }
-
-    QString man_addr = HDHomeRunDeviceIDList::tr("Manually Enter IP Address");
-    QString sel = man_addr;
-    devs.push_back(sel);
-
-    if (3 == devs.size() && current.startsWith("FFFFFFFF", Qt::CaseInsensitive))
-    {
-        current = sel = (current.endsWith("0")) ?
-            *(devs.begin()) : *(++devs.begin());
-    }
-    else
-    {
-        vector<QString>::const_iterator it = devs.begin();
-        for (; it != devs.end(); ++it)
-            sel = (current == *it) ? *it : sel;
-    }
-
-    QString usestr = QString(" -- ");
-    usestr += QObject::tr("Warning: already in use");
-
-    for (uint i = 0; i < devs.size(); i++)
-    {
-        const QString dev = devs[i];
-        QString desc = dev + (in_use[devs[i]] ? usestr : "");
-        desc = (current == devs[i]) ? dev : desc;
-        addSelection(desc, dev, dev == sel);
-    }
-
-    if (current != cur)
-    {
-        _deviceid->SetOverrideDeviceID(current);
-    }
-    else if (sel == man_addr && !current.isEmpty())
-    {
-        // Populate the proper values for IP address and tuner
-        QStringList selection = current.split("-");
-
-        _cardip->SetOldValue(selection.first());
-        _cardtuner->SetOldValue(selection.last());
-
-        _cardip->setValue(selection.first());
-        _cardtuner->setValue(selection.last());
-    }
+    MythUITextEditSetting::Load();
+    group.SetDeviceCheckBoxes(getValue());
 }
 
-void HDHomeRunDeviceIDList::Load(void)
+void HDHomeRunDeviceID::Save(void)
 {
-    clearSelections();
-
-    int cardid = m_parent.getCardID();
-    QString device = CardUtil::GetVideoDevice(cardid);
-    fillSelections(device);
+    setValue(group.GetDeviceCheckBoxes());
+    MythUITextEditSetting::Save();
 }
 
-void HDHomeRunDeviceIDList::UpdateDevices(const QString &v)
-{
-#if 0
-    LOG(VB_GENERAL, LOG_DEBUG, QString("Got signal with %1").arg(v));
-#endif
-    if (v == HDHomeRunDeviceIDList::tr("Manually Enter IP Address"))
-    {
-        _cardip->setEnabled(true);
-        _cardtuner->setEnabled(true);
-#if 0
-        LOG(VB_GENERAL, LOG_DEBUG, "Done");
-#endif
-    }
-    else if (!v.isEmpty())
-    {
-        if (_oldValue == HDHomeRunDeviceIDList::tr("Manually Enter IP Address"))
-        {
-            _cardip->setEnabled(false);
-            _cardtuner->setEnabled(false);
-        }
-        _deviceid->setValue(v);
-
-        // Update _cardip and cardtuner
-        _cardip->setValue((*_devicelist)[v].cardip);
-        _cardtuner->setValue(QString("%1").arg((*_devicelist)[v].cardtuner));
-        _desc->setValue((*_devicelist)[v].desc);
-    }
-    _oldValue = v;
-};
-
 // -----------------------
 // VBOX Configuration
 // -----------------------
@@ -2078 +1846 @@
 };
 
 
+class UseHDHomeRunDevice : public TransMythUICheckBoxSetting
+{
+  public:
+    explicit UseHDHomeRunDevice(QString &deviceid, QString &hwmodel,
+                                QString &ipaddr) :
+        TransMythUICheckBoxSetting()
+    {
+        setLabel(QObject::tr("Use HDHomeRun %1 (%2 %3)")
+                 .arg(deviceid).arg(hwmodel).arg(ipaddr));
+        setValue(false);
+        setHelpText(
+            QObject::tr("If enabled, use tuners from this HDHomeRun "
+                        "device."));
+    };
+};
+
 HDHomeRunConfigurationGroup::HDHomeRunConfigurationGroup
         (CaptureCard& a_parent, CardType &a_cardtype) :
     parent(a_parent)
@@ -2087 +1871 @@
     // Fill Device list
     FillDeviceList();
 
-    deviceid     = new HDHomeRunDeviceID(parent);
-    desc         = new GroupSetting();
-    desc->setLabel(tr("Description"));
-    cardip       = new HDHomeRunIP();
-    cardtuner    = new HDHomeRunTunerIndex();
-    deviceidlist = new HDHomeRunDeviceIDList(
-        deviceid, desc, cardip, cardtuner, &devicelist, parent);
+    deviceid     = new HDHomeRunDeviceID(parent, *this);
 
-    a_cardtype.addTargetedChild("HDHOMERUN", deviceidlist);
+    QMap<QString, HDHomeRunDevice>::iterator dit;
+    for (dit = devicelist.begin(); dit != devicelist.end(); ++dit)
+    {
+        HDHomeRunDevice &dev = *dit;
+        dev.checkbox = new UseHDHomeRunDevice(
+            dev.deviceid, dev.hwmodel, dev.cardip);
+        a_cardtype.addTargetedChild("HDHOMERUN", dev.checkbox);
+    }
     a_cardtype.addTargetedChild("HDHOMERUN", new EmptyAudioDevice(parent));
     a_cardtype.addTargetedChild("HDHOMERUN", new EmptyVBIDevice(parent));
     a_cardtype.addTargetedChild("HDHOMERUN", deviceid);
-    a_cardtype.addTargetedChild("HDHOMERUN", desc);
-    a_cardtype.addTargetedChild("HDHOMERUN", cardip);
-    a_cardtype.addTargetedChild("HDHOMERUN", cardtuner);
 
     GroupSetting *buttonRecOpt = new GroupSetting();
     buttonRecOpt->setLabel(tr("Recording Options"));
@@ -2109 +1891 @@
     buttonRecOpt->addChild(new ChannelTimeout(parent, 3000, 1750));
     buttonRecOpt->addChild(new HDHomeRunEITScan(parent));
     a_cardtype.addTargetedChild("HDHOMERUN", buttonRecOpt);
-
-    connect(cardip,    SIGNAL(NewIP(const QString&)),
-            deviceid,  SLOT(  SetIP(const QString&)));
-    connect(cardtuner, SIGNAL(NewTuner(const QString&)),
-            deviceid,  SLOT(  SetTuner(const QString&)));
 };
 
 void HDHomeRunConfigurationGroup::FillDeviceList(void)
@@ -2132 +1909 @@
         QStringList devinfo = dev.split(" ");
         QString devid = devinfo.at(0);
         QString devip = devinfo.at(1);
-        QString devtuner = devinfo.at(2);
+        QString hwmodel = devinfo.at(2);
 
         HDHomeRunDevice tmpdevice;
-        tmpdevice.deviceid   = devid;
-        tmpdevice.desc       = CardUtil::GetHDHRdesc(devid);
-        tmpdevice.cardip     = devip;
-        tmpdevice.inuse      = false;
-        tmpdevice.discovered = true;
-        tmpdevice.cardtuner = devtuner;
-        tmpdevice.mythdeviceid =
-            tmpdevice.deviceid + "-" + tmpdevice.cardtuner;
-        devicelist[tmpdevice.mythdeviceid] = tmpdevice;
-    }
-    uint found_device_count = devicelist.size();
-
-    // Now find configured devices
-
-    // returns "xxxxxxxx-n" or "ip.ip.ip.ip-n" values
-    QStringList db = CardUtil::GetVideoDevices("HDHOMERUN");
-
-    for (it = db.begin(); it != db.end(); ++it)
-    {
-        QMap<QString, HDHomeRunDevice>::iterator dit;
-
-        dit = devicelist.find(*it);
-
-        if (dit == devicelist.end())
-        {
-            if ((*it).toUpper() == "FFFFFFFF-0" && 2 == found_device_count)
-                dit = devicelist.begin();
-
-            if ((*it).toUpper() == "FFFFFFFF-1" && 2 == found_device_count)
-            {
-                dit = devicelist.begin();
-                ++dit;
-            }
-        }
-
-        if (dit != devicelist.end())
-        {
-            (*dit).inuse = true;
-            continue;
-        }
-
-        HDHomeRunDevice tmpdevice;
-        tmpdevice.mythdeviceid = *it;
-        tmpdevice.inuse        = true;
-        tmpdevice.discovered   = false;
-
-        if (ProbeCard(tmpdevice))
-            devicelist[tmpdevice.mythdeviceid] = tmpdevice;
+        tmpdevice.hwmodel  = hwmodel;
+        tmpdevice.cardip   = devip;
+        tmpdevice.deviceid = devid;
+        devicelist[tmpdevice.deviceid] = tmpdevice;
     }
 
 #if 0
@@ -2190 +1923 @@
     QMap<QString, HDHomeRunDevice>::iterator debugit;
     for (debugit = devicelist.begin(); debugit != devicelist.end(); ++debugit)
     {
-        LOG(VB_GENERAL, LOG_DEBUG, QString("%1: %2 %3 %4 %5 %6 %7")
-                .arg(debugit.key())
-                .arg((*debugit).mythdeviceid)
-                .arg((*debugit).deviceid)
-                .arg((*debugit).cardip)
-                .arg((*debugit).cardtuner)
-                .arg((*debugit).inuse)
-                .arg((*debugit).discovered));
+        LOG(VB_GENERAL, LOG_DEBUG, QString("%1: %2 %3")
+            .arg(debugit.key()).arg((*debugit).hwmodel)
+            .arg((*debugit).cardip));
     }
 #endif
 }
 
-bool HDHomeRunConfigurationGroup::ProbeCard(HDHomeRunDevice &tmpdevice)
+void HDHomeRunConfigurationGroup::SetDeviceCheckBoxes(QString devices)
 {
-#ifdef USING_HDHOMERUN
-    hdhomerun_device_t *thisdevice =
-        hdhomerun_device_create_from_str(
-            tmpdevice.mythdeviceid.toLocal8Bit().constData(), nullptr);
-
-    if (thisdevice)
+    QStringList devstrs = devices.split(",");
+    for (int i = 0; i < devstrs.size(); ++i)
     {
-        uint device_id = hdhomerun_device_get_device_id(thisdevice);
-        uint device_ip = hdhomerun_device_get_device_ip(thisdevice);
-        uint tuner     = hdhomerun_device_get_tuner(thisdevice);
-        hdhomerun_device_destroy(thisdevice);
-
-        if (device_id == 0)
-            tmpdevice.deviceid = "NOTFOUND";
-        else
-        {
-            tmpdevice.deviceid = QString("%1").arg(device_id, 8, 16);
-            tmpdevice.desc     = CardUtil::GetHDHRdesc(tmpdevice.deviceid);
-        }
-
-        tmpdevice.deviceid = tmpdevice.deviceid.toUpper();
+        // Get the HDHomeRun device ID using libhdhomerun.  We need to
+        // do it this way because legacy configurations could use an
+        // IP address and a tuner nubmer.
+        QByteArray ba = devstrs[i].toUtf8();
+        hdhomerun_device_t *device = hdhomerun_device_create_from_str(
+            ba.data(), nullptr);
+        if (!device)
+            continue;
+        QString devid = QString("%1").arg(
+            hdhomerun_device_get_device_id(device), 8, 16).toUpper();
+        hdhomerun_device_destroy(device);
 
-        tmpdevice.cardip = QString("%1.%2.%3.%4")
-            .arg((device_ip>>24) & 0xFF).arg((device_ip>>16) & 0xFF)
-            .arg((device_ip>> 8) & 0xFF).arg((device_ip>> 0) & 0xFF);
+        // If we know about this device, set its checkbox to on.
+        QMap<QString, HDHomeRunDevice>::iterator dit;
+        dit = devicelist.find(devid);
+        if (dit != devicelist.end())
+            (*dit).checkbox->setValue(true);
+    }
+}
 
-        tmpdevice.cardtuner = QString("%1").arg(tuner);
-        return true;
+QString HDHomeRunConfigurationGroup::GetDeviceCheckBoxes(void)
+{
+    // Return a string listing each HDHomeRun device with its checbox
+    // turned on.
+    QStringList devstrs;    
+    QMap<QString, HDHomeRunDevice>::iterator dit;
+    for (dit = devicelist.begin(); dit != devicelist.end(); ++dit)
+    {
+        if ((*dit).checkbox->boolValue())
+            devstrs << (*dit).deviceid;
     }
-#endif // USING_HDHOMERUN
-    Q_UNUSED(tmpdevice);
-    return false;
+    QString devices = devstrs.join(",");
+    return devices;
 }
 
 // -----------------------

mythtv/libs/libmythtv/videosource.h

@@ -380 +380 @@
     static void fillSelections(MythUIComboBoxSetting* setting);
 };
 
+class UseHDHomeRunDevice;
+
 class HDHomeRunDevice
 {
   public:
-    QString mythdeviceid;
     QString deviceid;
-    QString desc;
+    QString hwmodel;
     QString cardip;
-    QString cardtuner;
-    bool    inuse;
-    bool    discovered;
+    UseHDHomeRunDevice *checkbox;
 };
 
 typedef QMap<QString, HDHomeRunDevice> HDHomeRunDeviceList;
 
-class HDHomeRunDeviceIDList;
 class HDHomeRunDeviceID;
-class HDHomeRunIP;
-class HDHomeRunTunerIndex;
 class HDHomeRunConfigurationGroup : public GroupSetting
 {
     Q_OBJECT
@@ -406 +402 @@
 
   public:
     HDHomeRunConfigurationGroup(CaptureCard &parent, CardType &cardtype);
+    void SetDeviceCheckBoxes(QString devices);
+    QString GetDeviceCheckBoxes(void);
 
   private:
     void FillDeviceList(void);
-    bool ProbeCard(HDHomeRunDevice&);
 
   private:
     CaptureCard           &parent;
-    StandardSetting       *desc;
-    HDHomeRunDeviceIDList *deviceidlist;
     HDHomeRunDeviceID     *deviceid;
-    HDHomeRunIP           *cardip;
-    HDHomeRunTunerIndex   *cardtuner;
     HDHomeRunDeviceList    devicelist;
 };
 
@@ -878 +871 @@
     MythUICheckBoxSetting *schedgroup;
 };
 
-class HDHomeRunDeviceID;
-class HDHomeRunTunerIndex;
-
-class HDHomeRunIP : public MythUITextEditSetting
-{
-    Q_OBJECT
-
-  public:
-    HDHomeRunIP();
-
-    void setEnabled(bool e) override; // StandardSetting
-    void SetOldValue(const QString &s)
-        { _oldValue = s; _oldValue.detach(); };
-
-  signals:
-    void NewIP(const QString&);
-
-  public slots:
-    void UpdateDevices(const QString&);
-
-  private:
-    QString _oldValue;
-};
-
-class HDHomeRunTunerIndex : public MythUITextEditSetting
-{
-    Q_OBJECT
-
-  public:
-    HDHomeRunTunerIndex();
-
-    void setEnabled(bool e) override; // StandardSetting
-    void SetOldValue(const QString &s)
-        { _oldValue = s; _oldValue.detach(); };
-
-  signals:
-    void NewTuner(const QString&);
-
-  public slots:
-    void UpdateDevices(const QString&);
-
-  private:
-    QString _oldValue;
-};
-
-
-class HDHomeRunDeviceIDList : public TransMythUIComboBoxSetting
-{
-    Q_OBJECT
-
-  public:
-    HDHomeRunDeviceIDList(HDHomeRunDeviceID *deviceid,
-                          StandardSetting *desc,
-                          HDHomeRunIP       *cardip,
-                          HDHomeRunTunerIndex *cardtuner,
-                          HDHomeRunDeviceList *devicelist,
-                          const CaptureCard &parent);
-
-    void fillSelections(const QString &current);
-
-    void Load(void) override; // StandardSetting
-
-  public slots:
-    void UpdateDevices(const QString&);
-
-  private:
-    HDHomeRunDeviceID   *_deviceid;
-    StandardSetting     *_desc;
-    HDHomeRunIP         *_cardip;
-    HDHomeRunTunerIndex *_cardtuner;
-    HDHomeRunDeviceList *_devicelist;
-    const CaptureCard &m_parent;
-
-    QString              _oldValue;
-};
-
 class HDHomeRunDeviceID : public MythUITextEditSetting
 {
     Q_OBJECT
 
   public:
-    explicit HDHomeRunDeviceID(const CaptureCard &parent);
-
+    HDHomeRunDeviceID(const CaptureCard &parent,
+                      HDHomeRunConfigurationGroup &_group);
     void Load(void) override; // StandardSetting
-
-  public slots:
-    void SetIP(const QString&);
-    void SetTuner(const QString&);
-    void SetOverrideDeviceID(const QString&);
+    void Save(void) override; // StandardSetting
 
   private:
-    QString _ip;
-    QString _tuner;
-    QString _overridedeviceid;
+    HDHomeRunConfigurationGroup &group;
 };
 
 ///