Ticket #9727: snappyseeks_v3.patch

mythtv/libs/libmythtv/avformatdecoder.cpp

@@ -569 +569 @@
     long double seekts = desiredFrame * AV_TIME_BASE / fps;
     ts += (long long)seekts;
 
-    bool exactseeks = DecoderBase::getExactSeeks();
+    //bool exactseeks = DecoderBase::getExactSeeks();
+    // XXX figure out how to do snapping in this case
+    bool exactseeks = !DecoderBase::getSeekSnap();
 
     int flags = (dorewind || exactseeks) ? AVSEEK_FLAG_BACKWARD : 0;
 

mythtv/libs/libmythtv/decoderbase.cpp

@@ -39 +39 @@
       m_positionMapLock(QMutex::Recursive),
       dontSyncPositionMap(false),
 
-      exactseeks(false), livetv(false), watchingrecording(false),
+      seeksnap(-1), livetv(false), watchingrecording(false),
 
       hasKeyFrameAdjustTable(false), lowbuffers(false),
       getrawframes(false), getrawvideo(false),
@@ -516 +516 @@
 
     // Do any Extra frame-by-frame seeking for exactseeks mode
     // And flush pre-seek frame if we are allowed to and need to..
-    int normalframes = (exactseeks) ? desiredFrame - framesPlayed : 0;
+    int normalframes = desiredFrame - (framesPlayed - 1) > seeksnap
+        ? desiredFrame - framesPlayed : 0;
     normalframes = max(normalframes, 0);
     SeekReset(lastKey, normalframes, true, discardFrames);
 
@@ -568 +569 @@
     PosMapEntry e;
     {
         QMutexLocker locker(&m_positionMapLock);
-        int pos_idx  = min(pre_idx, post_idx);
-        e = m_positionMap[pos_idx];
+        PosMapEntry e_pre  = m_positionMap[pre_idx];
+        PosMapEntry e_post = m_positionMap[post_idx];
+        int pos_idx = pre_idx;
+        e = e_pre;
+        if (((uint64_t) (GetKey(e_post) - desiredFrame)) <= seeksnap &&
+            framesPlayed - 1 > GetKey(e_post) &&
+            GetKey(e_post) - desiredFrame <= desiredFrame - GetKey(e_pre))
+        {
+            // Snap to the right if e_post is within snap distance and
+            // is at least as close a snap as e_pre.  Take into
+            // account that if framesPlayed has already reached
+            // e_post, we should only snap to the left.
+            pos_idx = post_idx;
+            e = e_post;
+        }
         lastKey = GetKey(e);
 
         // ??? Don't rewind past the beginning of the file
@@ -731 +745 @@
 
     // Do any Extra frame-by-frame seeking for exactseeks mode
     // And flush pre-seek frame if we are allowed to and need to..
-    int normalframes = (exactseeks) ? desiredFrame - framesPlayed : 0;
+    int normalframes = desiredFrame - (framesPlayed - 1) > seeksnap
+        ? desiredFrame - framesPlayed : 0;
     normalframes = max(normalframes, 0);
     SeekReset(lastKey, normalframes, needflush, discardFrames);
 
@@ -789 +804 @@
     FindPosition(desiredFrame, hasKeyFrameAdjustTable, pre_idx, post_idx);
 
     // if exactseeks, use keyframe <= desiredFrame
-    uint pos_idx = (exactseeks) ? pre_idx : max(pre_idx, post_idx);
 
-    PosMapEntry e;
+    PosMapEntry e, e_pre, e_post;
     {
         QMutexLocker locker(&m_positionMapLock);
-        e = m_positionMap[pos_idx];
+        e_pre  = m_positionMap[pre_idx];
+        e_post = m_positionMap[post_idx];
+    }
+    e = e_pre;
+    if (((uint64_t) (GetKey(e_post) - desiredFrame)) <= seeksnap &&
+        (framesPlayed - 1 >= GetKey(e_pre) ||
+         GetKey(e_post) - desiredFrame < desiredFrame - GetKey(e_pre)))
+    {
+        // Snap to the right if e_post is within snap distance and is
+        // a closer snap than e_pre.  Take into account that if
+        // framesPlayed has already reached e_pre, we should only snap
+        // to the right.
+        e = e_post;
     }
     lastKey = GetKey(e);
 

mythtv/libs/libmythtv/decoderbase.h

@@ -97 +97 @@
     virtual void SetEof(bool eof)  { ateof = eof;  }
     bool         GetEof(void)      { return ateof; }
 
-    void setExactSeeks(bool exact) { exactseeks = exact; }
-    bool getExactSeeks(void) const { return exactseeks;  }
+    void setSeekSnap(uint64_t snap)  { seeksnap = snap; }
+    uint64_t getSeekSnap(void) const { return seeksnap;  }
     void setLiveTVMode(bool live)  { livetv = live;      }
 
     // Must be done while player is paused.
@@ -255 +255 @@
     vector<PosMapEntry> m_positionMap;
     bool dontSyncPositionMap;
 
-    bool exactseeks;
+    uint64_t seeksnap;
     bool livetv;
     bool watchingrecording;
 

mythtv/libs/libmythtv/mythplayer.cpp

@@ -147 +147 @@
       // Bookmark stuff
       bookmarkseek(0),
       // Seek
-      fftime(0),                    exactseeks(false),
+      fftime(0),                    seeksnap(-1),
       // Playback misc.
       videobuf_retries(0),          framesPlayed(0),
       totalFrames(0),               totalLength(0),
@@ -966 +966 @@
         return -1;
     }
 
