Ticket #13339: hdhr-locking-pooling-2.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 hdhrdev = id.toUpper() + " " + ip + " " +
-                                  QString("%1").arg(tuner);
-                devs.push_back(hdhrdev);
-            }
+            QString hdhrdev = id.toUpper() + " " + ip;
+            devs.push_back(hdhrdev);
         }
     }
 #endif // USING_HDHOMERUN
@@ -1396 +1392 @@
 {
     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::GetMasterId(void)
+{
+    return m_pParent ? m_pParent->GetMasterId() : m_inputid;
+}

mythtv/libs/libmythtv/recorders/channelbase.h

@@ -100 +100 @@
     // \brief Set inputid for scanning
     void SetInputID(uint _inputid) { m_inputid = _inputid; }
 
+    // \brief Get master input ID
+    int GetMasterId(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);
+    _stream_handler = HDHRStreamHandler::Get(_device_id, GetMasterId());
 
     _tuner_types = _stream_handler->GetTunerTypes();
     tunerType = (_tuner_types.empty()) ?
@@ -86 +86 @@
 
 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(),
+                                             _channel->GetMasterId(),
                                      (tvrec ? tvrec->GetInputId() : -1));
 
     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());
+    streamHandler = HDHRStreamHandler::Get(_channel->GetDevice(),
+                                           _channel->GetMasterId());
 }
 
 /** \fn HDHRSignalMonitor::~HDHRSignalMonitor()

mythtv/libs/libmythtv/recorders/hdhrstreamhandler.cpp

@@ -19 +19 @@
 #include "cardutil.h"
 #include "mythlogging.h"
 
-#define LOC      QString("HDHRSH%1(%2): ").arg(_recorder_ids_string) \
-                                          .arg(_device)
+#define LOC      QString("HDHRSH%1(%2,%3): ").arg(_recorder_ids_string) \
+                                             .arg(_devkey).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;
+HDHRDevSelectorCache             HDHRStreamHandler::_selectors;
 
-HDHRStreamHandler *HDHRStreamHandler::Get(const QString &devname,
+HDHRStreamHandler *HDHRStreamHandler::Get(const QString &devname, int devkey,
                                           int recorder_id)
 {
     QMutexLocker locker(&_handlers_lock);
 
-    QString devkey = devname.toUpper();
-
-    QMap<QString,HDHRStreamHandler*>::iterator it = _handlers.find(devkey);
+    QMap<int,HDHRStreamHandler*>::iterator it = _handlers.find(devkey);
 
     if (it == _handlers.end())
     {
-        HDHRStreamHandler *newhandler = new HDHRStreamHandler(devkey);
+        HDHRStreamHandler *newhandler = new HDHRStreamHandler(devname, devkey);
         newhandler->Open();
         _handlers[devkey] = newhandler;
         _handlers_refcnt[devkey] = 1;
@@ -64 +63 @@
 {
     QMutexLocker locker(&_handlers_lock);
 
-    QString devname = ref->_device;
+    int devkey = ref->_devkey;
 
-    QMap<QString,uint>::iterator rit = _handlers_refcnt.find(devname);
+    QMap<int,uint>::iterator rit = _handlers_refcnt.find(devkey);
     if (rit == _handlers_refcnt.end())
         return;
 
-    QMap<QString,HDHRStreamHandler*>::iterator it = _handlers.find(devname);
+    QMap<int,HDHRStreamHandler*>::iterator it = _handlers.find(devkey);
     if (it != _handlers.end())
         (*it)->DelRecorderId(recorder_id);
 
@@ -84 +83 @@
     if ((it != _handlers.end()) && (*it == ref))
     {
         LOG(VB_RECORD, LOG_INFO, QString("HDHRSH: Closing handler for %1")
-                           .arg(devname));
+                           .arg(devkey));
         ref->Close();
         delete *it;
         _handlers.erase(it);
@@ -93 +92 @@
     {
         LOG(VB_GENERAL, LOG_ERR,
             QString("HDHRSH Error: Couldn't find handler for %1")
-                .arg(devname));
+                .arg(devkey));
     }
 
     _handlers_refcnt.erase(rit);
     ref = nullptr;
 }
 
-HDHRStreamHandler::HDHRStreamHandler(const QString &device) :
+HDHRStreamHandler::HDHRStreamHandler(const QString &device, int devkey) :
     StreamHandler(device),
     _hdhomerun_device(nullptr),
     _tuner(-1),
     _tune_mode(hdhrTuneModeNone),
+    _devkey(devkey),
     _hdhr_lock(QMutex::Recursive)
 {
     setObjectName("HDHRStreamHandler");
@@ -115 +115 @@
  */
 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))
     {
@@ -226 +214 @@
 
     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();
 }
 
