Improvements to the ClearAllCache() function, allowing both shallow and deep clearing. Lots of bug fixes in VideoCacheThread, to correctly pre-roll and cache the correct frames, and a new method of disabling/enabling the cache thread.

src/Qt/VideoCacheThread.cpp

@@ -16,6 +16,8 @@
 #include "Exceptions.h"
 #include "Frame.h"
 #include "OpenMPUtilities.h"
+#include "Settings.h"
+#include "Timeline.h"
 
 #include <algorithm>
 #include <thread>    // for std::this_thread::sleep_for
@@ -27,7 +29,7 @@ namespace openshot
 	VideoCacheThread::VideoCacheThread()
 	: Thread("video-cache"), speed(0), last_speed(1), is_playing(false),
 	reader(NULL), current_display_frame(1), cached_frame_count(0),
-	min_frames_ahead(4), max_frames_ahead(8)
+	min_frames_ahead(4), max_frames_ahead(8), should_pause_cache(false)
     {
     }
 
@@ -45,8 +47,33 @@ namespace openshot
     // Seek the reader to a particular frame number and optionally start the pre-roll
     void VideoCacheThread::Seek(int64_t new_position, bool start_preroll)
     {
+        // Determine previous frame number (depending on speed)
+        int64_t previous_frame = new_position;
+        if (last_speed < 0) {
+            // backwards
+            previous_frame++;
+        } else if (last_speed > 0) {
+            // forward
+            previous_frame--;
+        }
+        if (previous_frame <= 0) {
+            // min frame is 1
+            previous_frame = 1;
+        }
+
+        // Clear cache if previous frame outside the cached range, which means we are
+        // requesting a non-contiguous frame compared to our current cache range
+        if (!reader->GetCache()->Contains(previous_frame)) {
+            Timeline *t = (Timeline *) reader;
+            t->ClearAllCache();
+        }
+
+        // Reset pre-roll when requested frame is not currently cached
 	    if (start_preroll && reader && reader->GetCache() && !reader->GetCache()->Contains(new_position)) {
             cached_frame_count = 0;
+            if (speed == 0) {
+                should_pause_cache = false;
+            }
 	    }
         Seek(new_position);
     }
@@ -71,22 +98,38 @@ namespace openshot
     // Start the thread
     void VideoCacheThread::run()
     {
+        // Get settings
+        Settings *s = Settings::Instance();
+
         // Types for storing time durations in whole and fractional microseconds
         using micro_sec = std::chrono::microseconds;
         using double_micro_sec = std::chrono::duration<double, micro_sec::period>;
-        bool should_pause_cache = false;
 
 		while (!threadShouldExit() && is_playing) {
+            // init local vars
+            min_frames_ahead = s->VIDEO_CACHE_MIN_PREROLL_FRAMES;
+            max_frames_ahead = s->VIDEO_CACHE_MAX_PREROLL_FRAMES;
+
             // Calculate on-screen time for a single frame
             const auto frame_duration = double_micro_sec(1000000.0 / reader->info.fps.ToDouble());
             int current_speed = speed;
+            
+            // Check for empty cache (and re-trigger preroll)
+            // This can happen when the user manually empties the timeline cache
+            if (reader->GetCache()->Count() == 0) {
+                should_pause_cache = false;
+                cached_frame_count = 0;
+            }
 
-            // Calculate increment (based on speed)
+            // Calculate increment (based on current_speed)
             // Support caching in both directions
-            int16_t increment = speed;
-            if (current_speed == 0 && should_pause_cache) {
+            int16_t increment = current_speed;
+
+            if (current_speed == 0 && should_pause_cache || !s->ENABLE_PLAYBACK_CACHING) {
                 // Sleep during pause (after caching additional frames when paused)
-                std::this_thread::sleep_for(frame_duration / 4);
+                // OR sleep when playback caching is disabled
+                current_display_frame = requested_display_frame;
+                std::this_thread::sleep_for(frame_duration / 2);
                 continue;
 
             } else if (current_speed == 0) {
@@ -106,14 +149,14 @@ namespace openshot
                 if (reader->GetCache() && reader->GetCache()->GetMaxBytes() > 0) {
                     // When paused, use 1/2 the cache size (so our cache will be 50% before the play-head, and 50% after it)
                     max_frames_ahead = (reader->GetCache()->GetMaxBytes() / bytes_per_frame) / 2;
-                    if (max_frames_ahead > 300) {
+                    if (max_frames_ahead > s->VIDEO_CACHE_MAX_FRAMES) {
                         // Ignore values that are too large, and default to a safer value
-                        max_frames_ahead = 300;
+                        max_frames_ahead = s->VIDEO_CACHE_MAX_FRAMES;
                     }
                 }
 
                 // Overwrite the increment to our cache position
-                // to fully cache frames while paused (support forward and rewind)
+                // to fully cache frames while paused (support forward and rewind caching)
                 if (last_speed > 0) {
                     increment = 1;
                 } else {
@@ -121,8 +164,7 @@ namespace openshot
                 }
 
             } else {
-                // Default max frames ahead (normal playback)
-                max_frames_ahead = 8;
+                // normal playback
                 should_pause_cache = false;
             }
 
@@ -134,19 +176,23 @@ namespace openshot
             int64_t ending_frame = starting_frame + max_frames_ahead;
 
             // Adjust ending frame for cache loop
-            if (speed < 0) {
+            if (last_speed < 0) {
                 // Reverse loop (if we are going backwards)
                 ending_frame = starting_frame - max_frames_ahead;
             }
-            if (ending_frame < 0) {
+            if (starting_frame < 1) {
                 // Don't allow negative frame number caching
-                ending_frame = 0;
+                starting_frame = 1;
+            }
+            if (ending_frame < 1) {
+                // Don't allow negative frame number caching
+                ending_frame = 1;
             }
 
             // Loop through range of frames (and cache them)
             int64_t uncached_frame_count = 0;
             int64_t already_cached_frame_count = 0;
-            for (int64_t cache_frame = starting_frame; cache_frame != ending_frame; cache_frame += increment) {
+            for (int64_t cache_frame = starting_frame; cache_frame != (ending_frame + increment); cache_frame += increment) {
                 cached_frame_count++;
                 if (reader && reader->GetCache() && !reader->GetCache()->Contains(cache_frame)) {
                     try
@@ -165,8 +211,10 @@ namespace openshot
                 if (requested_display_frame != current_display_frame) {
                     // cache will restart at a new position
                     if (speed >= 0 && (requested_display_frame < starting_frame || requested_display_frame > ending_frame)) {
+                        should_pause_cache = false;
                         break;
                     } else if (speed < 0 && (requested_display_frame > starting_frame || requested_display_frame < ending_frame)) {
+                        should_pause_cache = false;
                         break;
                     }
                 }
@@ -174,10 +222,14 @@ namespace openshot
                 if (current_speed != speed) {
                     break;
                 }
+                // Check if playback has stopped
+                if (!is_playing) {
+                    break;
+                }
             }
 
             // Update cache counts
-            if (cached_frame_count > max_frames_ahead && uncached_frame_count > (min_frames_ahead / 4)) {
+            if (current_speed == 1 && cached_frame_count > max_frames_ahead && uncached_frame_count > min_frames_ahead) {
                 // start cached count again (we have too many uncached frames)
                 cached_frame_count = 0;
             }
@@ -189,7 +241,7 @@ namespace openshot
             }
 
 			// Sleep for a fraction of frame duration
-			std::this_thread::sleep_for(frame_duration / 4);
+			std::this_thread::sleep_for(frame_duration / 2);
 		}
 
 	return;