Ticket #12168: iptv_extension_master_01.patch

mythtv/libs/libmythbase/mythsingledownload.cpp

@@ -8 +8 @@
  * ) works well.
  */
 
+#define LOC QString("MythSingleDownload: ")
+
 bool MythSingleDownload::DownloadURL(const QString &url, QByteArray *buffer,
-                                     uint timeout)
+                                     uint timeout, qint64 maxsize)
 {
     QMutexLocker  lock(&m_lock);
-
-    // create custom temporary event loop on stack
     QEventLoop   event_loop;
+    m_buffer = buffer;
 
     // the HTTP request
     QNetworkRequest req(url);
@@ -26 +27 @@
                      QNetworkRequest::AlwaysNetwork);
 
     // "quit()" the event-loop, when the network request "finished()"
-    connect(m_reply, SIGNAL(finished()), &event_loop, SLOT(quit()));
     connect(&m_timer, SIGNAL(timeout()), &event_loop, SLOT(quit()));
+    connect(m_reply, SIGNAL(finished()), &event_loop, SLOT(quit()));
+    connect(m_reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(Progress(qint64,qint64)));
 
-    // Configure timeout
+    // Configure timeout and size limit
+    m_maxsize = maxsize;
     m_timer.setSingleShot(true);
     m_timer.start(timeout);  // 30 secs. by default
 
@@ -37 +40 @@
 
     disconnect(&m_timer, SIGNAL(timeout()), &event_loop, SLOT(quit()));
     disconnect(m_reply, SIGNAL(finished()), &event_loop, SLOT(quit()));
+    disconnect(m_reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(Progress(qint64,qint64)));
 
     if (ret != 0)
     {
-        LOG(VB_GENERAL, LOG_ERR, QString("MythSingleDownload evenloop failed"));
+        LOG(VB_GENERAL, LOG_ERR, LOC + "eventloop failed");
     }
 
     QMutexLocker  replylock(&m_replylock);
-    if (m_timer.isActive())
+    if (!m_timer.isActive())
+    {
+        m_errorstring = "timed-out";
+        m_reply->abort();
+        ret = false;
+    }
+    else
     {
         m_timer.stop();
         m_errorcode = m_reply->error();
         if (m_errorcode == QNetworkReply::NoError)
         {
-            *buffer += m_reply->readAll();
-            delete m_reply;
-            m_reply = NULL;
+            *m_buffer += m_reply->readAll();
             m_errorstring.clear();
-            return true;
+            ret = true;
         }
         else
         {
             m_errorstring = m_reply->errorString();
-            delete m_reply;
-            m_reply = NULL;
-            return false;
+            ret = false;
         }
     }
-    else
-    {
-        m_errorstring = "timed-out";
-        m_timer.stop();
-        m_reply->abort();
-        delete m_reply;
-        m_reply = NULL;
-        return false;
-    }
+    delete m_reply;
+    m_reply = NULL;
+    m_buffer = NULL;
+    return ret;
 }
 
 void MythSingleDownload::Cancel(void)
@@ -80 +81 @@
     QMutexLocker  replylock(&m_replylock);
     if (m_reply)
     {
-        LOG(VB_GENERAL, LOG_INFO, "MythSingleDownload: Aborting download");
+        LOG(VB_GENERAL, LOG_INFO, LOC + "Aborting download");
         m_reply->abort();
     }
 }
+
+void MythSingleDownload::Progress(qint64 bytesRead, qint64 totalBytes)
+{
+    if(m_maxsize && bytesRead>=m_maxsize)
+    {
+        LOG(VB_GENERAL, LOG_INFO, LOC + QString("Reached specified max file size (%1 bytes)").arg(m_maxsize));
+        {
+            QMutexLocker  replylock(&m_replylock);
+            *m_buffer += m_reply->read(m_maxsize);
+        }
+        m_maxsize=0;
+        Cancel();
+    }
+}

mythtv/libs/libmythbase/mythsingledownload.h

@@ -28 +28 @@
    MythSingleDownload(void) : m_reply(NULL), m_errorcode(QNetworkReply::NoError) { ; }
    ~MythSingleDownload(void) { ; }
 
-   bool DownloadURL(const QString &url, QByteArray *buffer, uint timeout = 30000);
+   bool DownloadURL(const QString &url, QByteArray *buffer, uint timeout = 30000, qint64 maxsize = 0);
    void Cancel(void);
    QString ErrorString(void) const { return m_errorstring; }
    QNetworkReply::NetworkError ErrorCode(void) const { return m_errorcode; }
 