@@ -366 +349 @@
     if (_hdhomerun_device)
     {
         TuneChannel("none");
-        hdhomerun_device_destroy(_hdhomerun_device);
+        hdhomerun_device_tuner_lockkey_release(_hdhomerun_device);
         _hdhomerun_device = nullptr;
     }
 }
 
 bool HDHRStreamHandler::Connect(void)
 {
-    _hdhomerun_device = hdhomerun_device_create_from_str(
-        _device.toLocal8Bit().constData(), nullptr);
-
-    if (!_hdhomerun_device)
+    hdhomerun_device_selector_t *selector = _selectors.Get(_devkey, _device);
+    if (!selector)
     {
-        LOG(VB_GENERAL, LOG_ERR, LOC + "Unable to create hdhomerun object");
+        LOG(VB_GENERAL, LOG_ERR, LOC +
+            QString("Unable to get device selector"));
         return false;
     }
 
-    _tuner = hdhomerun_device_get_tuner(_hdhomerun_device);
-
-    if (hdhomerun_device_get_local_machine_addr(_hdhomerun_device) == 0)
+    _hdhomerun_device = hdhomerun_device_selector_choose_and_lock(
+        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"));
         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(
@@ -551 +522 @@
     LOG(VB_RECORD, LOG_INFO, LOC + QString("Tuning vchannel %1").arg(vchn));
     return !TunerSet("vchannel", vchn).isEmpty();
 }
+
+HDHRDevSelectorCache::HDHRDevSelectorCache(void)
+    : _map()
+{
+}
+
+HDHRDevSelectorCache::~HDHRDevSelectorCache(void)
+{
+    while (_map.size())
+    {
+        hdhomerun_device_selector_t *selector = _map.first();
+        hdhomerun_device_selector_destroy(selector, true);
+        _map.erase(_map.begin());
+    }
+}
+
+hdhomerun_device_selector_t *HDHRDevSelectorCache::Get(int devkey,
+                                                       QString device)
+{
+    QMap<int, hdhomerun_device_selector_t*>::iterator iter;
+    iter = _map.find(devkey);
+    if (iter != _map.end())
+        return *iter;
+
+    hdhomerun_device_selector_t *selector =
+        hdhomerun_device_selector_create(nullptr);
+    _map[devkey] = selector;
+
+    if (!selector)
+    {
+        LOG(VB_GENERAL, LOG_ERR,
+            QString("HDHRDevSelectorCache::Get(%1): "
+                    "Unable to create device selector").arg(device));
+        return nullptr;
+    }
+
+    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(selector, ba.data());
+        LOG(VB_GENERAL, LOG_INFO,
+            QString("HDHRDevSelectorCache::Get(%1): "
+                    "Added %2 devices from %3")
+            .arg(device).arg(n).arg(devices[i]));
+    }
+
+    return selector;
+}

mythtv/libs/libmythtv/recorders/hdhrstreamhandler.h

@@ -30 +30 @@
 #endif
 #else
 struct hdhomerun_device_t { int dummy; };
+struct hdhomerun_device_selector_t { int dummy; };
 #endif
 
+class HDHRDevSelectorCache
+{
+  public:
+    HDHRDevSelectorCache(void);
+    ~HDHRDevSelectorCache(void);
+    hdhomerun_device_selector_t *Get(int devkey, QString device);
+
+  private:
+    HDHRDevSelectorCache(const HDHRDevSelectorCache&);
+    HDHRDevSelectorCache& operator=(const HDHRDevSelectorCache&);
+
+    QMap<int, hdhomerun_device_selector_t*> _map;
+};
+
 enum HDHRTuneMode {
     hdhrTuneModeNone = 0,
     hdhrTuneModeFrequency,
@@ -49 +64 @@
 class HDHRStreamHandler : public StreamHandler
 {
   public:
-    static HDHRStreamHandler *Get(const QString &devicename,
+    static HDHRStreamHandler *Get(const QString &devicename, int devkey,
                                   int recorder_id = -1);
     static void Return(HDHRStreamHandler * & ref, int recorder_id = -1);
 
@@ -69 +84 @@
     bool TuneChannel(const QString &chanid);
     bool TuneProgram(uint mpeg_prog_num);
     bool TuneVChannel(const QString &vchn);
-    bool EnterPowerSavingMode(void);
 
   private:
-    explicit HDHRStreamHandler(const QString &);
+    explicit HDHRStreamHandler(const QString &, int devkey);
 
     bool Connect(void);
 
@@ -95 +109 @@
     int                     _tuner;
     vector<DTVTunerType>    _tuner_types;
     HDHRTuneMode            _tune_mode; // debug self check
+    int                     _devkey;
 
     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;
+    static HDHRDevSelectorCache              _selectors;
 };
 
 #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 GetMasterId(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()
-{
-    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()
+HDHomeRunDeviceID::HDHomeRunDeviceID(const CaptureCard &parent) :
+    MythUITextEditSetting(
+        new CaptureCardDBStorage(this, parent, "videodevice"))
 {
-    setLabel(QObject::tr("Tuner"));
-    setEnabled(false);
+    setLabel(QObject::tr("Devices"));
+    setHelpText(
+        QObject::tr(
+            "Device IDs, IP addresses or hostnames of HDHomerun devices. "
+            "Separate values by ',' to pool the tuners from multiple devices. "
+            "When devices are pooled, all devices must support the same set "
+            "of channels."));
     connect(this, SIGNAL(valueChanged( const QString&)),
             this, SLOT(  UpdateDevices(const QString&)));
-    _oldValue = "";
 };
 
-void HDHomeRunTunerIndex::setEnabled(bool e)
+void HDHomeRunDeviceID::UpdateDevices(const QString &v)
 {
-    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();
-    }
+    emit NewDeviceID(v);
 }
 
 HDHomeRunDeviceIDList::HDHomeRunDeviceIDList(
-    HDHomeRunDeviceID   *deviceid,
     StandardSetting     *desc,
-    HDHomeRunIP         *cardip,
-    HDHomeRunTunerIndex *cardtuner,
+    StandardSetting     *cardip,
+    HDHomeRunDeviceID   *deviceid,
     HDHomeRunDeviceList *devicelist,
     const CaptureCard &parent) :
-    _deviceid(deviceid),
     _desc(desc),
     _cardip(cardip),
-    _cardtuner(cardtuner),
+    _deviceid(deviceid),
     _devicelist(devicelist),
     m_parent(parent)
 {
     setLabel(QObject::tr("Available devices"));
     setHelpText(
         QObject::tr(
-            "Device ID and Tuner Number of available HDHomeRun devices."));
+            "Device ID of available HDHomeRun devices."));
 
     connect(this, SIGNAL(valueChanged( const QString&)),
             this, SLOT(  UpdateDevices(const QString&)));
@@ -1553 +1453 @@
         }
     }
 
