VideoCacheThread.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2025 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_VIDEO_CACHE_THREAD_H
#define OPENSHOT_VIDEO_CACHE_THREAD_H
 
#include "ReaderBase.h"
#include "AdaptivePreroll.h"
 
#include <AppConfig.h>
#include <juce_audio_basics/juce_audio_basics.h>
#include <atomic>
#include <cstdint>
#include <mutex>
#include <memory>
 
namespace openshot
{
    class Settings;
    using juce::Thread;
 
    class VideoCacheThread : public Thread
    {
    public:
        VideoCacheThread();
        ~VideoCacheThread() override;
 
        bool isReady();
        bool UsesCachedAudio() const { return cache_audio_only.load(); }
        void NotifyAudioCacheMiss() { audio_cache_miss.store(true); }
        void AcknowledgeAudioCacheMiss() { audio_cache_miss.store(false); }
 
        void Play() { notify(); };
 
        void Stop();
 
        void setSpeed(int new_speed);
 
        int getSpeed() const { return speed.load(); }
 
        void Seek(int64_t new_position);
 
        void Seek(int64_t new_position, bool start_preroll);
 
        void NotifyPlaybackPosition(int64_t new_position);
 
        bool StartThread();
 
        bool StopThread(int timeoutMs = 0);
 
        void EnableRequestDiagnostics(bool enabled) { diagnostics_enabled.store(enabled); }
        int64_t CancellationAcknowledgementUs() const { return acknowledgement_us.load(); }
        int64_t ObsoleteCompletionUs() const { return obsolete_completion_us.load(); }
        int64_t FirstCurrentFrameUs() const { return first_current_frame_us.load(); }
 
        void Reader(ReaderBase* new_reader);
 
    protected:
        void run() override;
 
        int64_t getBytes(int width, int height, int sample_rate, int channels, float fps);
 
        //---------- Helper functions, broken out for clarity & unit testing ----------
 
        int computeDirection() const;
 
        void handleUserSeek(int64_t playhead, int dir);
 
        void handleUserSeekWithPreroll(int64_t playhead,
                                       int dir,
                                       int64_t timeline_end,
                                       int64_t preroll_frames);
 
        int64_t computePrerollFrames(const Settings* settings) const;
 
        int64_t resolveTimelineEnd() const;
 
        int64_t clampToTimelineRange(int64_t frame, int64_t timeline_end) const;
 
        bool clearCacheIfPaused(int64_t playhead, bool paused, CacheBase* cache);
 
        void computeWindowBounds(int64_t playhead,
                                 int dir,
                                 int64_t ahead_count,
                                 int64_t timeline_end,
                                 int64_t& window_begin,
                                 int64_t& window_end) const;
 
        bool prefetchWindow(CacheBase* cache,
                            int64_t window_begin,
                            int64_t window_end,
                            int dir,
                            ReaderBase* reader,
                            int64_t max_frames_to_fetch = -1,
                            uint64_t generation = UINT64_MAX);
 
        void updateReadiness(CacheBase* cache, int64_t playhead, int dir);
        void resetReadiness(); // Requires seek_state_mutex.
 
        AdaptivePreroll preroll_policy;
        int64_t contiguous_ahead = 0;
        int64_t readiness_playhead = 1;
        int readiness_direction = 1;
        std::atomic<bool> audio_cache_miss{false};
        std::atomic<bool> cache_audio_only{false};
        int64_t observed_frame_bytes = 0;
        int64_t readiness_capacity = 0;
        int64_t readiness_physical_capacity = 0;
        int64_t readiness_timeline_end = 0;
        int64_t readiness_bytes_per_frame = 0;
        uint64_t readiness_epoch = 0;
        uint64_t readiness_generation = UINT64_MAX; 
        int64_t readiness_minimum_step = 0;
 
        //---------- Internal state ----------
 
        std::shared_ptr<Frame> last_cached_frame; 
 
        std::atomic<int> speed;            
        std::atomic<int> last_speed;       
        std::atomic<int> last_dir;         
        std::atomic<bool> userSeeked;      
        std::atomic<bool> preroll_on_next_fill; 
        std::atomic<bool> clear_cache_on_next_fill; 
        std::atomic<bool> scrub_active;    
 
        std::atomic<int64_t> requested_display_frame; 
        int64_t current_display_frame;   
        std::atomic<int64_t> cached_frame_count;      
 
        std::atomic<int64_t> min_frames_ahead;        
        int64_t timeline_max_frame;      
 
        ReaderBase* reader;              
        bool force_directional_cache;    
        uint64_t seen_timeline_cache_epoch; 
        bool timeline_cache_epoch_initialized; 
 
        std::atomic<int64_t> last_cached_index;       
        std::atomic<uint64_t> processed_generation{UINT64_MAX}; 
        std::atomic<uint64_t> request_generation{0}; 
        std::atomic<bool> diagnostics_enabled{false};
        std::atomic<int64_t> request_time_us{0};
        std::atomic<int64_t> acknowledgement_us{0};
        std::atomic<int64_t> obsolete_completion_us{0};
        std::atomic<int64_t> first_current_frame_us{0};
        void acknowledgeRequest(int64_t started_us);
        static int64_t monotonicUs();
        mutable std::mutex lifecycle_mutex; 
        mutable std::mutex seek_state_mutex;          
    };
 
} // namespace openshot
 
#endif // OPENSHOT_VIDEO_CACHE_THREAD_H