+  private slots:
+   void Progress(qint64 bytesRead, qint64 totalBytes);
+
   private:
 
     QNetworkAccessManager m_mgr;
@@ -43 +46 @@
 
     QString               m_errorstring;
     QNetworkReply::NetworkError m_errorcode;
+    QByteArray           *m_buffer;
+    qint64                m_maxsize;
 };
 
 #endif

mythtv/libs/libmythtv/channelscan/iptvchannelfetcher.h

@@ -39 +39 @@
                     uint programnumber) :
         m_name(name), m_xmltvid(xmltvid), m_programnumber(programnumber),
         m_tuning(data_url, data_bitrate,
-                 fec_type, fec_url0, fec_bitrate0, fec_url1, fec_bitrate1)
+                 fec_type, fec_url0, fec_bitrate0, fec_url1, fec_bitrate1,
+                 IPTVTuningData::inValid)
     {
     }
 
-    bool IsValid(void) const
-    {
-        return !m_name.isEmpty() && m_tuning.IsValid();
-    }
-
   public:
     QString m_name;
     QString m_xmltvid;

mythtv/libs/libmythtv/channelutil.cpp

@@ -1968 +1968 @@
 
     QString data_url, fec_url0, fec_url1;
     IPTVTuningData::FECType fec_type = IPTVTuningData::kNone;
+    IPTVTuningData::IPTVProtocol protocol = IPTVTuningData::inValid;
     uint bitrate[3] = { 0, 0, 0, };
     while (query.next())
     {
@@ -2010 +2011 @@
             case IPTVTuningData::kSMPTE2022_2:
                 break; // will be handled by type of first FEC stream
         }
+
+        if (data_url.toLower().startsWith("udp"))
+            protocol = IPTVTuningData::udp;
+
+        else if (data_url.toLower().startsWith("rtp"))
+            protocol = IPTVTuningData::rtp;
+
+        else if (data_url.toLower().startsWith("rtsp"))
+            protocol = IPTVTuningData::rtsp;
+
+        else if (data_url.toLower().startsWith("http") && ChannelUtil::IsHLSPlaylist(data_url))
+            protocol = IPTVTuningData::http_hls;
+
+        else if (data_url.toLower().startsWith("http"))
+            protocol = IPTVTuningData::http_ts;
     }
 
     IPTVTuningData tuning(data_url, bitrate[0], fec_type,
-                          fec_url0, bitrate[1], fec_url1, bitrate[2]);
+                          fec_url0, bitrate[1], fec_url1, bitrate[2],
+                          protocol);
     LOG(VB_GENERAL, LOG_INFO, QString("Loaded %1 for %2")
         .arg(tuning.GetDeviceName()).arg(chanid));
     return tuning;
 }
 
