framefifo.h

Go to the documentation of this file.

#ifndef framefifo_HEADER_GUARD
#define framefifo_HEADER_GUARD
/*
 * framefifo.h : Thread safe system of fifo and a stack
 * 
 * Copyright 2017-2020 Valkka Security Ltd. and 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 "frame.h"
#include "logging.h"
#include "macro.h"
 
struct FrameFifoContext {                                                                                                                                       // <pyapi>
  FrameFifoContext() : n_basic(50), n_avpkt(0), n_avframe(0), n_yuvpbo(0), n_setup(20), n_signal(20), n_marker(20), flush_when_full(DEFAULT_FRAMEFIFO_FLUSH_WHEN_FULL) {}     // <pyapi>
  FrameFifoContext(int n_basic, int n_avpkt, int n_avframe, int n_yuvpbo, int n_setup, int n_signal, bool flush_when_full) :                                    // <pyapi>
  n_basic(n_basic), n_avpkt(n_avpkt), n_avframe(n_avframe), n_yuvpbo(n_yuvpbo), n_setup(n_setup), n_signal(n_signal), n_marker(n_signal), flush_when_full(flush_when_full) {}       // <pyapi>
  FrameFifoContext(int n_signal) :                                                                                                                              // <pyapi>
  n_basic(0), n_avpkt(0), n_avframe(0), n_yuvpbo(0), n_setup(0), n_signal(n_signal), n_marker(n_signal), flush_when_full(DEFAULT_FRAMEFIFO_FLUSH_WHEN_FULL) {}  // <pyapi>
  int n_basic;     
  int n_avpkt;     
  int n_avframe;   
  int n_yuvpbo;    
  int n_setup;     
  int n_signal;    
  int n_marker;    
  bool flush_when_full; 
};                                                                                                                                                              // <pyapi>
 
 
class FrameFifo {                                                                                   
 
public:                                                                                             
  FrameFifo(const char *name, FrameFifoContext ctx =FrameFifoContext()); 
  virtual ~FrameFifo();                                                  
  ban_copy_ctor(FrameFifo);
  ban_copy_asm(FrameFifo);
  
protected:
  std::string      name;
  FrameFifoContext ctx;   
  
protected: // reservoir, stack & fifo queue
  std::map<FrameClass,Reservoir>  reservoirs;   
  std::map<FrameClass,Stack>      stacks;       
  Fifo                            fifo;         
  
protected: // mutex synchro
  std::mutex mutex;                         
  std::condition_variable condition;        
  std::condition_variable ready_condition;  
    
protected:
  virtual void recycle_(Frame* f);  
  virtual void recycleAll_();       
  
public:
    Reservoir &getReservoir(FrameClass cl) {return this->reservoirs[cl];}  
  
public:
  virtual bool writeCopy(Frame* f, bool wait=false);     
  virtual Frame* read(unsigned short int mstimeout=0);   
  virtual void recycle(Frame* f);                        
  virtual void recycleAll();                             
  virtual void dumpStacks();    
  virtual void dumpFifo();      
  virtual void diagnosis();     
  bool isEmpty();               
};                                                                      
 
 
class FDFrameFifo : public FrameFifo {
    
public:
    FDFrameFifo(const char *name, FrameFifoContext ctx =FrameFifoContext()); 
    virtual ~FDFrameFifo();                                                  
    //ban_copy_ctor(FDFrameFifo);
    //ban_copy_asm(FDFrameFifo);
    
private:
    int fd;
    
public:
    virtual bool writeCopy(Frame* f, bool wait=false);     
 
    virtual Frame* read(unsigned short int mstimeout=0);
    
public:
    const int getFD() {return this->fd;}
};
 
 
 
#endif