-    decoder->setExactSeeks(exactseeks);
+    decoder->setSeekSnap(seeksnap);
     decoder->setLiveTVMode(livetv);
     decoder->setWatchingRecording(watchingrecording);
     decoder->setTranscoding(transcoding);
@@ -2431 +2431 @@
         nextpos = 0;
 
     if (nextpos > 10)
-        DoFastForward(nextpos, true, false);
+        DoFastForward(nextpos, true, -1);
 
     player_ctx->SetPlayerChangingBuffers(false);
     LOG(VB_PLAYBACK, LOG_INFO, LOC + "JumpToProgram - end");
@@ -2475 +2475 @@
     // TODO handle initial commskip and/or cutlist skip as well
     if (bookmarkseek > 30)
     {
-        DoFastForward(bookmarkseek, true, false);
+        DoFastForward(bookmarkseek, true, -1);
         if (clearSavedPosition && !player_ctx->IsPIP())
             SetBookmark(true);
     }
@@ -2666 +2666 @@
             if (!msg.isEmpty())
                 SetOSDStatus(msg, kOSDTimeout_Med);
             if (jump)
-                DoJumpToFrame(jumpto, true, true);
+                DoJumpToFrame(jumpto, true, 0);
         }
         commBreakMap.SkipCommercials(0);
         return;
@@ -2684 +2684 @@
         if (!msg.isEmpty())
             SetOSDStatus(msg, kOSDTimeout_Med);
         if (jump)
-            DoJumpToFrame(jumpto, true, true);
+            DoJumpToFrame(jumpto, true, 0);
     }
 
     // Handle cutlist skipping
@@ -2701 +2701 @@
         }
         else
         {
-            DoJumpToFrame(jumpto, true, true);
+            DoJumpToFrame(jumpto, true, 0);
         }
     }
 }
@@ -3202 +3202 @@
     {
         videoOutput->SetPrebuffering(ffrew_skip == 1);
         if (decoder)
-            decoder->setExactSeeks(exactseeks && ffrew_skip == 1);
+            decoder->setSeekSnap(ffrew_skip == 1 ? seeksnap : -1);
         if (play_speed != 0.0f && !(last_speed == 0.0f && ffrew_skip == 1))
             DoJumpToFrame(framesPlayed + fftime - rewindtime);
     }
@@ -3250 +3250 @@
 }
 
 bool MythPlayer::DoRewind(uint64_t frames, bool override_seeks,
-                          bool seeks_wanted)
+                          uint64_t seeksnap_wanted)
 {
     if (player_ctx->buffer && !player_ctx->buffer->IsSeekingAllowed())
         return false;
 
     uint64_t number = frames + 1;
     uint64_t desiredFrame = (framesPlayed > number) ? framesPlayed - number : 0;
@@ -3259 +3259 @@
     if (desiredFrame < video_frame_rate)
         limitKeyRepeat = true;
 
-    WaitForSeek(desiredFrame, override_seeks, seeks_wanted);
+    WaitForSeek(desiredFrame, override_seeks, seeksnap_wanted);
     rewindtime = 0;
     ClearAfterSeek();
     return true;
@@ -3402 +3402 @@
 }
 
 bool MythPlayer::DoFastForward(uint64_t frames, bool override_seeks,
-                               bool seeks_wanted)
+                               uint64_t seeksnap_wanted)
 {
     if (player_ctx->buffer && !player_ctx->buffer->IsSeekingAllowed())
         return false;
 
     uint64_t number = frames - 1;
     uint64_t desiredFrame = framesPlayed + number;
@@ -3414 +3414 @@
             desiredFrame = endcheck;
     }
 
