Ticket #7195: 7191-gen2-v2.patch

libs/libmythtv/libmythtv.pro

@@ -153 +153 @@
 HEADERS += scheduledrecording.h
 HEADERS += signalmonitorvalue.h     signalmonitorlistener.h
 HEADERS += livetvchain.h            playgroup.h
-HEADERS += channelsettings.h        previewgenerator.h
+HEADERS += channelsettings.h
+HEADERS += previewgenerator.h       previewgeneratorqueue.h
 HEADERS += transporteditor.h        listingsources.h
 HEADERS += myth_imgconvert.h
 HEADERS += channelgroup.h           channelgroupsettings.h
@@ -177 +178 @@
 SOURCES += scheduledrecording.cpp
 SOURCES += signalmonitorvalue.cpp
 SOURCES += livetvchain.cpp          playgroup.cpp
-SOURCES += channelsettings.cpp      previewgenerator.cpp
+SOURCES += channelsettings.cpp
+SOURCES += previewgenerator.cpp     previewgeneratorqueue.cpp
 SOURCES += transporteditor.cpp
 SOURCES += channelgroup.cpp         channelgroupsettings.cpp
 SOURCES += myth_imgconvert.cpp

libs/libmythtv/previewgeneratorqueue.h

@@ +1 @@
+// -*- Mode: c++ -*-
+#ifndef _PREVIEW_GENERATOR_QUEUE_H_
+#define _PREVIEW_GENERATOR_QUEUE_H_
+
+#include <QStringList>
+#include <QDateTime>
+#include <QThread>
+#include <QMutex>
+#include <QMap>
+#include <QSet>
+
+#include "previewgenerator.h"
+#include "mythexp.h"
+
+class ProgramInfo;
+class QSize;
+
+class PreviewGenState
+{
+  public:
+    PreviewGenState() :
+        gen(NULL), genStarted(false),
+        attempts(0), lastBlockTime(0) {}
+    PreviewGenerator *gen;
+    bool              genStarted;
+    uint              attempts;
+    uint              lastBlockTime;
+    QDateTime         blockRetryUntil;
+    QSet<QString>     tokens;
+};
+typedef QMap<QString,PreviewGenState> PreviewMap;
+
+class MPUBLIC PreviewGeneratorQueue : public QThread
+{
+    Q_OBJECT
+
+  public:
+    static void CreatePreviewGeneratorQueue(
+        PreviewGenerator::Mode mode,
+        uint maxAttempts, uint minBlockSeconds);
+    static void TeardownPreviewGeneratorQueue();
+
+    static void GetPreviewImage(const ProgramInfo &pginfo, QString token)
+    {
+        GetPreviewImage(pginfo, QSize(0,0), "", -1, true, token);
+    }
+    static void GetPreviewImage(const ProgramInfo&, const QSize&,
+                                const QString &outputfile,
+                                long long time, bool in_seconds,
+                                QString token);
+    static void AddListener(QObject*);
+    static void RemoveListener(QObject*);
+
+  private:
+    PreviewGeneratorQueue(PreviewGenerator::Mode mode,
+                          uint maxAttempts, uint minBlockSeconds);
+    ~PreviewGeneratorQueue();
+
+    QString GeneratePreviewImage(ProgramInfo &pginfo, const QSize&,
+                                 const QString &outputfile,
+                                 long long time, bool in_seconds,
+                                 QString token);
+
+    void GetInfo(const QString &key, uint &queue_depth, uint &preview_tokens);
+    void SetPreviewGenerator(const QString &key, PreviewGenerator *g);
+    void IncPreviewGeneratorPriority(const QString &key, QString token);
+    void UpdatePreviewGeneratorThreads(void);
+    bool IsGeneratingPreview(const QString &key) const;
+    uint IncPreviewGeneratorAttempts(const QString &key);
+    void ClearPreviewGeneratorAttempts(const QString &key);
+
+    virtual bool event(QEvent *e); // QObject
+
+    void SendEvent(const ProgramInfo &pginfo,
+                   const QString &eventname,
+                   const QString &fn,
+                   const QString &token,
+                   const QString &msg);
+
+  private:
+    static PreviewGeneratorQueue *s_pgq;
+    QSet<QObject*> m_listeners;
+
+    mutable QMutex         m_lock;
+    PreviewGenerator::Mode m_mode;
+    PreviewMap             m_previewMap;
+    QMap<QString,QString>  m_tokenToKeyMap;
+    QStringList            m_queue;
+    uint                   m_running;
+    uint                   m_maxThreads;
+    uint                   m_maxAttempts;
+    uint                   m_minBlockSeconds;
+};
+
+#endif // _PREVIEW_GENERATOR_QUEUE_H_

libs/libmythtv/previewgenerator.cpp

@@ -1 +1 @@
 // C headers
 #include <cmath>
+#include <cassert>
 
 // POSIX headers
 #include <sys/time.h>
 #include <fcntl.h>
 
 // Qt headers
+#include <QCoreApplication>
+#include <QTemporaryFile>
 #include <QFileInfo>
+#include <QMetaType>
+#include <QThread>
 #include <QImage>
-#include <QMetaType>
+#include <QDir>
 #include <QUrl>
-#include <QDir>
 
 // MythTV headers
 #include "mythconfig.h"
@@ -27 +31 @@
 #include "playercontext.h"
 #include "mythdirs.h"
 #include "mythverbose.h"
+#include "remoteutil.h"
 
 #define LOC QString("Preview: ")
 #define LOC_ERR QString("Preview Error: ")
@@ -37 +42 @@
  *
  *   The usage is simple: First, pass a ProgramInfo whose pathname points
  *   to a local or remote recording to the constructor. Then call either
- *   Start(void) or Run(void) to generate the preview.
+ *   start(void) or Run(void) to generate the preview.
  *
- *   Start(void) will create a thread that processes the request,
+ *   start(void) will create a thread that processes the request,
  *   creating a sockets the the backend if the recording is not local.
  *
  *   Run(void) will process the request in the current thread, and it
@@ -47 +52 @@
  *   is not local.
  *
  *   The PreviewGenerator will send Qt signals when the preview is ready
- *   and when the preview thread finishes running if Start(void) was called.
+ *   and when the preview thread finishes running if start(void) was called.
  */
 
 /**
@@ -65 +70 @@
  */
 PreviewGenerator::PreviewGenerator(const ProgramInfo *pginfo,
                                    PreviewGenerator::Mode _mode)
-    : programInfo(*pginfo), mode(_mode), isConnected(false),
-      createSockets(false), serverSock(NULL), pathname(pginfo->GetPathname()),
+    : programInfo(*pginfo), mode(_mode), listener(NULL),
+      pathname(pginfo->GetPathname()),
       timeInSeconds(true),  captureTime(-1),  outFileName(QString::null),
-      outSize(0,0)
+      outSize(0,0), gotReply(false), pixmapOk(false)
 {
 }
 
@@ -84 +89 @@
 
 void PreviewGenerator::TeardownAll(void)
 {
-    if (!isConnected)
-        return;
-
-    const QString filename = programInfo.GetPathname() + ".png";
-
-    MythTimer t;
-    t.start();
-    for (bool done = false; !done;)
-    {
-        previewLock.lock();
-        if (isConnected)
-            emit previewThreadDone(filename, done);
-        else
-            done = true;
-        previewLock.unlock();
-        usleep(5000);
-    }
-    VERBOSE(VB_PLAYBACK, LOC + "previewThreadDone took "<<t.elapsed()<<"ms");
-    disconnectSafe();
+    previewWaitCondition.wakeAll();
+    listener = NULL;
 }
 
 void PreviewGenerator::deleteLater()
@@ -114 +102 @@
 void PreviewGenerator::AttachSignals(QObject *obj)
 {
     QMutexLocker locker(&previewLock);
-    qRegisterMetaType<bool>("bool &");
-    connect(this, SIGNAL(previewThreadDone(const QString&,bool&)),
-            obj,  SLOT(  previewThreadDone(const QString&,bool&)),
-            Qt::DirectConnection);
-    connect(this, SIGNAL(previewReady(const ProgramInfo*)),
-            obj,  SLOT(  previewReady(const ProgramInfo*)),
-            Qt::DirectConnection);
-    isConnected = true;
+    listener = obj;
 }
 
-/** \fn PreviewGenerator::disconnectSafe(void)
- *  \brief disconnects signals while holding previewLock, ensuring that
- *         no one will receive a signal from this class after this call.
- */
-void PreviewGenerator::disconnectSafe(void)
-{
-    QMutexLocker locker(&previewLock);
-    QObject::disconnect(this, NULL, NULL, NULL);
-    isConnected = false;
-}
-
-/** \fn PreviewGenerator::Start(void)
- *  \brief This call starts a thread that will create a preview.
- */
-void PreviewGenerator::Start(void)
-{
-    pthread_create(&previewThread, NULL, PreviewRun, this);
-    // detach, so we don't have to join thread to free thread local mem.
-    pthread_detach(previewThread);
-}
-
 /** \fn PreviewGenerator::RunReal(void)
  *  \brief This call creates a preview without starting a new thread.
  */
 bool PreviewGenerator::RunReal(void)
 {
+    QString msg;
+    QTime tm = QTime::currentTime();
     bool ok = false;
     bool is_local = IsLocal();
     if (is_local && (mode && kLocal) && LocalPreviewRun())
     {
         ok = true;
+        msg = QString("Generated on %1 in %2 seconds, starting at %3")
+            .arg(gCoreContext->GetHostName())
+            .arg(tm.elapsed()*0.001)
+            .arg(tm.toString(Qt::ISODate));
     }
     else if (mode & kRemote)
     {
@@ -166 +132 @@
                     "\n\t\t\tAttempting to regenerate preview on backend.\n");
         }
         ok = RemotePreviewRun();
+        if (ok)
+        {
+            msg = QString("Generated remotely in %1 seconds, starting at %2")
+                .arg(tm.elapsed()*0.001)
+                .arg(tm.toString(Qt::ISODate));
+        }
     }
     else
     {
         VERBOSE(VB_IMPORTANT, LOC_ERR + QString("Run() file not local: '%1'")
                 .arg(pathname));
+        msg = "Could not access recording";
     }
 
