src/ai_platform/MultiSourceProcess.h

#include <map>
#include <mutex>
#include <thread>
#include <list>
#include <vector>
#include <deque>
#include <set>
#include "header.h"
#include "acl/acl.h"
#include "acl/ops/acl_dvpp.h"
#include "task_param_manager.h"
#include "../reprocessing_module/snapshot_reprocessing.h"
#include "../reprocessing_module/save_snapshot_reprocessing.h"
#include "../ai_engine_module/VPTProcess.h"
#include "../ai_engine_module/face_det_ai_engine.h"
#include "../ai_engine_module/pedestrian_vehicle_retrograde.h"
#include "../ai_engine_module/pedestrian_vehicle_trespass.h"
#include "../ai_engine_module/tricycle_manned_process.h"
#include "../ai_engine_module/truck_manned_process.h"
#include "../ai_engine_module/motocycle_hs_process.h"
#include "../util/JpegUtil.h"
#ifdef POST_USE_RABBITMQ
#include "../reprocessing_module/mq_manager.hpp"
#endif
using namespace std;
class DeviceMemory;
class CMultiSourceProcess {
public:
  CMultiSourceProcess();
  ~CMultiSourceProcess();
  int InitAlgorthim(tsl_aiplatform_param vptParam);
  bool AddTask(task_param _cur_task_param);
  bool PauseTask(const string taskID);
  bool RestartTask(const string taskID);
  bool FinishTask(const string taskID);
  void CloseAllTask();
  int SnapShot(task_param param);
#ifdef POST_USE_RABBITMQ
  int AddMqConn(mq_type_t mq_type, rabbitmq_conn_params_t mq_conn_param);
  int GetTaskStatus(const string taskID);
#endif
public:
  int algorthim_process_thread();  // 算法处理线程
  void task_finished(const string task_id);
  void decoded_cbk(DeviceMemory* devFrame);
  void timing_snapshot_thread();
  // 发送录制消息给任务
  int recode_thread();
private:
  // 算法相关
  int algorthim_vpt(vector<DeviceMemory*> vec_gpuMem);
  // 人脸检测抓拍算法
  void algorthim_face_detect(vector<DeviceMemory*> vec_gpuMem);
  // 逆行
  void algorthim_retrograde(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs, vector<onelevel_det_result>& vptResult);
  // 闯入
  void algorthim_trespass(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs, 
                                                  vector<onelevel_det_result>& vptResult ,vector<vector<int>>& deleteObjectID);  
  
  // 三轮车载人
  void algorithm_tricycle_manned(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs, vector<onelevel_det_result>& vptResult);
  // 货车载人
  void algorithm_truck_manned(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs, vector<onelevel_det_result>& vptResult);
  // 二轮车超员及未戴盔
  void algorithm_motor_hs_process(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vpt_interest_imgs, vector<onelevel_det_result>& vptResult);
  
private:
  // 工具处理函数
  bool task_has_vpt_algor(const std::string &task_id);
  bool task_has_face_algor(const std::string &task_id);
  void clear_finished_task();
  bool finish_task(const string taskID, const bool delete_snapshot);
  int algorithm_vehicle_relult(vector<DeviceMemory*> vec_devMem, vector<onelevel_det_result>& vptResult, vector<vector<int>>& delete_object_id);
  void send_locus_finished_msg(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);
  void vehicle_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);
  void vehicle_locus_finished(const OBJ_KEY obj_key);
  bool save_snapshot_process(const OBJ_KEY &obj_key, const algorithm_type_t &algorithm_type, vpc_img_info img_info,  vpc_img_info roi_img,
                                       const long long id,const std::string &json_str);
  void retrograde_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);
  void trespass_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID);
  void void retrograde_trespass_alarm(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) ;(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) void retrograde_trespass_alarm(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) ; 
  //  village
  void manned_snapshot(vector<string>& vpt_interest_task_id, vector<DeviceMemory*> vec_vptMem, vector<vector<int>> deleteObjectID);
 
  void face_locus_finished(const OBJ_KEY obj_key);
  int snapshot_task(std::string& uri_or_name, const std::string& file_name, bool bInTask);
private:
  int m_devId; 
  snapshot_reprocessing *m_snapshot_reprocessing{nullptr};
  task_param_manager *m_task_param_manager{nullptr};
  save_snapshot_reprocessing *m_save_snapshot_reprocessing{nullptr};
  std::thread* m_timing_snapshot_thread;
  VPTProcess vpt_process;
  int skip_frame_ = 5; // 控制跳帧参数
  deque<DeviceMemory*> m_RgbDataList;
  mutex m_DataListMtx; 
  mutex m_FinishedTaskMtx;
  map<string,bool> m_FinishedTaskMap;
  thread* m_pAlgorthimThread;
  bool m_bfinish{false};
  int m_batch_size{1};
  set<OBJ_KEY> m_total_snapshot_info_multi_object;
  mutex m_total_mutex;
#ifdef POST_USE_RABBITMQ
  mq::Manager *mq_manager_{nullptr};
#endif
  ai_engine_module::pedestrian_vehicle_retrograde::PedestrianVehicleRetrograde pedestrian_vehicle_retrograde_;
  ai_engine_module::pedestrian_vehicle_trespass::PedestrianVehicleTrespass pedestrian_vehicle_trespass_;
  ai_engine_module::tricycle_manned_process::TricycleMannedProcess tricycle_manned_;
  ai_engine_module::truck_manned_process::TruckMannedProcess truck_manned_;
  ai_engine_module::motocycle_hs_process::MotorHsProcess motor_hsprocess_;
  face_det_ai_engine m_face_det_ai_engine; // 人脸检测
  deque<RecoderInfo> m_recoderinfo_queue;
  mutex m_recoderinfo_queue_mtx;
  thread* m_recode_thread {nullptr};
};