Ticket #7195: 7195-v1.patch

libs/libmythtv/previewgenerator.cpp

@@ -361 +361 @@
         else
         {
             VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Remote Preview failed due to an uknown error.");
+                    "Remote Preview failed due to an unknown error.");
         }
         return false;
     }
@@ -372 +372 @@
         QDir remotecachedir(remotecachedirname);
 
         if (!remotecachedir.exists())
-            remotecachedir.mkdir(remotecachedirname);
+        {
+            if (!remotecachedir.mkdir(remotecachedirname))
+            {
+                VERBOSE(VB_IMPORTANT, LOC_ERR +
+                        "Remote Preview failed because we could not create a "
+                        "remote cache directory");
+                return false;
+            }
+        }
 
         QString filename = programInfo.pathname.section('/',-1) + ".png";
         outFileName = QString("%1/%2").arg(remotecachedirname).arg(filename);

libs/libmyth/remoteutil.h

@@ -52 +52 @@
 MPUBLIC vector<uint> RemoteRequestFreeRecorderList(void);
 MPUBLIC void RemoteGeneratePreviewPixmap(const ProgramInfo *pginfo);
 MPUBLIC QDateTime RemoteGetPreviewLastModified(const ProgramInfo *pginfo);
+MPUBLIC QDateTime RemoteGetPreviewIfModified(
+    const ProgramInfo &pginfo, const QString &cachefile);
 MPUBLIC void RemoteFillProginfo(ProgramInfo *pginfo,
                                 const QString &playbackhostname);
 MPUBLIC QStringList RemoteRecordings(void);

libs/libmyth/remoteutil.cpp

@@ -1 +1 @@
 #include <unistd.h>
 
+#include <QFileInfo>
 #include <QFile>
+#include <QDir>
 
 #include "remoteutil.h"
 #include "programinfo.h"
@@ -287 +289 @@
     return retdatetime;
 }
 