+    QMutexLocker locker(&previewLock);
+    if (listener)
+    {
+        QString message = (ok) ? "PREVIEW_SUCCESS" : "PREVIEW_FAILED";
+        assert(!token.isEmpty());
+        QStringList list(token);
+        list.push_back(programInfo.MakeUniqueKey());
+        list.push_back(outFileName.isEmpty() ?
+                       (programInfo.GetPathname()+".png") : outFileName);
+        list.push_back(msg);
+        QCoreApplication::postEvent(listener, new MythEvent(message, list));
+    }
+
     return ok;
 }
 
 bool PreviewGenerator::Run(void)
 {
+    VERBOSE(VB_IMPORTANT, LOC + "Run() -- begin");
+
+    QString msg;
+    QTime tm = QTime::currentTime();
     bool ok = false;
     QString command = GetInstallPrefix() + "/bin/mythpreviewgen";
     bool local_ok = (IsLocal() && (mode & kLocal) &&
@@ -187 +177 @@
         if (mode & kRemote)
         {
             ok = RemotePreviewRun();
+            if (ok)
+            {
+                msg =
+                    QString("Generated remotely in %1 seconds, starting at %2")
+                    .arg(tm.elapsed()*0.001)
+                    .arg(tm.toString(Qt::ISODate));
+            }
         }
         else
         {
             VERBOSE(VB_IMPORTANT, LOC_ERR +
                     QString("Run() can not generate preview locally for: '%1'")
                     .arg(pathname));
+            msg = "Failed, local preview requested for remote file.";
         }
     }
     else
@@ -215 +213 @@
         if (!outFileName.isEmpty())
             command += QString("--outfile \"%1\" ").arg(outFileName);
 
+        command += " > /dev/null";
+
         int ret = myth_system(command, MYTH_SYSTEM_DONT_BLOCK_LIRC |
                                        MYTH_SYSTEM_DONT_BLOCK_JOYSTICK_MENU |
                                        MYTH_SYSTEM_DONT_BLOCK_PARENT);
         if (ret)
         {
-            VERBOSE(VB_IMPORTANT, LOC_ERR + "Encountered problems running " +
-                    QString("'%1'").arg(command));
+            msg = QString("Encountered problems running '%1'").arg(command);
+            VERBOSE(VB_IMPORTANT, LOC_ERR + msg);
         }
         else
         {
@@ -240 +240 @@
             QFileInfo fi(outname);
             ok = (fi.exists() && fi.isReadable() && fi.size());
             if (ok)
+            {
                 VERBOSE(VB_PLAYBACK, LOC + "Preview process ran ok.");
+                msg = QString("Generated on %1 in %2 seconds, starting at %3")
+                    .arg(gCoreContext->GetHostName())
+                    .arg(tm.elapsed()*0.001)
+                    .arg(tm.toString(Qt::ISODate));
+            }
             else
             {
                 VERBOSE(VB_IMPORTANT, LOC_ERR + "Preview process not ok." +
@@ -251 +257 @@
                 VERBOSE(VB_IMPORTANT, LOC_ERR +
                         QString("Despite command '%1' returning success")
                         .arg(command));
+                msg = QString("Failed to read preview image despite "
+                              "preview process returning success.");
             }
         }
     }
 
-    if (ok)
+    VERBOSE(VB_IMPORTANT, LOC + "Run() -- waiting on lock");
+    QMutexLocker locker(&previewLock);
+    VERBOSE(VB_IMPORTANT, LOC + "Run() -- got lock");
+
+    QString message = (ok) ? "PREVIEW_SUCCESS" : "PREVIEW_FAILED";
+    if (listener)
     {
-        QMutexLocker locker(&previewLock);
-        emit previewReady(&programInfo);
+        assert(!token.isEmpty());
+        QStringList list(token);
+        list.push_back(programInfo.MakeUniqueKey());
+        list.push_back(outFileName.isEmpty() ?
+                       (programInfo.GetPathname()+".png") : outFileName);
+        if (!msg.isEmpty())
+            list.push_back(msg);
+        QCoreApplication::postEvent(listener, new MythEvent(message, list));
     }
+    VERBOSE(VB_IMPORTANT, LOC + "Run() -- end");
 
     return ok;
 }
 
-void *PreviewGenerator::PreviewRun(void *param)
+void PreviewGenerator::run(void)
 {
-    // Lower scheduling priority, to avoid problems with recordings.
-    if (setpriority(PRIO_PROCESS, 0, 9))
-        VERBOSE(VB_IMPORTANT, LOC + "Setting priority failed." + ENO);
-    PreviewGenerator *gen = (PreviewGenerator*) param;
-    gen->createSockets = true;
-    gen->Run();
-    gen->deleteLater();
-    return NULL;
+    VERBOSE(VB_IMPORTANT, LOC + "run() -- begin");
+    setPriority(QThread::LowPriority);
+    Run();
+    connect(this, SIGNAL(finished()),
+            this, SLOT(deleteLater()));
+    VERBOSE(VB_IMPORTANT, LOC + "run() -- end");
 }
 
-bool PreviewGenerator::RemotePreviewSetup(void)
+bool PreviewGenerator::RemotePreviewRun(void)
 {
-    QString server = gCoreContext->GetSetting("MasterServerIP", "localhost");
-    int     port   = gCoreContext->GetNumSetting("MasterServerPort", 6543);
-    QString ann    = QString("ANN Monitor %2 %3")
-        .arg(gCoreContext->GetHostName()).arg(false);
+    VERBOSE(VB_IMPORTANT, LOC + "RemotePreviewRun() -- begin");
 
-    serverSock = gCoreContext->ConnectCommandSocket(server, port, ann);
-    return serverSock;
-}
-
-bool PreviewGenerator::RemotePreviewRun(void)
-{
-    QStringList strlist( "QUERY_GENPIXMAP" );
+    QStringList strlist( "QUERY_GENPIXMAP2" );
+    if (token.isEmpty())
+    {
+        token = QString("%1:%2")
+            .arg(programInfo.MakeUniqueKey()).arg(rand());
+    }
+    strlist.push_back(token);
     programInfo.ToStringList(strlist);
     strlist.push_back(timeInSeconds ? "s" : "f");
     encodeLongLong(strlist, captureTime);
@@ -305 +320 @@
     strlist.push_back(QString::number(outSize.width()));
     strlist.push_back(QString::number(outSize.height()));
 
-    bool ok = false;
+    gCoreContext->addListener(this);
+    pixmapOk = false;
 
-    if (createSockets)
-    {
-        if (!RemotePreviewSetup())
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to open sockets.");
-            return false;
-        }
-
-        if (serverSock)
-        {
-            serverSock->writeStringList(strlist);
-            ok = serverSock->readStringList(strlist, false);
-        }
-
-        RemotePreviewTeardown();
-    }
-    else
-    {
-        ok = gCoreContext->SendReceiveStringList(strlist);
-    }
-
+    bool ok = gCoreContext->SendReceiveStringList(strlist);
     if (!ok || strlist.empty() || (strlist[0] != "OK"))
     {
         if (!ok)
@@ -340 +336 @@
             VERBOSE(VB_IMPORTANT, LOC_ERR +
                     "Remote Preview failed, reason given: " <<strlist[1]);
         }
-        else
+
+        gCoreContext->removeListener(this);
+
+        return false;
+    }
+
+    VERBOSE(VB_IMPORTANT, LOC + "RemotePreviewRun() -- waiting on lock");
+    QMutexLocker locker(&previewLock);
+    VERBOSE(VB_IMPORTANT, LOC + "RemotePreviewRun() -- got lock");
+
+    // wait up to 30 seconds for the preview to complete
+    if (!gotReply)
+        previewWaitCondition.wait(&previewLock, 30 * 1000);
+
+    if (!gotReply)
+        VERBOSE(VB_IMPORTANT, LOC + "RemotePreviewRun() -- no reply..");
+
+    gCoreContext->removeListener(this);
+
+    VERBOSE(VB_IMPORTANT, LOC + "RemotePreviewRun() -- end");
+
+    return pixmapOk;
+}
+
+bool PreviewGenerator::event(QEvent *e)
+{
+    if (e->type() == (QEvent::Type) MythEvent::MythEventMessage)
+    {
+        MythEvent *me = (MythEvent*)e;
+        if (me->Message() == "GENERATED_PIXMAP" && me->ExtraDataCount() >= 2 &&
+            me->ExtraData(0) == token)
         {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    "Remote Preview failed due to an unknown error.");
+            VERBOSE(VB_IMPORTANT, LOC + "got GENERATED_PIXMAP event\n\n\n");
+            QMutexLocker locker(&previewLock);
+            gotReply = true;
+            pixmapOk = me->ExtraData(1) == "OK";
+            if (pixmapOk)
+            {
+                QByteArray data;
+                if (me->ExtraDataCount() >= 4)
+                {
+                    size_t length = me->ExtraData(2).toULongLong();
+                    quint16 checksum16 = me->ExtraData(3).toUInt();
+                    data = QByteArray::fromBase64(me->ExtraData(4).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));
+                        data.clear();
+                    }
+                    data.resize(length);
+
+                    if (checksum16 != qChecksum(data.constData(), data.size()))
+                    {
+                        VERBOSE(VB_IMPORTANT, LOC_ERR +
+                                "Preview checksum failed");
+                        data.clear();
+                    }
+                }
+                pixmapOk = (data.isEmpty()) ? false : SaveOutFile(data);
+            }
+
+            previewWaitCondition.wakeAll();
+
+            return true;
         }
-        return false;
     }
+    return QObject::event(e);
+}
 