-    QString man_addr = HDHomeRunDeviceIDList::tr("Manually Enter IP Address");
+    QString man_addr = HDHomeRunDeviceIDList::tr("Manually Enter Devices");
     QString sel = man_addr;
     devs.push_back(sel);
 
-    if (3 == devs.size() && current.startsWith("FFFFFFFF", Qt::CaseInsensitive))
+    if (devs.size() > 0 &&
+        current.compare("FFFFFFFF", Qt::CaseInsensitive) == 0)
     {
-        current = sel = (current.endsWith("0")) ?
-            *(devs.begin()) : *(++devs.begin());
+        current = sel = *(devs.begin());
     }
     else
     {
@@ -1579 +1479 @@
         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());
-    }
 }
 
 void HDHomeRunDeviceIDList::Load(void)
@@ -1608 +1492 @@
 
 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 (!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));
+        _deviceid->setValue((*_devicelist)[v].mythdeviceid);
         _desc->setValue((*_devicelist)[v].desc);
+        _cardip->setValue((*_devicelist)[v].cardip);
     }
     _oldValue = v;
 };
@@ -2087 +1952 @@
     // Fill Device list
     FillDeviceList();
 
-    deviceid     = new HDHomeRunDeviceID(parent);
     desc         = new GroupSetting();
     desc->setLabel(tr("Description"));
-    cardip       = new HDHomeRunIP();
-    cardtuner    = new HDHomeRunTunerIndex();
+    cardip       = new GroupSetting();
+    cardip->setLabel(tr("IP Address"));
+    deviceid     = new HDHomeRunDeviceID(parent);
     deviceidlist = new HDHomeRunDeviceIDList(
-        deviceid, desc, cardip, cardtuner, &devicelist, parent);
+        desc, cardip, deviceid, &devicelist, parent);
 
     a_cardtype.addTargetedChild("HDHOMERUN", deviceidlist);
     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);
+    a_cardtype.addTargetedChild("HDHOMERUN", deviceid);
 
     GroupSetting *buttonRecOpt = new GroupSetting();
     buttonRecOpt->setLabel(tr("Recording Options"));