+
+
+
+
+
+
+#include "HLSReader.h"
+
+bool ChannelUtil::IsHLSPlaylist(QString url)
+{
+    QByteArray buffer;
+
+    MythSingleDownload downloader;
+    downloader.DownloadURL(url, &buffer, 5000, 10000);
+    if (!buffer.size())
+    {
+        LOG(VB_GENERAL, LOG_ERR,QString("IsHLSPlaylist - Open Failed: %1")
+            .arg(downloader.ErrorString()));
+        return false;
+    }
+
+    QTextStream text(&buffer);
+    text.setCodec("UTF-8");
+    return (HLSReader::IsValidPlaylist(text));
+}
+
+
+
+
+
+
+
 // TODO This should be modified to load a complete channelinfo object including
 //      all fields from the database
 /**

mythtv/libs/libmythtv/channelutil.h

@@ -185 +185 @@
     static QString GetVideoFilters(uint sourceid, const QString &channum)
         { return GetChannelValueStr("videofilters", sourceid, channum); }
     static IPTVTuningData GetIPTVTuningData(uint chanid);
+    static bool IsHLSPlaylist(QString url);
 
     // Are there any other possibly useful sort orders?
     // e.g. Sorting by sourceid would probably be better done by two distinct

mythtv/libs/libmythtv/iptvtuningdata.h

@@ -8 +8 @@
 
 // MythTV headers
 #include "mythtvexp.h"
+#include "mythlogging.h"
 
 class MTV_PUBLIC IPTVTuningData
 {
@@ -31 +32 @@
         kSMPTE2022_2,
     } IPTVType;
 
+    typedef enum IPTVProtocol
+    {
+        inValid = 0,
+        udp,
+        rtp,
+        rtsp,
+        http_ts,
+        http_hls
+    } IPTVProtocol;
+
     IPTVTuningData() : m_fec_type(kNone)
     {
         memset(&m_bitrate, 0, sizeof(m_bitrate));
     }
 
     IPTVTuningData(const QString &data_url, uint data_bitrate,
-                   FECType fec_type,
+                   const FECType fec_type,
                    const QString &fec_url0, uint fec_bitrate0,
-                   const QString &fec_url1, uint fec_bitrate1) :
+                   const QString &fec_url1, uint fec_bitrate1,
+                   const IPTVProtocol protocol) :
         m_data_url(data_url),
-        m_fec_type(fec_type), m_fec_url0(fec_url0), m_fec_url1(fec_url1)
+        m_fec_type(fec_type), m_fec_url0(fec_url0), m_fec_url1(fec_url1),
+        m_protocol(protocol)
     {
         m_bitrate[0] = data_bitrate;
         m_bitrate[1] = fec_bitrate0;
@@ -51 +64 @@
     IPTVTuningData(const QString &data_url, uint data_bitrate,
                    const QString &fec_type,
                    const QString &fec_url0, uint fec_bitrate0,
-                   const QString &fec_url1, uint fec_bitrate1) :
+                   const QString &fec_url1, uint fec_bitrate1,
+                   const IPTVProtocol protocol) :
         m_data_url(data_url),
-        m_fec_type(kNone), m_fec_url0(fec_url0), m_fec_url1(fec_url1)
+        m_fec_type(kNone), m_fec_url0(fec_url0), m_fec_url1(fec_url1),
+        m_protocol(protocol)
     {
         m_bitrate[0] = data_bitrate;
         m_bitrate[1] = fec_bitrate0;
@@ -134 +149 @@
 
     uint GetURLCount(void) const { return 3; }
 
-    bool IsHLS(void) const
-    {
-        return m_data_url.scheme().startsWith("http") && m_data_url.isValid();
-    }
-
     bool IsValid(void) const
     {
-        return m_data_url.isValid() &&
-               (IsHLS() ||
-                ((m_data_url.scheme() == "rtp" || m_data_url.scheme() == "udp") && m_data_url.port() != -1) ||
-                m_data_url.scheme() == "rtsp"
-               );
+        bool ret = (m_data_url.isValid() && (IsUDP() || IsRTP() || IsRTSP() || IsHLS() || IsHTTPTS()));
+
+        LOG(VB_CHANNEL, LOG_DEBUG, QString("IPTVTuningdata (%1): IsValid = %2")
+            .arg(m_data_url.toString())
+            .arg(ret ? "true" : "false"));
+
+        return ret;
+    }
+
+    bool IsUDP(void) const
+    {
+        return (m_protocol == udp);
+    }
+
+    bool IsRTP(void) const
+    {
+        return (m_protocol == rtp);
+    }
+
+    bool IsRTSP(void) const
+    {
+        return (m_protocol == rtsp);
+    }
+
+    bool IsHLS() const
+    {
+        return (m_protocol == http_hls);
+    }
+
+    bool IsHTTPTS() const
+    {
+        return (m_protocol == http_ts);
     }
 
   public:
@@ -154 +191 @@
     QUrl m_fec_url0;
     QUrl m_fec_url1;
     uint m_bitrate[3];
+    IPTVProtocol m_protocol;
 };
 
 #endif // _IPTV_TUNING_DATA_H_

mythtv/libs/libmythtv/libmythtv.pro

@@ -666 +666 @@
     SOURCES += recorders/rtp/packetbuffer.cpp
     SOURCES += recorders/rtp/rtppacketbuffer.cpp
 
+    # Support for HTTP TS streams
+    HEADERS += recorders/httptsstreamhandler.h
+    SOURCES += recorders/httptsstreamhandler.cpp
+
     # Suppport for HLS recorder
     HEADERS += recorders/hlsstreamhandler.h
     SOURCES += recorders/hlsstreamhandler.cpp

mythtv/libs/libmythtv/mythsystemevent.cpp

@@ -403 +403 @@
         tr("Playback unpaused");
     m_settings["EventCmdPlayChanged"]          = // PLAY_CHANGED
         tr("Playback program changed");
+    m_settings["EventCmdTuningSignalTimeout"]  = // TUNING_SIGNAL_TIMEOUT
+        tr("Tuning signal waiting");
     m_settings["EventCmdMasterStarted"]        = // MASTER_STARTED
         tr("Master backend started");
     m_settings["EventCmdMasterShutdown"]       = // MASTER_SHUTDOWN

mythtv/libs/libmythtv/recorders/HLS/HLSReader.cpp

@@ -274 +274 @@
         line = text.readLine();
         if (line.isNull())
             break;
-        LOG(VB_RECORD, LOG_DEBUG, LOC +
+        LOG(VB_RECORD, LOG_DEBUG, /* LOC + */
             QString("IsValidPlaylist: |'%1'").arg(line));
         if (line.startsWith(QLatin1String("#EXT-X-TARGETDURATION"))  ||
             line.startsWith(QLatin1String("#EXT-X-MEDIA-SEQUENCE"))  ||

mythtv/libs/libmythtv/recorders/HLS/HLSReader.h

@@ -65 +65 @@
     static void CancelURL(const QString &url);
     static void CancelURL(const QStringList &urls);
     static QString RelativeURI(const QString& surl, const QString& spath);
+    
+    static bool IsValidPlaylist(QTextStream & text);
 
   protected:
     void Cancel(bool quiet = false);
@@ -81 +83 @@
 
   private:
     static QString DecodedURI(const QString& uri);
-
-    bool IsValidPlaylist(QTextStream & text);
-
     static QString ParseAttributes(const QString& line, const char* attr);
     static bool ParseDecimalValue(const QString& line, int& target);
     static bool ParseDecimalValue(const QString& line, int64_t& target);

mythtv/libs/libmythtv/recorders/cetonstreamhandler.cpp

@@ -107 +107 @@
 
 CetonStreamHandler::CetonStreamHandler(const QString &device) :
     IPTVStreamHandler(IPTVTuningData(
-                          "", 0, IPTVTuningData::kNone, "", 0, "", 0)),
+                          "", 0, IPTVTuningData::kNone, "", 0, "", 0, IPTVTuningData::inValid)),
     _card(0),
     _tuner(0),
     _using_cablecard(false),