+/// Download preview & get timestamp if newer than cachefile's
+/// last modified time, otherwise just get the timestamp
+QDateTime RemoteGetPreviewIfModified(
+    const ProgramInfo &pginfo, const QString &cachefile)
+{
+    QString loc_err("RemoteGetPreviewIfModified, Error: ");
+
+    QDateTime cacheLastModified;
+    QFileInfo cachefileinfo(cachefile);
+    if (cachefileinfo.exists())
+        cacheLastModified = cachefileinfo.lastModified();
+
+    QStringList strlist("QUERY_PIXMAP_GET_IF_MODIFIED");
+    strlist << ((cacheLastModified.isValid()) ? // unix secs, UTC
+                QString::number(cacheLastModified.toTime_t()) : QString("-1"));
+    strlist << QString::number(200 * 1024); // max size of preview file
+    pginfo.ToStringList(strlist);
+
+    if (!gContext->SendReceiveStringList(strlist) ||
+        strlist.empty() || strlist[0] == "ERROR")
+    {
+        VERBOSE(VB_IMPORTANT, loc_err +
+                QString("Remote error") +
+                ((strlist.size() >= 2) ?
+                 (QString(":\n\t\t\t") + strlist[1]) : QString("")));
+
+        return QDateTime();
+    }
+
+    if (strlist[0] == "WARNING")
+    {
+        VERBOSE(VB_NETWORK, QString("RemoteGetPreviewIfModified, Warning: ") +
+                QString("Remote warning") +
+                ((strlist.size() >= 2) ?
+                 (QString(":\n\t\t\t") + strlist[1]) : QString("")));
+
+        return QDateTime();
+    }
+
+    QDateTime retdatetime;
+    qlonglong timet = strlist[0].toLongLong();
+    if (timet >= 0)
+        retdatetime.setTime_t(timet);
+
+    if (strlist.size() < 4)
+    {
+        return retdatetime;
+    }
+
+    size_t  length     = strlist[1].toLongLong();
+    quint16 checksum16 = strlist[2].toUInt();
+    QByteArray data = QByteArray::fromBase64(strlist[3].toAscii());
+    if ((size_t) data.size() < length)
+    { // (note data.size() may be up to 3 bytes longer after decoding
+        VERBOSE(VB_IMPORTANT, loc_err +
+                QString("Preview size check failed %1 < %2")
+                .arg(data.size()).arg(length));
+        return QDateTime();
+    }
+
+    if (checksum16 != qChecksum(data.constData(), data.size()))
+    {
+        VERBOSE(VB_IMPORTANT, loc_err + "Preview checksum failed");
+        return QDateTime();
+    }
+
+    QString pdir(cachefile.section("/", 0, -2));
+    QDir cfd(pdir);
+    if (!cfd.exists() && !cfd.mkdir(pdir))
+    {
+        VERBOSE(VB_IMPORTANT, loc_err +
+                QString("Unable to create remote cache directory '%1'")
+                .arg(pdir));
+
+        return QDateTime();
+    }
+
+    QFile file(cachefile);
+    if (!file.open(QIODevice::WriteOnly|QIODevice::Truncate))
+    {
+        VERBOSE(VB_IMPORTANT, loc_err +
+                QString("Unable to open cached "
+                        "preview file for writing '%1'")
+                .arg(cachefile));
+
+        return QDateTime();
+    }
+
+    off_t offset = 0;
+    size_t remaining = length;
+    uint failure_cnt = 0;
+    while ((remaining > 0) && (failure_cnt < 5))
+    {
+        ssize_t written = file.write(data.data() + offset, remaining);
+        if (written < 0)
+        {
+            failure_cnt++;
+            usleep(50000);
+            continue;
+        }
+
+        failure_cnt  = 0;
+        offset      += written;
+        remaining   -= written;
+    }
+
+    if (remaining)
+    {
+        VERBOSE(VB_IMPORTANT, loc_err +
+                QString("Failed to write cached preview file '%1'")
+                .arg(cachefile));
+
+        file.resize(0); // in case unlink fails..
+        file.remove();  // closes fd
+        return QDateTime();
+    }
+
+    file.close();
+
+    return retdatetime;
+}
+
 void RemoteFillProginfo(ProgramInfo *pginfo, const QString &playbackhostname)
 {
     QStringList strlist( "FILL_PROGRAM_INFO" );

programs/mythfrontend/playbackbox.cpp

@@ -602 +602 @@
     QString oldimgfile = item->GetImage("preview");
     QString imagefile;
     if (oldimgfile.isEmpty() || force_preview_reload)
-        imagefile = getPreviewImage(pginfo);
+        imagefile = GetPreviewImage(pginfo);
 
     if (!imagefile.isEmpty())
         item->SetImage(imagefile, "preview", force_preview_reload);
@@ -3498 +3498 @@
     return false;
 }
 
-QDateTime PlaybackBox::getPreviewLastModified(ProgramInfo *pginfo)
-{
-    QDateTime datetime;
-    QString filename = pginfo->pathname + ".png";
-
-    if (filename.left(7) != "myth://")
-    {
-        QFileInfo retfinfo(filename);
-        if (retfinfo.exists())
-            datetime = retfinfo.lastModified();
-    }
-    else
-    {
-        datetime = RemoteGetPreviewLastModified(pginfo);
-    }
-
-    return datetime;
-}
-
 void PlaybackBox::IncPreviewGeneratorPriority(const QString &xfn)
 {
     QString fn = xfn.mid(qMax(xfn.lastIndexOf('/') + 1,0));
@@ -3678 +3659 @@
     UpdateProgramInfo(item, item == sel_item, true);
 }
 
-bool check_lastmod(LastCheckedMap &elapsedtime, const QString &filename)
+QString PlaybackBox::GetPreviewImage(ProgramInfo *pginfo)
 {
-    LastCheckedMap::iterator it = elapsedtime.find(filename);
+    if (!pginfo || pginfo->availableStatus == asPendingDelete)
+        return QString();
 
-    if (it != elapsedtime.end() && ((*it).elapsed() < 300))
-        return false;
+    QString filename = pginfo->GetPlaybackURL() + ".png";
 
-    elapsedtime[filename].restart();
-    return true;
-}
+    // If someone is asking for this preview it must be on screen
+    // and hence higher priority than anything else we may have
+    // queued up recently....
+    IncPreviewGeneratorPriority(filename);
 
