Hu Chunming / vpt_ascend_arm

  #include "FFRecoder.h"
  
  #include "../../ai_platform/common_header.h"
  #include "depend_headers.h"
  
  #include <list>
  #include <queue>
  #include <map>
  #include <string>
  #include <thread>
  #include <mutex>
  
  using namespace std;
  
  struct RecodeParam {
      AVRational time_base;
      RecoderInfo recoderInfo;
      AVCodecContext* avctx;
  };
  

  typedef std::function<bool(const char *msg)> mq_callback_t;
  

  class FFRecoderTaskManager {
  public:
      FFRecoderTaskManager();
  	virtual ~FFRecoderTaskManager();
  
      void cache_pkt(AVPacket* pkt, long long frame_nb);
      void create_recode_task(AVRational time_base, AVCodecContext* avctx, RecoderInfo& recoderInfo);
  

      bool init(AVStream* stream, AVCodecContext* avctx);

      void create_recode_task2(RecoderInfo& recoderInfo);
  

      void close();
  
      void set_mq_callback(mq_callback_t cb);
  

      bool init3(AVRational time_base, AVCodecContext* avctx);
      void cache_frame(AVFrame* frame, long long frame_nb);
  

  public:
      void recode_thread(RecodeParam param);
      list<DataPacket*>::iterator getStartIterator(unsigned long long frame_nb);

      list<DataPacket*>::iterator getEndIterator(unsigned long long frame_nb);

  
      void recode_thread2();

      void recode_thread4();
  
      list<DataFrame*>::iterator getStartIterator3(unsigned long long frame_nb);
      void recode_thread3();

  
  private:
      void save_intask_frame_nb(unsigned long long frame_nb);
      void save_intask_recoderinfo(RecoderInfo info);
      
  private:
      std::queue<int> m_key_frame_interval;
      std::list<unsigned long long> m_keyframe_nb_list;
      std::list<DataPacket*> m_pkt_list;
      mutex m_pkt_list_mtx; 
      unsigned long long m_last_key_frame_nb;
  
      std::list<unsigned long long> m_intask_frame_nb_list;
  
      std::list<RecoderInfo> m_recoderinfo_list;
      mutex m_recoderinfo_list_mtx;
  
      bool m_bExit{false};
  
      map<string, thread*> m_id_recoderTask;
      mutex m_task_creat_mtx; 
  
      AVRational m_time_base;
      AVCodecContext* m_avctx;

      AVStream* m_inStream;

      thread* m_recoder_thread{nullptr};
  
      mq_callback_t mq_publish_func;

  
      std::list<DataFrame*> m_frame_list;
      mutex m_frame_list_mtx; 

  };