Method run

src/Qt/VideoCacheThread.cpp:475–692

    }

    void VideoCacheThread::run()
    {
        using micro_sec        = std::chrono::microseconds;
        using double_micro_sec = std::chrono::duration<double, micro_sec::period>;

        while (!threadShouldExit()) {
            Settings* settings = Settings::Instance();
            CacheBase* cache   = reader ? reader->GetCache() : nullptr;
            Timeline* timeline = dynamic_cast<Timeline*>(reader);

            // Process deferred clears even when caching is currently disabled
            // (e.g. active scrub mode), so stale ranges are removed promptly.
            bool should_clear_cache = clear_cache_on_next_fill.exchange(false);
            if (should_clear_cache && timeline) {
                const int dir_on_clear = computeDirection();
                const int64_t clear_playhead = clampToTimelineRange(
                    requested_display_frame.load(), resolveTimelineEnd());
                timeline->ClearAllCache();
                cached_frame_count.store(0);
                // Reset ready baseline immediately after clear. Otherwise a
                // stale last_cached_index from the old cache window can make
                // isReady() report true before new preroll is actually filled.
                last_cached_index.store(clear_playhead - dir_on_clear);
            }

            // If caching disabled or no reader, mark cache as ready and sleep briefly
            if (!settings->ENABLE_PLAYBACK_CACHING || !cache) {
                cached_frame_count.store(cache ? cache->Count() : 0);
                min_frames_ahead.store(-1);
                std::this_thread::sleep_for(double_micro_sec(50000));
                continue;
            }

            // init local vars
            min_frames_ahead.store(settings->VIDEO_CACHE_MIN_PREROLL_FRAMES);

            if (!timeline) {
                std::this_thread::sleep_for(double_micro_sec(50000));
                continue;
            }
            int64_t  timeline_end = resolveTimelineEnd();
            int64_t  raw_playhead = requested_display_frame.load();
            int64_t  playhead     = clampToTimelineRange(raw_playhead, timeline_end);
            bool     paused       = (speed.load() == 0);
            int64_t  preroll_frames = computePrerollFrames(settings);

            cached_frame_count.store(cache->Count());

            // Compute effective direction (±1)
            int dir = computeDirection();
            if (speed.load() != 0) {
                last_dir.store(dir);
            }

            // If timeline-side cache invalidation occurred (e.g. ApplyJsonDiff / SetJson),
            // restart fill from the active playhead window so invalidated gaps self-heal.
            if (timeline) {
                bool epoch_changed = false;