+bool PreviewGenerator::SaveOutFile(QByteArray &data)
+{
     if (outFileName.isEmpty())
     {
-        QString remotecachedirname = QString("%1/remotecache").arg(GetConfDir());
+        QString remotecachedirname =
+            QString("%1/remotecache").arg(GetConfDir());
         QDir remotecachedir(remotecachedirname);
 
         if (!remotecachedir.exists())
@@ -368 +431 @@
         outFileName = QString("%1/%2").arg(remotecachedirname).arg(filename);
     }
 
-    // find file, copy/move to output file name & location...
+    bool ok = true;
+    if (data.isEmpty())
+    {
+        // find file, copy/move to output file name & location...
+        QString url = QString::null;
+        QString fn = QFileInfo(outFileName).fileName();
+        ok = false;
 
-    QString url = QString::null;
-    QString fn = QFileInfo(outFileName).fileName();
-    QByteArray data;
-    ok = false;
+        QStringList fileNames;
+        fileNames.push_back(
+            CreateAccessibleFilename(programInfo.GetPathname(), fn));
+        fileNames.push_back(
+            CreateAccessibleFilename(programInfo.GetPathname(), ""));
 
-    QStringList fileNames;
-    fileNames.push_back(
-        CreateAccessibleFilename(programInfo.GetPathname(), fn));
-    fileNames.push_back(
-        CreateAccessibleFilename(programInfo.GetPathname(), ""));
+        QStringList::const_iterator it = fileNames.begin();
+        for ( ; it != fileNames.end() && (!ok || data.isEmpty()); ++it)
+        {
+            data.resize(0);
+            url = *it;
+            RemoteFile *rf = new RemoteFile(url, false, false, 0);
+            ok = rf->SaveAs(data);
+            delete rf;
+        }
+    }
 
-    QStringList::const_iterator it = fileNames.begin();
-    for ( ; it != fileNames.end() && (!ok || data.isEmpty()); ++it)
+    if (!ok)
+        return false;
+
+    QFile file(outFileName);
+    ok = file.open(QIODevice::Unbuffered|QIODevice::WriteOnly);
+    if (!ok)
     {
-        data.resize(0);
-        url = *it;
-        RemoteFile *rf = new RemoteFile(url, false, false, 0);
-        ok = rf->SaveAs(data);
-        delete rf;
+        VERBOSE(VB_IMPORTANT, LOC_ERR + QString("Failed to open: '%1'")
+                .arg(outFileName));
     }
 
-    if (ok && data.size())
+    off_t offset = 0;
+    size_t remaining = data.size();
+    uint failure_cnt = 0;
+    while ((remaining > 0) && (failure_cnt < 5))
     {
-        QFile file(outFileName);
-        ok = file.open(QIODevice::Unbuffered|QIODevice::WriteOnly);
-        if (!ok)
+        ssize_t written = file.write(data.data() + offset, remaining);
+        if (written < 0)
         {
-            VERBOSE(VB_IMPORTANT, QString("Failed to open: '%1'")
-                    .arg(outFileName));
+            failure_cnt++;
+            usleep(50000);
+            continue;
         }
 
-        off_t offset = 0;
-        size_t remaining = (ok) ? data.size() : 0;
-        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 (ok && !remaining)
-        {
-            VERBOSE(VB_PLAYBACK, QString("Saved: '%1'")
-                    .arg(outFileName));
-        }
+        failure_cnt  = 0;
+        offset      += written;
+        remaining   -= written;
     }
-
-    return ok && data.size();
-}
-
-void PreviewGenerator::RemotePreviewTeardown(void)
-{
-    if (serverSock)
+    if (ok && !remaining)
     {
-        serverSock->DownRef();
-        serverSock = NULL;
+        VERBOSE(VB_PLAYBACK, LOC + QString("Saved: '%1'").arg(outFileName));
     }
+    else
+    {
+        file.remove();
+    }
+
+    return ok;
 }
 
 bool PreviewGenerator::SavePreview(QString filename,
@@ -476 +535 @@
     QImage small_img = img.scaled((int) ppw, (int) pph,
         Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 
-    QByteArray fname = filename.toAscii();
-    if (small_img.save(fname.constData(), "PNG"))
+    QTemporaryFile f(QFileInfo(filename).absoluteFilePath()+".XXXXXX");
+    f.setAutoRemove(false);
+    if (f.open() && small_img.save(&f, "PNG"))
     {
-        makeFileAccessible(fname.constData()); // Let anybody update it
-
-        VERBOSE(VB_PLAYBACK, LOC +
-                QString("Saved preview '%0' %1x%2")
-                .arg(filename).arg((int) ppw).arg((int) pph));
-
-        return true;
+        // Let anybody update it
+        makeFileAccessible(f.fileName().toLocal8Bit().constData());
+        QFile of(filename);
+        of.remove();
+        if (f.rename(filename))
+        {
+            VERBOSE(VB_PLAYBACK, LOC +
+                    QString("Saved preview '%0' %1x%2")
+                    .arg(filename).arg((int) ppw).arg((int) pph));
+            return true;
+        }
+        f.remove();
     }
 
-    // Save failed; if file exists, try saving to .new and moving over
-    QString newfile = filename + ".new";
-    QByteArray newfilea = newfile.toAscii();
-    if (QFileInfo(fname.constData()).exists() &&
-        small_img.save(newfilea.constData(), "PNG"))
-    {
-        makeFileAccessible(newfilea.constData());
-        rename(newfilea.constData(), fname.constData());
+    VERBOSE(VB_IMPORTANT, LOC_ERR +
+            QString("Failed to save preview '%0' %1x%2")
+            .arg(filename).arg((int) ppw).arg((int) pph));
 
-        VERBOSE(VB_PLAYBACK, LOC +
-                QString("Saved preview '%0' %1x%2")
-                .arg(filename).arg((int) ppw).arg((int) pph));
-
-        return true;
-    }
-
-    // Couldn't save, nothing else I can do?
     return false;
 }
 

libs/libmythtv/previewgeneratorqueue.cpp

@@ +1 @@
+#include <QCoreApplication>
+#include <QFileInfo>
+#include <QThread>
+
+#include "previewgeneratorqueue.h"
+#include "previewgenerator.h"
+#include "mythcorecontext.h"
+#include "mythcontext.h"
+#include "remoteutil.h"
+#include "mythdirs.h"
+
+#define LOC QString("PreviewQueue: ")
+#define LOC_ERR QString("PreviewQueue Error: ")
+#define LOC_WARN QString("PreviewQueue Warning: ")
+
+PreviewGeneratorQueue *PreviewGeneratorQueue::s_pgq = NULL;
+
+void PreviewGeneratorQueue::CreatePreviewGeneratorQueue(
+    PreviewGenerator::Mode mode,
+    uint maxAttempts, uint minBlockSeconds)
+{
+    s_pgq = new PreviewGeneratorQueue(mode, maxAttempts, minBlockSeconds);
+}
+
+void PreviewGeneratorQueue::TeardownPreviewGeneratorQueue()
+{
+    s_pgq->exit(0);
+    s_pgq->wait();
+    delete s_pgq;
+}
+
+PreviewGeneratorQueue::PreviewGeneratorQueue(
+    PreviewGenerator::Mode mode,
+    uint maxAttempts, uint minBlockSeconds) :
+    m_mode(mode),
+    m_running(0), m_maxThreads(2),
+    m_maxAttempts(maxAttempts), m_minBlockSeconds(minBlockSeconds)
+{
+    if (PreviewGenerator::kLocal & mode)
+    {
+        int idealThreads = QThread::idealThreadCount();
+        m_maxThreads = (idealThreads >= 1) ? idealThreads * 2 : 2;
+    }
+
+    moveToThread(this);
+    start();
+}
+
+PreviewGeneratorQueue::~PreviewGeneratorQueue()
+{
+    // disconnect preview generators
+    QMutexLocker locker(&m_lock);
+    PreviewMap::iterator it = m_previewMap.begin();
+    for (;it != m_previewMap.end(); ++it)
+    {
+        if ((*it).gen)
+            (*it).gen->deleteLater();
+    }
+}
+
+#include <cassert>
+void PreviewGeneratorQueue::GetPreviewImage(
+    const ProgramInfo &pginfo,
+    const QSize &outputsize,
+    const QString &outputfile,
+    long long time, bool in_seconds,
+    QString token)
+{
+    assert(!token.isEmpty());
+
+    if (!s_pgq)
+        return;
+
+    if (pginfo.GetPathname().isEmpty() ||
+        pginfo.GetBasename() == pginfo.GetPathname())
+    {
+        return;
+    }
+
+    QStringList extra;
+    pginfo.ToStringList(extra);
+    extra += token;
+    extra += QString::number(outputsize.width());
+    extra += QString::number(outputsize.height());
+    extra += outputfile;
+    extra += QString::number(time);
+    extra += (in_seconds ? "1" : "0");
+    MythEvent *e = new MythEvent("GET_PREVIEW", extra);
+    QCoreApplication::postEvent(s_pgq, e);
+}
+
+void PreviewGeneratorQueue::AddListener(QObject *listener)
+{
+    if (!s_pgq)
+        return;
+
+    QMutexLocker locker(&s_pgq->m_lock);
+    s_pgq->m_listeners.insert(listener);
+}
+
+void PreviewGeneratorQueue::RemoveListener(QObject *listener)
+{
+    if (!s_pgq)
+        return;
+
+    QMutexLocker locker(&s_pgq->m_lock);
+    s_pgq->m_listeners.remove(listener);
+}
+
+bool PreviewGeneratorQueue::event(QEvent *e)
+{
+    if (e->type() != (QEvent::Type) MythEvent::MythEventMessage)
+        return QObject::event(e);
+
+    MythEvent *me = (MythEvent*)e;
+    if (me->Message() == "GET_PREVIEW")
+    {
+        const QStringList list = me->ExtraDataList();
+        QStringList::const_iterator it = list.begin();
+        ProgramInfo evinfo(it, list.end());
+        QString token;
+        QSize outputsize;
+        QString outputfile;
+        long long time;
+        bool time_fmt_sec;
+        if (it != list.end())
+            token = (*it++);
+        if (it != list.end())
+            outputsize.setWidth((*it++).toInt());
+        if (it != list.end())
+            outputsize.setHeight((*it++).toInt());
+        if (it != list.end())
+            outputfile = (*it++);
+        if (it != list.end())
+            time = (*it++).toLongLong();
+        QString fn;
+        if (it != list.end())
+        {
+            time_fmt_sec = (*it++).toInt() != 0;
+            fn = GeneratePreviewImage(evinfo, outputsize, outputfile,
+                                      time, time_fmt_sec, token);
+        }
+        return true;
+    }
+    else if (me->Message() == "PREVIEW_SUCCESS" ||
+             me->Message() == "PREVIEW_FAILED")
+    {
+        QString token     = me->ExtraData(0);
+        QString pginfokey = me->ExtraData(1); // pginfo->MakeUniqueKey()
+        QString filename  = me->ExtraData(2); // outFileName
+        QString msg;
+        if (me->ExtraDataCount() >= 4)
+            msg = me->ExtraData(3);
+
+        VERBOSE(VB_PLAYBACK, LOC + QString("Preview '%1' processed")
+                .arg(token));
+
+        {
+        QMutexLocker locker(&m_lock);
+        QMap<QString,QString>::iterator kit = m_tokenToKeyMap.find(token);
+        if (kit == m_tokenToKeyMap.end())
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR +
+                    QString("Failed to find token %1 in map.").arg(token));
+            return true;
+        }
+        PreviewMap::iterator it = m_previewMap.find(*kit);
+        if (it == m_previewMap.end())
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR +
+                    QString("Failed to find key %1 in map.").arg(*kit));
+            return true;
+        }
+
+        (*it).gen           = NULL;
+        (*it).genStarted    = false;
+        if (me->Message() == "PREVIEW_SUCCESS")
+        {
+            (*it).attempts      = 0;
+            (*it).lastBlockTime = 0;
+            (*it).blockRetryUntil = QDateTime();
+        }
+        else
+        {
+            (*it).lastBlockTime =
+                max(m_minBlockSeconds, (*it).lastBlockTime * 2);
+            (*it).blockRetryUntil =
+                QDateTime::currentDateTime().addSecs((*it).lastBlockTime);
+        }
+
+        QStringList list;
+        list.push_back(pginfokey);
+        list.push_back(filename);
+        list.push_back("");
+        if (!msg.isEmpty())
+            list.push_back(msg);
+
+        QSet<QString>::const_iterator tit = (*it).tokens.begin();
+        for (; tit != (*it).tokens.end(); ++tit)
+        {
+            list[2] = (*tit);
+            QSet<QObject*>::iterator sit = m_listeners.begin();
+            for (; sit != m_listeners.end(); ++sit)
+            {
+                MythEvent *e = new MythEvent(me->Message(), list);
+                QCoreApplication::postEvent(*sit, e);
+            }
+        }
+        (*it).tokens.clear();
+
+        m_running--;
+        }
+
+        UpdatePreviewGeneratorThreads();
+
+        return true;
+    }
+    return false;
+}
+
+void PreviewGeneratorQueue::SendEvent(
+    const ProgramInfo &pginfo,
+    const QString &eventname,
+    const QString &fn, const QString &token, const QString &msg)
+{
+    VERBOSE(VB_IMPORTANT, QString("SendEvent(%1, %2, %3, %4)")
+            .arg(pginfo.toString(ProgramInfo::kTitleSubtitle))
+            .arg(eventname).arg(msg).arg(token));
+
+    QStringList list;
+    list.push_back(pginfo.MakeUniqueKey());
+    list.push_back(fn);
+    list.push_back(token);
+    list.push_back(msg);
+
+    QMutexLocker locker(&m_lock);
+    QSet<QObject*>::iterator it = m_listeners.begin();
+    for (; it != m_listeners.end(); ++it)
+    {
+        MythEvent *e = new MythEvent(eventname, list);
+        QCoreApplication::postEvent(*it, e);
+    }
+}
+
+QString PreviewGeneratorQueue::GeneratePreviewImage(
+    ProgramInfo &pginfo,
+    const QSize &size,
+    const QString &outputfile,
+    long long time, bool in_seconds,
+    QString token)
+{
+    QString key = QString("%1_%2x%3_%4%5")
+        .arg(pginfo.GetBasename()).arg(size.width()).arg(size.height())
+        .arg(time).arg(in_seconds?"s":"f");
+
+    if (pginfo.GetAvailableStatus() == asPendingDelete)
+    {
+        SendEvent(pginfo, "PREVIEW_FAILED", key, token, "Pending Delete");
+        return QString();
+    }
+
+    QString filename = (outputfile.isEmpty()) ?
+        pginfo.GetPathname() + ".png" : outputfile;
+    QString ret_file = filename;
+    QString ret;
+
+    bool is_special = !outputfile.isEmpty() || time >= 0 ||
+        size.width() || size.height();
+
+    bool needs_gen = true;
+    if (!is_special)
+    {
+        QDateTime previewLastModified;
+        bool streaming = filename.left(1) != "/";
+        bool locally_accessible = false;
+        bool bookmark_updated = false;
+
+        QDateTime bookmark_ts = pginfo.QueryBookmarkTimeStamp();
+        QDateTime cmp_ts = bookmark_ts.isValid() ?
+            bookmark_ts : pginfo.GetLastModifiedTime();
+
+        if (streaming)
+        {
+            ret_file = QString("%1/remotecache/%2")
+                .arg(GetConfDir()).arg(filename.section('/', -1));
+
+            QFileInfo finfo(ret_file);
+            if (finfo.isReadable() && finfo.lastModified() >= cmp_ts)
+            {
+                // 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 if (!IsGeneratingPreview(key))
+            {
+                previewLastModified =
+                    RemoteGetPreviewIfModified(pginfo, ret_file);
+            }
+        }
+        else
+        {
+            QFileInfo fi(filename);
+            if ((locally_accessible = fi.isReadable()))
+                previewLastModified = fi.lastModified();
+        }
+
+        bookmark_updated =
+            (!previewLastModified.isValid() || (previewLastModified < cmp_ts));
+
+        if (bookmark_updated && bookmark_ts.isValid() &&
+            previewLastModified.isValid())
+        {
+            ClearPreviewGeneratorAttempts(key);
+        }
+
+        if (0)
+        {
+            VERBOSE(VB_IMPORTANT, QString(
+                        "previewLastModified:  %1\n\t\t\t"
+                        "bookmark_ts:          %2\n\t\t\t"
+                        "pginfo.lastmodified: %3")
+                    .arg(previewLastModified.toString(Qt::ISODate))
+                    .arg(bookmark_ts.toString(Qt::ISODate))
+                    .arg(pginfo.GetLastModifiedTime(ISODate)));
+        }
+
+        bool preview_exists = previewLastModified.isValid();
+
+        if (0)
+        {
+            VERBOSE(VB_IMPORTANT,
+                    QString("Title: %1\n\t\t\t")
+                    .arg(pginfo.toString(ProgramInfo::kTitleSubtitle)) +
+                    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(preview_exists).arg(bookmark_updated)
+                    .arg((bookmark_updated || !preview_exists)));
+        }
+
+        needs_gen = bookmark_updated || !preview_exists;
+
+        if (!needs_gen)
+        {
+            if (locally_accessible)
+                ret = filename;
+            else if (preview_exists && QFileInfo(ret_file).isReadable())
+                ret = ret_file;
+        }
+    }
+
+    if (needs_gen && !IsGeneratingPreview(key))
+    {
+        uint attempts = IncPreviewGeneratorAttempts(key);
+        if (attempts < m_maxAttempts)
+        {
+            VERBOSE(VB_PLAYBACK, LOC +
+                    QString("Requesting preview for '%1'")
+                    .arg(key));
+            PreviewGenerator *pg = new PreviewGenerator(&pginfo, m_mode);
+            if (!outputfile.isEmpty() || time >= 0 ||
+                size.width() || size.height())
+            {
+                pg->SetPreviewTime(time, in_seconds);
+                pg->SetOutputFilename(outputfile);
+                pg->SetOutputSize(size);
+            }
+            pg->token = token;
+
+            SetPreviewGenerator(key, pg);
+
+            VERBOSE(VB_PLAYBACK, LOC +
+                    QString("Requested preview for '%1'").arg(key));
+        }
+        else if (attempts >= m_maxAttempts)
+        {
+            VERBOSE(VB_IMPORTANT, LOC_ERR +
+                    QString("Attempted to generate preview for '%1' "
+                            "%2 times; >= max(%3)")
+                    .arg(key).arg(attempts).arg(m_maxAttempts));
+        }
+    }
+    else if (needs_gen)
+    {
+        VERBOSE(VB_PLAYBACK, LOC +
+                "Not requesting preview as it "
+                "is already being generated");
+        IncPreviewGeneratorPriority(key, token);
+    }
+
+    UpdatePreviewGeneratorThreads();
+
+    if (!ret.isEmpty())
+    {
+        QString msg = "On Disk";
+        SendEvent(pginfo, "PREVIEW_SUCCESS", ret, token, msg);
+    }
+    else
+    {
+        uint queue_depth, token_cnt;
+        GetInfo(key, queue_depth, token_cnt);
+        QString msg = QString("Queue depth %1, our tokens %2")
+            .arg(queue_depth).arg(token_cnt);
+        SendEvent(pginfo, "PREVIEW_QUEUED", ret, token, msg);
+    }
+
+    return ret;
+}
+
+void PreviewGeneratorQueue::GetInfo(
+    const QString &key, uint &queue_depth, uint &token_cnt)
+{
+    QMutexLocker locker(&m_lock);
+    queue_depth = m_queue.size();
+    PreviewMap::iterator pit = m_previewMap.find(key);
+    token_cnt = (pit == m_previewMap.end()) ? 0 : (*pit).tokens.size();
+}
+
+void PreviewGeneratorQueue::IncPreviewGeneratorPriority(
+    const QString &key, QString token)
+{
+    QMutexLocker locker(&m_lock);
+    m_queue.removeAll(key);
+
+    PreviewMap::iterator pit = m_previewMap.find(key);
+    if (pit == m_previewMap.end())
+        return;
+
+    if ((*pit).gen && !(*pit).genStarted)
+        m_queue.push_back(key);
+
+    if (!token.isEmpty())
+    {
+        m_tokenToKeyMap[token] = key;
+        (*pit).tokens.insert(token);
+    }
+}
+
+void PreviewGeneratorQueue::UpdatePreviewGeneratorThreads(void)
+{
+    QMutexLocker locker(&m_lock);
+    QStringList &q = m_queue;
+    if (!q.empty() && (m_running < m_maxThreads))
+    {
+        QString fn = q.back();
+        q.pop_back();
+        PreviewMap::iterator it = m_previewMap.find(fn);
+        if (it != m_previewMap.end() && (*it).gen && !(*it).genStarted)
+        {
+            m_running++;
+            VERBOSE(VB_IMPORTANT, LOC + "Starting pg thread");
+            (*it).gen->start();
+            (*it).genStarted = true;
+        }
+    }
+}
+
+/** \brief Sets the PreviewGenerator for a specific file.
+ *  \return true iff call succeeded.
+ */
+void PreviewGeneratorQueue::SetPreviewGenerator(
+    const QString &key, PreviewGenerator *g)
+{
+    {
+        QMutexLocker locker(&m_lock);
+        m_tokenToKeyMap[g->token] = key;
+        PreviewGenState &state = m_previewMap[key];
+        if (state.gen)
+        {
+            if (!g->token.isEmpty())
+                state.tokens.insert(g->token);
+            g->deleteLater();
+        }
+        else
+        {
+            g->AttachSignals(this);
+            state.gen = g;
+            state.genStarted = false;
+            if (!g->token.isEmpty())
+                state.tokens.insert(g->token);
+        }
+    }
+
+    IncPreviewGeneratorPriority(key, "");
+}
+
+/** \brief Returns true if we have already started a
+ *         PreviewGenerator to create this file.
+ */
+bool PreviewGeneratorQueue::IsGeneratingPreview(const QString &key) const
+{
+    PreviewMap::const_iterator it;
+    QMutexLocker locker(&m_lock);
+
+    if ((it = m_previewMap.find(key)) == m_previewMap.end())
+        return false;
+
+    if ((*it).blockRetryUntil.isValid())
+        return QDateTime::currentDateTime() < (*it).blockRetryUntil;
+
+    return (*it).gen;
+}
+
+/** \fn PreviewGeneratorQueue::IncPreviewGeneratorAttempts(const QString&)
+ *  \brief Increments and returns number of times we have
+ *         started a PreviewGenerator to create this file.
+ */
+uint PreviewGeneratorQueue::IncPreviewGeneratorAttempts(const QString &key)
+{
+    QMutexLocker locker(&m_lock);
+    return m_previewMap[key].attempts++;
+}
+
+/** \fn PreviewGeneratorQueue::ClearPreviewGeneratorAttempts(const QString&)
+ *  \brief Clears the number of times we have
+ *         started a PreviewGenerator to create this file.
+ */
+void PreviewGeneratorQueue::ClearPreviewGeneratorAttempts(const QString &key)
+{
+    QMutexLocker locker(&m_lock);
+    m_previewMap[key].attempts = 0;
+    m_previewMap[key].lastBlockTime = 0;
+    m_previewMap[key].blockRetryUntil =
+        QDateTime::currentDateTime().addSecs(-60);
+}

libs/libmythtv/tv_rec.cpp

@@ -11 +11 @@
 using namespace std;
 
 // MythTV headers
+#include "previewgeneratorqueue.h"
 #include "mythconfig.h"
 #include "tv_rec.h"
 #include "osd.h"
@@ -25 +26 @@
 #include "recordingrule.h"
 #include "eitscanner.h"
 #include "RingBuffer.h"
-#include "previewgenerator.h"
 #include "storagegroup.h"
 #include "remoteutil.h"
 #include "tvremoteutil.h"
@@ -1132 +1132 @@
         if (!killFile)
         {
             if (curRecording->IsLocal())
-            {
-                (new PreviewGenerator(
-                    curRecording, PreviewGenerator::kLocal))->Start();
-            }
+                PreviewGeneratorQueue::GetPreviewImage(*curRecording, "");
 
             if (!tvchain)
             {
@@ -4471 +4468 @@
             if (!oldinfo->IsLocal())
                 oldinfo->SetPathname(oldinfo->GetPlaybackURL(false,true));
             if (oldinfo->IsLocal())
-            {
-                (new PreviewGenerator(
-                    oldinfo, PreviewGenerator::kLocal))->Start();
-            }
+                PreviewGeneratorQueue::GetPreviewImage(*oldinfo, "");
         }
         delete oldinfo;
     }

libs/libmythtv/previewgenerator.h

@@ -4 +4 @@
 
 #include <pthread.h>
 
+#include <QWaitCondition>
 #include <QString>
+#include <QThread>
 #include <QMutex>
 #include <QSize>
+#include <QSet>
 
 #include "programinfo.h"
 #include "util.h"
 
 class MythSocket;
+class PreviewGenerator;
 
-class MPUBLIC PreviewGenerator : public QObject
+// TODO Changes to make...
+// Update docs
+
+typedef QMap<QString,QDateTime> FileTimeStampMap;
+
+class MPUBLIC PreviewGenerator : public QThread
 {
     friend int preview_helper(const QString &chanid,
                               const QString &starttime,
@@ -47 +56 @@
     void SetOutputFilename(const QString&);
     void SetOutputSize(const QSize &size) { outSize = size; }
 
-    void Start(void);
+    void run(void); // QThread
     bool Run(void);
 
     void AttachSignals(QObject*);
-    void disconnectSafe(void);
 
-  signals:
-    void previewThreadDone(const QString&, bool&);
-    void previewReady(const ProgramInfo*);
-
   public slots:
     void deleteLater();
 
@@ -64 +68 @@
     virtual ~PreviewGenerator();
     void TeardownAll(void);
 
-    bool RemotePreviewSetup(void);
     bool RemotePreviewRun(void);
-    void RemotePreviewTeardown(void);
-
     bool LocalPreviewRun(void);
     bool IsLocal(void) const;
 
     bool RunReal(void);
 
-    static void *PreviewRun(void*);
-
     static char *GetScreenGrab(const ProgramInfo &pginfo,
                                const QString     &filename,
                                long long          seektime,
@@ -93 +92 @@
     static QString CreateAccessibleFilename(
         const QString &pathname, const QString &outFileName);
 
-  protected:
+    virtual bool event(QEvent *e); // QObject
+    bool SaveOutFile(QByteArray &data);
+
+//  protected:
+  public:
+    QWaitCondition     previewWaitCondition;
     QMutex             previewLock;
     pthread_t          previewThread;
     ProgramInfo        programInfo;
 
     Mode               mode;
-    bool               isConnected;
-    bool               createSockets;
-    MythSocket        *serverSock;
+    QObject           *listener;
     QString            pathname;
 
     /// tells us whether to use time as seconds or frame number
@@ -110 +112 @@
     long long          captureTime;
     QString            outFileName;
     QSize              outSize;
+
+    QString            token;
+    bool               gotReply;
+    bool               pixmapOk;
 };
 
 #endif // PREVIEW_GENERATOR_H_

libs/libmyth/remoteutil.cpp

@@ -357 +357 @@
         return retdatetime;
     }
 
-    size_t  length     = strlist[1].toLongLong();
+    size_t  length     = strlist[1].toULongLong();
     quint16 checksum16 = strlist[2].toUInt();
     QByteArray data = QByteArray::fromBase64(strlist[3].toAscii());
     if ((size_t) data.size() < length)
@@ -367 +367 @@
                 .arg(data.size()).arg(length));
         return QDateTime();
     }