@@ -150 +150 @@
     int rtspPort = 8554;
     QString url = QString("rtsp://%1:%2/cetonmpeg%3")
         .arg(_ip_address).arg(rtspPort).arg(_tuner);
-    m_tuning = IPTVTuningData(url, 0, IPTVTuningData::kNone, "", 0, "", 0);
+    m_tuning = IPTVTuningData(url, 0, IPTVTuningData::kNone, "", 0, "", 0, IPTVTuningData::rtsp);
     m_use_rtp_streaming = true;
 
     _valid = true;

new file mythtv/libs/libmythtv/recorders/httptsstreamhandler.cpp

@@ +1 @@
+// MythTV headers
+#include "httptsstreamhandler.h"
+#include "mythlogging.h"
+
+// POSIX headers
+#include <unistd.h> // for usleep
+
+#define LOC QString("HTTPTSSH(%1): ").arg(_device)
+
+// BUFFER_SIZE is a multiple of TS_SIZE
+#define TS_SIZE     188
+#define BUFFER_SIZE (512 * TS_SIZE)
+
+QMap<QString,HTTPTSStreamHandler*>  HTTPTSStreamHandler::s_handlers;
+QMap<QString,uint>               HTTPTSStreamHandler::s_handlers_refcnt;
+QMutex                           HTTPTSStreamHandler::s_handlers_lock;
+
+HTTPTSStreamHandler* HTTPTSStreamHandler::Get(const IPTVTuningData& tuning)
+{
+    QMutexLocker locker(&s_handlers_lock);
+
+    QString devkey = tuning.GetDeviceKey();
+
+    QMap<QString,HTTPTSStreamHandler*>::iterator it = s_handlers.find(devkey);
+
+    if (it == s_handlers.end())
+    {
+        HTTPTSStreamHandler* newhandler = new HTTPTSStreamHandler(tuning);
+        newhandler->Start();
+        s_handlers[devkey] = newhandler;
+        s_handlers_refcnt[devkey] = 1;
+
+        LOG(VB_RECORD, LOG_INFO,
+            QString("HTTPTSSH: Creating new stream handler %1 for %2")
+            .arg(devkey).arg(tuning.GetDeviceName()));
+    }
+    else
+    {
+        s_handlers_refcnt[devkey]++;
+        uint rcount = s_handlers_refcnt[devkey];
+        LOG(VB_RECORD, LOG_INFO,
+            QString("HTTPTSSH: Using existing stream handler %1 for %2")
+            .arg(devkey).arg(tuning.GetDeviceName()) +
+            QString(" (%1 in use)").arg(rcount));
+    }
+
+    return s_handlers[devkey];
+}
+
+HTTPTSStreamHandler::HTTPTSStreamHandler(const IPTVTuningData& tuning) :
+    IPTVStreamHandler(tuning)
+{
+    LOG(VB_GENERAL, LOG_INFO, LOC + "ctor");
+}
+
+HTTPTSStreamHandler::~HTTPTSStreamHandler(void)
+{
+    LOG(VB_GENERAL, LOG_INFO, LOC + "dtor");
+    Stop();
+}
+
+void HTTPTSStreamHandler::run(void)
+{
+    RunProlog();
+    int open_sleep = 250000;
+    LOG(VB_RECORD, LOG_INFO, LOC + "run() -- begin");
+    SetRunning(true, false, false);
+
+    m_reader   = new HTTPReader(this);
+    while (_running_desired)
+    {
+        if (!m_reader->DownloadStream(m_tuning.GetURL(0)))
+        {
+            LOG(VB_RECORD, LOG_INFO, LOC + "DownloadStream failed to recieve bytes from " + m_tuning.GetURL(0).toString());
+            usleep(open_sleep);
+            if (open_sleep < 10000000)
+                open_sleep += 250000;
+            continue;
+        }
+        open_sleep = 250000;
+    }
+
+    delete m_reader;
+    SetRunning(false, false, false);
+    RunEpilog();
+    LOG(VB_RECORD, LOG_INFO, LOC + "run() -- done");
+}
+
+
+#undef  LOC
+#define LOC QString("HTTPReader(%1): ").arg(m_parent->_device)
+
+bool HTTPReader::DownloadStream(const QUrl url)
+{
+    LOG(VB_RECORD, LOG_INFO, LOC + "DownloadStream -- begin");
+
+    QMutexLocker lock(&m_lock);
+    QEventLoop   event_loop;
+
+    m_buffer = new uint8_t[BUFFER_SIZE];
+    size = 0;
+    m_ok = false;
+
+    // the HTTP request
+    m_replylock.lock();
+    m_reply = m_mgr.get(QNetworkRequest(url));
+    m_replylock.unlock();
+
+    connect(&m_timer, SIGNAL(timeout()), &event_loop, SLOT(quit()));
+    connect(m_reply, SIGNAL(finished()), &event_loop, SLOT(quit()));
+    connect(m_reply,SIGNAL(readyRead()), this,        SLOT(HttpRead()));
+
+    // Configure timeout and size limit
+    m_timer.setSingleShot(true);
+    m_timer.start(10000);
+
+    event_loop.exec(); // blocks stack until quit() is called
+
+    disconnect(&m_timer, SIGNAL(timeout()), &event_loop, SLOT(quit()));
+    disconnect(m_reply, SIGNAL(finished()), &event_loop, SLOT(quit()));
+    disconnect(m_reply,SIGNAL(readyRead()), this,        SLOT(HttpRead()));
+
+    if (m_timer.isActive())
+        m_timer.stop();
+
+    QMutexLocker  replylock(&m_replylock);
+    if (!m_reply->error() == QNetworkReply::NoError)
+    {
+        LOG(VB_RECORD, LOG_ERR, LOC + "DownloadStream exited with " + m_reply->errorString());
+    }
+
+    delete m_reply;
+    m_reply = NULL;
+    delete[] m_buffer;
+    m_buffer=NULL;
+
+    LOG(VB_RECORD, LOG_INFO, LOC + "DownloadStream -- end");
+    return m_ok;
+}
+
+void HTTPReader::HttpRead()
+{
+    m_timer.stop();
+    m_ok = true;
+    ReadBytes();
+    WriteBytes();
+}
+
+void HTTPReader::ReadBytes()
+{
+    QMutexLocker replylock(&m_replylock);
+    QMutexLocker bufferlock(&m_bufferlock);
+
+    if(m_reply == NULL || m_buffer == NULL || size > BUFFER_SIZE)
+        return;
+
+    qint64 bytesRead = m_reply->read( reinterpret_cast<char*>(m_buffer+size), BUFFER_SIZE-size);
+    size += (bytesRead > 0 ? bytesRead : 0);
+    LOG(VB_RECORD, LOG_DEBUG, LOC + QString("ReadBytes: %1 bytes recieved").arg(bytesRead));
+}
+
+void HTTPReader::WriteBytes()
+{
+    if (size < TS_SIZE)
+        return;
+
+    QMutexLocker  replylock(&m_bufferlock);
+    int remainder = 0;
+    {
+        QMutexLocker locker(&m_parent->_listener_lock);
+        HTTPTSStreamHandler::StreamDataList::const_iterator sit;
+        sit = m_parent->_stream_data_list.begin();
+        for (; sit != m_parent->_stream_data_list.end(); ++sit)
+        {
+            remainder = sit.key()->ProcessData(m_buffer, size);
+        }
+    }
+    LOG(VB_RECORD, LOG_DEBUG, LOC + QString("WriteBytes: %1/%2 bytes remain").arg(remainder).arg(size));
+    memcpy(m_buffer, m_buffer+(size-remainder), remainder);
+    size = remainder;
+}
+
+void HTTPReader::Cancel(void)
+{
+    QMutexLocker  replylock(&m_replylock);
+    if (m_reply)
+    {
+        LOG(VB_RECORD, LOG_INFO, LOC + "Cancel: Aborting stream download");
+        m_reply->abort();
+    }
+}

