Hu Chunming / vpt_ascend_arm

  #include "./interface/DecoderManager.h"
  #include <mutex>
  #include <thread>
  #include <chrono>
  
  using namespace std;
  
  struct decode_cbk_userdata{
    string task_id;
    void* opaque;
    void* opaque1;
  };
  
  deque<DeviceMemory*> m_RgbDataList;
  mutex m_DataListMtx; 
  
  thread* m_pAlgorthimThread{nullptr};
  thread* m_recodeThread{nullptr};
  bool m_bfinish{false};
  int m_devId = 0;
  const char* task_id = "test0";
  int skip_frame_ = 5;
  int m_batch_size = 20;
  
  deque<RecoderInfo> m_recoderinfo_queue;
  mutex m_recoderinfo_queue_mtx;
  
  void algorthim_process_thread();
  void recode_thread();
  void algorthim_face_detect(vector<DeviceMemory*> vec_gpuMem);
  
  void test_recode_thread();
  
  void post_decod_cbk(const void * userPtr, DeviceMemory* devFrame){
      do{
          if(m_bfinish){
          break;
          }
          m_DataListMtx.lock();
          if(m_RgbDataList.size() >= 30){
          m_DataListMtx.unlock();
          std::this_thread::sleep_for(std::chrono::milliseconds(3));
          continue;
          }
          m_RgbDataList.push_back(devFrame);
          m_DataListMtx.unlock();
          break;
      }while (true);
  }
  
  void decode_finished_cbk(const void * userPtr){
      decode_cbk_userdata* ptr = (decode_cbk_userdata*)userPtr;
      if (ptr!= nullptr){
          printf("task finished: %s \n", ptr->task_id.c_str());
      }
      delete ptr;
      ptr = nullptr;
  }
  
  int main(){
  
      // 创建解码任务
      DecoderManager* pDecManager = DecoderManager::getInstance();
  
      MgrDecConfig config;
      config.name = task_id;
      config.cfg.uri = "/opt/cmhu/data/公安局老桥头_CVR15F89410_1465819864_1B.mp4";
      config.cfg.post_decoded_cbk = post_decod_cbk;
      config.cfg.decode_finished_cbk = decode_finished_cbk;
      config.cfg.force_tcp = true;  // rtsp用tcp
      config.cfg.gpuid = to_string(m_devId);
      config.cfg.skip_frame = skip_frame_;
  
      config.dec_type = DECODER_TYPE_DVPP;
      
      AbstractDecoder* dec = pDecManager->createDecoder(config);
      if (!dec){
          printf("创建解码器失败 \n");
          return false;
      }
  
      decode_cbk_userdata* userPtr = new decode_cbk_userdata;
      userPtr->task_id = string(task_id);
      pDecManager->setPostDecArg(config.name, userPtr);
      pDecManager->setFinishedDecArg(config.name, userPtr);
  
  
      int input_image_width = 0;
      int input_image_height = 0;
      pDecManager->getResolution(config.name, input_image_width, input_image_height);
  
      
      // 创建算法线程
      m_pAlgorthimThread = new thread([](void* arg) {
        algorthim_process_thread();
        return (void*)0;
      }
      , nullptr);
  
      // m_recodeThread = new thread([](void* arg) {
      //   recode_thread();
      //   return (void*)0;
      // }
      // , nullptr);
  
      m_recodeThread = new thread([](void* arg) {
        test_recode_thread();
        return (void*)0;
      }
      , nullptr);
  
      pDecManager->startDecodeByName(config.name);
  
      while (getchar() != 'q');
  }
  
  void algorthim_process_thread(){
  
      while (true){
          if(m_bfinish){
              break;
          }
  
          vector<DeviceMemory*> vec_gpuMem;
          m_DataListMtx.lock();
          while (!m_RgbDataList.empty()){
              DeviceMemory* gpuMem = m_RgbDataList.front();
              if(gpuMem->getMem() == nullptr){
                // 错误数据，直接删除
                delete gpuMem;
                gpuMem = nullptr;
                printf("mem is null \n");
              } else {
                vec_gpuMem.push_back(gpuMem);
              }
              m_RgbDataList.pop_front();
              if(vec_gpuMem.size() >= m_batch_size){
                  break;
              }
          }
          m_DataListMtx.unlock();
  
          if(vec_gpuMem.size() <= 0){
              std::this_thread::sleep_for(std::chrono::milliseconds(3));
              continue;
          }
  
          algorthim_face_detect(vec_gpuMem);
  
          for(int i=0;i < vec_gpuMem.size(); i++){
              DeviceMemory* mem = vec_gpuMem[i];
              if(mem->getSize() <= 0){
                continue;
              }
              delete mem;
              mem = nullptr;
          }
          vec_gpuMem.clear();
  
      }
  
      printf("algorthim_process_thread exit. \n");
  }
  
  static int interval = 0;
  static int obj_id = 0;
  
  void algorthim_face_detect(vector<DeviceMemory*> vec_gpuMem) {
    interval ++ ;
  
    if(interval % 50 != 0) {
      return;
    }
  
    for(int i= 0; i < vec_gpuMem.size(); i++) {
      DeviceMemory* mem = vec_gpuMem[i];
      string task_id = mem->getId();
    
      RecoderInfo recoderInfo;
      recoderInfo.task_id = task_id;
      recoderInfo.object_id = std::to_string(obj_id);
      recoderInfo.recoderPath = "./res/recode";
      recoderInfo.frame_nb = mem->getFrameNb();
  
      m_recoderinfo_queue_mtx.lock();
      m_recoderinfo_queue.push_back(recoderInfo);
      m_recoderinfo_queue_mtx.unlock();
  
      obj_id++;
  
    }
  }
  
  void test_recode_thread() {
    unsigned long long frame_index = 0;
    while(true) {
      std::this_thread::sleep_for(std::chrono::milliseconds(10));
  
      DeviceMemory* mem = nullptr;
      m_DataListMtx.lock();
      while (!m_RgbDataList.empty()){
          DeviceMemory* gpuMem = m_RgbDataList.front();
          if(gpuMem->getMem() == nullptr){
            // 错误数据，直接删除
            delete gpuMem;
            gpuMem = nullptr;
            printf("mem is null \n");
          } else {
            frame_index ++ ;
            if (frame_index % 50 == 0) {
              RecoderInfo recoderInfo;
              recoderInfo.task_id = gpuMem->getId();
              recoderInfo.object_id = std::to_string(obj_id);
              recoderInfo.recoderPath = "./res/recode";
              recoderInfo.frame_nb = gpuMem->getFrameNb();
  
              DecoderManager* pDecManager = DecoderManager::getInstance();
              pDecManager->doRecode(recoderInfo);
  
              obj_id++;
            }
            delete gpuMem;
            gpuMem = nullptr;
          }
          m_RgbDataList.pop_front();
      }
      m_DataListMtx.unlock();
    }
  }
  
  void recode_thread() {
    while(true) {
  
      m_recoderinfo_queue_mtx.lock();
      if(m_recoderinfo_queue.size() <= 0) {
        m_recoderinfo_queue_mtx.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
        continue;
      }
  
      RecoderInfo info = m_recoderinfo_queue.front();
      m_recoderinfo_queue.pop_front();
      m_recoderinfo_queue_mtx.unlock();
  
      DecoderManager* pDecManager = DecoderManager::getInstance();
      pDecManager->doRecode(info);
    }
  }