cachestream.h

Go to the documentation of this file.

#ifndef cachestream_HEADER_GUARD
#define cachestream_HEADER_GUARD
/*
 * cachestream.h :
 *
 * (c) Copyright 2017-2024 Sampsa Riikonen
 *
 * Authors: Sampsa Riikonen <sampsa.riikonen@iki.fi>
 *
 * This file is part of the Valkka library.
 *
 * Valkka is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>
 *
 */
 
#include "framefifo.h"
#include "filestream.h"
#include "Python.h"
 
/*   02 03 04 05 06 07 08 09 10 11 12 13
 *   a  a  b  A  a  b  c  C  c  c  B  A
 *
 *   seek to 10 :  <---- .. key frame for C, A found, but not for B .. if this is from blocks, ok
 *
 *   better idea: start iterating from the very beginning, save (overwrite) frame pointers during progress
 *
 *   Block request:
 *   when to request more blocks / frames ? .. when close enough to maxtime
 *
 *
 *   1   2    3
 *       2    3    4
 *
 */
 
struct FileStreamContext {                                         // <pyapi>
    FileStreamContext(SlotNumber slot, FrameFilter *framefilter) : // <pyapi>
        slot(slot), framefilter(framefilter)                       // <pyapi>
    {                         // <pyapi>
    }                         // <pyapi>
    FileStreamContext() {}    // <pyapi>
    SlotNumber slot;          // <pyapi>
    FrameFilter *framefilter; // <pyapi>
};                            // <pyapi>
 
struct FileCacheSignalPars
{
    FileStreamContext file_stream_ctx;
    long int mstimestamp;
    bool clear;
};
 
enum class FileCacheSignal
{
    none,
    exit,
    register_stream,
    deregister_stream,
    play_streams,
    stop_streams,
    clear,
    seek_streams,
    clear_streams,
    report_cache
};
 
struct FileCacheSignalContext
{
    FileCacheSignal signal;
    FileCacheSignalPars pars;
};
 
struct FrameCacheContext
{ // nothing here yet ..
    int nada;
};
 
class FrameCache
{
 
public:
    FrameCache(const char *name, FrameCacheContext ctx = FrameCacheContext());
    ~FrameCache();
    ban_copy_ctor(FrameCache);
    ban_copy_asm(FrameCache);
 
protected:
    std::string name;
    FrameCacheContext ctx; 
    long int mintime_;     
    long int maxtime_;     
    bool has_delta_frames; 
 
protected:
    Cache cache;           
    Cache::iterator state; 
 
protected:                                   // mutex synchro
    std::mutex mutex;                        
    std::condition_variable condition;       
    std::condition_variable ready_condition; 
 
public: // getters
    long int getMinTime_() { return this->mintime_; }
    long int getMaxTime_() { return this->maxtime_; }
    bool hasDeltaFrames() { return this->has_delta_frames; }
 
protected:
    void dump_();
    void clear_();
 
public:
    virtual bool writeCopy(Frame *f, bool wait = false); 
    // virtual Frame* read(unsigned short int mstimeout=0);   ///< Pop a frame from the end of the fifo and return the frame to the reservoir stack
    void clear();                         
    void dump();                          
    bool isEmpty();                       
    int seek(long int ms_streamtime_);    
    int keySeek(long int ms_streamtime_); 
    Frame *pullNextFrame();               
};
 
class CacheFrameFilter : public FrameFilter { // <pyapi>
 
public: // <pyapi>
    CacheFrameFilter(const char *name, FrameCache *framecache); 
 
protected:
    FrameCache *framecache;
 
protected:
    void go(Frame *frame);
}; // <pyapi>
 
class FileCacheThread : public AbstractFileThread { // <pyapi>
 
public:                                // <pyapi>
    FileCacheThread(const char *name); // <pyapi>
    virtual ~FileCacheThread();        // <pyapi>
 
protected:                // internal framefilter chain
    ForkFrameFilter fork; 
    TypeFrameFilter typefilter;
    SwitchFrameFilter switchfilter;
    CacheFrameFilter cache_filter_1, cache_filter_2;
 
protected:
    FrameCache frame_cache_1;
    FrameCache frame_cache_2;
    FrameCache *play_cache; 
    FrameCache *tmp_cache;  
    void (*callback)(long int mstimestamp);
    PyObject *pyfunc;             
    PyObject *pyfunc2;            
    long int target_mstimestamp_; 
    Frame *next;
    long int reftime; 
    long int walltime;
    AbstractFileState state;
    SetupFrame state_setupframe; 
 
protected:                                          // Thread member redefinitions
    std::deque<FileCacheSignalContext> signal_fifo; 
    std::vector<FrameFilter *> slots_;              
    // std::vector<SetupFrame*>           setup_frames;  ///< Slot number => SetupFrame mapping.  Book-keeping of SetupFrames
    std::vector<std::vector<SetupFrame *>> setup_frames; 
 
public: // redefined virtual functions
    void run();
    void preRun();
    void postRun();
    void sendSignal(FileCacheSignalContext signal_ctx);
 
public: // internal
    void switchCache();
    void dumpPlayCache();
    void dumpTmpCache();
    void sendSetupFrames(SetupFrame *f); 
    void stopStreams(bool send_state = true);
    void playStreams(bool send_state = true);
    void setRefTimeAndStop(bool send_state = true);                             
    void seekStreams(long int mstimestamp, bool clear, bool send_state = true); 
    void clear();                                                               
 
private: // internal
    void handleSignal(FileCacheSignalContext &signal_ctx);
    void handleSignals();
    int safeGetSlot(SlotNumber slot, FrameFilter *&ff);
    void registerStream(FileStreamContext &ctx);
    void deregisterStream(FileStreamContext &ctx);
 
public: // API must be called before thread start
    void setCallback(void func(long int));
 
public: // API // <pyapi>
    void setPyCallback(PyObject *pobj); // <pyapi>
 
    void setPyCallback2(PyObject *pobj); // <pyapi>
 
    void registerStreamCall(FileStreamContext &ctx);   // <pyapi>
    void deregisterStreamCall(FileStreamContext &ctx); // <pyapi>
 
    FrameFilter &getFrameFilter(); // <pyapi>
    void requestStopCall();        // <pyapi>
    void dumpCache();              // <pyapi>
    void stopStreamsCall();        // <pyapi>
    void playStreamsCall();        // <pyapi>
    void clearCall();              // <pyapi>
 
    void seekStreamsCall(long int mstimestamp, bool clear = false); // <pyapi>
};                                                                  // <pyapi>
 
#endif