new file mythtv/libs/libmythtv/recorders/httptsstreamhandler.h

@@ +1 @@
+#ifndef _HTTPTSSTREAMHANDLER_H_
+#define _HTTPTSSTREAMHANDLER_H_
+
+#include <vector>
+using namespace std;
+
+#include <QString>
+#include <QMutex>
+#include <QMap>
+#include <QNetworkAccessManager>
+#include <QNetworkRequest>
+#include <QNetworkReply>
+
+#include "channelutil.h"
+#include "iptvstreamhandler.h"
+
+class HTTPReader;
+
+class HTTPTSStreamHandler : public IPTVStreamHandler
+{
+    friend class HTTPReader;
+  public:
+    static HTTPTSStreamHandler* Get(const IPTVTuningData& tuning);
+
+protected:
+    HTTPTSStreamHandler(const IPTVTuningData &tuning);
+    virtual ~HTTPTSStreamHandler(void);
+    virtual void run(void);
+
+  protected:
+    HTTPReader*             m_reader;
+    // for implementing Get & Return
+    static QMutex                               s_handlers_lock;
+    static QMap<QString, HTTPTSStreamHandler*>  s_handlers;
+    static QMap<QString, uint>                  s_handlers_refcnt;
+};
+
+
+class MBASE_PUBLIC HTTPReader : public QObject
+{
+    Q_OBJECT
+
+  public:
+    HTTPReader(HTTPTSStreamHandler* parent) : m_parent(parent){}
+    void Cancel(void);
+    bool DownloadStream(const QUrl url);
+
+  protected:
+    void ReadBytes();
+    void WriteBytes();
+
+  private slots:
+    void HttpRead();
+
+  private:
+    HTTPTSStreamHandler     *m_parent;
+    QTimer                  m_timer;
+    QNetworkAccessManager   m_mgr;
+    QNetworkReply           *m_reply;
+    QMutex                  m_lock;
+    QMutex                  m_replylock;
+    QMutex                  m_bufferlock;
+    uint8_t                 *m_buffer;
+    bool                    m_ok;
+    int                     size;
+};
+
+#endif // _HTTPTSSTREAMHANDLER_H_

