streamhandler: simplify and standardize the use of inputid

One streamhandler will be created for an input, so just track a single id.

mythtv/libs/libmythtv/recorders/ExternalChannel.cpp

@@ -45,7 +45,7 @@ bool ExternalChannel::Open(void)
     if (!m_inputid)
         return false;
 
-    m_stream_handler = ExternalStreamHandler::Get(m_device);
+    m_stream_handler = ExternalStreamHandler::Get(m_device, GetInputID());
     if (!m_stream_handler || m_stream_handler->HasError())
     {
         LOG(VB_GENERAL, LOG_ERR, LOC + "Open failed");
@@ -62,7 +62,7 @@ void ExternalChannel::Close()
 
     if (IsOpen())
     {
-        ExternalStreamHandler::Return(m_stream_handler);
+        ExternalStreamHandler::Return(m_stream_handler, GetInputID());
         m_stream_handler = nullptr;
     }
 }

mythtv/libs/libmythtv/recorders/ExternalSignalMonitor.cpp

@@ -46,7 +46,8 @@ ExternalSignalMonitor::ExternalSignalMonitor(int db_cardnum,
     QString result;
 
     LOG(VB_CHANNEL, LOG_INFO, LOC + "ctor");
-    m_stream_handler = ExternalStreamHandler::Get(_channel->GetDevice());
+    m_stream_handler = ExternalStreamHandler::Get(channel->GetDevice(),
+                                                  channel->GetInputID());
     if (!m_stream_handler || m_stream_handler->HasError())
         LOG(VB_GENERAL, LOG_ERR, LOC + "Open failed");
     else
@@ -60,7 +61,7 @@ ExternalSignalMonitor::~ExternalSignalMonitor()
 {
     LOG(VB_CHANNEL, LOG_INFO, LOC + "dtor");
     Stop();
-    ExternalStreamHandler::Return(m_stream_handler);
+    ExternalStreamHandler::Return(m_stream_handler, channel->GetInputID());
 }
 
 /** \fn ExternalSignalMonitor::Stop(void)

mythtv/libs/libmythtv/recorders/ExternalStreamHandler.cpp

@@ -28,8 +28,7 @@
 #include "cardutil.h"
 #include "exitcodes.h"
 
-#define LOC QString("ExternalRec%1(%2): ").arg(_recorder_ids_string) \
-                                          .arg(_device)
+#define LOC QString("ExternalRec[%1](%2): ").arg(_inputid).arg(_device)
 
 ExternIO::ExternIO(const QString & app,
                    const QStringList & args)
@@ -461,7 +460,7 @@ QMap<QString,uint>              ExternalStreamHandler::m_handlers_refcnt;
 QMutex                          ExternalStreamHandler::m_handlers_lock;
 
 ExternalStreamHandler *ExternalStreamHandler::Get(const QString &devname,
-                                                  int recorder_id)
+                                                  int inputid)
 {
     QMutexLocker locker(&m_handlers_lock);
 
@@ -471,29 +470,29 @@ ExternalStreamHandler *ExternalStreamHandler::Get(const QString &devname,
 
     if (it == m_handlers.end())
     {
-        ExternalStreamHandler *newhandler = new ExternalStreamHandler(devname);
+        ExternalStreamHandler *newhandler =
+            new ExternalStreamHandler(devname, inputid);
         m_handlers[devkey] = newhandler;
         m_handlers_refcnt[devkey] = 1;
 
         LOG(VB_RECORD, LOG_INFO,
-            QString("ExternSH: Creating new stream handler %1 for %2")
-                .arg(devkey).arg(devname));
+            QString("ExternSH[%1]: Creating new stream handler %2 for %3")
+            .arg(inputid).arg(devkey).arg(devname));
     }
     else
     {
         m_handlers_refcnt[devkey]++;
         uint rcount = m_handlers_refcnt[devkey];
         LOG(VB_RECORD, LOG_INFO,
-            QString("ExternSH: Using existing stream handler for %1")
-                .arg(devkey) + QString(" (%1 in use)").arg(rcount));
+            QString("ExternSH[%1]: Using existing stream handler for %2")
+            .arg(inputid).arg(devkey) + QString(" (%1 in use)").arg(rcount));
     }
 
-    m_handlers[devkey]->AddRecorderId(recorder_id);
     return m_handlers[devkey];
 }
 
 void ExternalStreamHandler::Return(ExternalStreamHandler * & ref,
-                                   int recorder_id)
+                                   int inputid)
 {
     QMutexLocker locker(&m_handlers_lock);
 
@@ -505,11 +504,9 @@ void ExternalStreamHandler::Return(ExternalStreamHandler * & ref,
 
     QMap<QString, ExternalStreamHandler*>::iterator it =
         m_handlers.find(devname);
-    if (it != m_handlers.end())
-        (*it)->DelRecorderId(recorder_id);
 
-    LOG(VB_RECORD, LOG_INFO, QString("ExternSH: Return '%1' in use %2")
-        .arg(devname).arg(*rit));
+    LOG(VB_RECORD, LOG_INFO, QString("ExternSH[%1]: Return '%2' in use %3")
+        .arg(inputid).arg(devname).arg(*rit));
 
     if (*rit > 1)
     {
@@ -520,16 +517,16 @@ void ExternalStreamHandler::Return(ExternalStreamHandler * & ref,
 
     if ((it != m_handlers.end()) && (*it == ref))
     {
-        LOG(VB_RECORD, LOG_INFO, QString("ExternSH: Closing handler for %1")
-                           .arg(devname));
+        LOG(VB_RECORD, LOG_INFO, QString("ExternSH[%1]: Closing handler for %2")
+            .arg(inputid).arg(devname));
         delete *it;
         m_handlers.erase(it);
     }
     else
     {
         LOG(VB_GENERAL, LOG_ERR,
-            QString("ExternSH: Error: Couldn't find handler for %1")
-                .arg(devname));
+            QString("ExternSH[%1]: Error: Couldn't find handler for %2")
+            .arg(inputid).arg(devname));
     }
 
     m_handlers_refcnt.erase(rit);
@@ -540,8 +537,8 @@ void ExternalStreamHandler::Return(ExternalStreamHandler * & ref,
   ExternalStreamHandler
  */
 
-ExternalStreamHandler::ExternalStreamHandler(const QString & path)
-    : StreamHandler(path)
+ExternalStreamHandler::ExternalStreamHandler(const QString & path, int inputid)
+    : StreamHandler(path, inputid)
     , m_IO(nullptr)
     , m_tsopen(false)
     , m_io_errcnt(0)

mythtv/libs/libmythtv/recorders/ExternalStreamHandler.h

@@ -65,11 +65,11 @@ class ExternalStreamHandler : public StreamHandler
 
   public:
     static ExternalStreamHandler *Get(const QString &devicename,
-                                      int recorder_id = -1);
-    static void Return(ExternalStreamHandler * & ref, int recorder_id = -1);
+                                      int inputid);
+    static void Return(ExternalStreamHandler * & ref, int inputid);
 
   public:
-    explicit ExternalStreamHandler(const QString & path);
+    explicit ExternalStreamHandler(const QString & path, int inputid);
     ~ExternalStreamHandler(void) { CloseApp(); }
 
     void run(void) override; // MThread

mythtv/libs/libmythtv/recorders/asistreamhandler.cpp

@@ -24,15 +24,14 @@
 #include <dveo/asi.h>
 #include <dveo/master.h>
 
-#define LOC      QString("ASISH%1(%2): ").arg(_recorder_ids_string) \
-                                         .arg(_device)
+#define LOC      QString("ASISH[%1](%2): ").arg(_inputid).arg(_device)
 
 QMap<QString,ASIStreamHandler*> ASIStreamHandler::_handlers;
 QMap<QString,uint>              ASIStreamHandler::_handlers_refcnt;
 QMutex                          ASIStreamHandler::_handlers_lock;
 
 ASIStreamHandler *ASIStreamHandler::Get(const QString &devname,
-                                        int recorder_id)
+                                        int inputid)
 {
     QMutexLocker locker(&_handlers_lock);
 
@@ -42,30 +41,29 @@ ASIStreamHandler *ASIStreamHandler::Get(const QString &devname,
 
     if (it == _handlers.end())
     {
-        ASIStreamHandler *newhandler = new ASIStreamHandler(devname);
+        ASIStreamHandler *newhandler = new ASIStreamHandler(devname, inputid);
         newhandler->Open();
         _handlers[devkey] = newhandler;
         _handlers_refcnt[devkey] = 1;
 
         LOG(VB_RECORD, LOG_INFO,
-            QString("ASISH: Creating new stream handler %1 for %2")
-                .arg(devkey).arg(devname));
+            QString("ASISH[%1]: Creating new stream handler %2 for %3")
+            .arg(inputid).arg(devkey).arg(devname));
     }
     else
     {
         _handlers_refcnt[devkey]++;
         uint rcount = _handlers_refcnt[devkey];
         LOG(VB_RECORD, LOG_INFO,
-            QString("ASISH: Using existing stream handler %1 for %2")
-                .arg(devkey)
-                .arg(devname) + QString(" (%1 in use)").arg(rcount));
+            QString("ASISH[%1]: Using existing stream handler %2 for %3")
+            .arg(inputid).arg(devkey)
+            .arg(devname) + QString(" (%1 in use)").arg(rcount));
     }
 
-    _handlers[devkey]->AddRecorderId(recorder_id);
     return _handlers[devkey];
 }
 
