Ticket #9556: thumbs_v1.patch

mythtv/libs/libmythtv/deletemap.cpp

@@ -1 +1 @@
 #include <cmath>
 #include <stdint.h>
+#include <QCoreApplication>
+#include <QMutexLocker>
 
 #include "mythlogging.h"
 #include "mythcontext.h"
 #include "osd.h"
 #include "deletemap.h"
 #include "mythplayer.h"
+#include "mythuiimage.h"
 
 #define LOC     QString("DelMap: ")
 #define EDIT_CHECK do { \
@@ -15 +18 @@
     } \
 } while(0)
 
+class NextThumbnailEvent : public QEvent
+{
+public:
+    NextThumbnailEvent(ThumbnailCache *c) : QEvent(kEventType), m_cache(c) {}
+    static Type kEventType;
+    ThumbnailCache *m_cache;
+};
+
+QEvent::Type NextThumbnailEvent::kEventType =
+    (QEvent::Type) QEvent::registerEventType();
+
+ThumbnailCache::ThumbnailCache(PlayerContext *origCtx,
+                               const QVector<ThumbnailLayout> &images) :
+    MThread("Thumbnail loader")
+{
+    m_ctx = NULL;
+    m_origCtx = origCtx;
+    m_images = images;
+    m_isEventOutstanding = false;
+    m_totalDataBytes = 0;
+    m_maxDataBytes = gCoreContext->GetNumSetting("UIImageCacheSize", 20)
+        * 1024 * 1024 * 8;
+    m_keepRunning = true;
+    m_timestamp = 0;
+}
+
+ThumbnailCache::~ThumbnailCache(void)
+{
+    m_keepRunning = false;
+    wait();
+    if (m_ctx)
+        delete m_ctx;
+    QHash<uint64_t, ThumbnailCacheEntry>::iterator iter = m_cache.begin();
+    for (; iter != m_cache.end(); ++iter)
+    {
+        delete (*iter).m_image;
+        delete (*iter).m_data;
+    }
+}
+
+void ThumbnailCache::run(void)
+{
+    RunProlog();
+
+    m_ctx = new PlayerContext("Cutlist editor thumbnail");
+    m_rbuf = RingBuffer::Create(m_origCtx->buffer->GetFilename(), false);
+    m_ctx->SetRingBuffer(m_rbuf);
+    m_ctx->SetPlayingInfo(m_origCtx->playingInfo);
+    m_player =
+        new MythPlayer((PlayerFlags)(kAudioMuted | kVideoIsNull
+                                     /* | kDecodeAllowGPU*/));
+    m_ctx->SetPlayer(m_player);
+    m_ctx->player->SetPlayerInfo(NULL, NULL, true, m_ctx);
+
+    while (m_keepRunning)
+    {
+        bool isEmpty;
+        uint64_t target = 0;
+        {
+            QMutexLocker l(&m_cacheLock);
+            isEmpty = m_loadQueue.isEmpty();
+            if (!isEmpty)
+                target = m_loadQueue.front();
+        }
+        if (!isEmpty)
+        {
+            int bufflen, vw, vh;
+            float ar;
+            char *grab =
+                m_ctx->player->GetScreenGrabAtFrame(target, true, bufflen,
+                                                    vw, vh, ar);
+            {
+                QMutexLocker l(&m_cacheLock);
+                int length = vw * vh * 4;
+                m_totalDataBytes += length;
+                QImage *qi = new QImage((unsigned char *)grab, vw, vh,
+                                        QImage::Format_RGB32);
+                m_cache[target] = ThumbnailCacheEntry(qi, (unsigned char *)grab,
+                                                      length, m_timestamp++);
+                m_loadQueue.removeAll(target);
+                isEmpty = m_loadQueue.isEmpty();
+            }
+            LOG(VB_PLAYBACK, LOG_DEBUG,
+                QString("Grabbed frame %1, %2x%3").arg(target).arg(vw).arg(vh));
+        }
+        if (isEmpty)
+            usleep(1000);
+    }
+    RunEpilog();
+}
+
+void ThumbnailCache::customEvent(QEvent *event)
+{
+    if (event->type() == NextThumbnailEvent::kEventType)
+    {
+        NextThumbnailEvent *nte = dynamic_cast<NextThumbnailEvent*>(event);
+        nte->m_cache->m_isEventOutstanding = false;
+        nte->m_cache->Load();
+    }
+}
+
+void ThumbnailCache::Load(void)
+{
+    if (m_isEventOutstanding)
+        return;
+    bool moreToLoad = false;
+    {
+        QMutexLocker l(&m_cacheLock);
+        // Load all images that are cached.
+        for (int i = 0; i < m_images.size(); ++i)
+        {
+            if (!m_displayed.contains(i))
+            {
+                int offset = m_seekamount * m_images[i].m_steps;
+                uint64_t target = m_baseFrame + offset;
+                if (offset < 0 && target > m_baseFrame)
+                    target = 0; // handle underflow
+                if (m_cache.contains(target))
+                {
+                    MythUIImage *imageType = m_images[i].m_image;
+                    MythImage *mi = new MythImage(imageType->GetPainter());
+                    QImage *qi = m_cache[target].m_image;
+                    m_cache[target].m_timestamp = m_timestamp++;
+                    mi->Assign(*qi);
+                    imageType->SetImage(mi);
+                    m_displayed += i;
+                }
+                else
+                {
+                    moreToLoad = true;
+                    if (!m_loadQueue.contains(target))
+                        m_loadQueue += target;
+                }
+            }
+        }
+    }
+    if (moreToLoad)
+    {
+        QCoreApplication::postEvent(this, new NextThumbnailEvent(this));
+    }
+}
+
+void ThumbnailCache::Clear(uint64_t frame, int seekamount)
+{
+    QMutexLocker l(&m_cacheLock);
+    for (int i = 0 ; i < m_images.size(); ++i)
+        m_images[i].m_image->Reset();
+    m_displayed.clear();
+    m_baseFrame = frame;
+    m_seekamount = seekamount;
+    while (m_totalDataBytes > m_maxDataBytes && !m_cache.isEmpty())
+    {
+        // find and delete the oldest image
+        uint64_t oldestIndex = -1;
+        uint64_t oldestTimestamp = m_timestamp;
+        QHash<uint64_t, ThumbnailCacheEntry>::iterator iter = m_cache.begin();
+        while (m_totalDataBytes > m_maxDataBytes && iter != m_cache.end())
+        {
+            uint64_t key = iter.key();
+            ++iter;
+            uint64_t timestamp = m_cache[key].m_timestamp;
+            if (timestamp < oldestTimestamp)
+            {
+                oldestIndex = key;
+                oldestTimestamp = timestamp;
+            }
+        }
+        if (oldestIndex == (uint64_t)-1) // this shouldn't happen
+            break;
+        uint64_t key = oldestIndex;
+        ThumbnailCacheEntry entry = m_cache.take(key);
+        delete entry.m_image;
+        delete entry.m_data;
+        m_totalDataBytes -= entry.m_dataLength;
+        LOG(VB_PLAYBACK, LOG_DEBUG,
+            QString("Expired thumbnail frame=%1 size=%2 new cache size=%3")
+            .arg(key).arg(entry.m_dataLength).arg(m_totalDataBytes));
+    }
+    m_loadQueue.clear();
+}
+
+////////////////////////////////////////////////////////////////
+
 DeleteMapUndoEntry::DeleteMapUndoEntry(frm_dir_map_t dm, QString msg) :
     deleteMap(dm), message(msg) { }
 
