fdwritethread.h

#ifndef fdwriterthread_HEADER_GUARD
#define fdwriterthread_HEADER_GUARD
/*
 * fdwriterthread.h : A general thread that write frames into something described by a file descriptor
 * 
 * (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/>
 *
 */
 
#endif
 
#include <sys/select.h>
#include "thread.h"
#include "framefilter.h"
#include "framefifo.h"
 
 
// (1) A data structure for describing the outgoing connection
 
struct FDWriteContext {                                                                           // <pyapi>
    FDWriteContext() {}                                                                           // <pyapi>
    FDWriteContext(int fd, SlotNumber slot) : fd(fd), slot(slot) {}                               // <pyapi>
    int                 fd;              
    SlotNumber          slot;            
};                                                                                                // <pyapi>
 
inline std::ostream& operator<< (std::ostream& os, const FDWriteContext& ctx) {
  // https://stackoverflow.com/questions/4571611/making-operator-virtual
  os << "<FDWriteContext : slot = " << ctx.slot << " / fd = " << ctx.fd << " >";
  return os;
}
 
 
 
// (2) A class for handling the outgoing connection.  Used internally by the FDWriteThread.
 
class FDWrite {
  
public:
    FDWrite(FrameFifo& fifo, const FDWriteContext& ctx);  
    virtual ~FDWrite(); 
 
public: // init'd at constructor time
    const FDWriteContext     &ctx;     
    FrameFifo                &fifo;    
    std::deque<Frame*>       internal_fifo;
    
};
 
 
 
// (3) Define the communication with the Thread
 
struct FDWriteSignalPars {                                
    FDWriteContext fd_write_ctx;
}; 
 
 
enum class FDWriteSignal {
    none,
    exit,
    register_stream,
    deregister_stream
};
 
 
struct FDWriteSignalContext {
    FDWriteSignal         signal;
    FDWriteSignalPars     pars;
};
 
 
 
 
// (4) The Thread class
 
class FDWriteThread : public Thread {                                                 // <pyapi>
  
public:                                                                               // <pyapi>
    FDWriteThread(const char* name, FrameFifoContext fifo_ctx = FrameFifoContext());  // <pyapi>
    virtual ~FDWriteThread();                                                         // <pyapi>
        
protected: // frame input
    FDFrameFifo             infifo;           
    FifoFrameFilter         infilter;         
    BlockingFifoFrameFilter infilter_block;   
    std::vector<FDWrite*>   slots_;           
    std::list<FDWrite*>     fd_writes;        
    fd_set                  write_fds, read_fds; 
    int                     nfds;             
    struct timeval          timeout;
    
    
public: // redefined virtual functions
    void run();
    void preRun();
    void postRun();
    void preJoin();
    void postJoin();
      
protected:
    void handleSignal(const FDWriteSignalContext &signal_ctx); 
    
private: // internal
    void setMaxFD         ();
    int  safeGetSlot      (const SlotNumber slot, FDWrite*& fd_write);  
    void registerStream   (const FDWriteContext &ctx);
    void deregisterStream (const FDWriteContext &ctx);
    
public: // *** C & Python API *** .. these routines go through the condvar/mutex locking                                      // <pyapi>
    // inbound streams
    void registerStreamCall   (const FDWriteContext &ctx); 
    void deregisterStreamCall (const FDWriteContext &ctx); 
    void requestStopCall();
    FifoFrameFilter &getFrameFilter();                     
};                                                                                                                            // <pyapi>