-    WaitForSeek(desiredFrame, override_seeks, seeks_wanted);
+    WaitForSeek(desiredFrame, override_seeks, seeksnap_wanted);
     fftime = 0;
     ClearAfterSeek(false);
     return true;
 }
 
 void MythPlayer::DoJumpToFrame(uint64_t frame, bool override_seeks,
-                               bool seeks_wanted)
+                               uint64_t seeksnap_wanted)
 {
     if (frame > framesPlayed)
-        DoFastForward(frame - framesPlayed, override_seeks, seeks_wanted);
+        DoFastForward(frame - framesPlayed, override_seeks, seeksnap_wanted);
     else if (frame <= framesPlayed)
-        DoRewind(framesPlayed - frame, override_seeks, seeks_wanted);
+        DoRewind(framesPlayed - frame, override_seeks, seeksnap_wanted);
 }
 
 void MythPlayer::WaitForSeek(uint64_t frame, bool override_seeks,
-                             bool seeks_wanted)
+                             uint64_t seeksnap_wanted)
 {
     if (!decoder)
         return;
 
-    bool after  = exactseeks && (ffrew_skip == 1);
-    bool before = override_seeks ? seeks_wanted :
-                           (allpaused && !deleteMap.IsEditing()) ? true: after;
-    decoder->setExactSeeks(before);
+    uint64_t after  = (ffrew_skip == 1) ? seeksnap : -1;
+    uint64_t before = override_seeks ? seeksnap_wanted :
+                           (allpaused && !deleteMap.IsEditing()) ? 0: after;
+    decoder->setSeekSnap(before);
 
     bool islivetvcur = (livetv && player_ctx->tvchain &&
                         !player_ctx->tvchain->HasNext());
@@ -3480 +3480 @@
             osd->HideWindow("osd_message");
         osdLock.unlock();
     }