@@ -196 +382 @@
         osd->SetRegions("osd_program_editor", m_deleteMap, total);
     m_changed = false;
     m_cachedTotalForOSD = total;
+
+    // First-time creation of thumbnail loader/cacher
+    if (!m_thumbnails)
+    {
+        MythScreenType *win = osd->GetWindow("osd_program_editor");
+        QVector<ThumbnailLayout> images;
+        if (win)
+        {
+            QList<MythUIType *> *children = win->GetAllChildren();
+            if (children)
+            {
+                QList<MythUIType *>::const_iterator iter =
+                    children->constBegin();
+                for (; iter != children->constEnd(); ++iter)
+                {
+                    static const char *prefix = "thumbnail_";
+                    QString name = (*iter)->objectName();
+                    if (!name.startsWith(prefix))
+                        continue;
+                    MythUIImage *imageType = dynamic_cast<MythUIImage*> (*iter);
+                    if (!imageType)
+                        continue;
+                    bool ok = false;
+                    float steps = name.mid(strlen(prefix)).toFloat(&ok);
+                    if (!ok)
+                        continue;
+                    images +=
+                        ThumbnailLayout(imageType, steps,
+                                        imageType->GetArea().toQRect().size());
+                }
+            }
+        }
+
+        m_thumbnails = new ThumbnailCache(m_ctx, images);
+        // Start helper thread only if the theme contains thumbnail
+        // objects.
+        if (!images.isEmpty())
+            m_thumbnails->start();
+    }
+
+    m_thumbnails->Clear(m_ctx->player->GetFramesPlayed(), m_seekamount);
+    m_thumbnails->Load();
+}
+
+DeleteMap::~DeleteMap(void)
+{
+    if (m_thumbnails)
+        delete m_thumbnails;
 }
 
 /// Set the edit mode and optionally hide the edit mode OSD.

mythtv/libs/libmythtv/deletemap.h

@@ -5 +5 @@
 #include "programinfo.h"
 #include "playercontext.h"
 #include "mythtvexp.h"
+#include "mthread.h"
 
 class DeleteMap;
 
@@ -16 +17 @@
     DeleteMapUndoEntry(void);
 } DeleteMapUndoEntry;
 
