avfilethread.h

Go to the documentation of this file.

#ifndef avfilethread_HEADER_GUARD 
#define avfilethread_HEADER_GUARD
 
/*
 * avfilethread.h : A Thread handling files and sending frames to fifo
 * 
 * (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/>
 *
 */
 
// TODO: implement this as a subclass of AbstractFileThread
// TODO: rename FileThread to AVFileThread
 
#include "frame.h"
#include "thread.h"
#include "framefilter.h"
#include "logging.h"
#include "tools.h"
 
enum class FileState {                      // <pyapi>
  none,                                     // <pyapi>
  error,                                    // <pyapi>
  seek, // in the middle of a seek          // <pyapi>
  stop, // stream stopped                   // <pyapi>
  play  // stream is playing                // <pyapi> 
};                                          // <pyapi>
 
 
struct FileContext {                                                                               // <pyapi>
  FileContext(std::string filename, SlotNumber slot, FrameFilter* framefilter, long int st=0) :    // <pyapi>
  filename(filename), slot(slot), framefilter(framefilter), seektime_(st),                         // <pyapi>
  duration(0), mstimestamp(0), status(FileState::none)                                             // <pyapi>
  {}                              
  FileContext() : filename(""), slot(0), framefilter(NULL), seektime_(0),                          // <pyapi>
  duration(0), mstimestamp(0), status(FileState::none)                                             // <pyapi>
  {}                              
  std::string    filename;        
  SlotNumber     slot;            
  FrameFilter*   framefilter;     
  long int       seektime_;       
  long int       duration;        
  long int       mstimestamp;     
  FileState      status;          
};                                                                                                 // <pyapi>
 
 
// TODO: still ugly memory leaks with the bitstream filter.  Use this class to test things.
class TestFileStream {
  public:
  TestFileStream(const char* filename);
  ~TestFileStream(); 
  
public:
  AVFormatContext     *input_context;
 
public:
  AVPacket *avpkt;                 
  AVBitStreamFilterContext *annexb;
  void     pull();                   
};
 
 
class FileStream {
  
public:
  FileStream(FileContext &ctx);
  ~FileStream(); 
  
public:
  FileContext         &ctx;           
  AVFormatContext     *input_context;
  std::vector<AVBitStreamFilterContext*> filters;
  
public:
  SetupFrame  setupframe;             
  BasicFrame  out_frame;              
  long int    duration;               
  long int    reftime;                
  long int    target_mstimestamp_;    
  long int    frame_mstimestamp_;     
  FileState   state;                  
  AVPacket    *avpkt;                 
  
public: // getters
  SlotNumber getSlot() {return ctx.slot;}
  
public:
  void setRefMstime(long int ms_streamtime_);  
  void seek(long int ms_streamtime_);          
  void play();                                 
  void stop();                                 
  long int update(long int mstimestamp);       
  long int pullNextFrame();                    
};
 
 
enum class FileSignal {
  none,
  exit,                 
  open_stream,
  close_stream,
  seek_stream,
  play_stream,
  stop_stream,
  get_state            
};
 
 
struct FileSignalContext {
  FileSignal  signal;
  FileContext *file_context; 
};
 
 
class FileThread : public Thread { // <pyapi>
 
public:                                                // <pyapi>
  FileThread(const char* name, FrameFifoContext fifo_ctx=FrameFifoContext());        // <pyapi>
  ~FileThread();                                       // <pyapi>
  
protected: // frame input // TODO: implement writing to files with FileThread
  FrameFifo         infifo;     
  FifoFrameFilter   infilter;   
  
protected: // redefinitions
  std::deque<FileSignalContext> signal_fifo;    
  
protected:
  std::vector<FileStream*> slots_;          
  // TODO: all slots should be done in the future with std::map<SlotNumber,FileStream*>
  std::list<SlotNumber>   active_slots;     
  bool loop;                                
  // std::list<FileStream*>  streamlist;       // TODO: a better event loop: FileStream s that have frames to be presented are queued here
  
/* // some misc. ideas ..
protected:
  int                       count_streams_seeking; ///< number of stream seeking at the moment
  std::condition_variable   seek_condition;        ///< notified when all streams have stopped seeking 
*/
  
 
public: // redefined virtual functions
  void run();
  void preRun();
  void postRun();
  void sendSignal(FileSignalContext signal_ctx);         
  void sendSignalAndWait(FileSignalContext signal_ctx);  
  
protected:
  void handleSignals();
  
private: // internal
  int  safeGetSlot          (SlotNumber slot, FileStream*& stream);
  void openFileStream       (FileContext &file_ctx);
  void closeFileStream      (FileContext &file_ctx);
  void seekFileStream       (FileContext &file_ctx);
  void playFileStream       (FileContext &file_ctx);
  void stopFileStream       (FileContext &file_ctx);
  
public: // *** C & Python API *** .. these routines go through the condvar/mutex locking                                     // <pyapi>
  void closeFileStreamCall      (FileContext &file_ctx); 
  void openFileStreamCall       (FileContext &file_ctx); 
  void seekFileStreamCall       (FileContext &file_ctx); 
  void playFileStreamCall       (FileContext &file_ctx); 
  void stopFileStreamCall       (FileContext &file_ctx); 
  void requestStopCall();                                
  FifoFrameFilter &getFrameFilter();                     
};                                                                                                                          // <pyapi>
 
#endif