mythtv/libs/libmythtv/recorders/iptvchannel.cpp

@@ -12 +12 @@
 
 // MythTV headers
 #include "iptvstreamhandler.h"
+#include "httptsstreamhandler.h"
 #include "hlsstreamhandler.h"
 #include "iptvrecorder.h"
 #include "iptvchannel.h"
@@ -20 +21 @@
 
 #define LOC QString("IPTVChan[%1]: ").arg(GetCardID())
 
-IPTVChannel::IPTVChannel(TVRec *rec, const QString&) :
-    DTVChannel(rec), m_firsttune(true),
+IPTVChannel::IPTVChannel(TVRec *rec, const QString &videodev) :
+    DTVChannel(rec), m_videodev(videodev), m_firsttune(true),
     m_stream_handler(NULL), m_stream_data(NULL)
 {
     LOG(VB_CHANNEL, LOG_INFO, LOC + "ctor");
@@ -100 +101 @@
     {
         m_stream_handler = HLSStreamHandler::Get(m_last_tuning);
     }
+    else if (m_last_tuning.IsHTTPTS())
+    {
+        m_stream_handler = HTTPTSStreamHandler::Get(m_last_tuning);
+    }
     else
     {
         m_stream_handler = IPTVStreamHandler::Get(m_last_tuning);

mythtv/libs/libmythtv/recorders/iptvchannel.h

@@ -64 +64 @@
     mutable QMutex     m_stream_lock;
     IPTVStreamHandler *m_stream_handler;
     MPEGStreamData    *m_stream_data;
+    QString            m_videodev;
 };
 
 #endif // _IPTV_CHANNEL_H_

mythtv/libs/libmythtv/recorders/iptvstreamhandler.cpp

@@ -115 +115 @@
 {
     memset(m_sockets, 0, sizeof(m_sockets));
     memset(m_read_helpers, 0, sizeof(m_read_helpers));
-    m_use_rtp_streaming = m_tuning.GetDataURL().scheme().toUpper() == "RTP";
+    m_use_rtp_streaming = m_tuning.IsRTP();
 }
 
 void IPTVStreamHandler::run(void)
@@ -131 +131 @@
     // Setup
     CetonRTSP *rtsp = NULL;
     IPTVTuningData tuning = m_tuning;
-    if (m_tuning.GetURL(0).scheme().toLower() == "rtsp")
+    if(m_tuning.IsRTSP())
     {
         rtsp = new CetonRTSP(m_tuning.GetURL(0));
 
@@ -165 +165 @@
         urltuned.setScheme("rtp");
         urltuned.setPort(0);
         tuning = IPTVTuningData(urltuned.toString(), 0, IPTVTuningData::kNone,
-                                urltuned.toString(), 0, "", 0);
+                                urltuned.toString(), 0, "", 0, IPTVTuningData::rtp);
     }
 
     bool error = false;