+class ThumbnailCacheEntry
+{
+public:
+    ThumbnailCacheEntry(QImage *image, unsigned char *data,
+                        int dataLength, uint64_t timestamp) :
+        m_image(image), m_data(data), m_dataLength(dataLength),
+        m_timestamp(timestamp) {}
+    ThumbnailCacheEntry(void) : m_image(NULL), m_data(NULL), m_dataLength(0),
+            m_timestamp(0) {}
+
+    QImage *m_image;
+    unsigned char *m_data;
+    int m_dataLength;
+    uint64_t m_timestamp;
+};
+
+class ThumbnailLayout
+{
+public:
+    ThumbnailLayout(MythUIImage *image, float steps, QSize size) :
+        m_image(image), m_steps(steps), m_size(size) {}
+    ThumbnailLayout(void) : m_image(NULL), m_steps(0), m_size(QSize()) {}
+
+    MythUIImage *m_image;
+    float m_steps;
+    QSize m_size;
+};
+
+class ThumbnailCache : public QObject, public MThread
+{
+    Q_OBJECT
+public:
+    ThumbnailCache(PlayerContext *origCtx,
+                   const QVector<ThumbnailLayout> &images);
+    ~ThumbnailCache(void);
+
+    virtual void run(void);
+
+    virtual void customEvent(QEvent *);
+    void Load(void);
+    void Clear(uint64_t frame, int seekamount);
+
+    // Fields used by the lookahead thread
+    PlayerContext *m_ctx;
+    RingBuffer *m_rbuf;
+    MythPlayer *m_player;
+    volatile bool m_keepRunning;
+
+    QMutex m_cacheLock;
+    // m_cacheLock protects the following fields:
+
+    // An ordered queue of images to load, indexed by frame number
+    QList<uint64_t> m_loadQueue;
+
+    // Maps frame number to <QImage, image data, image data size, timestamp>
+    QHash<uint64_t, ThumbnailCacheEntry> m_cache;
+
+    // <image, steps from current frame>
+    QVector<ThumbnailLayout> m_images;
+
+    // which image indexes are finished displaying
+    QSet<int> m_displayed;
+
+    // used for the LRU cache
+    uint64_t m_timestamp;
+    int m_totalDataBytes;
+
+    // End of fields protected by m_cacheLock
+
+    bool m_isEventOutstanding;
+    uint64_t m_baseFrame;
+    int m_seekamount;
+    int m_maxDataBytes;
+    PlayerContext *m_origCtx;
+};
+
 class MTV_PUBLIC DeleteMap
 {
   public:
@@ -23 +100 @@
                  m_nextCutStartIsValid(false),
                  m_nextCutStart(0), m_changed(true),
                  m_seekamountpos(4), m_seekamount(30),
-                 m_ctx(0), m_cachedTotalForOSD(0), m_undoStackPointer(-1)
+                 m_ctx(NULL), m_cachedTotalForOSD(0), m_undoStackPointer(-1),
+                 m_thumbnails(NULL)
     {
         Push("");
     }
+    ~DeleteMap();
 
     void SetPlayerContext(PlayerContext *ctx) { m_ctx = ctx; }
     bool HandleAction(QString &action, uint64_t frame, uint64_t played,
@@ -108 +187 @@
     // Invariant: m_undoStack[m_undoStackPointer].deleteMap == m_deleteMap
     QVector<DeleteMapUndoEntry> m_undoStack;
     int m_undoStackPointer;
+
+    ThumbnailCache *m_thumbnails;
 };
 
 #endif // DELETEMAP_H

mythtv/libs/libmythtv/mythplayer.cpp

@@ -4143 +4143 @@
     memset(&orig,   0, sizeof(AVPicture));
     memset(&retbuf, 0, sizeof(AVPicture));
 
-    if (OpenFile(0) < 0)
+    bool alreadyOpen = videoOutput;
+
+    if (!alreadyOpen && OpenFile(0) < 0)
     {
         LOG(VB_GENERAL, LOG_ERR, LOC + "Could not open file for preview.");
         return NULL;
@@ -4166 +4168 @@
         return (char*) outputbuf;
     }
 
-    if (!InitVideo())
+    if (!alreadyOpen && !InitVideo())
     {
         LOG(VB_GENERAL, LOG_ERR, LOC +
             "Unable to initialize video for screen grab.");
@@ -4174 +4176 @@
     }
 
     ClearAfterSeek();
-    if (!decoderThread)
+    if (!alreadyOpen && !decoderThread)
         DecoderStart(true /*start paused*/);
     SeekForScreenGrab(number, frameNum, absolute);
     int tries = 0;
@@ -4305 +4307 @@
     if (hasFullPositionMap)
     {
         DiscardVideoFrame(videoOutput->GetLastDecodedFrame());
-        DoFastForward(number);
+        DoJumpToFrame(number);
     }
 }