valkkafs.h

Go to the documentation of this file.

#ifndef valkkafs_HEADER_GUARD
#define valkkafs_HEADER_GUARD
/*
 * valkkafs.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 "common.h"
#include "thread.h"
#include "framefilter.h"
#include "framefifo.h"
#include "rawrite.h"
#include "logging.h"
#include "Python.h"
 
/*
#include "boost/python/numpy.hpp"
namespace p = boost::python;
namespace np = boost::python::numpy;
// https://www.boost.org/doc/libs/1_64_0/libs/python/doc/html/numpy/reference/ndarray.html
// https://github.com/ndarray/Boost.NumPy/blob/master/libs/numpy/example/simple.cpp
// let's not use boost..
*/
 
class ValkkaFS {        // <pyapi>
 
public:                 // <pyapi>
    
    ValkkaFS(const char *device_file, const char *block_file, std::size_t blocksize, std::size_t n_blocks, bool init=false); // <pyapi>
    virtual ~ValkkaFS();        // <pyapi>
 
protected:
    std::string     device_file;
    std::string     block_file;
    std::size_t     blocksize;
    std::size_t     n_blocks;
    bool            init;           
    std::size_t     device_size;
    std::vector<long int> tab;      
    std::fstream    os;             
    
    std::mutex      mutex;
    long int        col_0;          
    long int        col_1;          
    long int        col_0_lu;       
    long int        col_1_lu;       
    std::size_t     current_row;    
    std::size_t     prev_row;       
    PyObject        *pyfunc;
    
private:
    void            callPyFunc(std::string msg, bool use_gil=true);
 
protected:
    const static std::size_t  n_cols = 2;
    
protected:
    std::size_t     ind(std::size_t i, std::size_t j);                  
    
public:
    void            setVal(std::size_t i, std::size_t j, long int val); 
    long int        getVal(std::size_t i, std::size_t j);
    std::size_t     getBlockSeek(std::size_t n_block);
    std::size_t     getCurrentBlockSeek();
    
public: // getters // <pyapi>
    const std::size_t   getBlockSize() {return this->blocksize;} // <pyapi>
    
public:                                  // <pyapi>
    std::size_t get_n_blocks();          // <pyapi>
    std::size_t get_n_cols();            // <pyapi>
    
    void dumpTable_();
    void updateDumpTable_(std::size_t n_block);
    
    void            dumpTable();              // <pyapi>
    void            readTable();          // <pyapi>
    std::string     getDevice();         // <pyapi>
    std::size_t     getDeviceSize();     // <pyapi>
    void            clearDevice(bool writethrough=false, bool verbose=false);       // <pyapi>
    void            clearTable();        // <pyapi>
    std::size_t     maxFrameSize();      // <pyapi>
    void            reportTable(std::size_t from=0, std::size_t to=0, bool show_all=false);       // <pyapi>
    
    void            updateTable(bool disk_write=false);      // <pyapi>
    
    void writeBlock(bool pycall=true, bool use_gil=true);
    
    void markFrame(long int mstimestamp);        
 
    virtual void markKeyFrame(long int mstimestamp);     
    
    void setCurrentBlock(std::size_t n_block);      // <pyapi>
    
    void setBlockCallback(PyObject* pobj);          // <pyapi>
    
    void setArrayCall(PyObject *pyobj);  // <pyapi>
};                                       // <pyapi>
 
 
class ValkkaFS2 : public ValkkaFS { // <pyapi>
 
public:                             // <pyapi>
    ValkkaFS2(const char *device_file, const char *block_file, std::size_t blocksize, std::size_t n_blocks, bool init=false); // <pyapi>
    virtual ~ValkkaFS2();            // <pyapi>
 
    virtual void markKeyFrame(long int mstimestamp);     
};                                  // <pyapi>
 
 
class ValkkaFSTool {                        // <pyapi>
    
public:                                     // <pyapi>
    ValkkaFSTool(ValkkaFS &valkkafs);       // <pyapi>
    ~ValkkaFSTool();                        // <pyapi>
    
protected:
    // std::fstream     is;
    RawReader        raw_reader;
    ValkkaFS         &valkkafs;
    
public:                                     // <pyapi>
    void dumpBlock(std::size_t n_block);    // <pyapi>
};                                          // <pyapi>
 
 
 
class ValkkaFSWriterThread : public Thread {         // <pyapi>
 
public:                                              // <pyapi>
    ValkkaFSWriterThread(const char *name, ValkkaFS &valkkafs, FrameFifoContext fifo_ctx=FrameFifoContext(), bool o_direct = false);  // <pyapi>
    ~ValkkaFSWriterThread();                                                               // <pyapi>
 
protected:
    ValkkaFS                            &valkkafs;
    // std::fstream                        filestream;
    RaWriter                            raw_writer;
    std::map<SlotNumber, IdNumber>      slot_to_id;  
    std::size_t                         bytecount;
    
protected: // frame input
    FrameFifo               infifo;           
    FifoFrameFilter         infilter;         
    BlockingFifoFrameFilter infilter_block;   
 
protected: // Thread member redefinitions
    std::deque<ValkkaFSWriterSignalContext> signal_fifo;   
  
public: // redefined virtual functions
    void run();
    void preRun();
    void postRun();
    void preJoin();
    void postJoin();
    void sendSignal(ValkkaFSWriterSignalContext signal_ctx);    
      
protected:
    void handleSignal(ValkkaFSWriterSignalContext &signal_ctx); 
    void handleSignals();                                       
 
protected:
    void saveCurrentBlock(bool pycall=true, bool use_gil=true);
    void setSlotId(SlotNumber slot, IdNumber id);
    void unSetSlotId(SlotNumber slot);
    void clearSlotId();
    void reportSlotId();
    void seek(std::size_t n_block);
    
// API
public:                                                       // <pyapi>
    FifoFrameFilter &getFrameFilter();                        // <pyapi>
    FifoFrameFilter &getBlockingFrameFilter();                // <pyapi>
    void setSlotIdCall(SlotNumber slot, IdNumber id);         // <pyapi>
    void unSetSlotIdCall(SlotNumber slot);                    // <pyapi>
    void clearSlotIdCall();                                   // <pyapi>
    void reportSlotIdCall();                                  // <pyapi>
    void seekCall(std::size_t n_block);                       // <pyapi>
    void requestStopCall();                                   // <pyapi>
};                                                            // <pyapi>
 
 
#endif