From 9fc79d4363024d5bfc6c759fd63ff2109e23c470 Mon Sep 17 00:00:00 2001 From: Hu Chunming <2657262686@qq.com> Date: Mon, 4 Aug 2025 20:39:02 +0800 Subject: [PATCH] 同步代码初步跑通 --- .vscode/launch.json | 4 ++-- readme.md | 4 ++-- src/Makefile | 2 +- src/ai_platform/Makefile | 80 -------------------------------------------------------------------------------- src/ai_platform/MultiSourceProcess.cpp | 364 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----- src/ai_platform/MultiSourceProcess.h | 34 +++++++++++++++++++++++++++++++--- src/ai_platform/det_obj_header.h | 3 +++ src/ai_platform/header.h | 93 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--- src/ai_platform/stl_aiplatform.cpp | 14 ++++++++++++-- src/ai_platform/stl_aiplatform.h | 8 ++++++-- src/ai_platform/task_param_manager.cpp | 279 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/ai_platform/task_param_manager.h | 5 +++++ src/decoder/dvpp/DvppDataMemory.hpp | 55 +++++++++++++++++++++++++++++++++++++++++++++++-------- src/decoder/dvpp/DvppDecoder.cpp | 1080 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- src/decoder/dvpp/DvppDecoder.h | 75 ++++++++++++++++++++++++++++++++++++++++++++++----------------------------- src/decoder/dvpp/VpcPicConverter.cpp | 79 ------------------------------------------------------------------------------- src/decoder/interface/DeviceMemory.hpp | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- src/decoder/interface/interface_headers.h | 4 +++- src/demo/demo.cpp | 1149 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--------------------------------------------------------------------------------------------------------------------------------- src/readme.txt | 20 ++++++++++++++++++-- src/reprocessing_module/save_snapshot_reprocessing.h | 1 + 21 files changed, 2561 insertions(+), 850 deletions(-) delete mode 100644 src/ai_platform/Makefile delete mode 100644 src/decoder/dvpp/VpcPicConverter.cpp diff --git a/.vscode/launch.json b/.vscode/launch.json index b55a2c7..50fe989 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -5,10 +5,10 @@ "version": "0.2.0", "configurations": [ { - "name": "dvpp", + "name": "demo", "type": "cppdbg", "request": "launch", - "program": "${workspaceFolder}/bin/vpt_proj", + "program": "${workspaceFolder}/bin/demo", "args": ["/home/cmhu/data/woyikewangh265.mp4","0", "0", "1"], "stopAtEntry": false, "cwd": "${workspaceFolder}/bin", diff --git a/readme.md b/readme.md index 2a3fa4e..c3284c3 100644 --- a/readme.md +++ b/readme.md @@ -33,7 +33,7 @@ ~~~ mkdir build cd ./build -cmake -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=../release .. -make -j100 +cmake -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=../release -D BUILD_opencv_world=ON .. +make -j make install ~~~ \ No newline at end of file diff --git a/src/Makefile b/src/Makefile index 42b25b1..7332b34 100644 --- a/src/Makefile +++ b/src/Makefile @@ -36,7 +36,7 @@ LIBS= -L $(SPDLOG_ROOT)/lib -l:libspdlog.a \ -L $(DEPEND_DIR) -lvpt_det -lsycheck \ -L $(OPENCV_ROOT)/lib -lopencv_video -lopencv_highgui -lopencv_imgproc -lopencv_core -lopencv_features2d -lopencv_flann\ -L $(JSON_ROOT)/lib -ljsoncpp \ - -L $(JSON_ROOT)/lib -lavformat -lavcodec -lswscale -lavutil -lavfilter -lswresample -lavdevice \ + -L $(FFMPEG_ROOT)/lib -lavformat -lavcodec -lswscale -lavutil -lavfilter -lswresample -lavdevice \ CXXFLAGS= -g -O0 -fPIC $(include_dir) $(lib_dir) $(lib) $(LIBS) $(DEFS) -lpthread -lrt -lz -fexceptions -std=c++11 -fvisibility=hidden -Wall -Wno-deprecated -Wdeprecated-declarations -Wl,-Bsymbolic -ldl diff --git a/src/ai_platform/Makefile b/src/ai_platform/Makefile deleted file mode 100644 index a456115..0000000 --- a/src/ai_platform/Makefile +++ /dev/null @@ -1,80 +0,0 @@ -# 各项目录 -LIB_DIR:=$(BUILD_DIR)/$(MODULE)/lib -DEP_DIR:=$(BUILD_DIR)/$(MODULE)/.dep -OBJ_DIR:=$(BUILD_DIR)/$(MODULE)/obj -SRC_DIR:=$(TOP_DIR)/$(MODULE) - -# 源文件以及中间目标文件和依赖文件 -SRCS:=$(notdir $(wildcard $(SRC_DIR)/*.cpp)) -OBJS:=$(addprefix $(OBJ_DIR)/, $(patsubst %.cpp, %.o, $(SRCS))) -DEPS:=$(addprefix $(DEP_DIR)/, $(patsubst %.cpp, %.d,a $(SRCS))) - -# 自动生成头文件依赖选项 -DEPFLAGS=-MT $@ -MMD -MP -MF $(DEP_DIR)/$*.d - -DEFS = -DENABLE_DVPP_INTERFACE - -# 最终目标文件 -TARGET:=$(BUILD_DIR)/bin/demo - - -include_dir=-I/usr/local/Ascend/ascend-toolkit/6.3.RC1.alpha001/runtime/include - -lib_dir=-L/usr/lib \ - -L/usr/local/lib \ - -L/usr/local/Ascend/driver/lib64 \ - -L/usr/local/Ascend/ascend-toolkit/6.3.RC1.alpha001/atc/lib64\ - -L/usr/local/Ascend/ascend-toolkit/6.3.RC1.alpha001/runtime/lib64 \ - -L/usr/local/Ascend/ascend-toolkit/6.3.RC1.alpha001/runtime/lib64/stub \ - -L/usr/local/Ascend/ascend-toolkit/6.3.RC1.alpha001/lib64 \ - -L/usr/local/Ascend/driver/lib64/driver - -lib=-lacl_dvpp -lascendcl -lmmpa -lglog -lgflags -lpthread -lz -lacl_dvpp_mpi -lruntime -lascendalog -lc_sec -lmsprofiler -lgert -lge_executor -lge_common \ - -lgraph -lascend_protobuf -lprofapi -lerror_manager -lexe_graph -lregister -lplatform - -INCLUDE= -I $(TOP_DIR)/interface \ - -LIBSPATH= -L $(BUILD_DIR)/interface/lib -l:interface.a \ - -L $(BUILD_DIR)/dvpp/lib -l:dvpp.a - -CXXFLAGS= -g -O0 -fPIC $(INCLUDE) $(include_dir) $(LIBSPATH) $(INCS) $(LIBS) $(lib_dir) $(lib) $(DEFS) -lpthread -lrt -lz -fexceptions -std=c++11 -fvisibility=hidden -Wl,-Bsymbolic -ldl - # -DUNICODE -D_UNICODE - -# 默认最终目标 -.PHONY:all -all:$(TARGET) - -# 生成最终目标 -$(TARGET): $(OBJS) | $(LIB_DIR) - @echo -e "\e[32m""Linking static library $(TARGET)""\e[0m" - @echo -e "$(CXX) -o $@ $^ $(DEPFLAGS) $(CXXFLAGS) $(MACROS)" - $(CXX) -o $@ $^ $(DEPFLAGS) $(CXXFLAGS) $(MACROS) - -# 若没有lib目录则自动生成 -$(LIB_DIR): - @mkdir -p $@ - -# 生成中间目标文件 -$(OBJ_DIR)/%.o:$(SRC_DIR)/%.cpp $(DEP_DIR)/%.d | $(OBJ_DIR) $(DEP_DIR) - @echo -e "\e[33m""Building object $@""\e[0m" - @echo -e "$(CXX) -c $(DEPFLAGS) $(CXXFLAGS) -o $@ $<" - $(CXX) -c $(DEPFLAGS) $(CXXFLAGS) -o $@ $< - -# 若没有obj目录则自动生成 -$(OBJ_DIR): - @mkdir -p $@ - -# 若没有.dep目录则自动生成 -$(DEP_DIR): - @mkdir -p $@ - -# 依赖文件会在生成中间文件的时候自动生成，这里只是为了防止报错 -$(DEPS): - -# 引入中间目标文件头文件依赖关系 -include $(wildcard $(DEPS)) - -# 直接删除组件build目录 -.PHONY:clean -clean: - @rm -rf $(BUILD_DIR)/$(MODULE) diff --git a/src/ai_platform/MultiSourceProcess.cpp b/src/ai_platform/MultiSourceProcess.cpp index ae45e50..5fde7bf 100644 --- a/src/ai_platform/MultiSourceProcess.cpp +++ b/src/ai_platform/MultiSourceProcess.cpp @@ -12,12 +12,17 @@ #include "../helpers/time_helper.hpp" #include "../helpers/os_helper.hpp" #include "../helpers/gen_json.hpp" +#include "../helpers/img_util.h" + #include "../reprocessing_module/save_snapshot_reprocessing.h" #include "macro_definition.h" #include "SourceSingleton.hpp" #include "../util/vpc_util.h" +#include "../util/common_tool.h" + +#include "ErrorInfo.h" // #define VEHICLE_MULTI_BOXES @@ -100,6 +105,15 @@ int CMultiSourceProcess::InitAlgorthim(tsl_aiplatform_param vptParam){ return ret; } + m_algorthim_region_leave.init(vptParam.gpuid, algorithm_type_t::HUMAN_LEAVE_REGION); + m_algorthim_region_dismiss.init(vptParam.gpuid, algorithm_type_t::HUMAN_REGION_DISMISS); + m_algorthim_region_fastmoving.init(vptParam.gpuid, algorithm_type_t::HUMAN_REGION_FAST_MOVING); + + m_human_gather.init(algorithm_type_t::HUMAN_GATHER); + m_human_density.init(algorithm_type_t::HUMAN_DENSITY); + m_human_region_gather.init(algorithm_type_t::HUMAN_REGION_GATHER); + m_vehicle_gather.init(algorithm_type_t::VEHICLE_GATHER); + m_task_param_manager = task_param_manager::getInstance(); m_snapshot_reprocessing = new snapshot_reprocessing(m_devId); m_save_snapshot_reprocessing = new save_snapshot_reprocessing(m_devId); @@ -146,13 +160,29 @@ int CMultiSourceProcess::AddMqConn(mq_type_t mq_type, rabbitmq_conn_params_t mq_ } /* 为报警类 绑定回调 传入mq_manager_.publish 内部直接调用*/ - if (mq_type_t::ALARM_MQ == mq_type) - m_save_snapshot_reprocessing->set_callback( + if (mq_type_t::ALARM_MQ == mq_type) { + if (m_save_snapshot_reprocessing!= nullptr) { + m_save_snapshot_reprocessing->set_callback( std::bind(&mq::Manager::publish, mq_manager_, mq_type, std::placeholders::_1, true)); + } + + + m_algorthim_region_leave.set_callback( + std::bind(&mq::Manager::publish, mq_manager_, mq_type, std::placeholders::_1, true)); + + m_algorthim_region_dismiss.set_callback( + std::bind(&mq::Manager::publish, mq_manager_, mq_type, std::placeholders::_1, true)); + + m_algorthim_region_fastmoving.set_callback( + std::bind(&mq::Manager::publish, mq_manager_, mq_type, std::placeholders::_1, true)); + } + return SUCCESS; } +#endif + /* 获取任务的状态 MQ返回 */ int CMultiSourceProcess::GetTaskStatus(const string taskID) { @@ -160,22 +190,30 @@ int CMultiSourceProcess::GetTaskStatus(const string taskID) { std::vector taskids; std::vector statues; + int sta = 0; if(pDecManager->isPausing(taskID)){ taskids.emplace_back(taskID); statues.emplace_back(2); - }else if(pDecManager->isRunning(taskID)){ + sta = 2; + } else if(pDecManager->isRunning(taskID)){ taskids.emplace_back(taskID); statues.emplace_back(1); + sta = 1; + } else if(pDecManager->isFinished(taskID)){ + taskids.emplace_back(taskID); + statues.emplace_back(0); + sta = 0; } +#ifdef POST_USE_RABBITMQ if (!taskids.empty()) { auto json_str = helpers::gen_json::gen_task_status_json(taskids, statues); mq_manager_->publish(mq_type_t::GET_TASK_MQ, json_str.c_str(),true); } +#endif - return SUCCESS; + return sta; } -#endif bool CMultiSourceProcess::AddTask(task_param _cur_task_param){ DecoderManager* pDecManager = DecoderManager::getInstance(); @@ -420,6 +458,16 @@ bool CMultiSourceProcess::finish_task(const string taskID, const bool delete_sna pedestrian_vehicle_retrograde_.force_release_result(taskID); //221024 byzsh #endif + m_TotalObjMtx.lock(); + for(auto ss = m_total_obj_info.begin(); ss != m_total_obj_info.end(); ) { + if (strcmp(ss->first.video_id.c_str(), taskID.c_str()) == 0) { + vector().swap(ss->second.center_points); + m_total_obj_info.erase(ss++); + } + else ss++; + } + m_TotalObjMtx.unlock(); + m_task_param_manager->delete_task_param(taskID); return true; @@ -516,6 +564,11 @@ int CMultiSourceProcess::algorthim_vpt(vector vec_gpuMem){ /* 一级检测器，内部已完成跟踪操作 */ vpt_process.process_gpu(vpt_interest_imgs.data(), vpt_interest_task_id, vptResult, deleteObjectID, unUsedResult); // do det & track. + gather_process(vec_vptMem, vptResult, algorithm_type_t::HUMAN_GATHER); // modified by zsh + gather_process(vec_vptMem, vptResult, algorithm_type_t::HUMAN_DENSITY); + gather_process(vec_vptMem, vptResult, algorithm_type_t::HUMAN_REGION_GATHER); + gather_process(vec_vptMem, vptResult, algorithm_type_t::VEHICLE_GATHER); + m_snapshot_reprocessing->screen_effective_snapshot(vptResult); #ifndef VEHICLE_MULTI_BOXES @@ -542,6 +595,19 @@ int CMultiSourceProcess::algorthim_vpt(vector vec_gpuMem){ // #endif + m_algorthim_region_leave.process(vec_vptMem, vptResult, deleteObjectID); + m_algorthim_region_dismiss.process(vec_vptMem, vptResult, deleteObjectID); + m_algorthim_region_fastmoving.process(vec_vptMem, vptResult, deleteObjectID); + + cross_line_process(vec_vptMem, vptResult, algorithm_type_t::HUMAN_CROSSING_LINE); + cross_line_process(vec_vptMem, vptResult, algorithm_type_t::HUMAN_CLIMB); + cross_line_process(vec_vptMem, vptResult, algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE); + + wander_detect(vec_vptMem, vptResult, algorithm_type_t::HUMAN_LINGER); + wander_detect(vec_vptMem, vptResult, algorithm_type_t::VEHICLE_ILLEGAL_PARKING); + // 轨迹记录 + trace_record(vec_vptMem, vptResult); + if(vptResult.size() > 0){ cout << vptResult[0].obj_count<< endl; } @@ -557,6 +623,35 @@ int CMultiSourceProcess::algorthim_vpt(vector vec_gpuMem){ return 0; } +// 轨迹记录 +void CMultiSourceProcess::trace_record(vector& vec_gpuMem, vector& vptResult) { + + for (size_t bidx = 0; bidx < vec_gpuMem.size(); bidx++){ + DeviceMemory* gpuMem = vec_gpuMem[bidx]; + string task_id = gpuMem->getId(); + + for (int c = 0; c < vptResult[bidx].obj_count; c++) { + //计算检测框坐标中心点 + sy_point center_point; + center_point.x_ = vptResult[bidx].obj[c].left + (vptResult[bidx].obj[c].right - vptResult[bidx].obj[c].left) * 0.5; + // center_point.y_ = vptResult[bidx].obj[c].top + (vptResult[bidx].obj[c].bottom - vptResult[bidx].obj[c].top) * 0.85; + center_point.y_ = vptResult[bidx].obj[c].bottom; // 越线检测以脚越线为标准 + + OBJ_KEY new_obj = { task_id, vptResult[bidx].obj[c].id }; + m_TotalObjMtx.lock(); + auto it = m_total_obj_info.find(new_obj); + if (it == m_total_obj_info.end()) + { + m_total_obj_info[new_obj].last_frame_nb = gpuMem->getFrameNb(); + m_total_obj_info[new_obj].last_ts = gpuMem->getTimesstamp(); + } + m_total_obj_info[new_obj].index = vptResult[bidx].obj[c].index; + m_total_obj_info[new_obj].center_points.push_back(center_point); + m_TotalObjMtx.unlock(); + } + } +} + int CMultiSourceProcess::algorithm_vehicle_relult(vector vec_devMem, vector& vptResult, vector>& delete_object_id) { vector results = m_snapshot_reprocessing->get_vehicle_snapshot(vec_devMem, vptResult, skip_frame_); @@ -988,4 +1083,263 @@ bool CMultiSourceProcess::save_snapshot_process(const OBJ_KEY &obj_key, const al } return true; +} + +void CMultiSourceProcess::cross_line_process(vector vec_gpuMem, vector& vptResult, algorithm_type_t eType) +{ + map> && algor_param = m_task_param_manager->get_task_other_params(); + + for (int bidx = 0; bidx < vec_gpuMem.size(); ++ bidx) { + + DeviceMemory* gpuMem = vec_gpuMem[bidx]; + string task_id = gpuMem->getId(); + + task_param_manager::algo_param_type_t_* cur_task_params = algor_param[task_id][eType]; + if (!cur_task_params) + { + continue; + } + + algor_config_param_illegal_crossing_line* algor_param = (algor_config_param_illegal_crossing_line*)cur_task_params->algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)cur_task_params->basic_param; + if (basic_param == nullptr || basic_param->adapt_param == nullptr) { + continue; + } + universal_algor_adapt_param *adapt_param = basic_param->adapt_param; + + jxline std_line(algor_param->p1.x_, algor_param->p1.y_, algor_param->p2.x_, algor_param->p2.y_); + + std::string cur_src_ts = std::to_string(helpers::timer::get_timestamp()); + std::string origin_file_path = basic_param->result_folder + helpers::os::sep + task_id + "_origin_" + cur_src_ts + ".jpg"; + + std::vector boxes; + for (int c = 0; c < vptResult[bidx].obj_count; c++) { + auto& obj_c = vptResult[bidx].obj[c]; + + bool bHuman = eType == algorithm_type_t::HUMAN_CROSSING_LINE || eType == algorithm_type_t::HUMAN_CLIMB; + + bool bCount = false; + if(bHuman && obj_c.index == (int)det_class_label_t::HUMAN) { + bCount = true; + } else if (eType == algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE && obj_c.index >= 4 && obj_c.index <= 8) { + bCount = true; + } + + sy_point center; + center.x_ = (obj_c.right + obj_c.left)/ 2 ; + center.y_ = (obj_c.bottom + obj_c.top) / 2; + if (!bCount || !common::isInPolygon(adapt_param->points, adapt_param->points_count, center)) { + continue; + } + + if (obj_c.confidence < algor_param->conf_threshold) + { + continue; + } + + int obj_width = obj_c.right - obj_c.left; + int obj_height = obj_c.right - obj_c.left; + if (obj_width < algor_param->minmum_width || obj_height < algor_param->minmum_height) + { + continue; + } + + //计算检测框坐标中心点 + sy_point center_point; + center_point.x_ = obj_c.left + (obj_c.right - obj_c.left) * 0.5; + center_point.y_ = obj_c.bottom; + + m_TotalObjMtx.lock(); + + OBJ_KEY obj_key = { task_id, obj_c.id }; + auto it = m_total_obj_info.find(obj_key); + if (it != m_total_obj_info.end()) + { + vector center_points = m_total_obj_info[obj_key].center_points; + sy_point last_pt = center_points[center_points.size() - 1]; + // 计算越线 + jxline cur_line(last_pt.x_, last_pt.y_, center_point.x_, center_point.y_); + bool bflag = common::is_intersect(cur_line, std_line); + if (bflag) + { + box_t box; + box.left = obj_c.left; + box.right = obj_c.right; + box.top = obj_c.top; + box.bottom = obj_c.bottom; + box.score = obj_c.confidence; + boxes.push_back(box); + } + } + m_TotalObjMtx.unlock(); + } + + if (boxes.size() <= 0) + { + continue; + } + + int algorithm_type = (int)eType; + string json_str = helpers::gen_json::gen_boxes_json(task_id, algorithm_type, boxes, origin_file_path); + + ImgSaveInfo info_origin; + info_origin.img_info = VPCUtil::vpc_devMem2vpcImg(gpuMem); + info_origin.file_path = origin_file_path; + info_origin.json_str = json_str; + m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(info_origin); + } +} + +void CMultiSourceProcess::wander_detect(vector& vec_gpuMem, vector& vptResult, algorithm_type_t eType) +{ + map> && algor_param = m_task_param_manager->get_task_other_params(); + + for (size_t i = 0; i < vec_gpuMem.size(); i++) + { + DeviceMemory* gpuMem = vec_gpuMem[i]; + string task_id = gpuMem->getId(); + long frame_nb = gpuMem->getFrameNb(); + + task_param_manager::algo_param_type_t_* cur_task_params = algor_param[task_id][eType]; + if (!cur_task_params) + { + continue; + } + + algor_config_param_behavior* algor_param = (algor_config_param_behavior*)cur_task_params->algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)cur_task_params->basic_param; + if (basic_param == nullptr || basic_param->adapt_param == nullptr) { + continue; + } + universal_algor_adapt_param *adapt_param = basic_param->adapt_param; + + long algor_skip_gap = algor_param->duration; + + std::string cur_src_ts = std::to_string(helpers::timer::get_timestamp()); + std::string origin_file_path = basic_param->result_folder + helpers::os::sep + task_id + "_origin_" + cur_src_ts + ".jpg"; + + std::vector boxes; + for (int c = 0; c < vptResult[i].obj_count; c++) { + auto& obj_c = vptResult[i].obj[c]; + + bool bCount = false; + if(eType == algorithm_type_t::HUMAN_LINGER && obj_c.index == (int)det_class_label_t::HUMAN) { + bCount = true; + } else if (eType == algorithm_type_t::VEHICLE_ILLEGAL_PARKING && obj_c.index >= 4 && obj_c.index <= 8) { + bCount = true; + } + + sy_point center; + center.x_ = (obj_c.right + obj_c.left)/ 2 ; + center.y_ = (obj_c.bottom + obj_c.top) / 2; + if (!bCount || !common::isInPolygon(adapt_param->points, adapt_param->points_count, center)) { + continue; + } + + if (obj_c.confidence < algor_param->conf_threshold) + { + continue; + } + + int obj_width = obj_c.right - obj_c.left; + int obj_height = obj_c.right - obj_c.left; + if (obj_width < algor_param->minmum_width || obj_height < algor_param->minmum_height) + { + continue; + } + + OBJ_KEY o_key = { task_id, obj_c.id }; + m_TotalObjMtx.lock(); + auto it = m_total_obj_info.find(o_key); + if (it != m_total_obj_info.end()) + { + long skip_gap = frame_nb - m_total_obj_info[o_key].last_frame_nb; + if (skip_gap > algor_skip_gap) + { + box_t box; + box.left = obj_c.left; + box.right = obj_c.right; + box.top = obj_c.top; + box.bottom = obj_c.bottom; + box.score = obj_c.confidence; + boxes.push_back(box); + + m_total_obj_info[o_key].last_frame_nb = frame_nb; // 更新帧号以判断下一次逗留 + } + } + + m_TotalObjMtx.unlock(); + } + + if (boxes.size() <= 0) + { + continue; + } + + int algorithm_type = (int)eType; + string json_str = helpers::gen_json::gen_boxes_json(task_id, algorithm_type, boxes, origin_file_path); + + ImgSaveInfo info_origin; + info_origin.img_info = VPCUtil::vpc_devMem2vpcImg(gpuMem); + info_origin.file_path = origin_file_path; + info_origin.json_str = json_str; + m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(info_origin); + } +} + +/* 每帧都需要做的算法模块 */ +int CMultiSourceProcess::gather_process(vector& vec_gpuMem, vector &ol_det_result, algorithm_type_t algor_type) { + /* 人数聚集算法功能 每帧都会获取算法结果 并返回 */ + std::vector results; + if (algor_type == algorithm_type_t::HUMAN_GATHER) { + results = m_human_gather.process(vec_gpuMem, ol_det_result); + } else if (algor_type == algorithm_type_t::HUMAN_DENSITY) { + results = m_human_density.process(vec_gpuMem, ol_det_result); + } else if (algor_type == algorithm_type_t::HUMAN_REGION_GATHER) { + results = m_human_region_gather.process(vec_gpuMem, ol_det_result); + } else if (algor_type == algorithm_type_t::VEHICLE_GATHER) { + results = m_vehicle_gather.process(vec_gpuMem, ol_det_result); + } + + int algorithm_type = (int)algor_type; + for (auto &result : results) { + + if (result.boxes.size() <= 0) + { + continue; + } + + auto task_id = result.task_id; + auto task_other_params = m_task_param_manager->get_task_other_param(task_id); + const auto &algor_other_params = task_other_params->find(algor_type); + if (algor_other_params == task_other_params->end()) { + LOG_ERROR("taskId {} not found algor {}", task_id.c_str(), (int)algor_type); + continue; + } + const algor_basic_config_param_t *basic_param = algor_other_params->second->basic_param; + + std::string cur_timestamp_ms = std::to_string(helpers::timer::get_timestamp()); + const std::string origin_file_path = basic_param->result_folder + helpers::os::sep + task_id + "_" + + std::to_string(result.boxes.size()) + "_" + std::to_string(result.id) + "_" + cur_timestamp_ms + ".jpg"; + + string json_str = helpers::gen_json::gen_boxes_json(task_id, algorithm_type, result.boxes, origin_file_path); + + ImgSaveInfo info_origin; + info_origin.img_info = result.origin_img; + info_origin.file_path = origin_file_path; + info_origin.json_str = json_str; + m_save_snapshot_reprocessing->reprocessing_process_wo_locus_async(info_origin); + } + + return 0; +} + +int CMultiSourceProcess::CountRunningTask() { + DecoderManager* pDecManager = DecoderManager::getInstance(); + return pDecManager->count(); +} + +void CMultiSourceProcess::CloseAllTask2() { + DecoderManager* pDecManager = DecoderManager::getInstance(); + pDecManager->closeAllDecoder(); } \ No newline at end of file diff --git a/src/ai_platform/MultiSourceProcess.h b/src/ai_platform/MultiSourceProcess.h index 6b3e350..e472b02 100644 --- a/src/ai_platform/MultiSourceProcess.h +++ b/src/ai_platform/MultiSourceProcess.h @@ -5,8 +5,7 @@ #include "../ai_engine_module/VPTProcess.h" #include "../reprocessing_module/snapshot_reprocessing.h" #include "../reprocessing_module/save_snapshot_reprocessing.h" -#include "../ai_engine_module/pedestrian_vehicle_retrograde.h" -#include "../ai_engine_module/pedestrian_vehicle_trespass.h" +#include "../ai_engine_module/ai_engine_module.h" #include "../util/JpegUtil.h" #include @@ -17,6 +16,10 @@ #include #include +#ifdef POST_USE_RABBITMQ +#include "../reprocessing_module/mq_manager.hpp" +#endif + using namespace std; @@ -37,9 +40,13 @@ public: #ifdef POST_USE_RABBITMQ int AddMqConn(mq_type_t mq_type, rabbitmq_conn_params_t mq_conn_param); - int GetTaskStatus(const string taskID); #endif + int GetTaskStatus(const string taskID); + + int CountRunningTask(); + void CloseAllTask2(); + public: int algorthim_process_thread(); // 算法处理线程 void task_finished(const string task_id); @@ -72,6 +79,15 @@ private: void trespass_snapshot(vector& vpt_interest_task_id, vector> deleteObjectID); void retrograde_trespass_alarm(const OBJ_KEY &obj_key, const algorithm_type_t &algor_type) ; + void cross_line_process(vector vec_devMem, vector& vptResult, algorithm_type_t eType); + + void wander_detect(vector& vec_gpuMem, vector& vptResult, algorithm_type_t eType); + + int gather_process(vector& vec_gpuMem, vector &ol_det_result, algorithm_type_t algor_type); + + // 轨迹记录 + void trace_record(vector& vec_gpuMem, vector& vptResult); + private: int m_devId; @@ -98,6 +114,9 @@ private: set m_total_snapshot_info_multi_object; mutex m_total_mutex; + mutex m_TotalObjMtx ; + map m_total_obj_info; // 记录目标轨迹 + JpegUtil jpegUtil; #ifdef POST_USE_RABBITMQ @@ -108,4 +127,13 @@ private: ai_engine_module::pedestrian_vehicle_retrograde::PedestrianVehicleRetrograde pedestrian_vehicle_retrograde_; ai_engine_module::pedestrian_vehicle_trespass::PedestrianVehicleTrespass pedestrian_vehicle_trespass_; + ai_engine_module::RegionLeave m_algorthim_region_leave; + ai_engine_module::RegionLeave m_algorthim_region_dismiss; + ai_engine_module::RegionLeave m_algorthim_region_fastmoving; + + GatherDetect m_human_gather; + GatherDetect m_human_density; + GatherDetect m_human_region_gather; + GatherDetect m_vehicle_gather; + }; \ No newline at end of file diff --git a/src/ai_platform/det_obj_header.h b/src/ai_platform/det_obj_header.h index 19a5f88..4e688dc 100644 --- a/src/ai_platform/det_obj_header.h +++ b/src/ai_platform/det_obj_header.h @@ -21,6 +21,9 @@ using namespace std; struct OBJ_INDEX { int index; int count; //用于对index的计数 + int last_frame_nb{0}; + int last_ts{0}; + vector center_points; //存储轨迹中心点坐标-- OBJ_INDEX() : count(0), index(0) {} }; diff --git a/src/ai_platform/header.h b/src/ai_platform/header.h index 4b414a5..4e91b0f 100644 --- a/src/ai_platform/header.h +++ b/src/ai_platform/header.h @@ -34,12 +34,44 @@ enum class algorithm_type_t { PEDESTRIAN_TRESPASS = 211, ROAD_WORK_DET = 212, // 221026byzsh施工占道 + HUMAN_LINGER = 214, // 人员徘徊 + HUMAN_REGION_GATHER = 215, // 区域人员聚集 + HUMAN_REGION_DISMISS = 216, // 人员逃散 + HUMAN_REGION_FAST_MOVING = 217, // 人员快速移动 + HUMAN_DENSITY = 218, // 人员密度 + HUMAN_CLIMB = 220, // 人员攀爬 + HUMAN_CROSSING_LINE = 221, // 人员越线 + HUMAN_LEAVE_REGION = 222, // 区域离开 + VEHICLE_SNAPSHOT = 301, VEHICLE_RETROGRADE = 310, VEHICLE_TRESPASS = 311, + VEHICLE_GATHER = 312, // 车辆聚集 + VEHICLE_ILLEGAL_PARKING = 313, // 车辆违停 + VEHICLE_ILLEGAL_CROSSING_LINE = 314, // 车辆压线 + VEHICLE_LEAVE_REGION = 315, // 区域离开 NONMOTOR_VEHICLE_SNAPSHOT = 401, TAKEAWAY_MEMBER_CLASSIFICATION = 402, + + FLOW_STATISTICS = 500, // 用于数量统计 + NONMOTOR_VEHICLE_NOHELMET = 501,// 电动/摩托车不戴头盔 + NONMOTOR_VEHICLE_OVERMAN = 502, // 电动/摩托车超员 + TRICYCLE_MANNED = 503, // 三轮车载人 + TRUCK_MANNED = 504, // 货车货箱载人 + NONMOTOR_VEHICLE_USEPHONE = 505,// 电动/摩托车驾乘人员使用手机 + NONMOTOR_VEHICLE_REFIT = 506, // 电动车改装(加雨棚) + PERSON_RUNNING_REDLIGHTS = 507, // 行人闯红灯 + NONMOTOR_RUNNING_REDLIGHTS = 508, // 非机动车闯红灯 + PERSON_IN_VEHICLELANE = 509, // 行人占用机动车道 + NONMOTOR_IN_VEHICLELANE = 510, // 非机动车占用机动车道 + NONMOTOR_CEOSSPARKLINE = 511, // 非机动车越过停止线 + PERSON_CROSS = 512, // 行人翻越护栏 + NONMOTOR_WRONGDIRECTION = 513, // 非机动车逆行 + VEHICLE_WRONGDIRECTION = 514, // 机动车逆行 + VEHICLE_SOLIDLINETURNAROUND = 515,// 机动车实线掉头 + VEHICLE_NOTGIVEWAY = 516, // 机动车不让行 + VEHICLE_NOTDECELERATION = 517, // 机动车不减速 }; @@ -243,6 +275,23 @@ typedef struct video_object_info { } video_object_info; #endif + +// 二轮车/三轮车/货车载人参数结构体 +#ifndef ___MANNED_INCIDENT_ALGOR_CONFIG_PARAM__ +#define ___MANNED_INCIDENT_ALGOR_CONFIG_PARAM__ +typedef struct algor_config_param_manned_incident { + int m, n; + int hs_count_threshold; //报警个数阈值 + int obj_min_height, obj_min_width; + float obj_confidence_threshold; + + algor_config_param_manned_incident() + : m(10), n(8), hs_count_threshold(1), obj_min_height(6), obj_min_width(17), + obj_confidence_threshold(0.0f) {} +} algor_config_param_manned_incident; +#endif // #ifndef ___MANNED_INCIDENT_ALGOR_CONFIG_PARAM__ + + // 人员聚集参数结构体 #ifndef ___HUMAN_GATHER_ALGOR_CONFIG_PARAM__ #define ___HUMAN_GATHER_ALGOR_CONFIG_PARAM__ @@ -352,6 +401,25 @@ typedef algor_config_param_pedestrian_safety_detector_basic algor_config_param_n #endif // #ifndef ___PEDESTRIAN_SAFETY_DETECTOR_ALGOR_CONFIG_PARAM__ +// 越线类 +typedef struct algor_config_param_illegal_crossing_line { + float conf_threshold{0.0}; // 目标检测阈值，小于该阈值不识别 + unsigned minmum_height, minmum_width; // 最小目标大小，小于该值不识别 + sy_point p1; // 线段起点 + sy_point p2; // 线段终点 +} algor_config_param_illegal_crossing_line; // 车辆压线/人员越线/人员攀爬 共用 + + +typedef struct algor_config_param_behavior { + float conf_threshold; // 目标检测阈值，小于该阈值不识别 + unsigned minmum_height, minmum_width; // 最小目标大小，小于该值不识别 + int duration; // 持续时长 + int moving_distance_threshold; // 像素变动距离阈值 + algor_config_param_behavior() + : duration(0), conf_threshold(0.0f), minmum_height(0), minmum_width(0), moving_distance_threshold(0) { + } +} algor_config_param_behavior; + // 行人安全检测参数 #ifndef ___RETROGRADE_ALGOR_CONFIG_PARAM__ @@ -412,22 +480,39 @@ typedef struct algor_config_param_snapshot { #endif +#ifndef __UNIVERSAL_ADAPTATON__ +#define __UNIVERSAL_ADAPTATON__ +#define ROI_MAX_POINT 50 +#define MAX_DIRECTION_LINE 50 +typedef struct universal_algor_adapt_param { + sy_point points[ROI_MAX_POINT]; + int points_count; //多边形顶点数量(不超过ROI_MAX_POINT) + // sy_direction direction[MAX_DIRECTION_LINE]; + int line_count; //拌线数量(不超过MAX_DIRECTION_LINE) + + universal_algor_adapt_param() + : points_count(0), line_count(0) { + } +} universal_algor_adapt_param; +#endif + // 算法的初始化参数 #ifndef __ALGOR_CONFIG_PARAM__BASIC__ #define __ALGOR_CONFIG_PARAM__BASIC__ typedef struct algor_basic_config_param_t { + universal_algor_adapt_param *adapt_param{nullptr}; //此处传入共性适配参数 sy_rect algor_valid_rect; char *result_folder_little; //目标快照抠图保存地址 char *result_folder; //目标快照大图保存地址 + char *video_folder; //目标视频保存地址 explicit algor_basic_config_param_t() - : result_folder_little(nullptr), result_folder(nullptr) {} + : result_folder_little(nullptr), result_folder(nullptr), video_folder(nullptr), algor_valid_rect(0,0,3840,2160) {} } algor_basic_config_param_t; #endif // #ifndef __ALGOR_CONFIG_PARAM__BASIC__ - //算法的初始化参数 #ifndef __ALGOR_CONFIG_PARAM__ #define __ALGOR_CONFIG_PARAM__ @@ -456,7 +541,7 @@ typedef struct task_param { algor_config_param *algor_config_params; //该路rtsp流配置的所有算法参数 int algor_counts; //该路rtsp流共配置几种算法 - int dec_type{0}; // 0: ffmpeg 1: gb28181 2:dvpp + int dec_type{0}; // 0: ffmpeg 1: gb28181 2:dvpp 3: dvpp_gb28181 int port; // gb28181时port为必填 int protocal; // gb28181 数据接收协议 0 : udp 1: tcp GB28181_REQUEST_STREAM_CALLBACK gb28181_request_stream_callback; @@ -552,7 +637,9 @@ typedef struct rabbitmq_conn_params_t #define __TSL_AIPLATFORM_PARAM__ typedef struct tsl_aiplatform_param { int gpuid; //指定显卡id + int sip_server_port; // sip服务端端口 char *trt_serialize_file; //缓存文件保存路径 + char *models_dir; // 模型文件目录 ai_log_level log_level; char *log_path; //日志文件路径 diff --git a/src/ai_platform/stl_aiplatform.cpp b/src/ai_platform/stl_aiplatform.cpp index df41d35..010c6f4 100644 --- a/src/ai_platform/stl_aiplatform.cpp +++ b/src/ai_platform/stl_aiplatform.cpp @@ -24,6 +24,7 @@ int add_mq_conn(void *handle, mq_type_t tstatus, rabbitmq_conn_params_t mq_conn_ CMultiSourceProcess* tools = (CMultiSourceProcess*)handle; return tools->AddMqConn(tstatus, mq_conn_param); } +#endif int get_task_status(void *handle, char *task_id) { @@ -31,8 +32,6 @@ int get_task_status(void *handle, char *task_id) return tools->GetTaskStatus(task_id); } -#endif - int add_task(void *handle, task_param param) { CMultiSourceProcess* tools = (CMultiSourceProcess*)handle; @@ -95,6 +94,17 @@ int tsl_aiplatform_release(void **handle) return SUCCESS; } +int count_running_task(void *handle) +{ + CMultiSourceProcess* tools = (CMultiSourceProcess*)handle; + return tools->CountRunningTask(); +} + +void close_all_task(void *handle) +{ + CMultiSourceProcess* tools = (CMultiSourceProcess*)handle; + tools->CloseAllTask2(); +} const char* get_tsl_aiplatform_version() { diff --git a/src/ai_platform/stl_aiplatform.h b/src/ai_platform/stl_aiplatform.h index 99d6dc6..db1bd44 100644 --- a/src/ai_platform/stl_aiplatform.h +++ b/src/ai_platform/stl_aiplatform.h @@ -43,12 +43,11 @@ extern "C" */ TSL_AIPLATFORM_API int add_mq_conn(void *handle, mq_type_t tstatus, rabbitmq_conn_params_t mq_conn_param); +#endif TSL_AIPLATFORM_API int get_task_status(void *handle, char *task_id); -#endif - /************************************************************************* * FUNCTION: add_task * PURPOSE: 添加任务 @@ -120,6 +119,11 @@ extern "C" TSL_AIPLATFORM_API int tsl_aiplatform_release(void **handle); + TSL_AIPLATFORM_API int count_running_task(void *handle); + + TSL_AIPLATFORM_API void close_all_task(void *handle); + + /************************************************************************* * FUNCTION: get_tsl_aiplatform_version * PURPOSE: 获取SDK版本号 diff --git a/src/ai_platform/task_param_manager.cpp b/src/ai_platform/task_param_manager.cpp index 2641ca9..c120a41 100644 --- a/src/ai_platform/task_param_manager.cpp +++ b/src/ai_platform/task_param_manager.cpp @@ -45,6 +45,68 @@ bool copy_algor_param_aux(const algorithm_type_t &algor_type, const std::string } } break; + // 农村相关事件 + case algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::NONMOTOR_VEHICLE_REFIT: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::NONMOTOR_IN_VEHICLELANE: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::NONMOTOR_CEOSSPARKLINE: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::NONMOTOR_WRONGDIRECTION: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::TRICYCLE_MANNED: + m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::PERSON_RUNNING_REDLIGHTS: + m_algor_config_params[task_id].human_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::PERSON_IN_VEHICLELANE: + m_algor_config_params[task_id].human_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::PERSON_CROSS: + m_algor_config_params[task_id].human_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::VEHICLE_WRONGDIRECTION: + m_algor_config_params[task_id].vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::VEHICLE_NOTGIVEWAY: + m_algor_config_params[task_id].vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND: + m_algor_config_params[task_id].vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::VEHICLE_NOTDECELERATION: + m_algor_config_params[task_id].vehicle_algors.insert(algor_type); + goto _manned_param_copy; + case algorithm_type_t::TRUCK_MANNED: { + m_algor_config_params[task_id].vehicle_algors.insert(algor_type); + _manned_param_copy : { + using algor_config_param_type = algor_config_param_manned_incident; + copied_algor_param->algor_param = new algor_config_param_type; + *((algor_config_param_type *)(copied_algor_param->algor_param)) = + *((algor_config_param_type *)algor_param); // deep copy. + } + } break; + + case algorithm_type_t::VEHICLE_GATHER: + case algorithm_type_t::HUMAN_REGION_GATHER: + case algorithm_type_t::HUMAN_DENSITY: case algorithm_type_t::HUMAN_GATHER: { m_algor_config_params[task_id].human_algors.insert(algor_type); using algor_config_param_type = algor_config_param_human_gather; @@ -53,6 +115,27 @@ bool copy_algor_param_aux(const algorithm_type_t &algor_type, const std::string *((algor_config_param_type *)algor_param); // deep copy. } break; + case algorithm_type_t::HUMAN_CROSSING_LINE: + case algorithm_type_t::HUMAN_CLIMB: + case algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE: + { + m_algor_config_params[task_id].human_algors.insert(algor_type); + using algor_config_param_type = algor_config_param_illegal_crossing_line; + copied_algor_param->algor_param = new algor_config_param_type; + *((algor_config_param_type *)(copied_algor_param->algor_param)) = + *((algor_config_param_type *)algor_param); // deep copy. + } break; + + case algorithm_type_t::HUMAN_LINGER: + case algorithm_type_t::VEHICLE_ILLEGAL_PARKING: + { + m_algor_config_params[task_id].human_algors.insert(algor_type); + using algor_config_param_type = algor_config_param_behavior; + copied_algor_param->algor_param = new algor_config_param_type; + *((algor_config_param_type *)(copied_algor_param->algor_param)) = + *((algor_config_param_type *)algor_param); // deep copy. + } break; + //221026byzsh--------------------------------------------------------- case algorithm_type_t::ROAD_WORK_DET: { @@ -216,11 +299,25 @@ void task_param_manager::add_task_param(string task_id, task_param task_param) { } else dst_basic_param->result_folder = nullptr; + if (src_basic_param->video_folder) { + dst_basic_param->video_folder = new char[strlen(src_basic_param->video_folder) + 1]; + strcpy(dst_basic_param->video_folder, src_basic_param->video_folder); + CreateResultFolder(dst_basic_param->video_folder, ""); + } else + dst_basic_param->video_folder = nullptr; + dst_basic_param->algor_valid_rect.left_ = src_basic_param->algor_valid_rect.left_; dst_basic_param->algor_valid_rect.top_ = src_basic_param->algor_valid_rect.top_; dst_basic_param->algor_valid_rect.width_ = src_basic_param->algor_valid_rect.width_; dst_basic_param->algor_valid_rect.height_ = src_basic_param->algor_valid_rect.height_; + /* 拷贝共性算法适配参数 */ + auto &adapt_param = src_basic_param->adapt_param; + if (adapt_param) { + dst_basic_param->adapt_param = new universal_algor_adapt_param; + *((universal_algor_adapt_param *)(dst_basic_param->adapt_param)) = *((universal_algor_adapt_param *)adapt_param); // deep copy. + } + copied_algor_param->basic_param = dst_basic_param; m_task_params[task_id][algor_config_param.algor_type] = copied_algor_param; } @@ -245,6 +342,18 @@ void task_param_manager::delete_task_param(string task_id) { delete[] cur_param->result_folder; cur_param->result_folder = nullptr; } + if (cur_param->video_folder) { + delete[] cur_param->video_folder; + cur_param->video_folder = nullptr; + } + + universal_algor_adapt_param *adapt_param = + (universal_algor_adapt_param *)cur_param->adapt_param; + if (adapt_param) { + delete (universal_algor_adapt_param *)cur_param->adapt_param; + cur_param->adapt_param = nullptr; + } + if (cur_param) { delete ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->basic_param; ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->basic_param = nullptr; @@ -273,6 +382,10 @@ void task_param_manager::delete_task_param(string task_id) { } break; } + + case algorithm_type_t::VEHICLE_GATHER: + case algorithm_type_t::HUMAN_REGION_GATHER: + case algorithm_type_t::HUMAN_DENSITY: case algorithm_type_t::HUMAN_GATHER: { algor_config_param_human_gather *algor_param = (algor_config_param_human_gather *)((algor_init_config_param_t *)m_task_params[task_id][iter.first]) @@ -285,6 +398,34 @@ void task_param_manager::delete_task_param(string task_id) { break; } + case algorithm_type_t::HUMAN_CROSSING_LINE: + case algorithm_type_t::HUMAN_CLIMB: + case algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE: + { + algor_config_param_illegal_crossing_line *algor_param = + (algor_config_param_illegal_crossing_line *)((algor_init_config_param_t *)m_task_params[task_id][iter.first]) + ->algor_param; + if (algor_param) { + delete (algor_config_param_illegal_crossing_line *)((algor_init_config_param_t *)m_task_params[task_id][iter.first]) + ->algor_param; + ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr; + } + break; + } + + case algorithm_type_t::HUMAN_LINGER: + case algorithm_type_t::VEHICLE_ILLEGAL_PARKING: + { + algor_config_param_behavior *algor_param = + (algor_config_param_behavior *)((algor_init_config_param_t *)m_task_params[task_id][iter.first]) + ->algor_param; + if (algor_param) { + delete (algor_config_param_behavior *)((algor_init_config_param_t *)m_task_params[task_id][iter.first]) + ->algor_param; + ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr; + } + break; + } //221026byzsh--------------------------------------------------------- case algorithm_type_t::ROAD_WORK_DET: { @@ -313,6 +454,49 @@ void task_param_manager::delete_task_param(string task_id) { break; } //-------------------------------------------------------------------- + // 农村相关事件 + case algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN: + goto _manned_param_delete; + case algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET: + goto _manned_param_delete; + case algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE: + goto _manned_param_delete; + case algorithm_type_t::NONMOTOR_VEHICLE_REFIT: + goto _manned_param_delete; + case algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS: + goto _manned_param_delete; + case algorithm_type_t::NONMOTOR_IN_VEHICLELANE: + goto _manned_param_delete; + case algorithm_type_t::NONMOTOR_CEOSSPARKLINE: + goto _manned_param_delete; + case algorithm_type_t::NONMOTOR_WRONGDIRECTION: + goto _manned_param_delete; + case algorithm_type_t::TRICYCLE_MANNED: + goto _manned_param_delete; + case algorithm_type_t::PERSON_RUNNING_REDLIGHTS: + goto _manned_param_delete; + case algorithm_type_t::PERSON_IN_VEHICLELANE: + goto _manned_param_delete; + case algorithm_type_t::PERSON_CROSS: + goto _manned_param_delete; + case algorithm_type_t::VEHICLE_WRONGDIRECTION: + goto _manned_param_delete; + case algorithm_type_t::VEHICLE_NOTGIVEWAY: + goto _manned_param_delete; + case algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND: + goto _manned_param_delete; + case algorithm_type_t::VEHICLE_NOTDECELERATION: + goto _manned_param_delete; + case algorithm_type_t::TRUCK_MANNED: { + _manned_param_delete : { + using ptr_t = algor_config_param_manned_incident; + ptr_t *algor_param = (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param; + if (algor_param) { + delete (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param; + ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr; + } + } + } break; case algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION: { algor_config_param_takeaway_member_classification *algor_param = @@ -373,6 +557,15 @@ void task_param_manager::delete_task_param(string task_id) { } } m_task_params.erase(task_id); + + if (m_algor_config_params.count(task_id)) { + m_algor_config_params[task_id].human_face_algors.clear(); + m_algor_config_params[task_id].human_algors.clear(); + m_algor_config_params[task_id].nonmotor_vehicle_algors.clear(); + m_algor_config_params[task_id].vehicle_algors.clear(); + m_algor_config_params.erase(task_id); + } + } void task_param_manager::task_param_manager_release() { @@ -419,3 +612,89 @@ map task_param_manager::get_task_algor_params() map> task_param_manager::get_task_other_params() { return m_task_params; } + +bool task_param_manager::task_has_vpt_algor(const std::string &task_id) { + auto algor_map = get_task_other_param(task_id); + if (algor_map == nullptr) + return false; + + return (algor_map->find(algorithm_type_t::HUMAN_GATHER) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_SNAPSHOT) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_GATHER) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_CROSSING_LINE) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_DENSITY) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_CLIMB) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_LINGER) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_ILLEGAL_PARKING) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_REGION_GATHER) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_LEAVE_REGION) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_REGION_DISMISS) != algor_map->end() || + algor_map->find(algorithm_type_t::HUMAN_REGION_FAST_MOVING) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT) != algor_map->end() || + algor_map->find(algorithm_type_t::SMOKING_DET) != algor_map->end() || + algor_map->find(algorithm_type_t::NO_REFLECTIVE_CLOTHING) != algor_map->end() || + algor_map->find(algorithm_type_t::NO_SAFETY_HELMET) != algor_map->end() || + algor_map->find(algorithm_type_t::CALL_PHONE_DET) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_SNAPSHOT) != algor_map->end() || + algor_map->find(algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION) != algor_map->end() || + algor_map->find(algorithm_type_t::PEDESTRIAN_FALL) != algor_map->end() || + algor_map->find(algorithm_type_t::PEDESTRIAN_FIGHT) != algor_map->end() || + algor_map->find(algorithm_type_t::PEDESTRIAN_RETROGRADE) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_RETROGRADE) != algor_map->end() || + algor_map->find(algorithm_type_t::PEDESTRIAN_TRESPASS) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_TRESPASS) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_REFIT) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_CEOSSPARKLINE) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_IN_VEHICLELANE) != algor_map->end() || + algor_map->find(algorithm_type_t::NONMOTOR_WRONGDIRECTION) != algor_map->end() || + algor_map->find(algorithm_type_t::PERSON_IN_VEHICLELANE) != algor_map->end() || + algor_map->find(algorithm_type_t::PERSON_RUNNING_REDLIGHTS) != algor_map->end() || + algor_map->find(algorithm_type_t::PERSON_CROSS) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_WRONGDIRECTION) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_NOTGIVEWAY) != algor_map->end() || + algor_map->find(algorithm_type_t::VEHICLE_NOTDECELERATION) != algor_map->end() || + algor_map->find(algorithm_type_t::TRICYCLE_MANNED) != algor_map->end() || + algor_map->find(algorithm_type_t::TRUCK_MANNED) != algor_map->end()); +} + +bool task_param_manager::task_has_face_algor(const std::string &task_id) { + auto algor_map = get_task_other_param(task_id); + if (nullptr != algor_map){ + return algor_map->find(algorithm_type_t::FACE_SNAPSHOT) != algor_map->end(); + } + + return false; +} + +int task_param_manager::get_video_timing_snapshot_interval(std::string& task_id) { + auto algor_map = get_task_other_param(task_id); + if (algor_map != nullptr) { + + // 设置定时截图的时间间隔 + auto algor = algor_map->find(algorithm_type_t::VIDEO_TIMING_SNAPSHOT); + if(algor != algor_map->end()){ + task_param_manager::algo_param_type_t_* cur_task_params = algor->second; + if(cur_task_params){ + int frame_stride = ((algor_config_video_timing_snapshot*)cur_task_params->algor_param)->frame_stride; + LOG_INFO("task {} snap time interval: {} s", task_id, frame_stride); + // 单位是ms, 乘以 1000 编成s + return frame_stride * 1000; + } + } + + // 测试代码 + // auto algor_face = algor_map->find(algorithm_type_t::FACE_SNAPSHOT); + // if(algor_face != algor_map->end()){ + // const algor_basic_config_param_t *cur_param = ((algor_init_config_param_t *)(algor_face->second))->basic_param; + // LOG_INFO("face_snapshot, result_folder: {} result_folder_little: {}", cur_param->result_folder, cur_param->result_folder_little); + // } + } + + return -1; +} \ No newline at end of file diff --git a/src/ai_platform/task_param_manager.h b/src/ai_platform/task_param_manager.h index cebb772..4161423 100644 --- a/src/ai_platform/task_param_manager.h +++ b/src/ai_platform/task_param_manager.h @@ -43,6 +43,11 @@ public: map> get_task_other_params(); void task_param_manager_release(); + bool task_has_vpt_algor(const std::string &task_id); + bool task_has_face_algor(const std::string &task_id); + + int get_video_timing_snapshot_interval(std::string& task_id); + private: task_param_manager(); task_param_manager(const task_param_manager& other); diff --git a/src/decoder/dvpp/DvppDataMemory.hpp b/src/decoder/dvpp/DvppDataMemory.hpp index 2ebe58a..2286532 100644 --- a/src/decoder/dvpp/DvppDataMemory.hpp +++ b/src/decoder/dvpp/DvppDataMemory.hpp @@ -1,33 +1,69 @@ +#ifndef __DVPP_DATA_MEMORY_HPP__ +#define __DVPP_DATA_MEMORY_HPP__ + #include +#include "depend_headers.h" #include "dvpp_headers.h" using namespace std; +// static int snap_free = 0; + class DvppDataMemory : public DeviceMemory { public: - DvppDataMemory(int _channel, int _width, int _width_stride, int _height, int _height_stride, int _size, string _id, string _dev_id, bool _key_frame) - :DeviceMemory(_channel, _width, _width_stride, _height, _height_stride, _id, _dev_id, _key_frame, false){ + DvppDataMemory(int _channel, int _width, int _width_stride, int _height, int _height_stride, int _size, string _id, string _dev_id, bool _key_frame, unsigned long long frame_nb) + :DeviceMemory(_channel, _width, _width_stride, _height, _height_stride, _id, _dev_id, _key_frame, frame_nb, false){ data_size = _size; + data_type = 1; int ret = acldvppMalloc((void **)&pHwRgb, data_size); if(ret != ACL_ERROR_NONE){ - cout << "acldvppMalloc failed" << endl; + LOG_ERROR("[{}]- acldvppMalloc failed", id); } } - DvppDataMemory( int _width, int _width_stride, int _height, int _height_stride, int _size, string _id, string _dev_id, bool _key_frame, unsigned char * pHwData) - :DeviceMemory(3, _width, _width_stride, _height, _height_stride, _id, _dev_id, _key_frame, false){ + DvppDataMemory( int _width, int _width_stride, int _height, int _height_stride, int _size, string _id, string _dev_id, bool _key_frame, unsigned long long frame_nb, unsigned char * pHwData) + :DeviceMemory(-1, _width, _width_stride, _height, _height_stride, _id, _dev_id, _key_frame, frame_nb, false){ data_size = _size; data_type = 1; pHwRgb = pHwData; } + DvppDataMemory(DvppDataMemory* pSrc):DeviceMemory(-1, pSrc->getWidth(), pSrc->getWidthStride(), pSrc->getHeight(), pSrc->getHeightStride(), pSrc->getId(), pSrc->getDeviceId(), pSrc->isKeyFrame(), pSrc->getFrameNb(), false){ + if(pSrc == nullptr) { + LOG_ERROR("[{}]- pSrc is nullptr", pSrc->getId()); + return; + } + + data_size = pSrc->getSize(); + int ret = acldvppMalloc((void **)&pHwRgb, data_size); + if(ret != ACL_ERROR_NONE){ + LOG_ERROR("[{}]- acldvppMalloc failed", pSrc->getId()); + return; + } + + ret = aclrtMemcpy(pHwRgb, data_size, pSrc->getMem(), pSrc->getSize(), ACL_MEMCPY_DEVICE_TO_DEVICE); + if(ret != ACL_ERROR_NONE){ + acldvppFree(pHwRgb); + LOG_ERROR("[{}]- aclrtMemcpy failed", pSrc->getId()); + return; + } + + data_type = 2; + timestamp = UtilTools::get_cur_time_ms(); + } + ~DvppDataMemory(){ + // if (data_type == 2) + // { + // snap_free++; + // LOG_INFO("[{}]- snap_free: {}", getId(), snap_free); + // } if (pHwRgb) { - int ret = acldvppFree((uint8_t*)pHwRgb); + int ret = acldvppFree(pHwRgb); if(ret != ACL_ERROR_NONE){ - cout << "acldvppFree failed" << endl; + LOG_ERROR("[{}]- acldvppFree failed", id); } pHwRgb = nullptr; } @@ -35,4 +71,7 @@ public: public: int data_type; // 0: rgb , 1: NV12 -}; \ No newline at end of file +}; + + +#endif // __DVPP_DATA_MEMORY_HPP__ \ No newline at end of file diff --git a/src/decoder/dvpp/DvppDecoder.cpp b/src/decoder/dvpp/DvppDecoder.cpp index 24bfa9c..59ac6fb 100644 --- a/src/decoder/dvpp/DvppDecoder.cpp +++ b/src/decoder/dvpp/DvppDecoder.cpp @@ -2,26 +2,83 @@ #include "DvppSourceManager.h" +#define CHECK_AND_RETURN(ret, message) \ + if(ret != 0) {LOG_ERROR("[{}]- {}", m_dec_name, message); return ret;} +#define CHECK_NOT_RETURN(ret, message) \ + if(ret != 0) {LOG_ERROR("[{}]- {}", m_dec_name, message);} +#define CHECK_AND_RETURN_NOVALUE(ret, message) \ + if(ret != 0) {LOG_ERROR("[{}]- {}", m_dec_name, message); return;} +#define CHECK_AND_BREAK(ret, message) \ + if(ret != 0) {LOG_ERROR("[{}]- {}", m_dec_name, message); break;} + + + + struct Vdec_CallBack_UserData { uint64_t frameId; + uint64_t frame_nb; long startTime; long sendTime; - // void* vdecOutputBuf; DvppDecoder* self; + Vdec_CallBack_UserData() { frameId = 0; + frame_nb = 0; } }; + +static long get_cur_time_ms() { + chrono::time_point tpMicro + = chrono::time_point_cast(chrono::system_clock::now()); + return tpMicro.time_since_epoch().count(); +} + +static void *ReportThd(void *arg) +{ + DvppDecoder *self = (DvppDecoder *)arg; + if(nullptr != self){ + self->doProcessReport(); + } + return (void *)0; +} + +static void VdecCallback(acldvppStreamDesc *input, acldvppPicDesc *output, void *pUserData) +{ + Vdec_CallBack_UserData *userData = (Vdec_CallBack_UserData *) pUserData; + if(nullptr != userData){ + DvppDecoder* self = userData->self; + if(self != nullptr){ + self->doVdppVdecCallBack(input, output, userData); + } + delete userData; + userData = nullptr; + } +} + +static int AVInterruptCallBackFun(void *param) +{ + DvppDecoder *pDecoder = (DvppDecoder*)param; + if (nullptr == pDecoder) return 0; + + long long cur_ts = get_cur_time_ms(); + long time_gap = cur_ts - pDecoder->get_last_read_ts(); + if (time_gap > 1000*30) { + LOG_WARN("摄像头异常，释放阻塞"); + //通知FFMpeg可以从阻塞工作线程中释放操作 + return 1; + } else { + //通知FFMpeg继续阻塞工作 + return 0; + } +} + DvppDecoder::DvppDecoder(){ - m_read_thread = 0; - m_decode_thread = 0; - m_cached_mem = nullptr; + m_read_thread = nullptr; fmt_ctx = nullptr; m_bRunning = false; - stream = nullptr; video_index = -1; pix_fmt = AV_PIX_FMT_NONE; m_dec_name = ""; @@ -32,72 +89,84 @@ DvppDecoder::DvppDecoder(){ m_bFinished = false; m_dec_keyframe = false; m_fps = 0.0; - - m_bSnapShoting = false; } DvppDecoder::~DvppDecoder(){ + close(); + + LOG_DEBUG("[{}]- ~DvppDecoder() in_count:{} out_count:{}", m_dec_name, m_in_count, m_out_count); } bool DvppDecoder::init(FFDecConfig cfg){ m_dec_name = cfg.dec_name; + m_frameSkip = cfg.skip_frame; AVCodecContext* avctx = init_FFmpeg(cfg); if(avctx == nullptr){ return false; } - bool bRet = init_vdpp(cfg, avctx); - if(!bRet){ - return false; - } + do + { + bool bRet = init_dvpp(cfg); + if(!bRet){ + break; + } - m_cfg = cfg; + m_cfg = cfg; - decode_finished_cbk = cfg.decode_finished_cbk; + decode_finished_cbk = cfg.decode_finished_cbk; - m_bFinished = false; + m_bFinished = false; - return true; + return true; + } while (0); + + release_ffmpeg(); + + return false; } AVCodecContext* DvppDecoder::init_FFmpeg(FFDecConfig config){ -#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100) - av_register_all(); -#endif -#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 10, 100) - avcodec_register_all(); -#endif - - avformat_network_init(); - - const char* uri = config.uri.c_str(); - fstream infile(uri); - if (infile.is_open()){ - m_bReal = false; - infile.close(); - } else { - m_bReal = true; - } + const char* input_file = config.uri.c_str(); // 打开输入视频文件 AVDictionary *options = nullptr; av_dict_set( &options, "bufsize", "655360", 0 ); av_dict_set( &options, "rtsp_transport", config.force_tcp ? "tcp" : "udp", 0 ); av_dict_set( &options, "stimeout", "30000000", 0 ); // 单位为 百万分之一秒 - - const char* input_file = uri; + av_dict_set( &options, "max_delay", "500000", 0); //设置最大时延 do{ fmt_ctx = avformat_alloc_context(); + // fmt_ctx->flags |= AVFMT_FLAG_NONBLOCK; if (avformat_open_input(&fmt_ctx, input_file, nullptr, &options) != 0) { LOG_ERROR("[{}]- Cannot open input file: {}", m_dec_name, input_file); break; } av_dump_format(fmt_ctx, 0, input_file, 0); + FILE* infile = fopen(input_file, "r"); + if(nullptr != infile) { + // 可以作为本地文件打开，那必然是文件 + m_bReal = false; + fclose(infile); + infile = nullptr; + } else { + // http://xxxx/xxx.mp4 也与文件同 + if (fmt_ctx->iformat && fmt_ctx->iformat->extensions) { + m_bReal = false; + } else { + m_bReal = true; + + fmt_ctx->interrupt_callback.callback = AVInterruptCallBackFun; + fmt_ctx->interrupt_callback.opaque = this; + m_last_read_ts = get_cur_time_ms(); + } + } + // 查找流信息 if (avformat_find_stream_info(fmt_ctx, nullptr) < 0) { LOG_ERROR("[{}]- Cannot find input stream information!", m_dec_name); @@ -111,9 +180,8 @@ AVCodecContext* DvppDecoder::init_FFmpeg(FFDecConfig config){ LOG_ERROR("[{}]- Cannot find a video stream in the input file!", m_dec_name); break; } - AVCodec *vcodec = avcodec_find_decoder(decoder->id); - avctx = avcodec_alloc_context3(vcodec); + avctx = avcodec_alloc_context3(decoder); if(avctx == nullptr){ LOG_ERROR("[{}]- alloc AVCodecContext failed!", m_dec_name); break; @@ -125,6 +193,12 @@ AVCodecContext* DvppDecoder::init_FFmpeg(FFDecConfig config){ if (avcodec_parameters_to_context(avctx, codecpar) < 0) break; + int enType = getVdecType(codecpar->codec_id, codecpar->profile); + if(-1 == enType) { + break; + } + m_enType = static_cast(enType); + const AVBitStreamFilter * filter = nullptr; if(codecpar->codec_id == AV_CODEC_ID_H264){ filter = av_bsf_get_by_name("h264_mp4toannexb"); @@ -146,9 +220,25 @@ AVCodecContext* DvppDecoder::init_FFmpeg(FFDecConfig config){ frame_width = codecpar->width; frame_height = codecpar->height; pix_fmt = (AVPixelFormat)codecpar->format; - m_fps = av_q2d(stream ->avg_frame_rate); - LOG_INFO("[{}]- init ffmpeg success! input:{} frame_width:{} frame_height:{} fps:{} ", m_dec_name, input_file, frame_width, frame_height, m_fps); + m_bResize = config.resize; + calcOutResolution(frame_width, frame_height); + + if (stream->avg_frame_rate.den) { + m_fps = av_q2d(stream ->avg_frame_rate); + } else { + m_fps = 0.0; + } + + m_vdec_out_size = frame_width * frame_height * 3 / 2; + + if (avctx->gop_size > 0) { + m_cache_gop = avctx->gop_size + 1; + } else { + m_cache_gop = 20; + } + + LOG_INFO("[{}]- init ffmpeg success! input:{} src:({}, {}) out:({}, {}) fps:{} ", m_dec_name, input_file, frame_width, frame_height, out_frame_width, out_frame_height, m_fps); return avctx; }while(0); @@ -160,42 +250,85 @@ AVCodecContext* DvppDecoder::init_FFmpeg(FFDecConfig config){ return nullptr; } - bool DvppDecoder::init_vdpp(FFDecConfig cfg, AVCodecContext* avctx) { +void DvppDecoder::calcOutResolution(int width, int height) { + if(m_bResize) { + float srcRatio = width / (float)height; + float stdRatio = 1920.0 / 1080.0f ; + int outWidth = 1920; + int outHeight = 1080; + if (srcRatio > stdRatio) { + outHeight = static_cast(outWidth * (float)height / width) ; + if (outHeight % 2 == 1) { + outHeight += 1; + } + } else if (srcRatio < stdRatio) { + outWidth = static_cast(outHeight * (float)width / height) ; + if (outWidth % 2 == 1) { + outWidth += 1; + } + } - LOG_INFO("[{}]- Init device start...", m_dec_name); + out_frame_width = outWidth; + out_frame_height = outHeight; + } else { + out_frame_width = width; + out_frame_height = height; + } +} - m_dvpp_deviceId = atoi(cfg.gpuid.c_str()); - - if(avctx->codec_id == AV_CODEC_ID_H264){ - // 66：Baseline，77：Main，>=100：High - if(avctx->profile == 77){ - enType = H264_MAIN_LEVEL; - }else if(avctx->profile < 77){ - enType = H264_BASELINE_LEVEL; - }else{ - enType = H264_HIGH_LEVEL; +int DvppDecoder::getVdecType(int videoType, int profile) +{ + int streamFormat = H264_MAIN_LEVEL; + + // VDEC only support　H265 main level，264 baseline level，main level，high level + if (videoType == AV_CODEC_ID_HEVC) { + streamFormat = H265_MAIN_LEVEL; + } else if (videoType == AV_CODEC_ID_H264) { + switch (profile) { + case FF_PROFILE_H264_BASELINE: + streamFormat = H264_BASELINE_LEVEL; + break; + case FF_PROFILE_H264_MAIN: + streamFormat = H264_MAIN_LEVEL; + break; + case FF_PROFILE_H264_HIGH: + case FF_PROFILE_H264_HIGH_10: + case FF_PROFILE_H264_HIGH_10_INTRA: + case FF_PROFILE_H264_MULTIVIEW_HIGH: + case FF_PROFILE_H264_HIGH_422: + case FF_PROFILE_H264_HIGH_422_INTRA: + case FF_PROFILE_H264_STEREO_HIGH: + case FF_PROFILE_H264_HIGH_444: + case FF_PROFILE_H264_HIGH_444_PREDICTIVE: + case FF_PROFILE_H264_HIGH_444_INTRA: + streamFormat = H264_HIGH_LEVEL; + break; + default: + LOG_INFO("Not support h264 profile {}, use as mp", profile); + streamFormat = H264_MAIN_LEVEL; + break; } - }else if(avctx->codec_id == AV_CODEC_ID_HEVC){ - // h265只有main - enType = H265_MAIN_LEVEL; - }else { - LOG_ERROR("[{}]- codec_id is not supported!", m_dec_name); - return false; + } else { + streamFormat = -1; + LOG_ERROR("Not support stream, type {}, profile {}", videoType, profile); } + return streamFormat; +} + + bool DvppDecoder::init_dvpp(FFDecConfig cfg) { + + LOG_INFO("[{}]- Init device start...", m_dec_name); + + m_dvpp_deviceId = atoi(cfg.gpuid.c_str()); + post_decoded_cbk = cfg.post_decoded_cbk; do{ - aclError ret = aclrtSetDevice(m_dvpp_deviceId); - if(ret != ACL_ERROR_NONE){ - LOG_ERROR("[{}]-aclrtSetDevice failed !", m_dec_name); - return false; - } - - ret = aclrtCreateContext(&m_context, m_dvpp_deviceId); + aclError ret = aclrtCreateContext(&m_context, m_dvpp_deviceId); if (ret != ACL_ERROR_NONE) { LOG_ERROR("[{}]-aclrtCreateContext failed !", m_dec_name); - return false; + break; } // DvppSourceManager 创建时包含 aclInit，析构时包含 aclFinalize @@ -203,9 +336,10 @@ AVCodecContext* DvppDecoder::init_FFmpeg(FFDecConfig config){ m_dvpp_channel = pSrcMgr->getChannel(m_dvpp_deviceId); if(m_dvpp_channel < 0){ LOG_ERROR("[{}]-该设备channel已经用完了!", m_dec_name); - return false; + break; } - m_vdec_out_size = avctx->width * avctx->height * 3 / 2; + + m_vpcUtils.init(m_dvpp_deviceId); LOG_INFO("[{}]- init vdpp success! device:{} channel:{}", m_dec_name, m_dvpp_deviceId, m_dvpp_channel); return true; @@ -223,14 +357,12 @@ bool DvppDecoder::isSurport(FFDecConfig& cfg){ bool DvppDecoder::start(){ m_bRunning = true; - pthread_create(&m_read_thread,0, - [](void* arg) + m_read_thread = new std::thread([](void* arg) { DvppDecoder* a=(DvppDecoder*)arg; a->read_thread(); return (void*)0; - } - ,this); + }, this); return true; } @@ -238,8 +370,10 @@ bool DvppDecoder::start(){ void DvppDecoder::close(){ m_bRunning=false; - if(m_read_thread != 0){ - pthread_join(m_read_thread,0); + if(m_read_thread != nullptr){ + m_read_thread->join(); + delete m_read_thread; + m_read_thread = nullptr; } } @@ -281,24 +415,56 @@ bool DvppDecoder::getResolution(int &width, int &height){ return true; } +bool DvppDecoder::getOutResolution( int &width, int &height ) { + width = out_frame_width; + height = out_frame_height; + return true; +} + float DvppDecoder::fps(){ return m_fps; } +long long DvppDecoder::get_last_read_ts() { + return m_last_read_ts; +} + +static int snap_count = 0; + DeviceMemory* DvppDecoder::snapshot(){ - // 注意内部有锁 - // 开始抓拍 - m_bSnapShoting = true; - std::unique_lock locker(m_cached_mutex); - while (m_cached_mem == nullptr) - m_cached_cond.wait_for(locker, std::chrono::milliseconds(400)); // Unlock mutex and wait to be notified - locker.unlock(); + int ret = aclrtSetCurrentContext(m_context); + if(ret != ACL_ERROR_NONE){ + LOG_ERROR("[{}]- aclrtSetCurrentContext failed", m_dec_name); + return nullptr; + } + + // 注意有锁 + DeviceMemory* snapshot_mem = nullptr; + int loop_times = 0; + while(m_bRunning) { + m_decoded_data_queue_mtx.lock(); + if(m_decoded_data_queue.size() <= 0) { + m_decoded_data_queue_mtx.unlock(); + loop_times++; + if(loop_times > 100) { + // 1s都没截取到图，退出 + break; + } + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + continue; + } + + DvppDataMemory* mem = m_decoded_data_queue.front(); + snapshot_mem = new DvppDataMemory(mem); + m_decoded_data_queue_mtx.unlock(); - DeviceMemory* mem = m_cached_mem; - m_cached_mem = nullptr; + // snap_count++; + // LOG_INFO("[{}]- snap_count:{} ", m_dec_name, snap_count); + break; + } - return mem; + return snapshot_mem; } int DvppDecoder::getCachedQueueLength(){ @@ -311,465 +477,204 @@ void DvppDecoder::release_ffmpeg() { av_bsf_free(&h264bsfc); h264bsfc = nullptr; } - if (fmt_ctx){ - avformat_close_input(&fmt_ctx); - fmt_ctx = nullptr; - } if(avctx){ avcodec_free_context(&avctx); avctx = nullptr; } + if (fmt_ctx){ + avformat_close_input(&fmt_ctx); + fmt_ctx = nullptr; + } + + LOG_DEBUG("[{}]- release_ffmpeg", m_dec_name); } void DvppDecoder::read_thread() { - int frame_count = 0; int ret = -1; - pthread_create(&m_decode_thread,0, + m_bExitReportThd = false; + pthread_t report_thread; + ret = pthread_create(&report_thread, nullptr, ReportThd, (void *)this); + if(ret != 0){ + LOG_ERROR("[{}]- pthread_create failed", m_dec_name); + return; + } + + m_bExitDisplayThd = false; + std::thread display_thread( [](void* arg) { DvppDecoder* a=(DvppDecoder*)arg; - a->decode_thread(); + a->display_thread(); return (void*)0; - } - ,this); - - AVPacket* pkt = nullptr; - while (m_bRunning){ - - if (!m_bReal){ - if (m_bPause){ - std::this_thread::sleep_for(std::chrono::milliseconds(3)); - continue; - } - } - - m_pktQueue_mutex.lock(); - if(m_pktQueue.size() > 10){ - m_pktQueue_mutex.unlock(); - std::this_thread::sleep_for(std::chrono::milliseconds(5)); - continue; - } - m_pktQueue_mutex.unlock(); - - pkt = av_packet_alloc(); - av_init_packet( pkt ); - - int result = av_read_frame(fmt_ctx, pkt); - if (result == AVERROR_EOF || result < 0){ - av_packet_free(&pkt); - pkt = nullptr; - LOG_ERROR("[{}]- Failed to read frame!", m_dec_name); - break; - } - - if (m_dec_keyframe && !(pkt->flags & AV_PKT_FLAG_KEY)) { - av_packet_free(&pkt); - pkt = nullptr; - continue; - } - - if (video_index == pkt->stream_index){ - - ret = av_bsf_send_packet(h264bsfc, pkt); - if(ret < 0) { - LOG_ERROR("[{}]- av_bsf_send_packet error!", m_dec_name); - av_packet_free(&pkt); - pkt = nullptr; - continue; - } - - bool bPushed = false; - while ((ret = av_bsf_receive_packet(h264bsfc, pkt)) == 0) { - if(pkt->size > g_pkt_size){ - LOG_ERROR("[{}]- pkt size 大于最大预设值!", m_dec_name); - break; - } - - if(!m_bRunning){ - break; - } - - m_pktQueue_mutex.lock(); - m_pktQueue.push(pkt); - m_pktQueue_mutex.unlock(); - - bPushed = true; - frame_count++; - } - - if(!bPushed){ - av_packet_free(&pkt); - pkt = nullptr; - } - } else { - // 音频等其他分量的情形 - av_packet_free(&pkt); - pkt = nullptr; - } - } - - m_bRunning=false; - - if(m_decode_thread != 0){ - pthread_join(m_decode_thread,0); - } - - m_pktQueue_mutex.lock(); - while(m_pktQueue.size() > 0){ - pkt = m_pktQueue.front(); - av_packet_free(&pkt); - pkt = nullptr; - m_pktQueue.pop(); - } - m_pktQueue_mutex.unlock(); - - decode_finished_cbk(m_finishedDecArg); - - LOG_INFO("[{}]- read thread exit.", m_dec_name); - m_bFinished = true; -} - -static void *ReportThd(void *arg) -{ - DvppDecoder *self = (DvppDecoder *)arg; - if(nullptr != self){ - self->doProcessReport(); - } - return (void *)0; -} - -void DvppDecoder::doProcessReport(){ - - aclError ret = aclrtSetDevice(m_dvpp_deviceId); - if(ret != ACL_ERROR_NONE){ - // cout << "aclrtSetDevice failed" << endl; - LOG_ERROR("aclrtSetDevice failed !"); - return ; - } - - aclrtContext ctx; - ret = aclrtCreateContext(&ctx, m_dvpp_deviceId); - if (ret != ACL_ERROR_NONE) { - // cout << "aclrtCreateContext failed " << endl; - LOG_ERROR("aclrtCreateContext failed !"); - return ; - } - - CHECK_AND_RETURN_NOVALUE(aclrtSetCurrentContext(ctx), "aclrtSetCurrentContext failed"); - // 阻塞等待vdec线程开始 - - while (!m_bExitReportThd) { - aclrtProcessReport(1000); - } - - ret = aclrtDestroyContext(ctx); - if(ret != ACL_ERROR_NONE){ - LOG_ERROR("aclrtDestroyContext failed !"); - } - LOG_INFO("doProcessReport exit."); -} - -static void VdecCallback(acldvppStreamDesc *input, acldvppPicDesc *output, void *pUserData) -{ - Vdec_CallBack_UserData *userData = (Vdec_CallBack_UserData *) pUserData; - if(nullptr != userData){ - DvppDecoder* self = userData->self; - if(self != nullptr){ - - self->doVdppVdecCallBack(input, output); - } - delete userData; - userData = nullptr; - } -} - -void DvppDecoder::doVdppVdecCallBack(acldvppStreamDesc *input, acldvppPicDesc *output){ - - m_vdecQueue_mutex.lock(); - if(m_vdecQueue.size() > 0){ - void* inputData = m_vdecQueue.front(); - acldvppFree(inputData); - inputData = nullptr; - m_vdecQueue.pop(); - } - m_vdecQueue_mutex.unlock(); - - - CHECK_AND_RETURN_NOVALUE(aclrtSetCurrentContext(m_context), "aclrtSetCurrentContext failed"); + }, + this + ); - void *outputDataDev = acldvppGetPicDescData(output); - uint32_t outputSize = acldvppGetPicDescSize(output); - uint32_t width = acldvppGetPicDescWidth(output); - uint32_t width_stride = acldvppGetPicDescWidthStride(output); - uint32_t height = acldvppGetPicDescHeight(output); - uint32_t height_stride = acldvppGetPicDescHeightStride(output); + aclvdecChannelDesc *vdecChannelDesc = nullptr; - do{ - int ret = acldvppGetPicDescRetCode(output); + do { + int ret = aclrtSetCurrentContext(m_context); if(ret != ACL_ERROR_NONE){ - LOG_ERROR("[{}]- decode result error, retCode:{} ", m_dec_name, ret); - acldvppFree(outputDataDev); - outputDataDev = nullptr; + LOG_ERROR("[{}]- aclrtSetCurrentContext failed", m_dec_name); break; } - if(width > 0 && height > 0 && outputSize > 0){ - DvppDataMemory* mem = new DvppDataMemory(width, width_stride, height, height_stride, outputSize, m_dec_name, to_string(m_dvpp_deviceId), false, (unsigned char *)outputDataDev); - if(mem){ - post_decoded_cbk(m_postDecArg, mem); - - if(m_bSnapShoting){ - // 缓存snapshot - std::unique_lock locker(m_cached_mutex); - - m_cached_mem = new DvppDataMemory(-1, width, width_stride, height, height_stride, outputSize, m_dec_name, to_string(m_dvpp_deviceId), false); - if(m_cached_mem != nullptr){ - aclrtMemcpy(m_cached_mem->getMem(), outputSize, (unsigned char *)outputDataDev, outputSize, ACL_MEMCPY_DEVICE_TO_DEVICE); - } - - locker.unlock(); - m_cached_cond.notify_one(); - m_bSnapShoting = false; - } - } else { - LOG_ERROR("[{}]- DvppDataMemory 创建失败！ ", m_dec_name, ret); - acldvppFree(outputDataDev); - outputDataDev = nullptr; - } - - } else { - LOG_WARN("[{}]- decode result error, width:{} width_stride:{} height:{} height_stride:{} size:{}", m_dec_name, width, width_stride, height, height_stride, outputSize); - acldvppFree(outputDataDev); - outputDataDev = nullptr; + vdecChannelDesc = aclvdecCreateChannelDesc(); + if (vdecChannelDesc == nullptr) { + LOG_ERROR("[{}]- aclvdecCreateChannelDesc failed", m_dec_name); + break; } - - // DvppDataMemory* rgbMem = picConverter.convert2bgr(output, width, height, false); - // if(rgbMem != nullptr){ - // #ifdef TEST_DECODER - // // D2H - // if(vdecHostAddr == nullptr){ - // CHECK_NOT_RETURN(aclrtMallocHost(&vdecHostAddr, width * height * 3), "aclrtMallocHost failed"); - // } - // uint32_t data_size = rgbMem->getSize(); - // CHECK_AND_RETURN_NOVALUE(aclrtMemcpy(vdecHostAddr, data_size, rgbMem->getMem(), data_size, ACL_MEMCPY_DEVICE_TO_HOST), "D2H aclrtMemcpy failed"); - - // // 保存vdec结果 - // if(count_frame > 45 && count_frame < 50) - // { - // string file_name = "./yuv_pic/vdec_out_"+ m_dec_name +".rgb" ; - // FILE *outputFile = fopen(file_name.c_str(), "a"); - // if(outputFile){ - // fwrite(vdecHostAddr, data_size, sizeof(char), outputFile); - // fclose(outputFile); - // } - // } - // else if(count_frame > 50 && vdecHostAddr != nullptr){ - // CHECK_NOT_RETURN(aclrtFreeHost(vdecHostAddr), "aclrtFreeHost failed"); - // vdecHostAddr = nullptr; - // } - // count_frame++; - // #endif - // post_decoded_cbk(m_postDecArg, rgbMem); - // }else{ - // LOG_ERROR("[{}]- convert2bgr failed !", m_dec_name); - // } - }while(0); - - CHECK_AND_RETURN_NOVALUE(acldvppDestroyStreamDesc(input), "acldvppDestroyStreamDesc failed"); - CHECK_AND_RETURN_NOVALUE(acldvppDestroyPicDesc(output), "acldvppDestroyPicDesc failed"); -} - -void DvppDecoder::decode_thread(){ - - long startTime = UtilTools::get_cur_time_ms(); - - int ret = -1; - - m_bExitReportThd = false; - pthread_t report_thread; - ret = pthread_create(&report_thread, nullptr, ReportThd, (void *)this); - if(ret != 0){ - LOG_ERROR("[{}]- pthread_create failed", m_dec_name); - return; - } - aclrtSetDevice(m_dvpp_deviceId); - aclrtContext ctx; - ret = aclrtCreateContext(&ctx, m_dvpp_deviceId); - if (ret != ACL_ERROR_NONE) { - // cout << "aclrtCreateContext failed " << endl; - LOG_ERROR("aclrtCreateContext failed !"); - return ; - } - - // 创建aclvdecChannelDesc类型的数据 - aclvdecChannelDesc *vdecChannelDesc = aclvdecCreateChannelDesc(); - if (vdecChannelDesc == nullptr) { - LOG_ERROR("[{}]- aclvdecCreateChannelDesc failed", m_dec_name); - return; - } - do{ // 创建 channel dec结构体 // 通道ID在dvpp层面为0~31 CHECK_AND_BREAK(aclvdecSetChannelDescChannelId(vdecChannelDesc, m_dvpp_channel), "aclvdecSetChannelDescChannelId failed"); CHECK_AND_BREAK(aclvdecSetChannelDescThreadId(vdecChannelDesc, report_thread), "aclvdecSetChannelDescThreadId failed"); CHECK_AND_BREAK(aclvdecSetChannelDescCallback(vdecChannelDesc, VdecCallback), "aclvdecSetChannelDescCallback failed"); - CHECK_AND_BREAK(aclvdecSetChannelDescEnType(vdecChannelDesc, enType), "aclvdecSetChannelDescEnType failed"); + CHECK_AND_BREAK(aclvdecSetChannelDescEnType(vdecChannelDesc, m_enType), "aclvdecSetChannelDescEnType failed"); CHECK_AND_BREAK(aclvdecSetChannelDescOutPicFormat(vdecChannelDesc, PIXEL_FORMAT_YUV_SEMIPLANAR_420), "aclvdecSetChannelDescOutPicFormat failed"); CHECK_AND_BREAK(aclvdecCreateChannel(vdecChannelDesc), "aclvdecCreateChannel failed"); - uint64_t frame_count = 0; - bool bBreak = false; - while (m_bRunning) - { - if (m_bPause){ - std::this_thread::sleep_for(std::chrono::milliseconds(3)); - continue; - } - int ret = sentFrame(vdecChannelDesc, frame_count); - if(ret == 2){ - bBreak = true; - break; - }else if(ret == 1){ - continue; - } - - frame_count++; - } + unsigned long long frame_nb = 0; + AVPacket* pkt = av_packet_alloc(); + av_init_packet( pkt ); + while (m_bRunning){ - // 尽量保证数据全部解码完成 - int sum = 0; - if(!bBreak){ - aclrtSetDevice(m_dvpp_deviceId); - aclrtSetCurrentContext(ctx); - while(m_pktQueue.size() > 0){ - int ret = sentFrame(vdecChannelDesc, frame_count); - if(ret == 2){ - break; + if (!m_bReal){ + if (m_bPause){ + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + continue; } - std::this_thread::sleep_for(std::chrono::milliseconds(3)); - sum++; - if(sum > 40){ - // 避免卡死 - break; + + // 非实时流，即为文件情形，因为不存在花屏问题，为保证不丢帧，这里做个循环等待 + m_decoded_data_queue_mtx.lock(); + if(m_decoded_data_queue.size() > 5){ + m_decoded_data_queue_mtx.unlock(); + std::this_thread::sleep_for(std::chrono::milliseconds(5)); + continue; + } + m_decoded_data_queue_mtx.unlock(); + + if(m_DvppCacheCounter.load() > m_cache_gop) { + // 解码器解码不过来 + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + continue; } + } else { + m_last_read_ts = get_cur_time_ms(); } - } - - sendVdecEos(vdecChannelDesc); - CHECK_NOT_RETURN(aclvdecDestroyChannel(vdecChannelDesc), "aclvdecDestroyChannel failed"); - }while(0); - - CHECK_NOT_RETURN(aclvdecDestroyChannelDesc(vdecChannelDesc), "aclvdecDestroyChannelDesc failed"); + int result = av_read_frame(fmt_ctx, pkt); + if (result == AVERROR_EOF || result < 0){ + av_packet_unref(pkt); + LOG_WARN("[{}]- Failed to read frame!", m_dec_name); + break; + } - // report_thread 需后于destroy退出 - m_bRunning = false; - m_bExitReportThd = true; - CHECK_NOT_RETURN(pthread_join(report_thread, nullptr), "pthread_join failed"); - - // 最后清理一遍未解码的数据 - m_vdecQueue_mutex.lock(); - if(m_vdecQueue.size() > 0){ - void* inputData = m_vdecQueue.front(); - acldvppFree(inputData); - inputData = nullptr; - m_vdecQueue.pop(); - } - m_vdecQueue_mutex.unlock(); + if (m_bReal && m_DvppCacheCounter.load() > m_cache_gop){ + // 解码器解码不过来。实时流在此处的处理会导致花屏，这是由于解码器性能问题导致，无法避免 + // 实时流在这里处理是为了避免长时间不读取数据导致数据中断 + av_packet_unref(pkt); + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + continue; + } - release_dvpp(); + if (m_dec_keyframe && !(pkt->flags & AV_PKT_FLAG_KEY)) { + av_packet_unref(pkt); + continue; + } - ret = aclrtDestroyContext(ctx); - if(ret != ACL_ERROR_NONE){ - LOG_ERROR("aclrtDestroyContext failed !"); - } + if (video_index == pkt->stream_index){ - LOG_INFO("[{}]- decode thread exit.", m_dec_name); -} + ret = av_bsf_send_packet(h264bsfc, pkt); + if(ret < 0) { + LOG_ERROR("[{}]- av_bsf_send_packet error!", m_dec_name); + av_packet_unref(pkt); + continue; + } -#include -#include -#include + int nSended = -1; + while ((ret = av_bsf_receive_packet(h264bsfc, pkt)) == 0) { + if(!m_bRunning){ + break; + } + nSended = sendPkt(vdecChannelDesc, pkt, frame_nb); + } + frame_nb++; -static int nRecoder = 0; + if(nSended < 0) { + // 执行出错，强行结束整个任务 + m_bRunning=false; + break; + } + } + av_packet_unref(pkt); + } + av_packet_free(&pkt); + pkt = nullptr; -int DvppDecoder::sentFrame(aclvdecChannelDesc *vdecChannelDesc, uint64_t frame_count){ + } while (0); - // 此处需要判断 m_vdecQueue 队列长度，避免占用过多显存 - m_vdecQueue_mutex.lock(); - if(m_vdecQueue.size() > 20){ - m_vdecQueue_mutex.unlock(); - std::this_thread::sleep_for(std::chrono::milliseconds(2)); - return 1; - } - m_vdecQueue_mutex.unlock(); + if (vdecChannelDesc) { + sendVdecEos(vdecChannelDesc); - AVPacket * pkt = nullptr; - m_pktQueue_mutex.lock(); - if(m_pktQueue.size() <= 0){ - m_pktQueue_mutex.unlock(); - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - return 1; + CHECK_NOT_RETURN(aclvdecDestroyChannel(vdecChannelDesc), "aclvdecDestroyChannel failed"); + CHECK_NOT_RETURN(aclvdecDestroyChannelDesc(vdecChannelDesc), "aclvdecDestroyChannelDesc failed"); + vdecChannelDesc = nullptr; } - pkt = m_pktQueue.front(); - m_pktQueue.pop(); - m_pktQueue_mutex.unlock(); - - // 解码 - void *vdecInputbuf = nullptr; - int ret = acldvppMalloc((void **)&vdecInputbuf, g_pkt_size); - if(ACL_ERROR_NONE != ret){ - LOG_ERROR("[{}]- acldvppMalloc failed!, ret:{}", m_dec_name, ret); - av_packet_free(&pkt); - pkt = nullptr; - return 2; + + m_bExitReportThd = true; + CHECK_NOT_RETURN(pthread_join(report_thread, nullptr), "report_thread join failed"); + + while(m_bRunning && m_decoded_data_queue.size() > 0) { + std::this_thread::sleep_for(std::chrono::milliseconds(5)); } - // std::ofstream outfile; - // string file_name = "./pkt/pkt"; - // file_name = file_name + to_string(nRecoder) + ".bin"; - // outfile.open(file_name.c_str(), std::ios::binary | std::ios::app); - // if (!outfile) { - // std::cerr << "Failed to open file!" << std::endl; - // return 2; - // } - - // outfile.write((const char*)pkt->data, pkt->size); - // outfile.close(); + m_bRunning=false; - // nRecoder ++ ; - // if(nRecoder >= 1000){ - - // return 2; - // } + m_bExitDisplayThd = true; + display_thread.join(); + release_ffmpeg(); + release_dvpp(); + m_bFinished = true; - ret = aclrtMemcpy(vdecInputbuf, pkt->size, pkt->data, pkt->size, ACL_MEMCPY_HOST_TO_DEVICE); - if(ACL_ERROR_NONE != ret){ - LOG_ERROR("[{}]- aclrtMemcpy failed", m_dec_name); - av_packet_free(&pkt); - pkt = nullptr; - return 2; - } + LOG_INFO("[{}]- read thread exit.", m_dec_name); - void *vdecOutputBuf = nullptr; - ret = acldvppMalloc((void **)&vdecOutputBuf, m_vdec_out_size); - if(ret != ACL_ERROR_NONE){ - LOG_ERROR("[{}]- acldvppMalloc failed", m_dec_name); - av_packet_free(&pkt); - pkt = nullptr; - return 2; + if(decode_finished_cbk) { + decode_finished_cbk(m_finishedDecArg); } +} + +int DvppDecoder::sendPkt(aclvdecChannelDesc *vdecChannelDesc, AVPacket* pkt, unsigned long long frame_nb){ + void *vdecInputbuf = nullptr; + void *vdecOutputBuf = nullptr; acldvppStreamDesc *input_stream_desc = nullptr; acldvppPicDesc *output_pic_desc = nullptr; do{ + int ret = acldvppMalloc((void **)&vdecInputbuf, pkt->size); + if(ACL_ERROR_NONE != ret){ + LOG_ERROR("[{}]- acldvppMalloc failed!, ret:{}", m_dec_name, ret); + break; + } + + ret = aclrtMemcpy(vdecInputbuf, pkt->size, pkt->data, pkt->size, ACL_MEMCPY_HOST_TO_DEVICE); + if(ACL_ERROR_NONE != ret){ + LOG_ERROR("[{}]- aclrtMemcpy failed", m_dec_name); + break; + } + + ret = acldvppMalloc((void **)&vdecOutputBuf, m_vdec_out_size); + if(ret != ACL_ERROR_NONE){ + LOG_ERROR("[{}]- acldvppMalloc failed", m_dec_name); + break; + } + input_stream_desc = acldvppCreateStreamDesc(); if (input_stream_desc == nullptr) { LOG_ERROR("[{}]- acldvppCreateStreamDesc failed", m_dec_name); @@ -784,49 +689,178 @@ int DvppDecoder::sentFrame(aclvdecChannelDesc *vdecChannelDesc, uint64_t frame_c CHECK_AND_BREAK(acldvppSetStreamDescSize(input_stream_desc, pkt->size), "acldvppSetStreamDescSize failed"); CHECK_AND_BREAK(acldvppSetPicDescData(output_pic_desc, vdecOutputBuf), "acldvppSetPicDescData failed"); CHECK_AND_BREAK(acldvppSetPicDescSize(output_pic_desc, m_vdec_out_size), "acldvppSetPicDescSize failed"); + CHECK_AND_BREAK(acldvppSetPicDescRetCode(output_pic_desc, 0), "acldvppSetPicDescRetCode failed"); Vdec_CallBack_UserData *user_data = NULL; user_data = new Vdec_CallBack_UserData; - user_data->frameId = frame_count; + user_data->frameId = frame_nb; + user_data->frame_nb = frame_nb; // user_data->startTime = startTime; user_data->sendTime = UtilTools::get_cur_time_ms(); user_data->self = this; + + m_in_count++; + + // 内部缓存计数加1 + m_DvppCacheCounter++; ret = aclvdecSendFrame(vdecChannelDesc, input_stream_desc, output_pic_desc, nullptr, reinterpret_cast(user_data)); - av_packet_free(&pkt); - pkt = nullptr; if(ret != ACL_ERROR_NONE){ + LOG_ERROR("[{}]- aclvdecSendFrame failed", m_dec_name); delete user_data; user_data = nullptr; - LOG_ERROR("[{}]- aclvdecSendFrame failed", m_dec_name); - break; + return -2; } - m_vdecQueue_mutex.lock(); - m_vdecQueue.push(vdecInputbuf); - m_vdecQueue_mutex.unlock(); - return 0; }while (0); - if(pkt != nullptr){ - av_packet_free(&pkt); - pkt = nullptr; + if (vdecInputbuf){ + acldvppFree(vdecInputbuf); + vdecInputbuf = nullptr; } // 报错情形 if(input_stream_desc){ CHECK_NOT_RETURN(acldvppDestroyStreamDesc(input_stream_desc), "acldvppDestroyStreamDesc failed"); } - if(output_pic_desc){ - CHECK_NOT_RETURN(acldvppDestroyPicDesc(output_pic_desc), "acldvppDestroyPicDesc failed"); - } if (vdecOutputBuf){ acldvppFree(vdecOutputBuf); vdecOutputBuf = nullptr; } - return 1; + if(output_pic_desc){ + CHECK_NOT_RETURN(acldvppDestroyPicDesc(output_pic_desc), "acldvppDestroyPicDesc failed"); + } + + return -1; +} + +void DvppDecoder::doProcessReport(){ + + aclError ret = aclrtSetDevice(m_dvpp_deviceId); + if(ret != ACL_ERROR_NONE){ + LOG_ERROR("[{}]-aclrtSetDevice failed !", m_dec_name); + return; + } + + while (!m_bExitReportThd) { + aclrtProcessReport(1000); + } + + ret = aclrtResetDevice(m_dvpp_deviceId); + if(ret != ACL_ERROR_NONE){ + LOG_ERROR("aclrtDestroyContext failed !"); + } + LOG_INFO("doProcessReport exit."); +} + +void DvppDecoder::doVdppVdecCallBack(acldvppStreamDesc *input, acldvppPicDesc *output, void *pUserData){ + + // 内部缓存计数减1 + m_DvppCacheCounter--; + + CHECK_AND_RETURN_NOVALUE(aclrtSetCurrentContext(m_context), "aclrtSetCurrentContext failed"); + + void *inputDataDev = acldvppGetStreamDescData(input); + acldvppFree(inputDataDev); + inputDataDev = nullptr; + + if(nullptr == pUserData){ + return; + } + + Vdec_CallBack_UserData *userData = (Vdec_CallBack_UserData *) pUserData; + uint64_t frame_nb = userData->frame_nb; + + m_out_count++; + + void *outputDataDev = acldvppGetPicDescData(output); + uint32_t outputSize = acldvppGetPicDescSize(output); + uint32_t width = acldvppGetPicDescWidth(output); + uint32_t width_stride = acldvppGetPicDescWidthStride(output); + uint32_t height = acldvppGetPicDescHeight(output); + uint32_t height_stride = acldvppGetPicDescHeightStride(output); + + do{ + int ret = acldvppGetPicDescRetCode(output); + if(ret != ACL_ERROR_NONE){ + LOG_ERROR("[{}]- decode result error, retCode:{} ", m_dec_name, ret); + acldvppFree(outputDataDev); + outputDataDev = nullptr; + break; + } + + if (m_bReal) { + // 实时流缓存长度大于25时做丢帧处理 + m_decoded_data_queue_mtx.lock(); + if(m_decoded_data_queue.size() >= 25){ + m_decoded_data_queue_mtx.unlock(); + LOG_WARN("[{}]- m_decoded_data_queue >= 25 ", m_dec_name); + acldvppFree(outputDataDev); + outputDataDev = nullptr; + break; + } + m_decoded_data_queue_mtx.unlock(); + } + + bool bCached = false; + if(width > 0 && height > 0 && outputSize > 0){ + + if (!m_bReal) { + while(!m_bExitReportThd) { + // 非实时流，即为文件情形，因为不存在花屏问题，为保证不丢帧，这里做个循环等待 + m_decoded_data_queue_mtx.lock(); + if(m_decoded_data_queue.size() >= 5){ + m_decoded_data_queue_mtx.unlock(); + std::this_thread::sleep_for(std::chrono::milliseconds(5)); + continue; + } + m_decoded_data_queue_mtx.unlock(); + break; + } + } + + // cout << m_dec_name << " 解码时间间隔： " << get_cur_time_ms() - last_ts << endl; + // last_ts = get_cur_time_ms(); + + // 换成解码后数据， 这里这样做的是为了保证解码一直持续进行，避免后续操作阻碍文件读取和解码从而导致花屏 + DvppDataMemory* mem = nullptr; + if (m_bResize && (width > 1920 || height > 1080)) { + + mem = m_vpcUtils.resize(output, out_frame_width, out_frame_height); + CHECK_AND_RETURN_NOVALUE(aclrtSetCurrentContext(m_context), "aclrtSetCurrentContext failed"); + if (mem) { + acldvppFree(outputDataDev); + outputDataDev = nullptr; + + mem->setDeviceId(to_string(m_dvpp_deviceId)); + mem->setId(m_dec_name); + mem->setFrameNb(frame_nb); + } + } else { + mem = new DvppDataMemory(width, width_stride, height, height_stride, outputSize, m_dec_name, to_string(m_dvpp_deviceId), false, frame_nb, (unsigned char *)outputDataDev); + } + + if(mem){ + m_decoded_data_queue.push(mem); + bCached = true; + } else { + // 逻辑完善 + delete mem; + mem = nullptr; + } + } + + if(!bCached) { + LOG_WARN("[{}]- decode result warning, width:{} width_stride:{} height:{} height_stride:{} size:{}", m_dec_name, width, width_stride, height, height_stride, outputSize); + acldvppFree(outputDataDev); + outputDataDev = nullptr; + } + }while(0); + + CHECK_AND_RETURN_NOVALUE(acldvppDestroyStreamDesc(input), "acldvppDestroyStreamDesc failed"); + CHECK_AND_RETURN_NOVALUE(acldvppDestroyPicDesc(output), "acldvppDestroyPicDesc failed"); } bool DvppDecoder::sendVdecEos(aclvdecChannelDesc *vdecChannelDesc) { @@ -855,14 +889,60 @@ bool DvppDecoder::sendVdecEos(aclvdecChannelDesc *vdecChannelDesc) { return true; } +void DvppDecoder::display_thread() { + LOG_INFO("[{}]- display_thread start...", m_dec_name); + unsigned long index = 0; + while(!m_bExitDisplayThd) { + m_decoded_data_queue_mtx.lock(); + if(m_decoded_data_queue.size() <= 0) { + m_decoded_data_queue_mtx.unlock(); + std::this_thread::sleep_for(std::chrono::milliseconds(5)); + continue; + } + + DvppDataMemory* mem = m_decoded_data_queue.front(); + m_decoded_data_queue.pop(); + m_decoded_data_queue_mtx.unlock(); + + if (mem) { + if ((m_frameSkip == 1 || index % m_frameSkip == 0) && post_decoded_cbk){ + post_decoded_cbk(m_postDecArg, mem); + } else { + delete mem; + mem = nullptr; + } + } + + index++; + if(index >= 100000){ + index = 0; + } + } + + m_decoded_data_queue_mtx.lock(); + while (m_decoded_data_queue.size() > 0){ + DvppDataMemory* mem = m_decoded_data_queue.front(); + m_decoded_data_queue.pop(); + delete mem; + mem = nullptr; + } + m_decoded_data_queue_mtx.unlock(); + + LOG_INFO("[{}]- display_thread exit.", m_dec_name); +} + void DvppDecoder::release_dvpp(){ if(m_context){ aclError ret = aclrtDestroyContext(m_context); if(ret != ACL_ERROR_NONE){ LOG_ERROR("[{}]- aclrtDestroyContext failed !", m_dec_name); } + m_context = nullptr; } - DvppSourceManager* pSrcMgr = DvppSourceManager::getInstance(); - pSrcMgr->releaseChannel(m_dvpp_deviceId, m_dvpp_channel); + if(m_dvpp_channel >= 0){ + DvppSourceManager* pSrcMgr = DvppSourceManager::getInstance(); + pSrcMgr->releaseChannel(m_dvpp_deviceId, m_dvpp_channel); + m_dvpp_channel = -1; + } } \ No newline at end of file diff --git a/src/decoder/dvpp/DvppDecoder.h b/src/decoder/dvpp/DvppDecoder.h index 5fb483f..6a5acd4 100644 --- a/src/decoder/dvpp/DvppDecoder.h +++ b/src/decoder/dvpp/DvppDecoder.h @@ -6,14 +6,18 @@ #include #include -#include +#include +#include +#include +#include "VpcUtils.h" using namespace std; typedef void(*RECEIVER_FINISHED_CALLBACK)(const void* userPtr); -const int g_pkt_size = 1024 * 1024; // 单个AVPacket大小的最大值 + +struct Vdec_CallBack_UserData; class DvppDecoder{ public: @@ -31,6 +35,7 @@ public: bool isFinished(); bool isPausing(); bool getResolution( int &width, int &height ); + bool getOutResolution( int &width, int &height ); bool isSurport(FFDecConfig& cfg); @@ -52,34 +57,41 @@ public: int getCachedQueueLength(); public: - void doVdppVdecCallBack(acldvppStreamDesc *input, acldvppPicDesc *output); + void doVdppVdecCallBack(acldvppStreamDesc *input, acldvppPicDesc *output, void *pUserData); void doProcessReport(); + long long get_last_read_ts(); private: AVCodecContext* init_FFmpeg(FFDecConfig config); - bool init_vdpp(FFDecConfig cfg, AVCodecContext* avctx); + bool init_dvpp(FFDecConfig cfg); void release_ffmpeg(); void read_thread(); - void decode_thread(); - int sentFrame(aclvdecChannelDesc *vdecChannelDesc, uint64_t frame_count); + int sendPkt(aclvdecChannelDesc *vdecChannelDesc, AVPacket* pkt, unsigned long long frame_nb); bool sendVdecEos(aclvdecChannelDesc *vdecChannelDesc); void release_dvpp(); + void display_thread(); + + int getVdecType(int videoType, int profile); + + void calcOutResolution(int w, int h); + private: FFDecConfig m_cfg; string m_dec_name; - const void * m_finishedDecArg; - DECODE_FINISHED_CALLBACK decode_finished_cbk; + const void * m_finishedDecArg {nullptr}; + DECODE_FINISHED_CALLBACK decode_finished_cbk {nullptr}; bool m_bFinished{false}; bool m_bRunning{false}; bool m_bPause{false}; + bool m_bExitReportThd{false}; + bool m_bExitDisplayThd{false}; // 读取数据 - AVStream* stream{nullptr}; int video_index{-1}; AVFormatContext *fmt_ctx{nullptr}; AVPixelFormat pix_fmt; @@ -88,36 +100,41 @@ private: int frame_width{0}; int frame_height{0}; - bool m_bReal; // 是否实时流 + int out_frame_width{0}; + int out_frame_height{0}; + bool m_bReal {false}; // 是否实时流 float m_fps{0.0}; - RECEIVER_FINISHED_CALLBACK receiver_finished_cbk; - - pthread_t m_read_thread{0}; - - bool m_dec_keyframe; + std::thread* m_read_thread{nullptr}; - mutex m_pktQueue_mutex; - queue m_pktQueue; + bool m_dec_keyframe {false}; + bool m_bResize {false}; // 解码 int m_dvpp_deviceId {-1}; int m_dvpp_channel {-1}; aclrtContext m_context{nullptr}; - acldvppStreamFormat enType; + acldvppStreamFormat m_enType; - pthread_t m_decode_thread{0}; - mutex m_vdecQueue_mutex; - queue m_vdecQueue; - - const void * m_postDecArg; - POST_DECODE_CALLBACK post_decoded_cbk; + const void * m_postDecArg {nullptr}; + POST_DECODE_CALLBACK post_decoded_cbk {nullptr}; int m_vdec_out_size {-1}; - // 截图 - bool m_bSnapShoting{false}; - DvppDataMemory* m_cached_mem{nullptr}; - mutex m_cached_mutex; - condition_variable m_cached_cond; + queue m_decoded_data_queue; + mutex m_decoded_data_queue_mtx; + + long long last_ts {0}; + + long long m_last_read_ts {0}; + + uint64_t m_in_count {0}; + uint64_t m_out_count {0}; + + int m_frameSkip {1}; + + std::atomic m_DvppCacheCounter{0}; + int m_cache_gop{0}; + + VpcUtils m_vpcUtils; }; \ No newline at end of file diff --git a/src/decoder/dvpp/VpcPicConverter.cpp b/src/decoder/dvpp/VpcPicConverter.cpp deleted file mode 100644 index 136506a..0000000 --- a/src/decoder/dvpp/VpcPicConverter.cpp +++ /dev/null @@ -1,79 +0,0 @@ -#include "VpcPicConverter.h" -#include "depend_headers.h" - -#define ALIGN_UP(val, align) (((val) % (align) == 0) ? (val) : (((val) / (align) + 1) * (align))) - -VpcPicConverter::VpcPicConverter(){ - -} - -VpcPicConverter::~VpcPicConverter(){ - if(nullptr == stream_){ - aclrtDestroyStream(stream_); - } -} - -int VpcPicConverter::init(aclrtContext context, string dec_name){ - - m_dec_name = dec_name; - - CHECK_AND_RETURN(aclrtSetCurrentContext(context), "aclrtSetCurrentContext failed"); - CHECK_AND_RETURN(aclrtCreateStream(&stream_), "aclrtCreateStream failed! "); - - dvppChannelDesc_ = acldvppCreateChannelDesc(); - - int ret = ACL_ERROR_NONE; - do - { - ret = acldvppCreateChannel(dvppChannelDesc_); - CHECK_AND_BREAK(ret, "acldvppCreateChannel failed !"); - - ret = acldvppSetChannelDescMode(dvppChannelDesc_, DVPP_CHNMODE_VPC); - CHECK_AND_BREAK(ret, "acldvppSetChannelDescMode failed !"); - } while (0); - - return ret; -} - -DvppDataMemory* VpcPicConverter::convert2bgr(acldvppPicDesc *inputDesc_, int out_width, int out_height, bool key_frame){ - - int out_buf_width = ALIGN_UP(out_width, 16) * 3; - int out_buf_height = ALIGN_UP(out_height, 2); - int out_buf_size = out_buf_width * out_buf_height; - - DvppDataMemory* rgbMem = new DvppDataMemory(3, out_buf_width, out_buf_width, out_buf_height, out_buf_height, out_buf_size, "", to_string(m_devId), key_frame); - void *outBufferDev_ = (void*)rgbMem->getMem(); - - acldvppPicDesc *outputDesc_= acldvppCreatePicDesc(); - acldvppSetPicDescData(outputDesc_, outBufferDev_); - acldvppSetPicDescFormat(outputDesc_, PIXEL_FORMAT_BGR_888); - acldvppSetPicDescWidth(outputDesc_, out_width); - acldvppSetPicDescHeight(outputDesc_, out_height); - acldvppSetPicDescWidthStride(outputDesc_, out_buf_width); - acldvppSetPicDescHeightStride(outputDesc_, out_buf_height); - acldvppSetPicDescSize(outputDesc_, out_buf_size); - - aclError ret = ACL_ERROR_NONE; - do{ - // 9. 执行异步色域转换，再调用aclrtSynchronizeStream接口阻塞程序运行，直到指定Stream中的所有任务都完成 - ret = acldvppVpcConvertColorAsync(dvppChannelDesc_, inputDesc_, outputDesc_, stream_); - if(ret != ACL_ERROR_NONE){ - LOG_ERROR("acldvppVpcConvertColorAsync failed - out_width:{} out_height:{} out_buf_width:{} out_buf_height:{} out_buf_size:{}", out_width, out_height, out_buf_width, out_buf_height, out_buf_size); - break; - } - ret = aclrtSynchronizeStream(stream_); - if(ret != ACL_ERROR_NONE){ - LOG_ERROR("aclrtSynchronizeStream failed - out_width:{} out_height:{} out_buf_width:{} out_buf_height:{} out_buf_size:{}", out_width, out_height, out_buf_width, out_buf_height, out_buf_size); - break; - } - }while(0); - - acldvppDestroyPicDesc(outputDesc_); - - if(ret != ACL_ERROR_NONE){ - delete rgbMem; - rgbMem = nullptr; - } - - return rgbMem; -} \ No newline at end of file diff --git a/src/decoder/interface/DeviceMemory.hpp b/src/decoder/interface/DeviceMemory.hpp index 63420ae..a5b913c 100644 --- a/src/decoder/interface/DeviceMemory.hpp +++ b/src/decoder/interface/DeviceMemory.hpp @@ -10,7 +10,7 @@ using namespace std; class DeviceMemory{ public: - DeviceMemory(int _channel, int _width, int _width_stride, int _height, int _height_stride, string _id, string _dev_id, bool _key_frame, bool _isused){ + DeviceMemory(int _channel, int _width, int _width_stride, int _height, int _height_stride, string _id, string _dev_id, bool _key_frame, unsigned long long _frame_nb, bool _isused){ channel = _channel; width = _width; width_stride = _width_stride; @@ -21,14 +21,19 @@ public: id = _id; device_id = _dev_id; key_frame = _key_frame; + frame_nb = _frame_nb; timestamp = UtilTools::get_cur_time_ms(); } virtual ~DeviceMemory(){} - + int getSize() { return data_size; } + + void setSize(int size) { + data_size = size; + } bool isIsused() { return isused; @@ -44,42 +49,90 @@ public: return id; } + void setId(string _id) { + id = _id; + } + string getDeviceId() { return device_id; } + void setDeviceId(string _device_id) { + device_id = _device_id; + } + unsigned char* getMem(){ return pHwRgb; } + void setMem(unsigned char* _pHwRgb) { + pHwRgb = _pHwRgb; + } + long long getTimesstamp(){ return timestamp; } + void setTimesstamp(long long _timestamp) { + timestamp = _timestamp; + } + int getWidth(){ return width; } + void setWidth(int _width) { + width = _width; + } + int getWidthStride(){ return width_stride; } + void setWidthStride(int _width_stride) { + width_stride = _width_stride; + } + int getHeight(){ return height; } + void setHeight(int _height) { + height = _height; + } + int getHeightStride(){ return height_stride; } + void setHeightStride(int _height_stride) { + height_stride = _height_stride; + } + int getChannel(){ return channel; } + void setChannel(int _channel) { + channel = _channel; + } + bool isKeyFrame(){ return key_frame; } + void setKeyFrame(bool _key_frame) { + key_frame = _key_frame; + } + + unsigned long long getFrameNb() { + return frame_nb; + } + + void setFrameNb(unsigned long long _frame_nb) { + frame_nb = _frame_nb; + } + public: int data_size; bool isused; @@ -94,6 +147,7 @@ public: int channel{3}; bool key_frame; long index; + unsigned long long frame_nb; }; #endif \ No newline at end of file diff --git a/src/decoder/interface/interface_headers.h b/src/decoder/interface/interface_headers.h index 7c01669..7d50257 100644 --- a/src/decoder/interface/interface_headers.h +++ b/src/decoder/interface/interface_headers.h @@ -35,6 +35,7 @@ struct FFDecConfig{ bool force_tcp{true}; // 是否指定使用tcp连接 int skip_frame{1}; // 跳帧数 string dec_name; + bool resize{false}; // 是否resize到1920,1080 int port; // gb28181接收数据的端口号 DECODE_REQUEST_STREAM_CALLBACK request_stream_cbk; // gb28181请求流 @@ -43,7 +44,8 @@ struct FFDecConfig{ enum DECODER_TYPE{ DECODER_TYPE_GB28181, DECODER_TYPE_FFMPEG, - DECODER_TYPE_DVPP + DECODER_TYPE_DVPP, + DECODER_TYPE_DVPP_GB28181 }; #endif \ No newline at end of file diff --git a/src/demo/demo.cpp b/src/demo/demo.cpp index 87a18d1..b3174ba 100644 --- a/src/demo/demo.cpp +++ b/src/demo/demo.cpp @@ -1,8 +1,67 @@ #include "../ai_platform/stl_aiplatform.h" #include +#include +#include +#include +#include +#include using namespace std; +#ifdef POST_USE_RABBITMQ + +void init_mq_conn(void *handle) { + for (auto key : {mq_type_t::ALARM_MQ, mq_type_t::GET_TASK_MQ, mq_type_t::HEART_BEAT_MQ, mq_type_t::SCREENSHORT_TASK_MQ, mq_type_t::TIMING_SCREENSHORT_TASK_MQ}) { + rabbitmq_conn_params_t mq_conn_params; + mq_conn_params.port = 5672; + + strcpy(mq_conn_params.ip, "192.168.60.126"); + strcpy(mq_conn_params.uname, "admin"); + strcpy(mq_conn_params.passwd, "123456"); + strcpy(mq_conn_params.vhost, "/"); + strcpy(mq_conn_params.exchange, "topExchange"); + strcpy(mq_conn_params.exchange_type, "topic"); + + // mq_conn_params.port = 5673; + // strcpy(mq_conn_params.ip, "192.168.10.187"); + // strcpy(mq_conn_params.uname, "admin"); + // strcpy(mq_conn_params.passwd, "admin123456"); + // strcpy(mq_conn_params.vhost, "/"); + // strcpy(mq_conn_params.exchange, "topExchange"); + // strcpy(mq_conn_params.exchange_type, "topic"); + + switch (key) { + case mq_type_t::ALARM_MQ: { + strcpy(mq_conn_params.queue, "topic.queue.alarm"); + strcpy(mq_conn_params.routing_key, "topic.queue.alarm.key"); + } break; + case mq_type_t::GET_TASK_MQ: { + strcpy(mq_conn_params.queue, "tsl.test.queue.get"); + strcpy(mq_conn_params.routing_key, "tsl.test.queue.get.key"); + } break; + case mq_type_t::HEART_BEAT_MQ: { + strcpy(mq_conn_params.queue, "tsl.test.queue.hb"); + strcpy(mq_conn_params.routing_key, "tsl.test.queue.hb.key"); + } break; + case mq_type_t::SCREENSHORT_TASK_MQ: { + strcpy(mq_conn_params.queue, "video.screenshort.queue.get"); + strcpy(mq_conn_params.routing_key, "video.screenshort.queue.key"); + } break; + case mq_type_t::TIMING_SCREENSHORT_TASK_MQ: { + strcpy(mq_conn_params.queue, "video.timingscreenshort.queue.get"); + strcpy(mq_conn_params.routing_key, "video.timingscreenshort.queue.key"); + } break; + } + + mq_conn_params.durable_exchange = true; + mq_conn_params.durable_queue = true; + + if (0 != add_mq_conn(handle, key, mq_conn_params)) // 队列走接口创建 + fprintf(stderr, "ip is %s port is %d\n", mq_conn_params.ip, mq_conn_params.port); + } +} + +#endif // #ifdef POST_USE_RABBITMQ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_type_t &algor_type) { auto algor_init_params = new algor_init_config_param_t; @@ -10,15 +69,19 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty case algorithm_type_t::FACE_SNAPSHOT: { auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; - basic_params->result_folder = "res/face"; - ; basic_params->result_folder_little = "res/face_little"; - ; + + //共性算法适配测试用 + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; } auto algor_params = new algor_config_param_snapshot; { algor_params->threshold = 0.5f; } @@ -30,13 +93,19 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty case algorithm_type_t::HUMAN_SNAPSHOT: { auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; - basic_params->result_folder = "res/human"; basic_params->result_folder_little = "res/human_little"; + + //共性算法适配测试用 + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; } auto algor_params = new algor_config_param_snapshot; { algor_params->threshold = 0.5f; } @@ -47,17 +116,27 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty case algorithm_type_t::PEDESTRIAN_FALL: { auto algor_params = new algor_config_param_pedestrian_fall; - { algor_params->threshold = 0.7f; } + { + algor_params->threshold = 0.85f; + algor_params->pedestrian_min_width = 20; + algor_params->pedestrian_min_height = 20; + algor_params->pedestrian_confidence_threshold = 0.85; + } auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; - basic_params->result_folder = "res/fall"; basic_params->result_folder_little = "res/fall_little"; + + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 0; adapt_params->points[0].y_ = 0; + adapt_params->points[1].x_ = 1920; adapt_params->points[1].y_ = 0; + adapt_params->points[2].x_ = 1920; adapt_params->points[2].y_ = 1080; + adapt_params->points[3].x_ = 0; adapt_params->points[3].y_ = 1080; + } + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -67,19 +146,26 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty case algorithm_type_t::PEDESTRIAN_FIGHT: { auto algor_params = new algor_config_param_pedestrian_fight; { - algor_params->threshold = 0.7f; - algor_params->iou_threshold = 0.1f; + algor_params->threshold = 0.85f; + algor_params->pedestrian_min_width = 20; + algor_params->pedestrian_min_height = 20; + algor_params->pedestrian_confidence_threshold = 0.85; } auto basic_params = new algor_basic_config_param_t; { - - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/fight"; basic_params->result_folder_little = "res/fight_little"; + + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 0; adapt_params->points[0].y_ = 0; + adapt_params->points[1].x_ = 1920; adapt_params->points[1].y_ = 0; + adapt_params->points[2].x_ = 1920; adapt_params->points[2].y_ = 1080; + adapt_params->points[3].x_ = 0; adapt_params->points[3].y_ = 1080; + } + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -90,19 +176,111 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto algor_params = new algor_config_param_human_gather; { - algor_params->frame_stride = 1; - // algor_params->human_count_threshold = 3; - algor_params->human_count_threshold = 1; + algor_params->frame_stride = 3; + algor_params->human_count_threshold = 3; } auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/gather"; basic_params->result_folder_little = "res/gather_little"; + + //共性算法适配测试用 + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + + case algorithm_type_t::HUMAN_REGION_GATHER: { + + auto algor_params = new algor_config_param_human_gather; + { + algor_params->frame_stride = 3; + algor_params->human_count_threshold = 3; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/region_gather"; + basic_params->result_folder_little = "res/region_gather_little"; + + //共性算法适配测试用 + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + + case algorithm_type_t::HUMAN_DENSITY: { + + auto algor_params = new algor_config_param_human_gather; + { + algor_params->frame_stride = 3; + algor_params->human_count_threshold = 3; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/human_density"; + basic_params->result_folder_little = "res/human_density_little"; + + //共性算法适配测试用 + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + + case algorithm_type_t::VEHICLE_GATHER: { + + auto algor_params = new algor_config_param_human_gather; + { + algor_params->frame_stride = 3; + algor_params->human_count_threshold = 1; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/vehicle_gather"; + basic_params->result_folder_little = "res/vehicle_gather_little"; + + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -122,12 +300,11 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/no_reflective_clothing"; basic_params->result_folder_little = "res/no_reflective_clothing_little"; + + auto adapt_params = new universal_algor_adapt_param; + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -147,12 +324,11 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/no_safety_helmet"; basic_params->result_folder_little = "res/no_safety_helmet_little"; + + auto adapt_params = new universal_algor_adapt_param; + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -172,12 +348,11 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/call_phone"; basic_params->result_folder_little = "res/call_phone_little"; + + auto adapt_params = new universal_algor_adapt_param; + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -197,12 +372,11 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/smoking"; basic_params->result_folder_little = "res/smoking_little"; + + auto adapt_params = new universal_algor_adapt_param; + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -213,18 +387,25 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/vehicle"; basic_params->result_folder_little = "res/vehicle_little"; + + //共性算法适配测试用 + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; } - auto algor_params = new algor_config_param_snapshot; - algor_params->threshold = 0.5f; - algor_params->snap_frame_interval = 5; - + { + algor_params->threshold = 0.5f; + algor_params->snap_frame_interval = 1; + } algor_init_params->algor_param = algor_params; algor_init_params->basic_param = basic_params; } break; @@ -233,12 +414,18 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/nonmotor"; basic_params->result_folder_little = "res/nonmotor_little"; + + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; } auto algor_params = new algor_config_param_snapshot; @@ -247,6 +434,7 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty algor_init_params->algor_param = algor_params; algor_init_params->basic_param = basic_params; } break; + case algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION: { auto algor_params = new algor_config_param_takeaway_member_classification; @@ -258,12 +446,11 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/takeaway"; basic_params->result_folder_little = "res/takeaway_little"; + + auto adapt_params = new universal_algor_adapt_param; + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -288,12 +475,11 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/pedestrian_retrograde"; basic_params->result_folder_little = "res/pedestrian_retrograde_little"; + + auto adapt_params = new universal_algor_adapt_param; + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -319,13 +505,10 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/vehicle_retrograde"; basic_params->result_folder_little = "res/vehicle_retrograde_little"; + auto adapt_params = new universal_algor_adapt_param; + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -338,31 +521,123 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto algor_params = new algor_config_param_pedestrian_trespass; { algor_params->conf_threshold = 0.5f; - algor_params->minmum_height = 64; - algor_params->minmum_width = 32; + algor_params->minmum_height = 20; + algor_params->minmum_width = 20; algor_params->points_count = 4; - algor_params->points[0].x_ = 200; - algor_params->points[0].y_ = 200; + algor_params->points[0].x_ = 505; + algor_params->points[0].y_ = 481; - algor_params->points[1].x_ = 600; - algor_params->points[1].y_ = 200; + algor_params->points[1].x_ = 741; + algor_params->points[1].y_ = 881; - algor_params->points[2].x_ = 600; - algor_params->points[2].y_ = 500; + algor_params->points[2].x_ = 1911; + algor_params->points[2].y_ = 667; - algor_params->points[3].x_ = 200; - algor_params->points[3].y_ = 500; + algor_params->points[3].x_ = 1484; + algor_params->points[3].y_ = 410; } auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/pedestrian_trespass"; basic_params->result_folder_little = "res/pedestrian_trespass_little"; + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 0; adapt_params->points[0].y_ = 0; + adapt_params->points[1].x_ = 1920; adapt_params->points[1].y_ = 0; + adapt_params->points[2].x_ = 1920; adapt_params->points[2].y_ = 1080; + adapt_params->points[3].x_ = 0; adapt_params->points[3].y_ = 1080; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + + } break; + + case algorithm_type_t::HUMAN_LEAVE_REGION: { + // 578 1300 600 + auto algor_params = new algor_config_param_trespass_basic; + { + algor_params->conf_threshold = 0.5f; + algor_params->minmum_height = 20; + algor_params->minmum_width = 20; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/human_region_leave"; + basic_params->result_folder_little = "res/human_region_leave_little"; + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + + } break; + + case algorithm_type_t::HUMAN_REGION_DISMISS: { + // 578 1300 600 + auto algor_params = new algor_config_param_trespass_basic; + { + algor_params->conf_threshold = 0.5f; + algor_params->minmum_height = 20; + algor_params->minmum_width = 20; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/human_region_dismiss"; + basic_params->result_folder_little = "res/human_region_dismiss_little"; + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + + } break; + + case algorithm_type_t::HUMAN_REGION_FAST_MOVING: { + // 578 1300 600 + auto algor_params = new algor_config_param_trespass_basic; + { + algor_params->conf_threshold = 0.5f; + algor_params->minmum_height = 20; + algor_params->minmum_width = 20; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/human_region_fastmoving"; + basic_params->result_folder_little = "res/human_region_fastmoving_little"; + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -375,31 +650,36 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto algor_params = new algor_config_param_vehicle_trespass; { algor_params->conf_threshold = 0.5f; - algor_params->minmum_height = 64; - algor_params->minmum_width = 64; - algor_params->points_count = 4; + algor_params->minmum_height = 20; + algor_params->minmum_width = 20; - algor_params->points[0].x_ = 500; - algor_params->points[0].y_ = 500; + algor_params->points_count = 4; + algor_params->points[0].x_ = 505; + algor_params->points[0].y_ = 481; - algor_params->points[1].x_ = 1500; - algor_params->points[1].y_ = 500; + algor_params->points[1].x_ = 741; + algor_params->points[1].y_ = 881; - algor_params->points[2].x_ = 1500; - algor_params->points[2].y_ = 900; + algor_params->points[2].x_ = 1911; + algor_params->points[2].y_ = 667; - algor_params->points[3].x_ = 500; - algor_params->points[3].y_ = 900; + algor_params->points[3].x_ = 1484; + algor_params->points[3].y_ = 410; } auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - basic_params->algor_valid_rect.width_ = 1920; - basic_params->algor_valid_rect.height_ = 1080; basic_params->result_folder = "res/vehicle_trespass"; basic_params->result_folder_little = "res/vehicle_trespass_little"; + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 0; adapt_params->points[0].y_ = 0; + adapt_params->points[1].x_ = 1920; adapt_params->points[1].y_ = 0; + adapt_params->points[2].x_ = 1920; adapt_params->points[2].y_ = 1080; + adapt_params->points[3].x_ = 0; adapt_params->points[3].y_ = 1080; + } + basic_params->adapt_param = adapt_params; } algor_init_params->algor_param = algor_params; @@ -426,12 +706,6 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty auto basic_params = new algor_basic_config_param_t; { - basic_params->algor_valid_rect.top_ = 0; - basic_params->algor_valid_rect.left_ = 0; - // basic_params->algor_valid_rect.width_ = 1920; - // basic_params->algor_valid_rect.height_ = 1080; - basic_params->algor_valid_rect.width_ = 2560; - basic_params->algor_valid_rect.height_ = 1440; basic_params->result_folder = "res/road_work"; basic_params->result_folder_little = "res/road_work_little"; } @@ -456,6 +730,155 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty algor_init_params->basic_param = basic_params; } break; + case algorithm_type_t::HUMAN_CROSSING_LINE: { + auto algor_params = new algor_config_param_illegal_crossing_line; + { + algor_params->p1.x_ = 827; + algor_params->p1.y_ = 321; + algor_params->p2.x_ = 1911; + algor_params->p2.y_ = 1072; + algor_params->conf_threshold = 0.6; + algor_params->minmum_width = 20; + algor_params->minmum_height = 20; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/human_cross_line"; + basic_params->result_folder_little = "res/human_cross_line_little"; + //共性算法适配测试用 + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 0; adapt_params->points[0].y_ = 0; + adapt_params->points[1].x_ = 1920; adapt_params->points[1].y_ = 0; + adapt_params->points[2].x_ = 1920; adapt_params->points[2].y_ = 1080; + adapt_params->points[3].x_ = 0; adapt_params->points[3].y_ = 1080; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + + case algorithm_type_t::HUMAN_CLIMB: { + auto algor_params = new algor_config_param_illegal_crossing_line; + { + algor_params->p1.x_ = 827; + algor_params->p1.y_ = 321; + algor_params->p2.x_ = 1911; + algor_params->p2.y_ = 1072; + algor_params->conf_threshold = 0.5; + algor_params->minmum_width = 20; + algor_params->minmum_height = 20; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/human_climb"; + basic_params->result_folder_little = "res/human_climb_little"; + + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 0; adapt_params->points[0].y_ = 0; + adapt_params->points[1].x_ = 1920; adapt_params->points[1].y_ = 0; + adapt_params->points[2].x_ = 1920; adapt_params->points[2].y_ = 1080; + adapt_params->points[3].x_ = 0; adapt_params->points[3].y_ = 1080; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + + case algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE: { + auto algor_params = new algor_config_param_illegal_crossing_line; + { + algor_params->p1.x_ = 827; + algor_params->p1.y_ = 321; + algor_params->p2.x_ = 1911; + algor_params->p2.y_ = 1072; + algor_params->minmum_width = 10; + algor_params->minmum_height = 10; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/vehicle_cross_line"; + basic_params->result_folder_little = "res/vehicle_cross_line_little"; + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 0; adapt_params->points[0].y_ = 0; + adapt_params->points[1].x_ = 1920; adapt_params->points[1].y_ = 0; + adapt_params->points[2].x_ = 1920; adapt_params->points[2].y_ = 1080; + adapt_params->points[3].x_ = 0; adapt_params->points[3].y_ = 1080; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + + case algorithm_type_t::HUMAN_LINGER: { + auto algor_params = new algor_config_param_behavior; + { + algor_params->duration = 50; //帧 + algor_params->minmum_width = 20; + algor_params->minmum_height = 20; + algor_params->conf_threshold = 0.5; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/human_linger"; + basic_params->result_folder_little = "res/human_linger_little"; + + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + case algorithm_type_t::VEHICLE_ILLEGAL_PARKING: { + auto algor_params = new algor_config_param_behavior; + { + algor_params->duration = 25; //帧 + algor_params->minmum_width = 10; + algor_params->minmum_height = 10; + } + + auto basic_params = new algor_basic_config_param_t; + { + basic_params->result_folder = "res/vehicle_parking"; + basic_params->result_folder_little = "res/vehicle_parking_little"; + auto adapt_params = new universal_algor_adapt_param; + { + adapt_params->points_count = 4; // 0表示不生效 + adapt_params->points[0].x_ = 505; adapt_params->points[0].y_ = 481; + adapt_params->points[1].x_ = 741; adapt_params->points[1].y_ = 881; + adapt_params->points[2].x_ = 1911; adapt_params->points[2].y_ = 667; + adapt_params->points[3].x_ = 1484; adapt_params->points[3].y_ = 410; + } + basic_params->adapt_param = adapt_params; + } + + algor_init_params->algor_param = algor_params; + algor_init_params->basic_param = basic_params; + } break; + default: { if (algor_init_params != nullptr) { delete algor_init_params; @@ -469,24 +892,148 @@ void set_task_params(task_param &tparam, const unsigned &idx, const algorithm_ty tparam.algor_config_params[idx].algor_init_config_param = algor_init_params; } + static long long get_cur_time(){ chrono::time_point tpMicro = chrono::time_point_cast(chrono::system_clock::now()); return tpMicro.time_since_epoch().count(); } -string createTask(void *handle, std::vector algor_vec, int gi){ +static int nTaskId = 0; + +string createTask(void *handle, std::vector algor_vec, int gi, bool bFlag = true){ task_param tparam; - // tparam.ipc_url = "rtsp://admin:ad123456@192.168.60.108:554/cam/realmonitor?channel=1&subtype=0"; - // tparam.ipc_url = "/data1/cmhu/data/bayue.mp4"; - tparam.ipc_url = "/data1/cmhu/data/Street.uvf"; - // tparam.ipc_url = "rtsp://admin:ad123456@192.168.60.165:554/cam/realmonitor?channel=1&subtype=0"; + + switch(gi){ + case 0: + tparam.ipc_url = "rtsp://admin:admin@123456@192.168.60.176:554/cam/realmonitor?channel=1&subtype=0"; + break; + case 1: + tparam.ipc_url = "rtsp://122.97.218.170:8604/openUrl/V5nXRHa?params=eyJwcm90b2NhbCI6InJ0c3AiLCJjbGllbnRUeXBlIjoib3Blbl9hcGkiLCJleHByaWVUaW1lIjotMSwicHJvdG9jb2wiOiJydHNwIiwiZXhwaXJlVGltZSI6MzAwLCJlbmFibGVNR0MiOnRydWUsImV4cGFuZCI6InN0YW5kYXJkPXJ0c3Amc3RyZWFtZm9ybT1ydHAiLCJhIjoiMTBjZjM4N2JjY2Y5NDg3YzhjNWYzNjE2M2ViMWUyNTJ8MXwwfDEiLCJ0IjoxfQ=="; + break; + case 2: + tparam.ipc_url = "rtsp://admin:ad123456@192.168.10.166:554/cam/realmonitor?channel=1&subtype=0"; + break; + case 3: + tparam.ipc_url = "rtsp://122.97.218.170:8604/openUrl/LBBYTra?params=eyJwcm90b2NhbCI6InJ0c3AiLCJjbGllbnRUeXBlIjoib3Blbl9hcGkiLCJleHByaWVUaW1lIjotMSwicHJvdG9jb2wiOiJydHNwIiwiZXhwaXJlVGltZSI6MzAwLCJlbmFibGVNR0MiOnRydWUsImV4cGFuZCI6InN0YW5kYXJkPXJ0c3Amc3RyZWFtZm9ybT1ydHAiLCJhIjoiOTgzYjRjMmUxMThlNGU1OTlkYThmMTI3NTkyMGViODV8MXwwfDEiLCJ0IjoxfQ=="; + // tparam.ipc_url = "rtsp://122.97.218.170:8604/openUrl/V5nXRHa?params=eyJwcm90b2NhbCI6InJ0c3AiLCJjbGllbnRUeXBlIjoib3Blbl9hcGkiLCJleHByaWVUaW1lIjotMSwicHJvdG9jb2wiOiJydHNwIiwiZXhwaXJlVGltZSI6MzAwLCJlbmFibGVNR0MiOnRydWUsImV4cGFuZCI6InN0YW5kYXJkPXJ0c3Amc3RyZWFtZm9ybT1ydHAiLCJhIjoiMTBjZjM4N2JjY2Y5NDg3YzhjNWYzNjE2M2ViMWUyNTJ8MXwwfDEiLCJ0IjoxfQ=="; + break; + case 4: + tparam.ipc_url = "/data/share/data/Street.uvf"; + break; + case 5: + tparam.ipc_url = "/data/share/data/公安局老桥头_CVR15F89410_1465819864_1B.mp4"; + break; + case 6: + tparam.ipc_url = "/data/share/data/不带头盔2.mp4"; + break; + case 7: + tparam.ipc_url = "/data/share/data/hczr1.mp4"; + break; + case 8: + tparam.ipc_url = "/data/share/data/燕高路口高点_CVR_2015-12-30_09-00-00_2015-12-30.mp4"; + break; + case 9: + // tparam.ipc_url = "/opt/share/data/1-00000002d55_h265.mp4"; + tparam.ipc_url = "/data/share/data/duan1.mp4"; + break; + case 10: + tparam.ipc_url = "/data/share/data/gs1-00000001.mp4"; + break; + case 11: + tparam.ipc_url = "/data/share/data/98.mp4"; + break; + case 12: + tparam.ipc_url = "/data/share/data/AV_12345_1_20230108110849847_D_1673147329847729.mp4"; + break; + case 13: + tparam.ipc_url = "/data/share/data/nx_1-00000002.mp4"; + break; + case 14: + tparam.ipc_url = "/data/share/data/nx1-0000001.mp4"; + break; + case 15: + tparam.ipc_url = "/data/share/data/nx1-00000002.mp4"; + break; + case 16: + tparam.ipc_url = "/data/share/data/Street.uvf"; + break; + case 17: + tparam.ipc_url = "/data/share/data/xiancun.mp4"; + break; + case 18: + tparam.ipc_url = "rtsp://192.168.60.146:8554/w_1_out"; + break; + case 19: + tparam.ipc_url = "/data/share/data/42_44.avi"; + break; + case 20: + tparam.ipc_url = "/data/share/data/37_70.avi"; + break; + case 21: + tparam.ipc_url = "/data/share/data/192_25.avi"; + break; + case 22: + tparam.ipc_url = "/data/share/data/31_4.avi"; + break; + case 23: + tparam.ipc_url = "/data/share/data/146_192.avi"; + break; + case 24: + tparam.ipc_url = "/data/share/data/146_187.mp4"; + break; + case 25: + // 公安内网 + tparam.ipc_url = "rtsp://192.168.51.200:8554/320202202308231001001002"; + break; + case 26: + // FFmpeg生成的解码错误数据流 + tparam.ipc_url = "rtsp://192.168.10.4:8554/street"; + break; + case 27: + tparam.ipc_url = "/data/share/data/Street_4k_265.mp4"; + break; + case 28: + tparam.ipc_url = "http://192.168.60.179:10016/公安局老桥头_CVR15F89410_1465819864_1B.mp4"; + break; + case 29: + tparam.ipc_url = "http://192.168.60.179:10016/不带头盔2.mp4"; + break; + case 30: + tparam.ipc_url = "/data/share/data/149_45.avi"; + break; + case 31: + tparam.ipc_url = "/data/share/data/146_88.avi"; + break; + case 32: + tparam.ipc_url = "/data/share/data/141_74.avi"; + break; + case 33: + tparam.ipc_url = "/data/share/data/human_gather.mp4"; + break; + case 34: + tparam.ipc_url = "/data/share/data/12.mp4"; + break; + case 35: + tparam.ipc_url = "/data/cmhu/data/铁路文化宫-门口1_20D40580_1607648331.avi"; + break; + default: + tparam.ipc_url = "/opt/share/data/Street.uvf"; + break; + } + tparam.algor_counts = algor_vec.size(); tparam.dec_type = 2; - std::string task_id_str = "test_task_id_" + std::to_string(gi); + if (bFlag){ + nTaskId = gi; + } + + std::string task_id_str = "test_task_id_" + std::to_string(nTaskId); tparam.task_id = task_id_str.c_str(); + nTaskId++; + tparam.algor_config_params = new algor_config_param[tparam.algor_counts]; for (size_t idx = 0; idx < algor_vec.size(); ++idx) @@ -496,13 +1043,151 @@ string createTask(void *handle, std::vector algor_vec, int gi) if (result_code != 0) printf("[Error]: "); printf("--- task_id: %s result code: %d\n", tparam.task_id, result_code); + + + // 释放参数 + for (size_t idx = 0; idx < algor_vec.size(); ++idx) { + if(tparam.algor_config_params[idx].algor_type == algorithm_type_t::VIDEO_TIMING_SNAPSHOT) { + algor_config_param_road_work* algor_param = (algor_config_param_road_work*)tparam.algor_config_params[idx].algor_init_config_param->algor_param; + delete algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)tparam.algor_config_params[idx].algor_init_config_param->basic_param; + delete basic_param; + + algor_init_config_param_t* config_param = tparam.algor_config_params[idx].algor_init_config_param; + delete config_param; + } else if(tparam.algor_config_params[idx].algor_type == algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) { + algor_config_param_manned_incident* algor_param = (algor_config_param_manned_incident*)tparam.algor_config_params[idx].algor_init_config_param->algor_param; + delete algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)tparam.algor_config_params[idx].algor_init_config_param->basic_param; + delete basic_param; + + algor_init_config_param_t* config_param = tparam.algor_config_params[idx].algor_init_config_param; + delete config_param; + }else if(tparam.algor_config_params[idx].algor_type == algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) { + algor_config_param_manned_incident* algor_param = (algor_config_param_manned_incident*)tparam.algor_config_params[idx].algor_init_config_param->algor_param; + delete algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)tparam.algor_config_params[idx].algor_init_config_param->basic_param; + delete basic_param; + + algor_init_config_param_t* config_param = tparam.algor_config_params[idx].algor_init_config_param; + delete config_param; + } + } + delete[] tparam.algor_config_params; + return task_id_str; } + +string createTask_dvpp28181(void *handle, std::vector algor_vec, int gi, bool bFlag = true){ + task_param tparam; + + switch(gi){ + case 0: + tparam.ipc_url = "34020000001310004065"; + break; + case 1: + tparam.ipc_url = "34020000001310000001"; + break; + case 2: + tparam.ipc_url = "34020000001320000166"; + break; + case 3: + tparam.ipc_url = "32120200002160000077"; + break; + case 4: + tparam.ipc_url = "34020000001320000207"; + break; + case 5: + tparam.ipc_url = "34020000001310000176"; + break; + default: + tparam.ipc_url = "34020000001310004065"; + break; + } + + tparam.algor_counts = algor_vec.size(); + tparam.dec_type = 3; + tparam.protocal = 0; + + if (bFlag){ + nTaskId = gi; + } + + std::string task_id_str = "test_task_id_" + std::to_string(nTaskId); + tparam.task_id = task_id_str.c_str(); + + nTaskId++; + + tparam.algor_config_params = new algor_config_param[tparam.algor_counts]; + + for (size_t idx = 0; idx < algor_vec.size(); ++idx) + set_task_params(tparam, idx, algor_vec.at(idx)); + + const int result_code = add_task(handle, tparam); + if (result_code != 0) + printf("[Error]: "); + printf("--- task_id: %s result code: %d\n", tparam.task_id, result_code); + + + // 释放参数 + for (size_t idx = 0; idx < algor_vec.size(); ++idx) { + if(tparam.algor_config_params[idx].algor_type == algorithm_type_t::VIDEO_TIMING_SNAPSHOT) { + algor_config_param_road_work* algor_param = (algor_config_param_road_work*)tparam.algor_config_params[idx].algor_init_config_param->algor_param; + delete algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)tparam.algor_config_params[idx].algor_init_config_param->basic_param; + delete basic_param; + + algor_init_config_param_t* config_param = tparam.algor_config_params[idx].algor_init_config_param; + delete config_param; + } else if(tparam.algor_config_params[idx].algor_type == algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) { + algor_config_param_manned_incident* algor_param = (algor_config_param_manned_incident*)tparam.algor_config_params[idx].algor_init_config_param->algor_param; + delete algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)tparam.algor_config_params[idx].algor_init_config_param->basic_param; + delete basic_param; + + algor_init_config_param_t* config_param = tparam.algor_config_params[idx].algor_init_config_param; + delete config_param; + } else if(tparam.algor_config_params[idx].algor_type == algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) { + algor_config_param_manned_incident* algor_param = (algor_config_param_manned_incident*)tparam.algor_config_params[idx].algor_init_config_param->algor_param; + delete algor_param; + algor_basic_config_param_t* basic_param = (algor_basic_config_param_t*)tparam.algor_config_params[idx].algor_init_config_param->basic_param; + delete basic_param; + + algor_init_config_param_t* config_param = tparam.algor_config_params[idx].algor_init_config_param; + delete config_param; + } + } + delete[] tparam.algor_config_params; + + return task_id_str; +} + +void test_snapshot(void *handle){ + task_param tparam; + tparam.ipc_url = "rtsp://admin:ad123456@192.168.60.165:554/cam/realmonitor?channel=1&subtype=0"; + + tparam.algor_counts = 1; + tparam.dec_type = 2; + + std::string task_id_str = "test_task_id_default" ; + tparam.task_id = task_id_str.c_str(); + + tparam.algor_config_params = new algor_config_param[tparam.algor_counts]; + + set_task_params(tparam, 0, algorithm_type_t::VIDEO_SNAPSHOT); + + const int result_code = screenshot_task(handle, tparam); + if (result_code != 0) + printf("[Error]: "); + printf("--- task_id: %s result code: %d\n", tparam.task_id, result_code); +} + void test_gpu(int gpuID){ tsl_aiplatform_param vptParam; vptParam.gpuid = gpuID; vptParam.trt_serialize_file = ""; + vptParam.models_dir = "."; vptParam.log_days = 1; vptParam.log_level = AI_LOG_LEVEL_TRACE; @@ -521,16 +1206,222 @@ void test_gpu(int gpuID){ printf("Init Success\n"); } +#ifdef POST_USE_RABBITMQ + init_mq_conn(handle); +#endif // #ifdef POST_USE_RABBITMQ + std::vector algor_vec = {algorithm_type_t::FACE_SNAPSHOT, algorithm_type_t::HUMAN_SNAPSHOT,algorithm_type_t::ROAD_WORK_DET, algorithm_type_t::PEDESTRIAN_RETROGRADE, algorithm_type_t::VEHICLE_RETROGRADE, - algorithm_type_t::PEDESTRIAN_TRESPASS, algorithm_type_t::VEHICLE_TRESPASS, algorithm_type_t::VEHICLE_SNAPSHOT, algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT, algorithm_type_t::VIDEO_TIMING_SNAPSHOT}; + algorithm_type_t::PEDESTRIAN_TRESPASS, algorithm_type_t::VEHICLE_TRESPASS, algorithm_type_t::VEHICLE_SNAPSHOT, algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT, algorithm_type_t::VIDEO_TIMING_SNAPSHOT + , algorithm_type_t::VIDEO_SNAPSHOT, algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET, algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN, algorithm_type_t::TRICYCLE_MANNED, algorithm_type_t::TRUCK_MANNED}; + + + std::vector algor_vec2 = {algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET, algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN, algorithm_type_t::TRICYCLE_MANNED, algorithm_type_t::TRUCK_MANNED, algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE, + algorithm_type_t::NONMOTOR_VEHICLE_REFIT, algorithm_type_t::PERSON_RUNNING_REDLIGHTS, algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS, algorithm_type_t::PERSON_IN_VEHICLELANE, algorithm_type_t::NONMOTOR_IN_VEHICLELANE, + algorithm_type_t::NONMOTOR_CEOSSPARKLINE, algorithm_type_t::PERSON_CROSS, algorithm_type_t::NONMOTOR_WRONGDIRECTION, algorithm_type_t::VEHICLE_WRONGDIRECTION, algorithm_type_t::VEHICLE_NOTGIVEWAY, + algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND, algorithm_type_t::VEHICLE_NOTDECELERATION}; - string task_id = createTask(handle, algor_vec, 0 + gpuID * 10); - // string task_id1 = createTask(handle, algor_vec, 1 + gpuID * 10); - // string task_id2 = createTask(handle, algor_vec, 2 + gpuID * 10); + std::vector algor_vec3 = {algorithm_type_t::PERSON_CROSS, algorithm_type_t::NONMOTOR_WRONGDIRECTION, algorithm_type_t::VEHICLE_WRONGDIRECTION, algorithm_type_t::VEHICLE_NOTGIVEWAY, + algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND}; + + std::vector algor_vec_human = {algorithm_type_t::HUMAN_SNAPSHOT, algorithm_type_t::VIDEO_TIMING_SNAPSHOT, algorithm_type_t::FACE_SNAPSHOT, algorithm_type_t::HUMAN_GATHER, algorithm_type_t::HUMAN_REGION_GATHER + ,algorithm_type_t::HUMAN_DENSITY,algorithm_type_t::HUMAN_LINGER, algorithm_type_t::HUMAN_REGION_FAST_MOVING, algorithm_type_t::HUMAN_REGION_DISMISS, algorithm_type_t::HUMAN_CLIMB, algorithm_type_t::HUMAN_CROSSING_LINE + , algorithm_type_t::HUMAN_LEAVE_REGION}; + + std::vector algor_vec_car = {algorithm_type_t::VEHICLE_SNAPSHOT, algorithm_type_t::VEHICLE_TRESPASS, algorithm_type_t::VEHICLE_GATHER, algorithm_type_t::VEHICLE_ILLEGAL_PARKING + ,algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE}; + + std::vector algor_wenhuagong = {algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT, algorithm_type_t::VEHICLE_TRESPASS,algorithm_type_t::VEHICLE_SNAPSHOT,algorithm_type_t::VEHICLE_GATHER,algorithm_type_t::VEHICLE_ILLEGAL_PARKING,algorithm_type_t::VEHICLE_ILLEGAL_CROSSING_LINE + ,algorithm_type_t::HUMAN_GATHER, algorithm_type_t::FACE_SNAPSHOT, algorithm_type_t::HUMAN_LEAVE_REGION, algorithm_type_t::HUMAN_REGION_DISMISS, algorithm_type_t::HUMAN_REGION_FAST_MOVING, algorithm_type_t::HUMAN_SNAPSHOT, algorithm_type_t::HUMAN_REGION_GATHER, algorithm_type_t::HUMAN_DENSITY, algorithm_type_t::HUMAN_CROSSING_LINE, algorithm_type_t::HUMAN_CLIMB, algorithm_type_t::HUMAN_LINGER + }; + + // int repeat_num = 1000; + // createTask(handle, algor_vec2, 0, false); + // createTask(handle, algor_vec2, 2, false); + // while(repeat_num--) { + // printf("============================:%d\n",repeat_num); + // vector task_ids; + // for (int i = 4; i < 10; i ++) { + // string task_id = createTask(handle, algor_vec2, i, false); + // task_ids.push_back(task_id); + // } + + // // test_snapshot(handle); + // sleep(60); //60s + // close_all_task(handle); + // for (auto& task_id : task_ids) { + // finish_task(handle, (char*)task_id.data(), 0); + // sleep(5); + // } + + // } + + // createTask(handle, algor_vec2, 19, false); + // createTask(handle, algor_vec2, 20, false); + // createTask(handle, algor_vec2, 21, false); + // createTask(handle, algor_vec2, 22, false); + // createTask(handle, algor_vec2, 23, false); + // createTask(handle, algor_vec2, 24, false); + // createTask(handle, algor_vec2, 30, false); + // createTask(handle, algor_vec2, 31, false); + + // createTask(handle, algor_vec_human, 33, false); + + createTask(handle, algor_wenhuagong, 35, false); + + // int task_index = 0; + // while (true) + // { + // int task_count = count_running_task(handle); + // if (task_count < 1) + // { + // // if (task_index > 7) + // // { + // // task_index = 0; + // // break; + // // } + + // createTask(handle, algor_vec2, 19, false); + // task_index++; + // // createTask(handle, algor_vec2, 29, false); + // // task_index++; + // } + + // std::this_thread::sleep_for(std::chrono::seconds(5)); + // } + + + + // char ch = 'a'; + // while (ch != 'q') { + // ch = getchar(); + // switch (ch) + // { + // case 'a': + // createTask(handle, algor_vec2, 28, false); + // break; + // case 'c': + // close_all_task(handle); + // break; + // default: + // break; + // } + + // } + + // finish_task(handle, (char*)task_id.data(), 0); + + // finish_task(handle, (char*)task_id1.data(), 0); while (getchar() != 'q'); + + tsl_aiplatform_release(&handle); +} + +void test_dvpp28181(int gpuID) { + tsl_aiplatform_param vptParam; + vptParam.gpuid = gpuID; + vptParam.sip_server_port = 15080; + vptParam.trt_serialize_file = ""; + vptParam.models_dir = "."; + + vptParam.log_days = 1; + vptParam.log_level = AI_LOG_LEVEL_TRACE; + // vptParam.log_level = AI_LOG_LEVEL_DEBUG; + vptParam.log_mem = 64 * 1024 * 1024; // 64MB. + vptParam.log_path = "logs/main.log"; + vptParam.vpt_thred = 0.45; + vptParam.rblock_thred = 0.4; + + void *handle; + int flag = tsl_aiplatform_init(&handle, vptParam); + if (0 != flag) { + printf("Init Failed! Error Code: %d\n", flag); + return; + } else { + printf("Init Success\n"); + } + +#ifdef POST_USE_RABBITMQ +init_mq_conn(handle); +#endif // #ifdef POST_USE_RABBITMQ + + std::vector algor_vec = {algorithm_type_t::FACE_SNAPSHOT, algorithm_type_t::HUMAN_SNAPSHOT,algorithm_type_t::ROAD_WORK_DET, algorithm_type_t::PEDESTRIAN_RETROGRADE, algorithm_type_t::VEHICLE_RETROGRADE, + algorithm_type_t::PEDESTRIAN_TRESPASS, algorithm_type_t::VEHICLE_TRESPASS, algorithm_type_t::VEHICLE_SNAPSHOT, algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT, algorithm_type_t::VIDEO_TIMING_SNAPSHOT + , algorithm_type_t::VIDEO_SNAPSHOT, algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET, algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN, algorithm_type_t::TRICYCLE_MANNED, algorithm_type_t::TRUCK_MANNED}; + + + std::vector algor_vec2 = {algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET, algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN, algorithm_type_t::TRICYCLE_MANNED, algorithm_type_t::TRUCK_MANNED, algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE, + algorithm_type_t::NONMOTOR_VEHICLE_REFIT, algorithm_type_t::PERSON_RUNNING_REDLIGHTS, algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS, algorithm_type_t::PERSON_IN_VEHICLELANE, algorithm_type_t::NONMOTOR_IN_VEHICLELANE, + algorithm_type_t::NONMOTOR_CEOSSPARKLINE, algorithm_type_t::PERSON_CROSS, algorithm_type_t::NONMOTOR_WRONGDIRECTION, algorithm_type_t::VEHICLE_WRONGDIRECTION, algorithm_type_t::VEHICLE_NOTGIVEWAY, + algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND, algorithm_type_t::VEHICLE_NOTDECELERATION}; + // std::vector algor_vec3 = {algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET, algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN, algorithm_type_t::TRICYCLE_MANNED, algorithm_type_t::TRUCK_MANNED, algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE, + // algorithm_type_t::NONMOTOR_VEHICLE_REFIT, algorithm_type_t::PERSON_RUNNING_REDLIGHTS, algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS}; + std::vector algor_vec3 = {algorithm_type_t::PERSON_CROSS, algorithm_type_t::NONMOTOR_WRONGDIRECTION, algorithm_type_t::VEHICLE_WRONGDIRECTION, algorithm_type_t::VEHICLE_NOTGIVEWAY, + algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND}; + + + + int status = -1; + while (true) + { + status = get_task_status(handle,"34020000001320000207"); + if (status == 0) + { + createTask_dvpp28181(handle, algor_vec, 4, false); + } - finish_task(handle, (char*)task_id.data(), 0); + status = get_task_status(handle,"34020000001310000176"); + if (status == 0) + { + createTask_dvpp28181(handle, algor_vec, 5, false); + } + + std::this_thread::sleep_for(std::chrono::seconds(5)); + } + + + +char ch = 'a'; +while (ch != 'q') { + ch = getchar(); + switch (ch) + { + case '0': + createTask_dvpp28181(handle, algor_vec, 0, false); + break; + case '1': + createTask_dvpp28181(handle, algor_vec, 1, false); + break; + case '2': + createTask_dvpp28181(handle, algor_vec, 2, false); + break; + case '3': + createTask_dvpp28181(handle, algor_vec, 3, false); + break; + case '4': + createTask_dvpp28181(handle, algor_vec, 4, false); + break; + case '5': + createTask_dvpp28181(handle, algor_vec, 5, false); + break; + case '6': + createTask(handle, algor_vec2, 2, false); + break; + case '7': + createTask(handle, algor_vec2, 0, false); + break; + case 'c': + close_all_task(handle); + break; + default: + break; + } + +} + + // finish_task(handle, (char*)task_id.data(), 0); + + // finish_task(handle, (char*)task_id1.data(), 0); tsl_aiplatform_release(&handle); } @@ -538,23 +1429,23 @@ void test_gpu(int gpuID){ int main(int argc, char *argv[]) { printf("new test\n"); - if (argc < 4) { - fprintf(stderr, "./xxx 0 2 10 1 ## [start_ai_id, end_ai_id) repeat_num gpu_id\n"); - return -1; - } + // if (argc < 4) { + // fprintf(stderr, "./xxx 0 2 10 1 ## [start_ai_id, end_ai_id) repeat_num gpu_id\n"); + // return -1; + // } - //! load params. - int start_id = atoi(argv[1]); - int end_id = atoi(argv[2]); - int repeat_num = atoi(argv[3]); - int gpuID = atoi(argv[4]); + // //! load params. + // int start_id = atoi(argv[1]); + // int end_id = atoi(argv[2]); + // int repeat_num = atoi(argv[3]); + // int gpuID = atoi(argv[4]); test_gpu(0); // test_gpu(1); // test_gpu(2); // test_gpu(3); - while (getchar() != 'q'); + // test_dvpp28181(0); printf("Done.\n"); diff --git a/src/readme.txt b/src/readme.txt index fbba678..2ac2a19 100644 --- a/src/readme.txt +++ b/src/readme.txt @@ -18,6 +18,22 @@ 注意事项说明: - 当前版本跟踪前三帧无结果输出 -中科院自动化所 模式识别实验室图像视频组 -2023年03月16日 \ No newline at end of file +### ffmpeg编译 +~~~ +./configure --enable-debug --extra-cflags=-g --extra-ldflags=-g --disable-optimizations --disable-stripping --disable-x86asm --enable-nonfree --disable-vaapi --extra-cflags=-fPIC --enable-shared --enable-pic --enable-ffplay --prefix=./release +~~~ +其中以下是用于调试的，编译release可以去掉： +~~~ +--enable-debug --extra-cflags=-g --extra-ldflags=-g --disable-optimizations --disable-stripping +~~~ +然后 make , make install + +### jsoncpp/opencv/spdlog 编译 +~~~ +mkdir build +cd ./build +cmake -D CMAKE_BUILD_TYPE=Release -D CMAKE_INSTALL_PREFIX=../release -D BUILD_opencv_world=ON -D WITH_CUDA=OFF -D WITH_CUDNN=OFF -D BUILD_opencv_ml=OFF -D OPENCV_EXTRA_MODULES_PATH=../opencv_contrib-4.5.4/modules .. +make -j +make install +~~~ \ No newline at end of file diff --git a/src/reprocessing_module/save_snapshot_reprocessing.h b/src/reprocessing_module/save_snapshot_reprocessing.h index 38d160a..7ddebc2 100644 --- a/src/reprocessing_module/save_snapshot_reprocessing.h +++ b/src/reprocessing_module/save_snapshot_reprocessing.h @@ -42,6 +42,7 @@ public: void save_snapshot_reprocessing_release(); #ifdef POST_USE_RABBITMQ + typedef std::function callback_t; void set_callback(callback_t cb); #endif -- libgit2 0.21.4