@@ -2109 +1973 @@
     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 +1991 @@
         QStringList devinfo = dev.split(" ");
         QString devid = devinfo.at(0);
         QString devip = devinfo.at(1);
-        QString devtuner = devinfo.at(2);
+        QString devtuner = "";
+        if (devinfo.size() > 2)
+            devtuner = 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;
+        tmpdevice.mythdeviceid = devid;
         devicelist[tmpdevice.mythdeviceid] = tmpdevice;
     }
     uint found_device_count = devicelist.size();
@@ -2190 +2048 @@
     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")
+        LOG(VB_GENERAL, LOG_DEBUG, QString("%1: %2 %3 %4 %5 %6")
                 .arg(debugit.key())
                 .arg((*debugit).mythdeviceid)
                 .arg((*debugit).deviceid)
-                .arg((*debugit).cardip)
-                .arg((*debugit).cardtuner)
+                .arg((*debugit).deviceid)
                 .arg((*debugit).inuse)
                 .arg((*debugit).discovered));
     }
@@ -2213 +2070 @@
     {
         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
+        if (device_id != 0)
         {
-            tmpdevice.deviceid = QString("%1").arg(device_id, 8, 16);
-            tmpdevice.desc     = CardUtil::GetHDHRdesc(tmpdevice.deviceid);
+            tmpdevice.desc     = CardUtil::GetHDHRdesc(tmpdevice.mythdeviceid);
         }
 
-        tmpdevice.deviceid = tmpdevice.deviceid.toUpper();
-
         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);
 
-        tmpdevice.cardtuner = QString("%1").arg(tuner);
         return true;
     }
 #endif // USING_HDHOMERUN

mythtv/libs/libmythtv/videosource.h

@@ -384 +384 @@
 {
   public:
     QString mythdeviceid;
-    QString deviceid;
     QString desc;
     QString cardip;
-    QString cardtuner;
+    QString deviceid;
     bool    inuse;
     bool    discovered;
 };
@@ -396 +395 @@
 
 class HDHomeRunDeviceIDList;
 class HDHomeRunDeviceID;
-class HDHomeRunIP;
-class HDHomeRunTunerIndex;
 class HDHomeRunConfigurationGroup : public GroupSetting
 {
     Q_OBJECT
@@ -414 +411 @@
   private:
     CaptureCard           &parent;
     StandardSetting       *desc;
+    StandardSetting       *cardip;
     HDHomeRunDeviceIDList *deviceidlist;
     HDHomeRunDeviceID     *deviceid;
-    HDHomeRunIP           *cardip;
-    HDHomeRunTunerIndex   *cardtuner;
     HDHomeRunDeviceList    devicelist;
 };
 
@@ -878 +874 @@
     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
+class HDHomeRunDeviceID : public MythUITextEditSetting
 {
     Q_OBJECT
 
   public:
-    HDHomeRunTunerIndex();
-
-    void setEnabled(bool e) override; // StandardSetting
-    void SetOldValue(const QString &s)
-        { _oldValue = s; _oldValue.detach(); };
+    HDHomeRunDeviceID(const CaptureCard &parent);
 
   signals:
-    void NewTuner(const QString&);
+    void NewDeviceID(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,
+    HDHomeRunDeviceIDList(StandardSetting *desc,
+                          StandardSetting *cardip,
+                          HDHomeRunDeviceID *deviceid,
                           HDHomeRunDeviceList *devicelist,
                           const CaptureCard &parent);
 
@@ -944 +907 @@
     void UpdateDevices(const QString&);
 
   private:
-    HDHomeRunDeviceID   *_deviceid;
     StandardSetting     *_desc;
-    HDHomeRunIP         *_cardip;
-    HDHomeRunTunerIndex *_cardtuner;
+    StandardSetting     *_cardip;
+    HDHomeRunDeviceID   *_deviceid;
     HDHomeRunDeviceList *_devicelist;
     const CaptureCard &m_parent;
 
     QString              _oldValue;
 };
 
-class HDHomeRunDeviceID : public MythUITextEditSetting
-{
-    Q_OBJECT
-
-  public:
-    explicit HDHomeRunDeviceID(const CaptureCard &parent);
-
-    void Load(void) override; // StandardSetting
-
-  public slots:
-    void SetIP(const QString&);
-    void SetTuner(const QString&);
-    void SetOverrideDeviceID(const QString&);
-
-  private:
-    QString _ip;
-    QString _tuner;
-    QString _overridedeviceid;
-};
-
 ///
 class VBoxDeviceID;
 class VBoxTunerIndex;