+
     int start_port = 0;
     for (uint i = 0; i < IPTV_SOCKET_COUNT; i++)
     {
@@ -279 +280 @@
 
     if (!error)
     {
-        if (m_use_rtp_streaming)
+        if (m_tuning.IsRTP() || m_tuning.IsRTSP())
             m_buffer = new RTPPacketBuffer(tuning.GetBitrate(0));
         else
             m_buffer = new UDPPacketBuffer(tuning.GetBitrate(0));

mythtv/libs/libmythtv/recorders/iptvstreamhandler.h

@@ -12 +12 @@
 #include <QMutex>
 #include <QMap>
 
+#include <QNetworkAccessManager>
+#include <QtNetwork>
+
 #include "channelutil.h"
 #include "streamhandler.h"
 

mythtv/libs/libmythtv/tv_rec.cpp

@@ -3889 +3889 @@
                         expire.addMSecs(genOpt.channel_timeout * 2);
                 }
                 signalMonitorCheckCnt = 0;
+
+                //System Event TUNING_TIMEOUT deadline
+                QDateTime expire = MythDate::current();
+                signalEventCmdTimeout = expire.addMSecs(genOpt.channel_timeout);
+                signalEventCmdSent = false;
             }
         }
 
@@ -3927 +3932 @@
 MPEGStreamData *TVRec::TuningSignalCheck(void)
 {
     RecStatusType newRecStatus = rsRecording;
+    if ((signalMonitor->IsErrored() ||
+         MythDate::current() > signalEventCmdTimeout) &&
+         !signalEventCmdSent)
+    {
+        gCoreContext->SendSystemEvent(QString("TUNING_SIGNAL_TIMEOUT CARDID %1").arg(cardid));
+        signalEventCmdSent=true;
+    }
     if (signalMonitor->IsAllGood())
     {
         LOG(VB_RECORD, LOG_INFO, LOC + "TuningSignalCheck: Have a good signal");

mythtv/libs/libmythtv/tv_rec.h

@@ -329 +329 @@
     SignalMonitor    *signalMonitor;
     EITScanner       *scanner;
 
+    QDateTime         signalEventCmdTimeout;
+    bool              signalEventCmdSent;
+
     QDateTime         signalMonitorDeadline;
     uint              signalMonitorCheckCnt;