-QString PlaybackBox::getPreviewImage(ProgramInfo *pginfo)
-{
-    QString filename;
+    QDateTime previewLastModified;
+    QString ret_file = filename;
+    bool streaming = filename.left(1) != "/";
+    bool locally_accessible = false;
+    bool bookmark_updated = false;
 
-    if (!pginfo || pginfo->availableStatus == asPendingDelete)
-        return filename;
+    if (m_previewFromBookmark || streaming)
+    {
+        if (streaming)
+        {
+            ret_file = QString("%1/remotecache/%2")
+                .arg(GetConfDir()).arg(filename.section('/', -1));
 
-    filename = pginfo->GetPlaybackURL() + ".png";
+            QFileInfo finfo(ret_file);
+            if (finfo.exists() &&
+                (!m_previewFromBookmark ||
+                 (finfo.lastModified() >= pginfo->lastmodified)))
+            {
+                // This is just an optimization to avoid
+                // hitting the backend if our cached copy
+                // is newer than the bookmark, or if we have
+                // a preview and do not update it when the
+                // bookmark changes.
+                previewLastModified = finfo.lastModified();
+            }
+            else
+            {
+                previewLastModified =
+                    RemoteGetPreviewIfModified(*pginfo, ret_file);
+            }
+        }
+        else
+        {
+            QFileInfo fi(filename);
+            if ((locally_accessible = fi.exists()))
+                previewLastModified = fi.lastModified();
+        }
 
-    IncPreviewGeneratorPriority(filename);
+        bookmark_updated =
+            m_previewFromBookmark &&
+            ((!previewLastModified.isValid() ||
+              (previewLastModified <  pginfo->lastmodified &&
+               previewLastModified >= pginfo->recendts)));
+    }
+    else
+    {
+        locally_accessible = QFileInfo(filename).exists();
+    }
 
-    bool check_date = check_lastmod(m_previewLastModifyCheck, filename);
+    bool up_to_date_preview_exists =
+        locally_accessible || previewLastModified.isValid();
 
-    QDateTime previewLastModified;
+    if (0)
+    {
+        VERBOSE(VB_IMPORTANT,
+                QString("File  '%1' \n\t\t\tCache '%2'")
+                .arg(filename).arg(ret_file) +
+                QString("\n\t\t\tPreview Exists: %1, "
+                        "Bookmark Updated: %2, "
+                        "Need Preview: %3")
+                .arg(up_to_date_preview_exists).arg(bookmark_updated)
+                .arg((bookmark_updated || !up_to_date_preview_exists)));
+    }
 
-    if (check_date)
-        previewLastModified = getPreviewLastModified(pginfo);
-
-    if (m_previewFromBookmark && check_date &&
-        (!previewLastModified.isValid() ||
-         (previewLastModified <  pginfo->lastmodified &&
-          previewLastModified >= pginfo->recendts)) &&
-        !pginfo->IsEditing() &&
-        !JobQueue::IsJobRunning(JOB_COMMFLAG, pginfo) &&
+    if ((bookmark_updated || !up_to_date_preview_exists) &&
         !IsGeneratingPreview(filename))
     {
         uint attempts = IncPreviewGeneratorAttempts(filename);
@@ -3729 +3752 @@
                             "%2 times, giving up.")
                     .arg(filename).arg(PreviewGenState::maxAttempts));
         }
-
-        if (attempts >= PreviewGenState::maxAttempts)
-            return filename;
     }
 
     UpdatePreviewGeneratorThreads();
 
-    // Image is local
-    if (QFileInfo(filename).exists())
-        return filename;
+    QString ret = (locally_accessible) ?
+        filename : (previewLastModified.isValid()) ?
+        ret_file : (QFileInfo(ret_file).exists()) ?
+        ret_file : QString();
 
