Hu Chunming / vpt_ascend_arm

#include "./interface/DecoderManager.h"
#include <mutex>
#include <thread>
#include <chrono>
#include "../common/logger.hpp"

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};

bool m_bfinish{false};
int m_devId = 0;
const char* task_id = "test0";
int skip_frame_ = 5;
int m_batch_size = 20;


void algorthim_process_thread();

void snap_shot_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;
    }
}

bool create_task(string task_id) {
    
    // 创建解码任务
    DecoderManager* pDecManager = DecoderManager::getInstance();

    MgrDecConfig config;
    config.name = task_id;
    config.cfg.uri = "/data/share/data/Street.uvf";
    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);

    dec->setSnapTimeInterval(1000);


    int input_image_width = 0;
    int input_image_height = 0;
    pDecManager->getResolution(config.name, input_image_width, input_image_height);

    pDecManager->startDecodeByName(config.name);
    // pDecManager->closeAllDecoder();

    return true;
}

int main(){

    set_default_logger(LogLevel(0), "test_decode","logs/main.log", 64 * 1024 * 1024, 64 * 1024 * 1024);
    LOG_INFO("编译时间：{} {}", __DATE__, __TIME__);

    printf("start... \n");

    DecoderManager* pDecManager = DecoderManager::getInstance();


    // 创建算法线程
    m_pAlgorthimThread = new thread([](void* arg) {
      algorthim_process_thread();
      return (void*)0;
    }
    , nullptr);

    thread snap_thread = thread([](void* arg) {
      snap_shot_thread();
      return (void*)0;
    }
    , nullptr);

    

    char ch = 'a';
    int task_id = 1;

    while (ch != 'q') {
        ch = getchar();
        switch (ch)
        {
        case '4':
            for (size_t i = 0; i < 4; i++) 
            {
                create_task(to_string(task_id));  
                task_id++;
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
            break;
        case 'a':
                create_task(to_string(task_id));  
                task_id++;
                std::this_thread::sleep_for(std::chrono::seconds(1));
            break;
        case 'c':
            pDecManager->closeAllDecoder();
            break;
        default:
            break;
        }
    }
}

void do_work(vector<DeviceMemory*> vec_gpuMem){
  for(int i=0;i < vec_gpuMem.size(); i++){
      DeviceMemory* mem = vec_gpuMem[i];
    //   printf("task:%s  width:%d  height:%d ts:%lld \n", mem->getId().c_str(), mem->getWidth(), mem->getHeight(), mem->getTimesstamp());
  }
}

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;
        }

        // do work
        do_work(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();

        vector<DeviceMemory*>().swap(vec_gpuMem);

    }

    printf("algorthim_process_thread exit. \n");
}

void snap_shot_thread(){
    DecoderManager* pDecManager = DecoderManager::getInstance();
      while (true){
        if(m_bfinish){
            break;
        }

        vector<DeviceMemory*> vec_devMem = pDecManager->timing_snapshot_all();
        for(auto devMem : vec_devMem){
            delete devMem;
            devMem = nullptr;
        }
        // vec_devMem.clear();

        vector<DeviceMemory*>().swap(vec_devMem);

        std::this_thread::sleep_for(std::chrono::milliseconds(600));

    }
}