+    data.resize(length);
 
     if (checksum16 != qChecksum(data.constData(), data.size()))
     {

programs/mythfrontend/playbackbox.cpp

@@ -8 +8 @@
 #include <QTimer>
 #include <QMap>
 
-// libmythdb
-#include "oldsettings.h"
-#include "mythdb.h"
-#include "mythdbcon.h"
-#include "mythverbose.h"
-#include "mythdirs.h"
-
-// libmythtv
-#include "tv.h"
+// MythTV
+#include "previewgeneratorqueue.h"
+#include "mythuiprogressbar.h"
 #include "mythplayer.h"
+#include "mythuibuttonlist.h"
+#include "mythcorecontext.h"
+#include "mythsystemevent.h"
+#include "mythuistatetype.h"
+#include "mythuicheckbox.h"
+#include "mythuitextedit.h"
+#include "mythdialogbox.h"
 #include "recordinginfo.h"
-#include "playgroup.h"
-#include "mythsystemevent.h"
-
-// libmyth
-#include "mythcorecontext.h"
-#include "util.h"
+#include "mythuihelper.h"
 #include "storagegroup.h"
+#include "mythuibutton.h"
+#include "mythverbose.h"
+#include "mythuiimage.h"
 #include "programinfo.h"
-
-// libmythui
-#include "mythuihelper.h"
+#include "oldsettings.h"
 #include "mythuitext.h"
-#include "mythuibutton.h"
-#include "mythuibuttonlist.h"
-#include "mythuistatetype.h"
-#include "mythdialogbox.h"
-#include "mythuitextedit.h"
-#include "mythuiimage.h"
-#include "mythuicheckbox.h"
-#include "mythuiprogressbar.h"
-
 #include "remoteutil.h"
 
 //  Mythfrontend
 #include "playbackboxlistitem.h"
 #include "customedit.h"
+#include "mythdbcon.h"
+#include "playgroup.h"
+#include "mythdirs.h"
+#include "proglist.h"
+#include "mythdb.h"
+#include "util.h"
+#include "tv.h"
 
 #define LOC      QString("PlaybackBox: ")
 #define LOC_WARN QString("PlaybackBox Warning: ")
@@ -447 +442 @@
 PlaybackBox::~PlaybackBox(void)
 {
     gCoreContext->removeListener(this);
+    PreviewGeneratorQueue::RemoveListener(this);
 
     for (uint i = 0; i < sizeof(m_artImage) / sizeof(MythUIImage*); i++)
     {
@@ -517 +513 @@
 void PlaybackBox::Load(void)
 {
     m_programInfoCache.WaitForLoadToComplete();
+    PreviewGeneratorQueue::AddListener(this);
 }
 
 void PlaybackBox::Init()
@@ -797 +794 @@
 
     QString oldimgfile = item->GetImage("preview");
     if (oldimgfile.isEmpty() || force_preview_reload)
-        m_helper.GetPreviewImage(*pginfo);
+        m_preview_tokens.insert(m_helper.GetPreviewImage(*pginfo));
 
     if ((GetFocusWidget() == m_recordingList) && is_sel)
     {
@@ -864 +861 @@
  *  gets updated as well.
  */
 void PlaybackBox::HandlePreviewEvent(
-    const QString &piKey, const QString &previewFile)
+    const QString &piKey, const QString &previewFile, const QString &token)
 {
+    QSet<QString>::iterator it = m_preview_tokens.find(token);
+    if (it == m_preview_tokens.end())
+        return;
+    m_preview_tokens.erase(it);
+
     if (previewFile.isEmpty())
         return;
 
@@ -3803 +3805 @@
             // asPendingDelete, we need to put them back now..
             ScheduleUpdateUIList();
         }
-        else if (message == "PREVIEW_READY" && me->ExtraDataCount() == 2)
+        else if (message == "PREVIEW_SUCCESS" && me->ExtraDataCount() >= 3)
         {
-            HandlePreviewEvent(me->ExtraData(0), me->ExtraData(1));
+            HandlePreviewEvent(
+                me->ExtraData(0), me->ExtraData(1), me->ExtraData(2));
         }
+        else if (message == "PREVIEW_FAILED" && me->ExtraDataCount() >= 3)
+        {
+            QString token = me->ExtraData(2);
+            QSet<QString>::iterator it = m_preview_tokens.find(token);
+            if (it == m_preview_tokens.end())
+                return;
+            m_preview_tokens.erase(it);
+        }
         else if (message == "AVAILABILITY" && me->ExtraDataCount() == 8)
         {
             const uint kMaxUIWaitTime = 100; // ms

programs/mythfrontend/playbackboxhelper.h

@@ -17 +17 @@
 class QObject;
 class QTimer;
 
-class PreviewGenState
-{
-  public:
-    PreviewGenState() :
-        gen(NULL), genStarted(false), ready(false),
-        attempts(0), lastBlockTime(0) {}
-    PreviewGenerator *gen;
-    bool              genStarted;
-    bool              ready;
-    uint              attempts;
-    uint              lastBlockTime;
-    QDateTime         blockRetryUntil;
-
-    static const uint maxAttempts;
-    static const uint minBlockSeconds;
-};
-typedef QMap<QString,PreviewGenState> PreviewMap;
-typedef QMap<QString,QDateTime>       FileTimeStampMap;
-
 typedef enum CheckAvailabilityType {
     kCheckForCache,
     kCheckForMenuAction,
@@ -72 +53 @@
     void UndeleteRecording(uint chanid, const QDateTime &recstartts);
     void CheckAvailability(const ProgramInfo&,
                            CheckAvailabilityType cat = kCheckForCache);
-    void GetPreviewImage(const ProgramInfo&);
+    QString GetPreviewImage(const ProgramInfo&);
 
     QString LocateArtwork(const QString &seriesid, const QString &title,
                           ArtworkType, const QString &host,
@@ -83 +64 @@
     uint64_t GetFreeSpaceTotalMB(void) const;
     uint64_t GetFreeSpaceUsedMB(void) const;
 
-  private slots:
-    void previewThreadDone(const QString &fn, bool &success);
-    void previewReady(const ProgramInfo *pginfo);
-
   private:
     void UpdateFreeSpace(void);
 
-    QString GeneratePreviewImage(ProgramInfo &pginfo);
-    bool SetPreviewGenerator(const QString &fn, PreviewGenerator *g);
-    void IncPreviewGeneratorPriority(const QString &fn);
-    void UpdatePreviewGeneratorThreads(void);
-    bool IsGeneratingPreview(const QString &fn, bool really = false) const;
-    uint IncPreviewGeneratorAttempts(const QString &fn);
-    void ClearPreviewGeneratorAttempts(const QString &fn);
-
   private:
     QObject            *m_listener;
     PBHEventHandler    *m_eventHandler;
@@ -107 +76 @@
     uint64_t            m_freeSpaceTotalMB;
     uint64_t            m_freeSpaceUsedMB;
 
-    // Preview Pixmap Variables ///////////////////////////////////////////////
-    mutable QMutex      m_previewGeneratorLock;
-    uint                m_previewGeneratorMode;
-    FileTimeStampMap    m_previewFileTS;
-    bool                m_previewSuspend;
-    PreviewMap          m_previewGenerator;
-    QStringList         m_previewGeneratorQueue;
-    uint                m_previewGeneratorRunning;
-    uint                m_previewGeneratorMaxThreads;
-
     // Artwork Variables //////////////////////////////////////////////////////
     QHash<QString, QString>    m_artworkFilenameCache;
 };

programs/mythfrontend/playbackboxhelper.cpp

@@ -7 +7 @@
 #include <QFileInfo>
 #include <QDir>
 
+#include "previewgeneratorqueue.h"
 #include "playbackboxhelper.h"
-#include "previewgenerator.h"
 #include "mythcorecontext.h"
 #include "tvremoteutil.h"
 #include "storagegroup.h"
@@ -277 +277 @@
         }
         else if (me->Message() == "GET_PREVIEW")
         {
-            ProgramInfo evinfo(me->ExtraDataList());
+            QString token = me->ExtraData(0);
+            QStringList list = me->ExtraDataList();
+            QStringList::const_iterator it = list.begin()+1;
+            ProgramInfo evinfo(it, list.end());
             if (!evinfo.HasPathname())
                 return true;
 
-            QStringList list;
+            list.clear();
             evinfo.ToStringList(list);
             list += QString::number(kCheckForCache);
             if (asAvailable != CheckAvailability(list))
                 return true;
 
-            QString fn = m_pbh.GeneratePreviewImage(evinfo);
-            if (!fn.isEmpty())
-            {
-                QStringList list;
-                list.push_back(evinfo.MakeUniqueKey());
-                list.push_back(fn);
-                MythEvent *e = new MythEvent("PREVIEW_READY", list);
-                QCoreApplication::postEvent(m_pbh.m_listener, e);
-            }
+            // Now we can actually request the preview...
+            PreviewGeneratorQueue::GetPreviewImage(evinfo, token);
 
             return true;
         }
@@ -458 +454 @@
 
 //////////////////////////////////////////////////////////////////////
 
-const uint PreviewGenState::maxAttempts     = 5;
-const uint PreviewGenState::minBlockSeconds = 60;
-
 PlaybackBoxHelper::PlaybackBoxHelper(QObject *listener) :
     m_listener(listener), m_eventHandler(NULL),
     // Free Space Tracking Variables
-    m_freeSpaceTotalMB(0ULL), m_freeSpaceUsedMB(0ULL),
-    // Preview Image Variables
-    m_previewGeneratorRunning(0), m_previewGeneratorMaxThreads(2)
+    m_freeSpaceTotalMB(0ULL), m_freeSpaceUsedMB(0ULL)
 {
-    m_previewGeneratorMode = PreviewGenerator::kRemote;
-
-    int idealThreads = QThread::idealThreadCount();
-    if (idealThreads >= 1)
-        m_previewGeneratorMaxThreads = idealThreads * 2;
-
     start();
 }
 
@@ -482 +467 @@
     exit();
     wait();
 
-    // disconnect preview generators
-    QMutexLocker locker(&m_previewGeneratorLock);
-    PreviewMap::iterator it = m_previewGenerator.begin();
-    for (;it != m_previewGenerator.end(); ++it)
-    {
-        if ((*it).gen)
-            (*it).gen->disconnectSafe();
-    }
-
     // delete the event handler
     delete m_eventHandler;
     m_eventHandler = NULL;
@@ -620 +596 @@
     return QString();
 }
 
-void PlaybackBoxHelper::GetPreviewImage(const ProgramInfo &pginfo)
+QString PlaybackBoxHelper::GetPreviewImage(const ProgramInfo &pginfo)
 {
-    QStringList extra;
-    pginfo.ToStringList(extra);
-    MythEvent *e = new MythEvent("GET_PREVIEW", extra);
-    QCoreApplication::postEvent(m_eventHandler, e);
-}
-
-QString PlaybackBoxHelper::GeneratePreviewImage(ProgramInfo &pginfo)
-{
     if (pginfo.GetAvailableStatus() == asPendingDelete)
         return QString();
 
-    QString filename = pginfo.GetPathname() + ".png";
+    QString token = QString("%1:%2")
+        .arg(pginfo.MakeUniqueKey()).arg(rand());
 
-    // 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);
+    QStringList extra(token);
+    pginfo.ToStringList(extra);
+    MythEvent *e = new MythEvent("GET_PREVIEW", extra);
+    QCoreApplication::postEvent(m_eventHandler, e);
 
-    QDateTime previewLastModified;
-    QString ret_file = filename;
-    bool streaming = filename.left(1) != "/";
-    bool locally_accessible = false;
-    bool bookmark_updated = false;
-
-    QDateTime bookmark_ts = pginfo.QueryBookmarkTimeStamp();
-    QDateTime cmp_ts = bookmark_ts.isValid() ?
-        bookmark_ts : pginfo.GetLastModifiedTime();
-
-    if (streaming)
-    {
-        ret_file = QString("%1/remotecache/%2")
-            .arg(GetConfDir()).arg(filename.section('/', -1));
-
-        QFileInfo finfo(ret_file);
-        if (finfo.isReadable() && finfo.lastModified() >= cmp_ts)
-        {
-            // 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 if (!IsGeneratingPreview(filename))
-        {
-            previewLastModified =
-                RemoteGetPreviewIfModified(pginfo, ret_file);
-        }
-    }
-    else
-    {
-        QFileInfo fi(filename);
-        if ((locally_accessible = fi.isReadable()))
-            previewLastModified = fi.lastModified();
-    }
-
-    bookmark_updated =
-        (!previewLastModified.isValid() || (previewLastModified < cmp_ts));
-
-    if (bookmark_updated && bookmark_ts.isValid() &&
-        previewLastModified.isValid())
-    {
-        ClearPreviewGeneratorAttempts(filename);
-    }
-
-    if (0)
-    {
-        VERBOSE(VB_IMPORTANT, QString(
-                    "previewLastModified:  %1\n\t\t\t"
-                    "bookmark_ts:          %2\n\t\t\t"
-                    "pginfo.lastmodified: %3")
-                .arg(previewLastModified.toString(Qt::ISODate))
-                .arg(bookmark_ts.toString(Qt::ISODate))
-                .arg(pginfo.GetLastModifiedTime(ISODate)));
-    }
-
-    bool preview_exists = previewLastModified.isValid();
-
-    if (0)
-    {
-        VERBOSE(VB_IMPORTANT,
-                QString("Title: %1\n\t\t\t")
-                .arg(pginfo.toString(ProgramInfo::kTitleSubtitle)) +
-                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(preview_exists).arg(bookmark_updated)
-                .arg((bookmark_updated || !preview_exists)));
-    }
-
-    if ((bookmark_updated || !preview_exists) &&
-        !IsGeneratingPreview(filename))
-    {
-        uint attempts = IncPreviewGeneratorAttempts(filename);
-        if (attempts < PreviewGenState::maxAttempts)
-        {
-            VERBOSE(VB_PLAYBACK, LOC +
-                    QString("Requesting preview for '%1'")
-                    .arg(filename));
-            PreviewGenerator::Mode mode =
-                (PreviewGenerator::Mode) m_previewGeneratorMode;
-            PreviewGenerator *pg = new PreviewGenerator(&pginfo, mode);
-            while (!SetPreviewGenerator(filename, pg)) usleep(50000);
-            VERBOSE(VB_PLAYBACK, LOC +
-                    QString("Requested preview for '%1'")
-                    .arg(filename));
-        }
-        else if (attempts == PreviewGenState::maxAttempts)
-        {
-            VERBOSE(VB_IMPORTANT, LOC_ERR +
-                    QString("Attempted to generate preview for '%1' "
-                            "%2 times, giving up.")
-                    .arg(filename).arg(PreviewGenState::maxAttempts));
-        }
-    }
-    else if (bookmark_updated || !preview_exists)
-    {
-        VERBOSE(VB_PLAYBACK, LOC +
-                "Not requesting preview as it "
-                "is already being generated");
-    }
-
-    UpdatePreviewGeneratorThreads();
-
-    QString ret = (locally_accessible) ?
-        filename : (previewLastModified.isValid()) ?
-        ret_file : (QFileInfo(ret_file).isReadable()) ?
-        ret_file : QString();
-
-    //VERBOSE(VB_IMPORTANT, QString("Returning: '%1'").arg(ret));
-
-    return ret;
+    return token;
 }
-
-void PlaybackBoxHelper::IncPreviewGeneratorPriority(const QString &xfn)
-{
-    QString fn = xfn.mid(max(xfn.lastIndexOf('/') + 1,0));
-
-    QMutexLocker locker(&m_previewGeneratorLock);
-    m_previewGeneratorQueue.removeAll(fn);
-
-    PreviewMap::iterator pit = m_previewGenerator.find(fn);
-    if (pit != m_previewGenerator.end() && (*pit).gen && !(*pit).genStarted)
-        m_previewGeneratorQueue.push_back(fn);
-}
-
-void PlaybackBoxHelper::UpdatePreviewGeneratorThreads(void)
-{
-    QMutexLocker locker(&m_previewGeneratorLock);
-    QStringList &q = m_previewGeneratorQueue;
-    if (!q.empty() &&
-        (m_previewGeneratorRunning < m_previewGeneratorMaxThreads))
-    {
-        QString fn = q.back();
-        q.pop_back();
-        PreviewMap::iterator it = m_previewGenerator.find(fn);
-        if (it != m_previewGenerator.end() && (*it).gen && !(*it).genStarted)
-        {
-            m_previewGeneratorRunning++;
-            (*it).gen->Start();
-            (*it).genStarted = true;
-        }
-    }
-}
-
-/** \fn PlaybackBoxHelper::SetPreviewGenerator(const QString&, PreviewGenerator*)
- *  \brief Sets the PreviewGenerator for a specific file.
- *  \return true iff call succeeded.
- */
-bool PlaybackBoxHelper::SetPreviewGenerator(const QString &xfn, PreviewGenerator *g)
-{
-    QString fn = xfn.mid(max(xfn.lastIndexOf('/') + 1,0));
-
-    if (!m_previewGeneratorLock.tryLock())
-        return false;
-
-    if (!g)
-    {
-        m_previewGeneratorRunning = max(0, (int)m_previewGeneratorRunning - 1);
-        PreviewMap::iterator it = m_previewGenerator.find(fn);
-        if (it == m_previewGenerator.end())
-        {
-            m_previewGeneratorLock.unlock();
-            return false;
-        }
-
-        (*it).gen        = NULL;
-        (*it).genStarted = false;
-        (*it).ready      = false;
-        (*it).lastBlockTime =
-            max(PreviewGenState::minBlockSeconds, (*it).lastBlockTime * 2);
-        (*it).blockRetryUntil =
-            QDateTime::currentDateTime().addSecs((*it).lastBlockTime);
-
-        m_previewGeneratorLock.unlock();
-        return true;
-    }
-
-    g->AttachSignals(this);
-    m_previewGenerator[fn].gen = g;
-    m_previewGenerator[fn].genStarted = false;
-    m_previewGenerator[fn].ready = false;
-
-    m_previewGeneratorLock.unlock();
-    IncPreviewGeneratorPriority(xfn);
-
-    return true;
-}
-
-/** \fn PlaybackBoxHelper::IsGeneratingPreview(const QString&, bool) const
- *  \brief Returns true if we have already started a
- *         PreviewGenerator to create this file.
- */
-bool PlaybackBoxHelper::IsGeneratingPreview(const QString &xfn, bool really) const
-{
-    PreviewMap::const_iterator it;
-    QMutexLocker locker(&m_previewGeneratorLock);
-
-    QString fn = xfn.mid(max(xfn.lastIndexOf('/') + 1,0));
-    if ((it = m_previewGenerator.find(fn)) == m_previewGenerator.end())
-        return false;
-
-    if (really)
-        return ((*it).gen && !(*it).ready);
-
-    if ((*it).blockRetryUntil.isValid())
-        return QDateTime::currentDateTime() < (*it).blockRetryUntil;
-
-    return (*it).gen;
-}
-
-/** \fn PlaybackBoxHelper::IncPreviewGeneratorAttempts(const QString&)
- *  \brief Increments and returns number of times we have
- *         started a PreviewGenerator to create this file.
- */
-uint PlaybackBoxHelper::IncPreviewGeneratorAttempts(const QString &xfn)
-{
-    QMutexLocker locker(&m_previewGeneratorLock);
-    QString fn = xfn.mid(max(xfn.lastIndexOf('/') + 1,0));
-    return m_previewGenerator[fn].attempts++;
-}
-
-/** \fn PlaybackBoxHelper::ClearPreviewGeneratorAttempts(const QString&)
- *  \brief Clears the number of times we have
- *         started a PreviewGenerator to create this file.
- */
-void PlaybackBoxHelper::ClearPreviewGeneratorAttempts(const QString &xfn)
-{
-    QMutexLocker locker(&m_previewGeneratorLock);
-    QString fn = xfn.mid(max(xfn.lastIndexOf('/') + 1,0));
-    m_previewGenerator[fn].attempts = 0;
-    m_previewGenerator[fn].lastBlockTime = 0;
-    m_previewGenerator[fn].blockRetryUntil =
-        QDateTime::currentDateTime().addSecs(-60);
-}
-
-void PlaybackBoxHelper::previewThreadDone(const QString &fn, bool &success)
-{
-    VERBOSE(VB_PLAYBACK, LOC + QString("Preview for '%1' done").arg(fn));
-    success = SetPreviewGenerator(fn, NULL);
-    UpdatePreviewGeneratorThreads();
-}
-
-/** \fn PlaybackBoxHelper::previewReady(const ProgramInfo*)
- *  \brief Callback used by PreviewGenerator to tell us a m_preview
- *         we requested has been returned from the backend.
- *  \param pginfo ProgramInfo describing the previewed recording.
- */
-void PlaybackBoxHelper::previewReady(const ProgramInfo *pginfo)
-{
-    if (!pginfo)
-        return;
-
-    QString xfn = pginfo->GetPathname() + ".png";
-    QString fn = xfn.mid(max(xfn.lastIndexOf('/') + 1,0));
-
-    VERBOSE(VB_PLAYBACK, LOC + QString("Preview for '%1' ready")
-            .arg(pginfo->GetPathname()));
-
-    m_previewGeneratorLock.lock();
-    PreviewMap::iterator it = m_previewGenerator.find(fn);
-    if (it != m_previewGenerator.end())
-    {
-        (*it).ready         = true;
-        (*it).attempts      = 0;
-        (*it).lastBlockTime = 0;
-    }
-    m_previewGeneratorLock.unlock();
-
-    if (pginfo)
-    {
-        QStringList list;
-        list.push_back(pginfo->MakeUniqueKey());
-        list.push_back(xfn);
-        MythEvent *e = new MythEvent("PREVIEW_READY", list);
-        QCoreApplication::postEvent(m_listener, e);
-    }
-}

programs/mythfrontend/main.cpp

@@ -19 +19 @@
 #include <QApplication>
 #include <QTimer>
 
+#include "previewgeneratorqueue.h"
 #include "mythconfig.h"
 #include "tv.h"
 #include "proglist.h"
@@ -1458 +1459 @@
 
     BackendConnectionManager bcm;
 
+    PreviewGeneratorQueue::CreatePreviewGeneratorQueue(
+        PreviewGenerator::kRemote, 50, 60);
+
     int ret = qApp->exec();
 
+    PreviewGeneratorQueue::TeardownPreviewGeneratorQueue();
+
     delete sysEventHandler;
 
     pmanager->DestroyAllPlugins();

programs/mythfrontend/playbackbox.h

@@ -16 +16 @@
 #include <QObject>
 #include <QMutex>
 #include <QMap>
+#include <QSet>
 
 #include "jobqueue.h"
 #include "tv_play.h"
@@ -317 +318 @@
     void UpdateUIListItem(MythUIButtonListItem *item, bool is_sel,
                           bool force_preview_reload = false);
 
-    void HandlePreviewEvent(const QString &piKey, const QString &previewFile);
+    void HandlePreviewEvent(
+        const QString &piKey, const QString &previewFile, const QString &token);
     void HandleRecordingRemoveEvent(uint chanid, const QDateTime &recstartts);
     void HandleRecordingAddEvent(const ProgramInfo &evinfo);
     void HandleUpdateProgramInfoEvent(const ProgramInfo &evinfo);
@@ -443 +445 @@
     QStringList         m_player_selected_new_show;
     /// Main helper thread
     PlaybackBoxHelper   m_helper;
+    /// Outstanding preview image requests
+    QSet<QString>       m_preview_tokens;
 };
 
 class GroupSelector : public MythScreenType

programs/mythbackend/playbacksock.h

@@ -70 +70 @@
     QStringList GetSGFileQuery(QString &host, QString &groupname,
                                QString &filename);
 
-    QStringList GenPreviewPixmap(const ProgramInfo *pginfo);
-    QStringList GenPreviewPixmap(const ProgramInfo *pginfo,
+    QStringList GenPreviewPixmap(const QString &token,
+                                 const ProgramInfo *pginfo);
+    QStringList GenPreviewPixmap(const QString &token,
+                                 const ProgramInfo *pginfo,
                                  bool               time_fmt_sec,
                                  long long          time,
                                  const QString     &outputFile,

programs/mythbackend/main.cpp

@@ -51 +51 @@
 #include "programinfo.h"
 #include "dbcheck.h"
 #include "jobqueue.h"
-#include "previewgenerator.h"
 #include "mythcommandlineparser.h"
 #include "mythsystemevent.h"
 

programs/mythbackend/playbacksock.cpp

@@ -262 +262 @@
     return strlist;
 }
 
-QStringList PlaybackSock::GenPreviewPixmap(const ProgramInfo *pginfo)
+QStringList PlaybackSock::GenPreviewPixmap(
+    const QString &token, const ProgramInfo *pginfo)
 {
-    QStringList strlist( QString("QUERY_GENPIXMAP") );
+    QStringList strlist( QString("QUERY_GENPIXMAP2") );
+    strlist += token;
     pginfo->ToStringList(strlist);
 
     SendReceiveStringList(strlist);
@@ -272 +274 @@
     return strlist;
 }
 
-QStringList PlaybackSock::GenPreviewPixmap(const ProgramInfo *pginfo,
+QStringList PlaybackSock::GenPreviewPixmap(const QString &token,
+                                           const ProgramInfo *pginfo,
                                            bool               time_fmt_sec,
                                            long long          time,
                                            const QString     &outputFile,
                                            const QSize       &outputSize)
 {
-    QStringList strlist(QString("QUERY_GENPIXMAP"));
+    QStringList strlist(QString("QUERY_GENPIXMAP2"));
+    strlist += token;
     pginfo->ToStringList(strlist);
     strlist.push_back(time_fmt_sec ? "s" : "f");
     encodeLongLong(strlist, time);

programs/mythbackend/mainserver.cpp

@@ -26 +26 @@
 #endif // !__linux__
 
 #include <QCoreApplication>
+#include <QThreadPool>
 #include <QDateTime>
+#include <QRunnable>
 #include <QFile>
 #include <QDir>
 #include <QThread>
@@ -37 +39 @@
 #include <QTcpServer>
 #include <QTimer>
 
+#include "previewgeneratorqueue.h"
 #include "exitcodes.h"
 #include "mythcontext.h"
 #include "mythverbose.h"
@@ -53 +56 @@
 #include "scheduledrecording.h"
 #include "jobqueue.h"
 #include "autoexpire.h"
-#include "previewgenerator.h"
 #include "storagegroup.h"
 #include "compat.h"
 #include "RingBuffer.h"
@@ -65 +67 @@
 #include "mythdirs.h"
 #include "mythdownloadmanager.h"
 
-
 /** Milliseconds to wait for an existing thread from
  *  process request thread pool.
  */
@@ -184 +185 @@
 {
     AutoExpire::Update(true);
 
+    PreviewGeneratorQueue::CreatePreviewGeneratorQueue(
+        PreviewGenerator::kLocalAndRemote, ~0, 0);
+    PreviewGeneratorQueue::AddListener(this);
+
     for (int i = 0; i < PRT_STARTUP_THREAD_COUNT; i++)
     {
         ProcessRequestThread *prt = new ProcessRequestThread(this);
@@ -237 +242 @@
 
 MainServer::~MainServer()
 {
+    PreviewGeneratorQueue::RemoveListener(this);
+    PreviewGeneratorQueue::TeardownPreviewGeneratorQueue();
+
     if (mythserver)
     {
         mythserver->disconnect();
@@ -546 +554 @@
         else
             HandleFileTransferQuery(listline, tokens, pbs);
     }
-    else if (command == "QUERY_GENPIXMAP")
+    else if (command == "QUERY_GENPIXMAP2")
     {
         HandleGenPreviewPixmap(listline, pbs);
     }
@@ -734 +742 @@
     {
         MythEvent *me = (MythEvent *)e;
 
+        QString message = me->Message();
+        QString error;
+        if (message == "PREVIEW_SUCCESS" || message == "PREVIEW_QUEUED")
+        {
+            bool ok = false;
+            QString filename;
+            QString pginfokey;
+            QString token;
+            if (me->ExtraDataCount() >= 3)
+            {
+                ok = true;
+                pginfokey = me->ExtraData(0);
+                filename  = me->ExtraData(1);
+                token     = me->ExtraData(2);
+            }
+
+            if (message == "PREVIEW_QUEUED")
+            {
+                VERBOSE(VB_IMPORTANT, QString("Preview Queued: '%1' '%2' '%3'")
+                        .arg(pginfokey).arg(filename).arg(token));
+                return;
+            }
+
+            QFile file(filename);
+            ok = ok && file.open(QIODevice::ReadOnly);
+
+            if (ok)
+            {
+                VERBOSE(VB_IMPORTANT, QString("Preview Success: '%1' '%2' '%3'")
+                        .arg(pginfokey).arg(filename).arg(token));
+
+                QByteArray data = file.readAll();
+                QStringList extra(token);
+                extra += "OK";
+                extra += QString::number(data.size());
+                extra += QString::number(
+                    qChecksum(data.constData(), data.size()));
+                extra += QString(data.toBase64());
+                MythEvent me("GENERATED_PIXMAP", extra);    
+                gCoreContext->dispatch(me);
+                return;
+            }
+            else
+            {
+                message = "PREVIEW_FAILED";
+                error = QString("Failed to read '%1'")
+                    .arg(filename);
+                VERBOSE(VB_IMPORTANT, LOC_ERR + error);
+            }
+        }
+
+        if (message == "PREVIEW_FAILED" && me->ExtraDataCount() >= 3)
+        {
+            QString pginfokey = me->ExtraData(0);
+            QString filename  = me->ExtraData(1);
+            QString token     = me->ExtraData(2);
+            QString msg = me->ExtraDataCount() >= 4 ? me->ExtraData(3) : error;
+            QStringList extra(token);
+            extra.push_back("ERROR");
+            extra.push_back(msg);
+
+            VERBOSE(VB_IMPORTANT, QString("Preview Failed: '%1' '%2' '%3'"
+                                          "\n\t\t\tMsg: %4")
+                    .arg(pginfokey).arg(filename).arg(token)
+                    .arg(msg));
+
+            MythEvent me("GENERATED_PIXMAP", extra);
+            gCoreContext->dispatch(me);
+            return;
+        }
+
         if (me->Message().left(11) == "AUTO_EXPIRE")
         {
             QStringList tokens = me->Message()
@@ -4876 +4955 @@
 {
     MythSocket *pbssock = pbs->getSocket();
 
+    if (slist.size() < 3)
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Too few params in pixmap request");
+        QStringList outputlist("ERROR");
+        outputlist += "TOO_FEW_PARAMS";
+        SendResponse(pbssock, outputlist);
+        return;
+    }
+
     bool      time_fmt_sec   = true;
     long long time           = -1;
     QString   outputfile;
@@ -4883 +4971 @@
     int       height         = -1;
     bool      has_extra_data = false;
 
-    QStringList::const_iterator it = slist.begin() + 1;
+    QString token = slist[1];
+    if (token.isEmpty())
+    {
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to parse pixmap request. "
+                "Token absent");
+        QStringList outputlist("ERROR");
+        outputlist += "TOKEN_ABSENT";
+        SendResponse(pbssock, outputlist);
+    }    
+
+    QStringList::const_iterator it = slist.begin() + 2;
     QStringList::const_iterator end = slist.end();
     ProgramInfo pginfo(it, end);
     bool ok = pginfo.HasPathname();
     if (!ok)
     {
-        VERBOSE(VB_IMPORTANT, "MainServer: Failed to parse pixmap request.");
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to parse pixmap request. "
+                "ProgramInfo missing pathname");
         QStringList outputlist("BAD");
-        outputlist += "ERROR_INVALID_REQUEST";
+        outputlist += "NO_PATHNAME";
         SendResponse(pbssock, outputlist);
     }
     if (it != slist.end())
@@ -4936 +5035 @@
             if (has_extra_data)
             {
                 outputlist = slave->GenPreviewPixmap(
-                    &pginfo, time_fmt_sec, time, outputfile, outputsize);
+                    token, &pginfo, time_fmt_sec, time, outputfile, outputsize);
             }
             else
             {
-                outputlist = slave->GenPreviewPixmap(&pginfo);
+                outputlist = slave->GenPreviewPixmap(token, &pginfo);
             }
 
             slave->DownRef();
@@ -4955 +5054 @@
 
     if (!pginfo.IsLocal())
     {
-        VERBOSE(VB_IMPORTANT, "MainServer: HandleGenPreviewPixmap: Unable to "
+        VERBOSE(VB_IMPORTANT, LOC_ERR + "HandleGenPreviewPixmap: Unable to "
                 "find file locally, unable to make preview image.");
-        QStringList outputlist( "BAD" );
-        outputlist += "ERROR_NOFILE";
+        QStringList outputlist( "ERROR" );
+        outputlist += "FILE_INACCESSIBLE";
         SendResponse(pbssock, outputlist);
         return;
     }
 
-    PreviewGenerator *previewgen = new PreviewGenerator(&pginfo);
     if (has_extra_data)
     {
-        previewgen->SetOutputSize(outputsize);
-        previewgen->SetOutputFilename(outputfile);
-        previewgen->SetPreviewTime(time, time_fmt_sec);
+        PreviewGeneratorQueue::GetPreviewImage(
+            pginfo, outputsize, outputfile, time, time_fmt_sec, token);
     }
-    ok = previewgen->Run();
-    previewgen->deleteLater();
-
-    if (ok)
-    {
-        QStringList outputlist("OK");
-        if (!outputfile.isEmpty())
-            outputlist += outputfile;
-        SendResponse(pbssock, outputlist);
-    }
     else
     {
-        VERBOSE(VB_IMPORTANT, "MainServer: Failed to make preview image.");
-        QStringList outputlist( "BAD" );
-        outputlist += "ERROR_UNKNOWN";
-        SendResponse(pbssock, outputlist);
+        PreviewGeneratorQueue::GetPreviewImage(pginfo, token);
     }
+
+    QStringList outputlist("OK");
+    if (!outputfile.isEmpty())
+        outputlist += outputfile;
+    SendResponse(pbssock, outputlist);
 }
 
 void MainServer::HandlePixmapLastModified(QStringList &slist, PlaybackSock *pbs)