-    // If this is a remote frontend then check the remote file cache
-    QString cachefile = QString("%1/remotecache/%3").arg(GetConfDir())
-                                                .arg(filename.section('/', -1));
-    QFileInfo cachefileinfo(cachefile);
-    if (!cachefileinfo.exists() ||
-        previewLastModified.addSecs(-60) > cachefileinfo.lastModified())
-    {
-        if (!IsGeneratingPreview(filename))
-        {
-            uint attempts = IncPreviewGeneratorAttempts(filename);
-            if (attempts < PreviewGenState::maxAttempts)
-            {
-                SetPreviewGenerator(filename, new PreviewGenerator(pginfo,
-                                (PreviewGenerator::Mode)m_previewGeneratorMode));
-            }
-            else if (attempts == PreviewGenState::maxAttempts)
-            {
-                VERBOSE(VB_IMPORTANT, LOC_ERR +
-                        QString("Attempted to generate m_preview for '%1' "
-                                "%2 times, giving up.")
-                        .arg(filename).arg(PreviewGenState::maxAttempts));
-            }
-        }
-    }
+    //VERBOSE(VB_IMPORTANT, QString("Returning: '%1'").arg(ret));
 
-    if (cachefileinfo.exists())
-        return cachefile;
-
-    return "";
+    return ret;
 }
 
 void PlaybackBox::showIconHelp(void)

programs/mythfrontend/playbackbox.h

@@ -56 +56 @@
 typedef QMap<QString,ProgramList>       ProgramMap;
 typedef QMap<QString,QString>           Str2StrMap;
 typedef QMap<QString,PreviewGenState>   PreviewMap;
-typedef QMap<QString,MythTimer>         LastCheckedMap;
 
 class PlaybackBox : public ScheduleCommon
 {
@@ -272 +271 @@
     void UpdateProgressBar(void);
 
     QString cutDown(const QString &, QFont *, int);
-    QDateTime getPreviewLastModified(ProgramInfo *);
-    QString getPreviewImage(ProgramInfo *);
+    QString GetPreviewImage(ProgramInfo *);
 
     bool play(ProgramInfo *rec, bool inPlaylist = false);
     void stop(ProgramInfo *);
@@ -431 +429 @@
     // Preview Pixmap Variables ///////////////////////////////////////////////
     bool                m_previewFromBookmark;
     uint                m_previewGeneratorMode;
-    LastCheckedMap      m_previewLastModifyCheck;
     QMap<QString,QDateTime> m_previewFileTS;
     bool                m_previewSuspend;
     mutable QMutex      m_previewGeneratorLock;

programs/mythbackend/playbacksock.h

@@ -59 +59 @@
                                  const QString     &outputFile,
                                  const QSize       &outputSize);
     QDateTime PixmapLastModified(const ProgramInfo *pginfo);
+
     bool CheckFile(ProgramInfo *pginfo);
 
     bool IsBusy(int        capturecardnum,
@@ -78 +79 @@
                                     const vector<uint> &excluded_cardids);
     void CancelNextRecording(int capturecardnum, bool cancel);
 
+    QStringList ForwardRequest(const QStringList&);
+
   private:
     bool SendReceiveStringList(QStringList &strlist, uint min_reply_length = 0);
 

programs/mythbackend/mainserver.h

@@ -128 +128 @@
     void HandleSetVerbose(QStringList &slist, PlaybackSock *pbs);
     void HandleGenPreviewPixmap(QStringList &slist, PlaybackSock *pbs);
     void HandlePixmapLastModified(QStringList &slist, PlaybackSock *pbs);
+    void HandlePixmapGetIfModified(const QStringList &slist, PlaybackSock *pbs);
     void HandleIsRecording(QStringList &slist, PlaybackSock *pbs);
     void HandleCheckRecordingActive(QStringList &slist, PlaybackSock *pbs);
     void HandleFillProgramInfo(QStringList &slist, PlaybackSock *pbs);

programs/mythbackend/playbacksock.cpp

@@ -481 +481 @@
     SendReceiveStringList(strlist);
 }
 
+QStringList PlaybackSock::ForwardRequest(const QStringList &slist)
+{
+    QStringList strlist = slist;
+
+    if (SendReceiveStringList(strlist))
+        return strlist;
+
+    return QStringList();
+}
+
 /* vim: set expandtab tabstop=4 shiftwidth=4: */

programs/mythbackend/mainserver.cpp

@@ -532 +532 @@
     {
         HandlePixmapLastModified(listline, pbs);
     }
+    else if (command == "QUERY_PIXMAP_GET_IF_MODIFIED")
+    {
+        HandlePixmapGetIfModified(listline, pbs);
+    }
     else if (command == "QUERY_ISRECORDING")
     {
         HandleIsRecording(listline, pbs);
@@ -4614 +4618 @@
         strlist = QStringList( "BAD" );
 
     SendResponse(pbssock, strlist);
-    delete pginfo;
 }
 
