From 3c2078c96eb38fcab861c124eb024126b4968a9f Mon Sep 17 00:00:00 2001 From: Hu Chunming <2657262686@qq.com> Date: Mon, 4 Aug 2025 21:10:06 +0800 Subject: [PATCH] 原版jni --- src/Makefile | 87 --------------------------------------------------------------------------------------- src/tsl_aiplatform_jni/AiEngineNativeInterface.cpp | 908 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/tsl_aiplatform_jni/com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h | 100 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1008 insertions(+), 87 deletions(-) delete mode 100644 src/Makefile create mode 100644 src/tsl_aiplatform_jni/AiEngineNativeInterface.cpp create mode 100644 src/tsl_aiplatform_jni/com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h diff --git a/src/Makefile b/src/Makefile deleted file mode 100644 index 7332b34..0000000 --- a/src/Makefile +++ /dev/null @@ -1,87 +0,0 @@ -XX = g++ - - -PROJECT_ROOT= /data1/cmhu/vpt_ascend - -DEPEND_DIR = $(PROJECT_ROOT)/bin -SRC_ROOT = $(PROJECT_ROOT)/src - -TARGET= $(PROJECT_ROOT)/bin/vpt_proj - -THIRDPARTY_ROOT = $(PROJECT_ROOT)/3rdparty -SPDLOG_ROOT = $(THIRDPARTY_ROOT)/spdlog-1.9.2/release -OPENCV_ROOT = $(THIRDPARTY_ROOT)/opencv-4.5.4/release -JSON_ROOT = $(THIRDPARTY_ROOT)/jsoncpp-1.9.5/release -FFMPEG_ROOT = $(THIRDPARTY_ROOT)/ffmpeg-4.2.2/release - -DEFS = -DENABLE_DVPP_INTERFACE - -include_dir=-I/usr/local/Ascend/ascend-toolkit/6.3.RC1/x86_64-linux/include \ - -I $(SPDLOG_ROOT)/include \ - -I $(SRC_ROOT)/common \ - -I $(OPENCV_ROOT)/include/opencv4 \ - -I $(JSON_ROOT)/include \ - -I $(FFMPEG_ROOT)/include \ - -lib_dir=-L/usr/local/Ascend/ascend-toolkit/6.3.RC1/runtime/lib64 \ - -L/usr/local/Ascend/ascend-toolkit/latest/lib64 \ - -L/usr/local/Ascend/ascend-toolkit/latest/runtime/lib64 \ - -L/usr/local/Ascend/ascend-toolkit/latest/acllib/lib64 \ - -L/usr/local/Ascend/ascend-toolkit/6.3.RC1/runtime/lib64/stub \ - -lib=-lacl_dvpp -lascendcl -lacl_dvpp_mpi -lruntime -lascendalog -lc_sec -lmsprofiler -lgert -lmmpa -lascend_hal -lexe_graph -lge_executor -lgraph -lprofapi -lascend_protobuf -lerror_manager -lopencv_dnn -lopencv_calib3d -lhybrid_executor -lregister -ldavinci_executor -lge_common -lge_common_base \ - -lplatform -lgraph_base -lqos_manager - -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 $(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 - - - -SRCS:=$(wildcard $(SRC_ROOT)/ai_platform/*.cpp) \ - $(wildcard $(SRC_ROOT)/decoder/interface/*.cpp) \ - $(wildcard $(SRC_ROOT)/decoder/dvpp/*.cpp) \ - $(wildcard $(SRC_ROOT)/demo/*.cpp) \ - $(wildcard $(SRC_ROOT)/ai_engine_module/sort/*.cpp) \ - $(wildcard $(SRC_ROOT)/ai_engine_module/*.cpp) \ - $(wildcard $(SRC_ROOT)/util/*.cpp) \ - $(wildcard $(SRC_ROOT)/reprocessing_module/*.cpp) \ - -OBJS = $(patsubst %.cpp, %.o, $(notdir $(SRCS))) - - -$(TARGET):$(OBJS) - rm -f $(TARGET) - $(XX) -o $@ $^ $(CXXFLAGS) - rm -f *.o - -%.o:$(SRC_ROOT)/decoder/dvpp/%.cpp - $(XX) $(CXXFLAGS) -c $< - -%.o:$(SRC_ROOT)/decoder/interface/%.cpp - $(XX) $(CXXFLAGS) -c $< - -%.o:$(SRC_ROOT)/ai_platform/%.cpp - $(XX) $(CXXFLAGS) -c $< - -%.o:$(SRC_ROOT)/ai_engine_module/sort/%.cpp - $(XX) $(CXXFLAGS) -c $< - -%.o:$(SRC_ROOT)/ai_engine_module/%.cpp - $(XX) $(CXXFLAGS) -c $< - -%.o:$(SRC_ROOT)/demo/%.cpp - $(XX) $(CXXFLAGS) -c $< - -%.o:$(SRC_ROOT)/util/%.cpp - $(XX) $(CXXFLAGS) -c $< - -%.o:$(SRC_ROOT)/reprocessing_module/%.cpp - $(XX) $(CXXFLAGS) -c $< - -clean: - rm -f *.o $(TARGET) \ No newline at end of file diff --git a/src/tsl_aiplatform_jni/AiEngineNativeInterface.cpp b/src/tsl_aiplatform_jni/AiEngineNativeInterface.cpp new file mode 100644 index 0000000..2bfe5ae --- /dev/null +++ b/src/tsl_aiplatform_jni/AiEngineNativeInterface.cpp @@ -0,0 +1,908 @@ +#include "com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h" +#include "header.h" +#include "iostream" +#include "stl_aiplatform.h" +#include "sy_common.h" +#include "sy_errorinfo.h" +#include +#include +using namespace std; + +/** + * */ +JavaVM *g_jvm = NULL; +jclass g_jcls_vptdtJavaCallBack; //callback函数的class +jobject g_obj_vptdtJavaCallBack; //callback函数的obj + +ai_log_level getLogLevel(int logLevel); + +/* + * Class: com_objecteye_nativeinterface_AiEngineNativeInterface + * Method: load + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_load(JNIEnv *env, jclass jcls) { + printf("strat VPTDTJNI_load \n"); + int ret = env->GetJavaVM(&g_jvm); + if (ret == 0) { + JNIEnv *g_env; + int getEnvStatus = g_jvm->GetEnv((void **)&g_env, JNI_VERSION_1_8); + if (getEnvStatus == JNI_OK){ + printf(" GetEnv successed \n"); + g_jcls_vptdtJavaCallBack = (jclass)env->NewGlobalRef(env->FindClass("com/objecteye/vehicle/vptdtJavaCallBack")); + printf(" NewGlobalRef successed \n"); + jmethodID mid_vptdtJavaCallBack = env->GetMethodID(g_jcls_vptdtJavaCallBack, "", "()V"); + printf(" GetMethodID successed \n"); + g_obj_vptdtJavaCallBack = env->NewGlobalRef(env->NewObject(g_jcls_vptdtJavaCallBack, mid_vptdtJavaCallBack)); + } + ret = getEnvStatus; + } + printf("end VPTDTJNI_load \n"); + return ret; +} + +/* + * Class: com_objecteye_nativeinterface_AiEngineNativeInterface + * Method: init + * Signature: ([Ljava/lang/Long;Lcom/objecteye/pojo/ruijin/AiEngineParam;)I + */ +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_init(JNIEnv *env, jobject obj, + jlongArray handleArray, + jobject aiEngineParam) { + + // getFieldID + jclass cls_aiEngineParam = env->GetObjectClass(aiEngineParam); + jfieldID fid_aiEngineParam_gpuid = env->GetFieldID(cls_aiEngineParam, "gpuID", "I"); + jfieldID fid_aiEngineParam_sipServerPort = env->GetFieldID(cls_aiEngineParam, "sipServerPort", "I"); + jfieldID fid_aiEngineParam_trtSerializeFileFolder = env->GetFieldID(cls_aiEngineParam, "trtSerializeFileFolder", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_modelsDir = env->GetFieldID(cls_aiEngineParam, "modelsDir", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_logLevel = env->GetFieldID(cls_aiEngineParam, "logLevel", "I"); + jfieldID fid_aiEngineParam_logPath = env->GetFieldID(cls_aiEngineParam, "logPath", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_logDays = env->GetFieldID(cls_aiEngineParam, "logDays", "I"); + jfieldID fid_aiEngineParam_logMem = env->GetFieldID(cls_aiEngineParam, "logMem", "D"); + + + // getObjectField + jint aiEngineParam_gpuid = env->GetIntField(aiEngineParam, fid_aiEngineParam_gpuid); + jint aiEngineParam_sipServerPort = env->GetIntField(aiEngineParam, fid_aiEngineParam_sipServerPort); + jstring str_aiEngineParam_trtSerializeFileFolder = + (jstring)env->GetObjectField(aiEngineParam, fid_aiEngineParam_trtSerializeFileFolder); + const char *aiEngineParam_trtSerializeFileFolder = + env->GetStringUTFChars(str_aiEngineParam_trtSerializeFileFolder, JNI_FALSE); + jstring str_aiEngineParam_modelsDir = + (jstring)env->GetObjectField(aiEngineParam, fid_aiEngineParam_modelsDir); + const char *aiEngineParam_modelsDir = + env->GetStringUTFChars(str_aiEngineParam_modelsDir, JNI_FALSE); + + // log + jstring str_aiEngineParam_logPath = (jstring)env->GetObjectField(aiEngineParam, fid_aiEngineParam_logPath); + const char *aiEngineParam_logPath = env->GetStringUTFChars(str_aiEngineParam_logPath, JNI_FALSE); + + jint aiEngineParam_logDays = env->GetIntField(aiEngineParam, fid_aiEngineParam_logDays); + jdouble aiEngineParam_logMem = env->GetDoubleField(aiEngineParam, fid_aiEngineParam_logMem); + jint aiEngineParam_logLevel = env->GetIntField(aiEngineParam, fid_aiEngineParam_logLevel); + + // jobject to c++ + void *aiEngineHandle = nullptr; + + tsl_aiplatform_param mAiEngineParam; + mAiEngineParam.gpuid = aiEngineParam_gpuid; + mAiEngineParam.sip_server_port= aiEngineParam_sipServerPort; + mAiEngineParam.trt_serialize_file = (char *)aiEngineParam_trtSerializeFileFolder; + mAiEngineParam.models_dir = (char *)aiEngineParam_modelsDir; + + mAiEngineParam.log_level = getLogLevel(aiEngineParam_logLevel); + mAiEngineParam.log_path = (char *)aiEngineParam_logPath; + mAiEngineParam.log_days = aiEngineParam_logDays; + mAiEngineParam.log_mem = aiEngineParam_logMem; + + printf("-- *************** Summary **********************.\n"); + printf("-- sip server port:%d \n", (int)aiEngineParam_sipServerPort); + printf("-- [logger]\n"); + printf("-- level :%d(int)\n", (int)aiEngineParam_logLevel); + printf("-- path :%s(str)\n", (char *)aiEngineParam_logPath); + printf("-- kp :%d(int)\n", (int)aiEngineParam_logDays); + printf("-- mem :%d(int)\n", (int)aiEngineParam_logMem); + printf("-- **********************************************.\n"); + + + // init + int ret = tsl_aiplatform_init(&aiEngineHandle, mAiEngineParam); + if (ret == 0) { + jlong temp[1]; + temp[0] = (jlong)aiEngineHandle; + env->SetLongArrayRegion(handleArray, 0, 1, temp); + } + env->ReleaseStringUTFChars(str_aiEngineParam_trtSerializeFileFolder, aiEngineParam_trtSerializeFileFolder); + env->ReleaseStringUTFChars(str_aiEngineParam_logPath, aiEngineParam_logPath); + + return ret; +} + +jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addMqConn(JNIEnv *env, jobject thisObject, + jlong handle, jint task_type, + jobject rabbitmq_conn) { + // rabbitmq + jclass cls_rabbitmq_conn = env->GetObjectClass(rabbitmq_conn); + + jfieldID fid_aiEngineParam_rbmq_ip = env->GetFieldID(cls_rabbitmq_conn, "ip", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_rbmq_port = env->GetFieldID(cls_rabbitmq_conn, "port", "I"); + + jfieldID fid_aiEngineParam_rbmq_username = env->GetFieldID(cls_rabbitmq_conn, "username", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_rbmq_password = env->GetFieldID(cls_rabbitmq_conn, "password", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_rbmq_vhost = env->GetFieldID(cls_rabbitmq_conn, "vhost", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_rbmq_exchange = env->GetFieldID(cls_rabbitmq_conn, "exchange", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_rbmq_exchange_type = + env->GetFieldID(cls_rabbitmq_conn, "exchangeType", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_rbmq_queue = env->GetFieldID(cls_rabbitmq_conn, "queue", "Ljava/lang/String;"); + jfieldID fid_aiEngineParam_rbmq_routingKey = env->GetFieldID(cls_rabbitmq_conn, "routingKey", "Ljava/lang/String;"); + + jfieldID fid_aiEngineParam_rbmq_durable_exchange = env->GetFieldID(cls_rabbitmq_conn, "durable_exchange", "Z"); + jfieldID fid_aiEngineParam_rbmq_durable_queue = env->GetFieldID(cls_rabbitmq_conn, "durable_queue", "Z"); + + jstring str_rbmq_ip = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_ip); + const char *str_rbmq_ip_c = env->GetStringUTFChars(str_rbmq_ip, JNI_FALSE); + jint int_rbmq_port = env->GetIntField(rabbitmq_conn, fid_aiEngineParam_rbmq_port); + jstring str_rbmq_username = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_username); + const char *str_rbmq_username_c = env->GetStringUTFChars(str_rbmq_username, JNI_FALSE); + jstring str_rbmq_password = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_password); + const char *str_rbmq_password_c = env->GetStringUTFChars(str_rbmq_password, JNI_FALSE); + jstring str_rbmq_vhost = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_vhost); + const char *str_rbmq_vhost_c = env->GetStringUTFChars(str_rbmq_vhost, JNI_FALSE); + jstring str_rbmq_exchange = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_exchange); + const char *str_rbmq_exchange_c = env->GetStringUTFChars(str_rbmq_exchange, JNI_FALSE); + jstring str_rbmq_exchange_type = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_exchange_type); + const char *str_rbmq_exchange_type_c = env->GetStringUTFChars(str_rbmq_exchange_type, JNI_FALSE); + jstring str_rbmq_queue = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_queue); + const char *str_rbmq_queue_c = env->GetStringUTFChars(str_rbmq_queue, JNI_FALSE); + jstring str_rbmq_routingKey = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_routingKey); + const char *str_rbmq_routingKey_c = env->GetStringUTFChars(str_rbmq_routingKey, JNI_FALSE); + + jboolean bool_rbmq_durable_exchange = env->GetBooleanField(rabbitmq_conn, fid_aiEngineParam_rbmq_durable_exchange); + jboolean bool_rbmq_durable_queue = env->GetBooleanField(rabbitmq_conn, fid_aiEngineParam_rbmq_durable_queue); + + rabbitmq_conn_params_t mq_conn_params; + { + + strcpy(mq_conn_params.ip, str_rbmq_ip_c); + strcpy(mq_conn_params.uname, str_rbmq_username_c); + strcpy(mq_conn_params.passwd, str_rbmq_password_c); + strcpy(mq_conn_params.vhost, str_rbmq_vhost_c); + strcpy(mq_conn_params.exchange, str_rbmq_exchange_c); + strcpy(mq_conn_params.exchange_type, str_rbmq_exchange_type_c); + strcpy(mq_conn_params.queue, str_rbmq_queue_c); + strcpy(mq_conn_params.routing_key, str_rbmq_routingKey_c); + mq_conn_params.port = int_rbmq_port; + mq_conn_params.durable_queue = bool_rbmq_durable_queue; + mq_conn_params.durable_exchange = bool_rbmq_durable_exchange; + } + + env->ReleaseStringUTFChars(str_rbmq_ip, str_rbmq_ip_c); + env->ReleaseStringUTFChars(str_rbmq_username, str_rbmq_username_c); + env->ReleaseStringUTFChars(str_rbmq_password, str_rbmq_password_c); + env->ReleaseStringUTFChars(str_rbmq_vhost, str_rbmq_vhost_c); + env->ReleaseStringUTFChars(str_rbmq_exchange, str_rbmq_exchange_c); + env->ReleaseStringUTFChars(str_rbmq_exchange_type, str_rbmq_exchange_type_c); + env->ReleaseStringUTFChars(str_rbmq_queue, str_rbmq_queue_c); + env->ReleaseStringUTFChars(str_rbmq_routingKey, str_rbmq_routingKey_c); + + printf("[RabbitMQ] Init\n\t task type: %d ip: %s port is %d username is %s password is %s vhost is %s exchange is %s " + "exchange_type is %s queue is %s routing key is %s durable_exchange is %d durable_queue is %d\n", + (int)task_type, mq_conn_params.ip, mq_conn_params.port, mq_conn_params.uname, mq_conn_params.passwd, + mq_conn_params.vhost, mq_conn_params.exchange, mq_conn_params.exchange_type, mq_conn_params.queue, + mq_conn_params.routing_key, mq_conn_params.durable_exchange, mq_conn_params.durable_queue); + + int status = 0; + void *aiEngineHanle = (void *)handle; + if (0 != (status = add_mq_conn(aiEngineHanle, static_cast(task_type), mq_conn_params))) + fprintf(stderr, "add mq conn failed.\n"); + return status; +} + + +// 请求视频流 +bool gb28181_request_stream_callback(const char *task_id){ + + printf("request stream. taskId :%s.\n", task_id); + + //java回调---------------------------------------- + void *p; + // printf("1 \n"); + g_jvm->AttachCurrentThread(&p, NULL); + // printf("2 \n"); + JNIEnv *callBack_env = (JNIEnv *)p; + + jint ret = 0; + if(callBack_env != nullptr){ + jmethodID mid_requestStreamhCallback = callBack_env->GetMethodID(g_jcls_vptdtJavaCallBack, "vptdtEventJavaCallBack", "(Ljava/lang/String;)I"); + // printf("3 \n"); + if(mid_requestStreamhCallback != nullptr){ + // printf("4 \n"); + ret = (jint)callBack_env->CallIntMethod(g_obj_vptdtJavaCallBack, mid_requestStreamhCallback, callBack_env->NewStringUTF(task_id)); + } + // printf("5 \n"); + } + g_jvm->DetachCurrentThread(); + + printf("request stream. taskId :%s ret: %d \n", task_id, ret); + + if(ret == 0){ + return false; + } + + printf("request stream end .\n"); + + return true; +} + + +/* + * Class: com_objecteye_nativeinterface_AiEngineNativeInterface + * Method: addTask + * Signature: (JLcom/objecteye/pojo/ruijin/TaskParam;)I + */ +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addTask(JNIEnv *env, jobject obj, + jlong handle, + jobject taskParam) { + int code = 0; + + // getFieldID + jclass cls_taskParam = env->GetObjectClass(taskParam); + jfieldID fid_taskParam_ipcUrl = env->GetFieldID(cls_taskParam, "ipcUrl", "Ljava/lang/String;"); + jfieldID fid_taskParam_algorConfigParams = + env->GetFieldID(cls_taskParam, "algorConfigParams", "Ljava/util/ArrayList;"); + jfieldID fid_taskParam_algorCounts = env->GetFieldID(cls_taskParam, "algorCounts", "I"); + jfieldID fid_taskParam_taskId = env->GetFieldID(cls_taskParam, "taskId", "Ljava/lang/String;"); + + jfieldID fid_taskParam_dec_type = env->GetFieldID(cls_taskParam, "decType", "I"); + jfieldID fid_taskParam_port = env->GetFieldID(cls_taskParam, "port", "I"); + jfieldID fid_taskParam_protocal = env->GetFieldID(cls_taskParam, "protocal", "I"); + + // getObjectField + jstring str_taskParam_ipcUrl = (jstring)env->GetObjectField(taskParam, fid_taskParam_ipcUrl); + const char *taskParam_ipcUrl = env->GetStringUTFChars(str_taskParam_ipcUrl, JNI_FALSE); + jint taskParam_algorCounts = env->GetIntField(taskParam, fid_taskParam_algorCounts); + jstring str_taskParam_taskId = (jstring)env->GetObjectField(taskParam, fid_taskParam_taskId); + const char *taskParam_taskId = env->GetStringUTFChars(str_taskParam_taskId, JNI_FALSE); + jobject taskParam_algorConfigParams = env->GetObjectField(taskParam, fid_taskParam_algorConfigParams); + + jint taskParam_dec_type = env->GetIntField(taskParam, fid_taskParam_dec_type); + jint taskParam_port = env->GetIntField(taskParam, fid_taskParam_port); + jint taskParam_protocal = env->GetIntField(taskParam, fid_taskParam_protocal); + + jclass cls_syRectParam = env->FindClass("com/objecteye/pojo/common/SyRectParam"); + jfieldID fid_syRectParam_left = env->GetFieldID(cls_syRectParam, "left", "I"); + jfieldID fid_syRectParam_top = env->GetFieldID(cls_syRectParam, "top", "I"); + jfieldID fid_syRectParam_width = env->GetFieldID(cls_syRectParam, "width", "I"); + jfieldID fid_syRectParam_height = env->GetFieldID(cls_syRectParam, "height", "I"); + + // java to C++ + task_param mTaskParam; + mTaskParam.ipc_url = taskParam_ipcUrl; + mTaskParam.algor_counts = taskParam_algorCounts; + mTaskParam.task_id = taskParam_taskId; + mTaskParam.algor_config_params = new algor_config_param[mTaskParam.algor_counts]; + mTaskParam.dec_type = taskParam_dec_type; + mTaskParam.port = taskParam_port; + mTaskParam.protocal = taskParam_protocal; + mTaskParam.gb28181_request_stream_callback = gb28181_request_stream_callback; + + map snapshot_little_AlgorConfigParamResSnapshotFolderMap; + map psnapshot_little_AlgorConfigParamResSnapshotFolderMap; + map snapshot_AlgorConfigParamResSnapshotFolderMap; + map psnapshot_AlgorConfigParamResSnapshotFolderMap; + map snapshot_AlgorConfigParamResVideoFolderMap; + map psnapshot_AlgorConfigParamResVideoFolderMap; + + jclass cls_arraylist = env->FindClass("java/util/ArrayList"); + // method in class ArrayList + jmethodID mid_arraylist_get = env->GetMethodID(cls_arraylist, "get", "(I)Ljava/lang/Object;"); + + for (size_t i = 0; i < taskParam_algorCounts; i++) { + jobject obj_algorConfigParam = env->CallObjectMethod(taskParam_algorConfigParams, mid_arraylist_get, i); + jclass cls_algorConfigParam = env->GetObjectClass(obj_algorConfigParam); + + jfieldID fid_algorConfigParam_algorType = env->GetFieldID(cls_algorConfigParam, "algorType", "I"); + jint algorConfigParam_algorType = env->GetIntField(obj_algorConfigParam, fid_algorConfigParam_algorType); + + jfieldID fid_algorConfigParam_algorInitParam = + env->GetFieldID(cls_algorConfigParam, "algorInitParam", "Ljava/lang/Object;"); + jobject algorConfigParam_algorInitParam = + env->GetObjectField(obj_algorConfigParam, fid_algorConfigParam_algorInitParam); + + jclass cls_AlgorConfigParam = env->GetObjectClass(algorConfigParam_algorInitParam); + + /* assign public variables. */ + auto algor_basic_param = new algor_basic_config_param_t; + { + jfieldID fid_ssAlgorConfigParam_algorRect = + env->GetFieldID(cls_AlgorConfigParam, "algor_valid_rect", "Lcom/objecteye/pojo/common/SyRectParam;"); + jobject ssAlgorConfigParam_algorRect = + env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_algorRect); + + jint ssAlgorConfigParam_algorRect_left = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_left); + jint ssAlgorConfigParam_algorRect_top = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_top); + jint ssAlgorConfigParam_algorRect_width = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_width); + jint ssAlgorConfigParam_algorRect_height = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_height); + + jfieldID fid_ssAlgorConfigParam_snapshotLittleFolder = + env->GetFieldID(cls_AlgorConfigParam, "result_folder_little", "Ljava/lang/String;"); + jfieldID fid_ssAlgorConfigParam_snapshotFolder = + env->GetFieldID(cls_AlgorConfigParam, "result_folder", "Ljava/lang/String;"); + jfieldID fid_ssAlgorConfigParam_videoFolder = + env->GetFieldID(cls_AlgorConfigParam, "video_folder", "Ljava/lang/String;"); //视频存储地址 + + snapshot_little_AlgorConfigParamResSnapshotFolderMap[i] = + (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_snapshotLittleFolder); + psnapshot_little_AlgorConfigParamResSnapshotFolderMap[i] = + (char *)env->GetStringUTFChars(snapshot_little_AlgorConfigParamResSnapshotFolderMap[i], JNI_FALSE); + snapshot_AlgorConfigParamResSnapshotFolderMap[i] = + (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_snapshotFolder); + psnapshot_AlgorConfigParamResSnapshotFolderMap[i] = + (char *)env->GetStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[i], JNI_FALSE); + snapshot_AlgorConfigParamResVideoFolderMap[i] = + (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_videoFolder); + psnapshot_AlgorConfigParamResVideoFolderMap[i] = + (char *)env->GetStringUTFChars(snapshot_AlgorConfigParamResVideoFolderMap[i], JNI_FALSE); + + auto algor_init_config_param = new algor_init_config_param_t; + + + algor_basic_param->algor_valid_rect.top_ = ssAlgorConfigParam_algorRect_top; + algor_basic_param->algor_valid_rect.left_ = ssAlgorConfigParam_algorRect_left; + algor_basic_param->algor_valid_rect.width_ = ssAlgorConfigParam_algorRect_width; + algor_basic_param->algor_valid_rect.height_ = ssAlgorConfigParam_algorRect_height; + + algor_basic_param->result_folder = psnapshot_AlgorConfigParamResSnapshotFolderMap[i]; + algor_basic_param->result_folder_little = psnapshot_little_AlgorConfigParamResSnapshotFolderMap[i]; + algor_basic_param->video_folder = psnapshot_AlgorConfigParamResVideoFolderMap[i]; + + algor_init_config_param->basic_param = algor_basic_param; + mTaskParam.algor_config_params[i].algor_init_config_param = algor_init_config_param; + mTaskParam.algor_config_params[i].algor_type = static_cast(algorConfigParam_algorType); + } + + switch (static_cast(algorConfigParam_algorType)) { + case algorithm_type_t::FACE_SNAPSHOT: + // printf("FACE_SNAPSHOT result_folder: %s result_folder_little: %s \n", algor_basic_param->result_folder, algor_basic_param->result_folder_little); + case algorithm_type_t::HUMAN_SNAPSHOT: + case algorithm_type_t::VEHICLE_SNAPSHOT: + case algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT: { + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F"); + jfieldID fid_snap_frame_interval = env->GetFieldID(cls_AlgorConfigParam, "snap_frame_interval", "I"); + jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + jfloat j_snap_frame_interval = env->GetFloatField(algorConfigParam_algorInitParam, fid_snap_frame_interval); + + typedef algor_config_param_snapshot algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + algor_param->threshold = (float)j_threshold; + algor_param->snap_frame_interval = (int)j_snap_frame_interval; + } break; + + //农村违法分析 + case algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET: + case algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN: + case algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE: + case algorithm_type_t::NONMOTOR_VEHICLE_REFIT: + case algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS: + case algorithm_type_t::NONMOTOR_IN_VEHICLELANE: + case algorithm_type_t::NONMOTOR_CEOSSPARKLINE: + case algorithm_type_t::NONMOTOR_WRONGDIRECTION: + case algorithm_type_t::PERSON_IN_VEHICLELANE: + case algorithm_type_t::PERSON_CROSS: + case algorithm_type_t::PERSON_RUNNING_REDLIGHTS: + case algorithm_type_t::TRICYCLE_MANNED: + case algorithm_type_t::VEHICLE_WRONGDIRECTION: + case algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND: + case algorithm_type_t::VEHICLE_NOTGIVEWAY: + case algorithm_type_t::VEHICLE_NOTDECELERATION: + case algorithm_type_t::TRUCK_MANNED: { + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "hs_threshold", "I"); + jint j_hs_threshold = env->GetIntField(algorConfigParam_algorInitParam, fid); + fid = env->GetFieldID(cls_AlgorConfigParam, "m_frame", "I"); + jint j_m_frame = env->GetIntField(algorConfigParam_algorInitParam, fid); + fid = env->GetFieldID(cls_AlgorConfigParam, "n_frame", "I"); + jint j_n_frame = env->GetIntField(algorConfigParam_algorInitParam, fid); + fid = env->GetFieldID(cls_AlgorConfigParam, "obj_min_width", "I"); + jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid); + fid = env->GetFieldID(cls_AlgorConfigParam, "obj_min_height", "I"); + jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid); + fid = env->GetFieldID(cls_AlgorConfigParam, "obj_confidence_threshold", "F"); + jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + std::printf("%s:%d i is %d mn is [%d %d] threshold is %d\n", __FILE__, __LINE__, i, (int)j_m_frame, + (int)j_n_frame, (int)j_hs_threshold); + + typedef algor_config_param_manned_incident algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + + algor_param->m = (int)j_m_frame; + algor_param->n = (int)j_n_frame; + algor_param->hs_count_threshold = (int)j_hs_threshold; + + algor_param->obj_min_width = (int)j_min_width; + algor_param->obj_min_height = (int)j_min_height; + algor_param->obj_confidence_threshold = (float)j_confidence_threshold; + } break; + + + case algorithm_type_t::HUMAN_GATHER: { + + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "frame_stride", "I"); + jint j_frame_stride = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "human_count_threshold", "I"); + jint j_human_count_thre = env->GetIntField(algorConfigParam_algorInitParam, fid); + + typedef algor_config_param_human_gather algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + algor_param->frame_stride = (int)j_frame_stride; + algor_param->human_count_threshold = (int)j_human_count_thre; + } break; + //221026byzsh-------------------------------------------------------------------------------------------- + case algorithm_type_t::ROAD_WORK_DET: { + + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "frame_stride", "I"); + jint j_frame_stride = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "rblock_count_threshold", "I"); + jint j_rblock_count_thre = env->GetIntField(algorConfigParam_algorInitParam, fid); + + typedef algor_config_param_road_work algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + algor_param->frame_stride = (int)j_frame_stride; + algor_param->rblock_count_threshold = (int)j_rblock_count_thre; + } break; + //-------------------------------------------------------------------------------------------------------- + + //230220byzsh-------------------------------------------------------------------------------------------- + case algorithm_type_t::VIDEO_TIMING_SNAPSHOT: { + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "frame_stride", "I"); + jint j_frame_stride = env->GetIntField(algorConfigParam_algorInitParam, fid); + typedef algor_config_param_road_work algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + algor_param->frame_stride = (int)j_frame_stride; + printf("VIDEO_TIMING_SNAPSHOT j_frame_stride: %d \n", algor_param->frame_stride); + + } break; + //-------------------------------------------------------------------------------------------------------- + + case algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION: { + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F"); + jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "m_frame", "I"); + jint j_m_frame = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "n_frame", "I"); + jint j_n_frame = env->GetIntField(algorConfigParam_algorInitParam, fid); + + // std::printf("%s:%d i is %d mn is [%d %d] threshold is %f\n", __FILE__, __LINE__, i, (int)j_m_frame, + // (int)j_n_frame, (float)j_threshold); + + typedef algor_config_param_takeaway_member_classification algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + + // std::printf("%s:%d i is %d CKPT:2\n", __FILE__, __LINE__, i); + + algor_param->m = (int)j_m_frame; + algor_param->n = (int)j_n_frame; + algor_param->threshold = (float)j_threshold; + + std::printf("%s:%d i is %d mn is [%d %d] threshold is %f\n", __FILE__, __LINE__, i, algor_param->m, + algor_param->n, algor_param->threshold); + } break; + case algorithm_type_t::PEDESTRIAN_FIGHT: { + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F"); + jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I"); + jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I"); + jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F"); + jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, (float)j_threshold); + + typedef algor_config_param_pedestrian_fight algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + + algor_param->threshold = (float)j_threshold; + algor_param->pedestrian_min_width = (int)j_min_width; + algor_param->pedestrian_min_height = (int)j_min_height; + algor_param->pedestrian_confidence_threshold = (float)j_confidence_threshold; + + } break; + case algorithm_type_t::PEDESTRIAN_FALL: { + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F"); + jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I"); + jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I"); + jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F"); + jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, (float)j_threshold); + + typedef algor_config_param_pedestrian_fall algor_config_param_type; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + + algor_param->threshold = (float)j_threshold; + algor_param->pedestrian_min_width = (int)j_min_width; + algor_param->pedestrian_min_height = (int)j_min_height; + algor_param->pedestrian_confidence_threshold = (float)j_confidence_threshold; + + // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, algor_param->threshold); + } break; + + case algorithm_type_t::SMOKING_DET: + case algorithm_type_t::CALL_PHONE_DET: + case algorithm_type_t::NO_SAFETY_HELMET: + case algorithm_type_t::NO_REFLECTIVE_CLOTHING: { + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F"); + jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "m_frame", "I"); + jint j_m_frame = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "n_frame", "I"); + jint j_n_frame = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I"); + jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I"); + jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F"); + jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + std::printf("[%s:%d] tereshold %.2f mn [%d %d] minimum wh [%d %d] minimum_threshold %.2f\n", __FILE__, __LINE__, + (float)j_threshold, (int)j_m_frame, (int)j_n_frame, (int)j_min_width, (int)j_min_height, + (float)j_confidence_threshold); + + using algor_config_param_type = algor_config_param_pedestrian_safety_detector_basic; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + + algor_param->m = (int)j_m_frame; + algor_param->n = (int)j_n_frame; + algor_param->conf_threshold = (float)j_threshold; + algor_param->pedestrian_min_width = (int)j_min_width; + algor_param->pedestrian_min_height = (int)j_min_height; + algor_param->pedestrian_confidence_threshold = (float)j_confidence_threshold; + + // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, algor_param->threshold); + } break; + + case algorithm_type_t::VEHICLE_RETROGRADE: + case algorithm_type_t::PEDESTRIAN_RETROGRADE: { + + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "px1", "I"); + jint j_px1 = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "py1", "I"); + jint j_py1 = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "px2", "I"); + jint j_px2 = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "py2", "I"); + jint j_py2 = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "direction", "I"); + jint j_direction = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I"); + jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I"); + jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F"); + jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F"); + jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + std::printf( + "[%s:%d] point [(%d, %d), (%d, %d)] direction %d threshold %.2f minimum wh [%d %d] minimum_threshold %.2f\n", + __FILE__, __LINE__, (int)j_px1, (int)j_py1, (int)j_px2, (int)j_py2, (int)j_direction, (float)j_threshold, + (int)j_min_width, (int)j_min_height, (float)j_confidence_threshold); + + using algor_config_param_type = algor_config_param_retrograde_basic; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + + algor_param->px1 = (int)j_px1; + algor_param->px2 = (int)j_px2; + algor_param->py1 = (int)j_py1; + algor_param->py2 = (int)j_py2; + algor_param->conf_threshold = (float)j_confidence_threshold; + algor_param->minmum_width = std::max(0, (int)j_min_width); + algor_param->minmum_height = std::max(0, (int)j_min_height); + algor_param->direction = (int)j_direction; + } break; + + case algorithm_type_t::PEDESTRIAN_TRESPASS: + case algorithm_type_t::VEHICLE_TRESPASS: { + + jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "points_count", "I"); + jint j_points_count = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I"); + jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I"); + jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid); + + fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F"); + jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid); + + using algor_config_param_type = algor_config_param_trespass_basic; + mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type; + auto algor_param = + (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param; + + fid = env->GetFieldID(cls_AlgorConfigParam, "points", "[I"); + jintArray j_points = (jintArray)env->GetObjectField(algorConfigParam_algorInitParam, fid); + jint *points = (jint *)env->GetIntArrayElements(j_points, 0); + + for (size_t i = 0; i < (int)j_points_count; i++) { + /* + jobject obj_pointConfigParam = env->CallObjectMethod(j_points, mid_arraylist_points_get, i); + jclass cls_pointConfigParam = env->GetObjectClass(obj_pointConfigParam); + printf("33333333333"); + jfieldID fid_pointConfigParam_x = env->GetFieldID(cls_pointConfigParam, "x", "I"); + jint point_x = env->GetIntField(obj_pointConfigParam, fid_pointConfigParam_x); + + jfieldID fid_pointConfigParam_y = env->GetFieldID(cls_pointConfigParam, "y", "I"); + jint point_y = env->GetIntField(obj_pointConfigParam, fid_pointConfigParam_y); + */ + algor_param->points[i].x_ = (int)points[i * 2]; + algor_param->points[i].y_ = (int)points[i * 2 + 1]; + } + + algor_param->conf_threshold = (float)j_confidence_threshold; + algor_param->minmum_width = std::max(0, (int)j_min_width); + algor_param->minmum_height = std::max(0, (int)j_min_height); + algor_param->points_count = (int)j_points_count; + + std::printf("[%s:%d] points_count %d minmum_width %df minmum_height %d conf_threshold %.2f\n", __FILE__, __LINE__, + (int)j_points_count, (int)j_min_width, (int)j_min_height, (float)j_confidence_threshold); + + for (size_t i = 0; i < (int)j_points_count; i++) + printf(" i %d point (%d %d)\n", i, algor_param->points[i].x_, algor_param->points[i].y_); + } break; + + default: { + fprintf(stderr, "%s:%d Add Task Failed (Invalid algorithm type). \n", __FILE__, __LINE__); + code = -1; + } break; + } + } + + void *aiEngineHanle = (void *)handle; + code = add_task(aiEngineHanle, mTaskParam); + + if (!snapshot_little_AlgorConfigParamResSnapshotFolderMap.empty()) { + map::iterator iter = snapshot_little_AlgorConfigParamResSnapshotFolderMap.begin(); + while (iter != snapshot_little_AlgorConfigParamResSnapshotFolderMap.end()) { + env->ReleaseStringUTFChars(snapshot_little_AlgorConfigParamResSnapshotFolderMap[iter->first], + psnapshot_little_AlgorConfigParamResSnapshotFolderMap[iter->first]); + env->ReleaseStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[iter->first], + psnapshot_AlgorConfigParamResSnapshotFolderMap[iter->first]); + iter++; + } + snapshot_little_AlgorConfigParamResSnapshotFolderMap.clear(); + psnapshot_little_AlgorConfigParamResSnapshotFolderMap.clear(); + snapshot_AlgorConfigParamResSnapshotFolderMap.clear(); + psnapshot_AlgorConfigParamResSnapshotFolderMap.clear(); + } + + env->ReleaseStringUTFChars(str_taskParam_ipcUrl, taskParam_ipcUrl); + env->ReleaseStringUTFChars(str_taskParam_taskId, taskParam_taskId); + return code; +} + +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getTaskStatus(JNIEnv *env, + jobject thisObject, + jlong handle, + jstring task_id) { + int code = -1; + void *aiEngineHanle = (void *)handle; + if (aiEngineHanle != NULL) { + const char *p_taskId = env->GetStringUTFChars(task_id, JNI_FALSE); + code = get_task_status(aiEngineHanle, (char *)p_taskId); + env->ReleaseStringUTFChars(task_id, p_taskId); + } + return code; +} + +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_pauseTask(JNIEnv *env, jobject obj, + jlong handle, + jstring taskId, + jint max_timeout_ms) { + int code = -1; + void *aiEngineHanle = (void *)handle; + const char *p_taskId = env->GetStringUTFChars(taskId, JNI_FALSE); + code = pause_task(aiEngineHanle, (char *)p_taskId, (int)max_timeout_ms); + env->ReleaseStringUTFChars(taskId, p_taskId); + return code; +} + +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_restartTask( + JNIEnv *env, jobject obj, jlong handle, jstring taskId, jint max_timeout_ms) { + int code = -1; + void *aiEngineHanle = (void *)handle; + const char *p_taskId = env->GetStringUTFChars(taskId, JNI_FALSE); + code = restart_task(aiEngineHanle, (char *)p_taskId, (int)max_timeout_ms); + env->ReleaseStringUTFChars(taskId, p_taskId); + return code; +} + +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_finishTask( + JNIEnv *env, jobject obj, jlong handle, jstring taskId, jint max_timeout_ms) { + int code = -1; + void *aiEngineHanle = (void *)handle; + const char *p_taskId = env->GetStringUTFChars(taskId, JNI_FALSE); + code = finish_task(aiEngineHanle, (char *)p_taskId, (int)max_timeout_ms); + env->ReleaseStringUTFChars(taskId, p_taskId); + return code; +} + +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_release(JNIEnv *env, jobject obj, + jlong handle) { + int error_code = -1; + void *aiEngineHanle = (void *)handle; + if (aiEngineHanle != NULL) + error_code = tsl_aiplatform_release(&aiEngineHanle); + return error_code; +} + +JNIEXPORT jstring JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getVersion(JNIEnv *env, + jobject obj) { + const char *version = get_tsl_aiplatform_version(); + return env->NewStringUTF(version); +} + + +/* + * Class: com_objecteye_nativeinterface_AiEngineNativeInterface + * Method: screenshot_task + * Signature: (JLcom/objecteye/pojo/TaskParam;)I + * added by zsh 220802 + */ +JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_screenShotTask(JNIEnv *env, jobject obj, + jlong handle, + jobject taskParam) { + int code = 0; + + // getFieldID + jclass cls_taskParam = env->GetObjectClass(taskParam); + jfieldID fid_taskParam_ipcUrl = env->GetFieldID(cls_taskParam, "ipcUrl", "Ljava/lang/String;"); + jfieldID fid_taskParam_algorConfigParams = + env->GetFieldID(cls_taskParam, "algorConfigParams", "Ljava/util/ArrayList;"); + jfieldID fid_taskParam_algorCounts = env->GetFieldID(cls_taskParam, "algorCounts", "I"); + jfieldID fid_taskParam_taskId = env->GetFieldID(cls_taskParam, "taskId", "Ljava/lang/String;"); + + // getObjectField + jstring str_taskParam_ipcUrl = (jstring)env->GetObjectField(taskParam, fid_taskParam_ipcUrl); + const char *taskParam_ipcUrl = env->GetStringUTFChars(str_taskParam_ipcUrl, JNI_FALSE); + jint taskParam_algorCounts = env->GetIntField(taskParam, fid_taskParam_algorCounts); + jstring str_taskParam_taskId = (jstring)env->GetObjectField(taskParam, fid_taskParam_taskId); + const char *taskParam_taskId = env->GetStringUTFChars(str_taskParam_taskId, JNI_FALSE); + jobject taskParam_algorConfigParams = env->GetObjectField(taskParam, fid_taskParam_algorConfigParams); + + // java to C++ + task_param mTaskParam; + mTaskParam.ipc_url = taskParam_ipcUrl; + mTaskParam.algor_counts = taskParam_algorCounts; + mTaskParam.task_id = taskParam_taskId; + mTaskParam.algor_config_params = new algor_config_param[mTaskParam.algor_counts]; + + map snapshot_AlgorConfigParamResSnapshotFolderMap; + map psnapshot_AlgorConfigParamResSnapshotFolderMap; + + jclass cls_arraylist = env->FindClass("java/util/ArrayList"); + // method in class ArrayList + jmethodID mid_arraylist_get = env->GetMethodID(cls_arraylist, "get", "(I)Ljava/lang/Object;"); + + for (size_t i = 0; i < taskParam_algorCounts; i++) { + jobject obj_algorConfigParam = env->CallObjectMethod(taskParam_algorConfigParams, mid_arraylist_get, i); + jclass cls_algorConfigParam = env->GetObjectClass(obj_algorConfigParam); + + jfieldID fid_algorConfigParam_algorType = env->GetFieldID(cls_algorConfigParam, "algorType", "I"); + jint algorConfigParam_algorType = env->GetIntField(obj_algorConfigParam, fid_algorConfigParam_algorType); + + jfieldID fid_algorConfigParam_algorInitParam = + env->GetFieldID(cls_algorConfigParam, "algorInitParam", "Ljava/lang/Object;"); //可去掉？ + jobject algorConfigParam_algorInitParam = + env->GetObjectField(obj_algorConfigParam, fid_algorConfigParam_algorInitParam); //可去掉 + + jclass cls_AlgorConfigParam = env->GetObjectClass(algorConfigParam_algorInitParam); + + + /* assign public variables. */ + { + jfieldID fid_ssAlgorConfigParam_snapshotFolder = + env->GetFieldID(cls_AlgorConfigParam, "result_folder", "Ljava/lang/String;"); + + snapshot_AlgorConfigParamResSnapshotFolderMap[i] = + (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_snapshotFolder); + psnapshot_AlgorConfigParamResSnapshotFolderMap[i] = + (char *)env->GetStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[i], JNI_FALSE); + + auto algor_init_config_param = new algor_init_config_param_t; + auto algor_basic_param = new algor_basic_config_param_t; + + algor_basic_param->result_folder = psnapshot_AlgorConfigParamResSnapshotFolderMap[i]; + + algor_init_config_param->basic_param = algor_basic_param; + mTaskParam.algor_config_params[i].algor_init_config_param = algor_init_config_param; + mTaskParam.algor_config_params[i].algor_type = static_cast(algorConfigParam_algorType); + } + + } + + void *aiEngineHanle = (void *)handle; + code = screenshot_task(aiEngineHanle, mTaskParam); + + if (!snapshot_AlgorConfigParamResSnapshotFolderMap.empty()) { + map::iterator iter = snapshot_AlgorConfigParamResSnapshotFolderMap.begin(); + while (iter != snapshot_AlgorConfigParamResSnapshotFolderMap.end()) { + env->ReleaseStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[iter->first], + psnapshot_AlgorConfigParamResSnapshotFolderMap[iter->first]); + iter++; + } + snapshot_AlgorConfigParamResSnapshotFolderMap.clear(); + psnapshot_AlgorConfigParamResSnapshotFolderMap.clear(); + } + + env->ReleaseStringUTFChars(str_taskParam_ipcUrl, taskParam_ipcUrl); + env->ReleaseStringUTFChars(str_taskParam_taskId, taskParam_taskId); + return code; +} + + +ai_log_level getLogLevel(int logLevel) { + switch (logLevel) { + case -1: + return AI_LOG_LEVEL_CLOSE; + case 0: + return AI_LOG_LEVEL_TRACE; + case 1: + return AI_LOG_LEVEL_DEBUG; + case 2: + return AI_LOG_LEVEL_INFO; + case 3: + return AI_LOG_LEVEL_WARNING; + case 4: + return AI_LOG_LEVEL_ERROR; + } + return AI_LOG_LEVEL_DEBUG; +} diff --git a/src/tsl_aiplatform_jni/com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h b/src/tsl_aiplatform_jni/com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h new file mode 100644 index 0000000..1013126 --- /dev/null +++ b/src/tsl_aiplatform_jni/com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h @@ -0,0 +1,100 @@ +/* + * @Author: zhaoshuaihua + * @Date: 2022-08-02 20:01:51 + * @Last Modified by: zhaoshuaihua + * @Email: zhaoshuaihua@objecteye.com + * @Description: + */ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class com_objecteye_nativeinterface_TSLAiEngineNativeInter */ + +#ifndef _Included_com_objecteye_nativeinterface_TSLAiEngineNativeInter +#define _Included_com_objecteye_nativeinterface_TSLAiEngineNativeInter +#ifdef __cplusplus +extern "C" +{ +#endif + + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: load + * Signature: ()I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_load(JNIEnv *, jclass); + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: init + * Signature: ([Ljava/lang/Long;Lcom/objecteye/pojo/ruijin/TSLAiEngineParam;)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_init(JNIEnv *, jobject, jlongArray, jobject); + + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: addMqConn + * Signature: (JLcom/objecteye/pojo/ruijin/MqParam;)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addMqConn(JNIEnv *, jobject, jlong, jint, jobject); + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: addTask + * Signature: (JLcom/objecteye/pojo/ruijin/TaskParam;)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addTask(JNIEnv *, jobject, jlong, jobject); + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: getTaskStatus + * Signature: (JLjava/lang/String;)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getTaskStatus(JNIEnv *, jobject, jlong, jstring); + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: pauseTask + * Signature: (JLjava/lang/String;I)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_pauseTask(JNIEnv *, jobject, jlong, jstring, jint); + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: restartTask + * Signature: (JLjava/lang/String;I)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_restartTask(JNIEnv *, jobject, jlong, jstring, jint); + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: finishTask + * Signature: (JLjava/lang/String;I)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_finishTask(JNIEnv *, jobject, jlong, jstring, jint); + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: release + * Signature: (J)I + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_release(JNIEnv *, jobject, jlong); + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: getVersion + * Signature: ()Ljava/lang/String; + */ + JNIEXPORT jstring JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getVersion(JNIEnv *, jobject); + + /* + * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface + * Method: screenshot_task + * Signature: (JLcom/objecteye/pojo/TaskParam;)I + * added by zsh 220802 + */ + JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_screenShotTask(JNIEnv *, jobject, jlong, jobject); + + +#ifdef __cplusplus +} +#endif +#endif -- libgit2 0.21.4