-void ASIStreamHandler::Return(ASIStreamHandler * & ref, int recorder_id)
+void ASIStreamHandler::Return(ASIStreamHandler * & ref, int inputid)
 {
     QMutexLocker locker(&_handlers_lock);
 
@@ -76,8 +74,6 @@ void ASIStreamHandler::Return(ASIStreamHandler * & ref, int recorder_id)
         return;
 
     QMap<QString,ASIStreamHandler*>::iterator it = _handlers.find(devname);
-    if (it != _handlers.end())
-        (*it)->DelRecorderId(recorder_id);
 
     if (*rit > 1)
     {
@@ -88,28 +84,30 @@ void ASIStreamHandler::Return(ASIStreamHandler * & ref, int recorder_id)
 
     if ((it != _handlers.end()) && (*it == ref))
     {
-        LOG(VB_RECORD, LOG_INFO, QString("ASISH: Closing handler for %1")
-                           .arg(devname));
+        LOG(VB_RECORD, LOG_INFO, QString("ASISH[%1]: Closing handler for %2")
+            .arg(inputid).arg(devname));
         ref->Close();
         delete *it;
         _handlers.erase(it);
     }
     else
     {
         LOG(VB_GENERAL, LOG_ERR,
-            QString("ASISH Error: Couldn't find handler for %1")
-                .arg(devname));
+            QString("ASISH[%1] Error: Couldn't find handler for %2")
+            .arg(inputid).arg(devname));
     }
 
     _handlers_refcnt.erase(rit);
     ref = nullptr;
 }
 
-ASIStreamHandler::ASIStreamHandler(const QString &device) :
-    StreamHandler(device),
-    _device_num(-1), _buf_size(-1), _fd(-1),
-    _packet_size(TSPacket::kSize), _clock_source(kASIInternalClock),
-    _rx_mode(kASIRXSyncOnActualConvertTo188), _drb(nullptr)
+ASIStreamHandler::ASIStreamHandler(const QString &device, int inputd)
+    : StreamHandler(device, inputid)
+    , _device_num(-1), _buf_size(-1), _fd(-1)
+    , _packet_size(TSPacket::kSize)
+    , _clock_source(kASIInternalClock)
+    , _rx_mode(kASIRXSyncOnActualConvertTo188)
+    , _drb(nullptr)
 {
     setObjectName("ASISH");
 }

mythtv/libs/libmythtv/recorders/asistreamhandler.h

@@ -44,9 +44,8 @@ typedef enum ASIRXMode
 class ASIStreamHandler : public StreamHandler
 {
   public:
-    static ASIStreamHandler *Get(const QString &devicename,
-                                 int recorder_id = -1);
-    static void Return(ASIStreamHandler * & ref, int recorder_id = -1);
+    static ASIStreamHandler *Get(const QString &devicename, int inputid);
+    static void Return(ASIStreamHandler * & ref, int inputid);
 
     void AddListener(MPEGStreamData *data,
                      bool /*allow_section_reader*/ = false,
@@ -60,7 +59,7 @@ class ASIStreamHandler : public StreamHandler
     void SetRXMode(ASIRXMode m);
 
   private:
-    explicit ASIStreamHandler(const QString &);
+    explicit ASIStreamHandler(const QString &, int inputid);
 
     bool Open(void);
     void Close(void);

mythtv/libs/libmythtv/recorders/cetonchannel.cpp

@@ -32,7 +32,7 @@ bool CetonChannel::Open(void)
     if (IsOpen())
         return true;
 
-    _stream_handler = CetonStreamHandler::Get(_device_id);
+    _stream_handler = CetonStreamHandler::Get(_device_id, GetInputID());
 
     tunerType = DTVTunerType::kTunerTypeATSC;
     _tuner_types.push_back(tunerType);
@@ -53,7 +53,7 @@ void CetonChannel::Close(void)
     if (!IsOpen())
         return; // this caller didn't have it open in the first place..
 
-    CetonStreamHandler::Return(_stream_handler);
+    CetonStreamHandler::Return(_stream_handler, GetInputID());
 }
 
 bool CetonChannel::EnterPowerSavingMode(void)

mythtv/libs/libmythtv/recorders/cetonsignalmonitor.cpp

@@ -43,7 +43,8 @@ CetonSignalMonitor::CetonSignalMonitor(int db_cardnum,
 
     AddFlags(kSigMon_WaitForSig);
 
-    streamHandler = CetonStreamHandler::Get(_channel->GetDevice());
+    streamHandler = CetonStreamHandler::Get(channel->GetDevice(),
+                                            channel->GetInputID());
 }
 
 /** \fn CetonSignalMonitor::~CetonSignalMonitor()
@@ -53,7 +54,7 @@ CetonSignalMonitor::~CetonSignalMonitor()
 {
     LOG(VB_CHANNEL, LOG_INFO, LOC + "dtor");
     Stop();
-    CetonStreamHandler::Return(streamHandler);
+    CetonStreamHandler::Return(streamHandler, channel->GetInputID());
 }
 
 /** \fn CetonSignalMonitor::Stop(void)