-    decoder->setExactSeeks(after);
+    decoder->setSeekSnap(after);
 }
 
 /** \fn MythPlayer::ClearAfterSeek(bool)
@@ -3519 +3519 @@
 }
 
 void MythPlayer::SetPlayerInfo(TV *tv, QWidget *widget,
-                               bool frame_exact_seek, PlayerContext *ctx)
+                               uint64_t frame_seek_snap, PlayerContext *ctx)
 {
     deleteMap.SetPlayerContext(ctx);
     m_tv = tv;
     parentWidget = widget;
-    exactseeks   = frame_exact_seek;
+    seeksnap     = frame_seek_snap;
     player_ctx   = ctx;
     livetv       = ctx->tvchain;
 }
@@ -3607 +3607 @@
     {
         QString action = actions[i];
         handled = true;
+        int seekamount = deleteMap.GetSeekAmount();
         if (action == ACTION_LEFT)
         {
             if (deleteMap.GetSeekAmount() > 0)
             {
-                DoRewind(deleteMap.GetSeekAmount(), true, true);
+                DoRewind(seekamount, true, seekamount > 1 ? seekamount / 2 : 0);
             }
             else
                 HandleArbSeek(false);
@@ -3620 +3621 @@
         {
             if (deleteMap.GetSeekAmount() > 0)
             {
-                DoFastForward(deleteMap.GetSeekAmount(), true, true);
+                DoFastForward(seekamount, true, seekamount > 1 ? seekamount / 2 : 0);
             }
             else
                 HandleArbSeek(true);
@@ -3651 +3652 @@
 #define FFREW_MULTICOUNT 10
         else if (action == ACTION_BIGJUMPREW)
         {
-            if (deleteMap.GetSeekAmount() > 0)
-                DoRewind(deleteMap.GetSeekAmount() * FFREW_MULTICOUNT,
-                         true, true);
+            if (seekamount > 0)
+                DoRewind(seekamount * FFREW_MULTICOUNT,
+                            true, seekamount > 1 ? seekamount * FFREW_MULTICOUNT / 2: 0);
             else
             {
                 int fps = (int)ceil(video_frame_rate);
-                DoRewind(fps * FFREW_MULTICOUNT / 2, true, true);
+                DoRewind(fps * FFREW_MULTICOUNT / 2, true, 0);
             }
         }
         else if (action == ACTION_BIGJUMPFWD)
         {
-            if (deleteMap.GetSeekAmount() > 0)
-                DoFastForward(deleteMap.GetSeekAmount() * FFREW_MULTICOUNT,
-                              true, true);
+            if (seekamount > 0)
+                DoFastForward(seekamount * FFREW_MULTICOUNT,
+                              true, seekamount > 1 ? seekamount * FFREW_MULTICOUNT / 2: 0);
             else
             {
                 int fps = (int)ceil(video_frame_rate);
-                DoFastForward(fps * FFREW_MULTICOUNT / 2, true, true);
+                DoFastForward(fps * FFREW_MULTICOUNT / 2, true, 0);
             }
         }
         else if (action == ACTION_SELECT)
@@ -3769 +3770 @@
         long long framenum = deleteMap.GetNearestMark(framesPlayed,
                                                       totalFrames, right);
         if (right && (framenum > (int64_t)framesPlayed))
-            DoFastForward(framenum - framesPlayed, true, true);
+            DoFastForward(framenum - framesPlayed, true, 0);
         else if (!right && ((int64_t)framesPlayed > framenum))
-            DoRewind(framesPlayed - framenum, true, true);
+            DoRewind(framesPlayed - framenum, true, 0);
     }
     else
     {
@@ -3782 +3783 @@
             // the position map uses MARK_GOP_BYFRAME. (see DecoderBase)
             float editKeyFrameDist = keyframedist <= 2 ? 18 : keyframedist;
 
-            DoFastForward((long long)(editKeyFrameDist * 1.1), true, false);
+            DoFastForward((long long)(editKeyFrameDist * 1.1), true, -1);
         }
         else
         {
-            DoRewind(2, true, false);
+            DoRewind(2, true, -1);
         }
     }
 }
@@ -4115 +4116 @@
 
     if (frameNumber >= 0)
     {
-        DoJumpToFrame(frameNumber, true, true);
+        DoJumpToFrame(frameNumber, true, 0);
         ClearAfterSeek();
     }
 
@@ -4200 +4201 @@
     if (copyaudio && decoder)
         decoder->SetRawAudioState(true);
 
-    SetExactSeeks(true);
+    SetSeekSnap(0);
     if (decoder)
     {
-        decoder->setExactSeeks(exactseeks);
+        decoder->setSeekSnap(seeksnap);
         decoder->SetLowBuffers(true);
     }
 }

mythtv/libs/libmythtv/mythplayer.h

@@ -116 +116 @@
     bool InitVideo(void);
 
     // Public Sets
-    void SetPlayerInfo(TV *tv, QWidget *widget, bool frame_exact_seek,
+    void SetPlayerInfo(TV *tv, QWidget *widget, uint64_t frame_seek_snap,
                        PlayerContext *ctx);
     void SetNullVideo(void)                   { using_null_videoout = true; }
-    void SetExactSeeks(bool exact)            { exactseeks = exact; }
+    void SetSeekSnap(uint64_t snap)           { seeksnap = snap; }
     void SetLength(int len)                   { totalLength = len; }
     void SetFramesPlayed(uint64_t played);
     void SetVideoFilters(const QString &override);
@@ -490 +490 @@
     // These actually execute commands requested by public members
     virtual void ChangeSpeed(void);
     bool DoFastForward(uint64_t frames, bool override_seeks = false,
-                       bool seeks_wanted = false);
+                       uint64_t seeksnap_wanted = -1);
     bool DoRewind(uint64_t frames, bool override_seeks = false,
-                  bool seeks_wanted = false);
+                  uint64_t seeksnap_wanted = -1);
     void DoJumpToFrame(uint64_t frame, bool override_seeks = false,
-                       bool seeks_wanted = false);
+                       uint64_t seeksnap_wanted = -1);
 
     // Private seeking stuff
     void WaitForSeek(uint64_t frame, bool override_seeks = false,
-                     bool seeks_wanted = false);
+                     uint64_t seeksnap_wanted = -1);
     void ClearAfterSeek(bool clearvideobuffers = true);
 
     // Private chapter stuff
@@ -588 +588 @@
     /// If fftime>0, number of frames to seek forward.
     /// If fftime<0, number of frames to seek backward.
     long long fftime;
-    /// Iff true we ignore seek amount and try to seek to an
-    /// exact frame ignoring key frame restrictions.
-    bool     exactseeks;
+    /// When seeking, snap to a key frame if the target is within
+    /// seeksnap frames.  Use seeksnap=0 for exact seeks,
+    /// seeksnap=-1 for completely non-exact seeks.
+    uint64_t seeksnap;
 
     // Playback misc.
     /// How often we have tried to wait for a video output buffer and failed

mythtv/programs/mythcommflag/PrePostRollFlagger.cpp

@@ -26 +26 @@
 void PrePostRollFlagger::Init()
 {
     ClassicCommDetector::Init();
-    player->SetExactSeeks(true);
+    player->SetSeekSnap(0);
 }
 
 bool PrePostRollFlagger::go()
@@ -230 +230 @@
     player->DiscardVideoFrame(player->GetRawVideoFrame(0));
 
     long long tmpStartFrame = startFrame;
-    player->SetExactSeeks(true);
+    player->SetSeekSnap(0);
     VideoFrame* f = player->GetRawVideoFrame(tmpStartFrame);
     float aspect = player->GetVideoAspect();
     currentFrameNumber = f->frameNumber;