+void MainServer::HandlePixmapGetIfModified(
+    const QStringList &slist, PlaybackSock *pbs)
+{
+    QStringList strlist;
+
+    MythSocket *pbssock = pbs->getSocket();
+    if (slist.size() < (3 + NUMPROGRAMLINES))
+    {
+        strlist = QStringList("ERROR");
+        strlist += "1: Parameter list too short";
+        SendResponse(pbssock, strlist);
+        return;
+    }
+
+    QDateTime cachemodified;
+    if (slist[1].toInt() != -1)
+        cachemodified.setTime_t(slist[1].toInt());
+
+    int max_file_size = slist[2].toInt();
+
+    ProgramInfo pginfo;
+
+    if (!pginfo.FromStringList(slist, 3))
+    {
+        strlist = QStringList("ERROR");
+        strlist += "2: Invalid ProgramInfo";
+        SendResponse(pbssock, strlist);
+        return;
+    }
+
+    pginfo.pathname = GetPlaybackURL(&pginfo) + ".png";
+    if (pginfo.pathname.left(1) == "/")
+    {
+        QFileInfo finfo(pginfo.pathname);
+        if (finfo.exists())
+        {
+            size_t fsize = finfo.size();
+            QDateTime lastmodified = finfo.lastModified();
+            bool out_of_date = !cachemodified.isValid() ||
+                (lastmodified > cachemodified);
+
+            if (out_of_date && (fsize > 0) && ((ssize_t)fsize < max_file_size))
+            {
+                QByteArray data;
+                QFile file(pginfo.pathname);
+                bool open_ok = file.open(QIODevice::ReadOnly);
+                if (open_ok)
+                    data = file.readAll();
+
+                if (data.size())
+                {
+                    VERBOSE(VB_FILE, QString("Read preview file '%1'")
+                            .arg(pginfo.pathname));
+                    strlist += QString::number(lastmodified.toTime_t());
+                    strlist += QString::number(data.size());
+                    strlist += QString::number(
+                        qChecksum(data.constData(), data.size()));
+                    strlist += QString(data.toBase64());
+                }
+                else
+                {
+                    VERBOSE(VB_IMPORTANT,
+                            QString("Failed to read preview file '%1'")
+                            .arg(pginfo.pathname));
+
+                    strlist = QStringList("ERROR");
+                    strlist +=
+                        QString("3: Failed to read preview file '%1'%2")
+                        .arg(pginfo.pathname)
+                        .arg((open_ok) ? "" : " open failed");
+                }
+            }
+            else if (out_of_date && (max_file_size > 0))
+            {
+                if (fsize >= (size_t) max_file_size)
+                {
+                    strlist = QStringList("WARNING");
+                    strlist += QString("1: Preview file too big %1 > %2")
+                        .arg(fsize).arg(max_file_size);
+                }
+                else
+                {
+                    strlist = QStringList("ERROR");
+                    strlist += "4: Preview file is invalid";
+                }
+            }
+            else
+            {
+                strlist += QString::number(lastmodified.toTime_t());
+            }
+
+            SendResponse(pbssock, strlist);
+            return;
+        }
+    }
+
+    // handle remote ...
+    if (ismaster && pginfo.hostname != gContext->GetHostName())
+    {
+        PlaybackSock *slave = getSlaveByHostname(pginfo.hostname);
+        if (!slave)
+        {
+            strlist = QStringList("ERROR");
+            strlist +=
+                "5: Could not locate mythbackend that made this recording";
+            SendResponse(pbssock, strlist);
+            return;
+        }
+
+        strlist = slave->ForwardRequest(slist);
+
+        slave->DownRef(); slave = NULL;
+
+        if (!strlist.empty())
+        {
+            SendResponse(pbssock, strlist);
+            return;
+        }
+    }
+
+    strlist = QStringList("WARNING");
+    strlist += "2: Could not locate requested file";
+    SendResponse(pbssock, strlist);
+}
+
 void MainServer::HandleBackendRefresh(MythSocket *socket)
 {
     gContext->RefreshBackendConfig();