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 <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();
 
        void Play() {};
 
        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 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);
 
        //---------- 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;       
        mutable std::mutex seek_state_mutex;          
    };
 
} // namespace openshot
 
#endif // OPENSHOT_VIDEO_CACHE_THREAD_H