Hu Chunming / vpt_ascend

Browse Code »

Commit 3c2078c96eb38fcab861c124eb024126b4968a9f

Authored by Hu Chunming 2025-08-04 21:10:06 +0800

1 parent 8af3795e

原版jni

Inline Side-by-side

Showing 3 changed files with 1008 additions and 87 deletions

src/Makefile deleted

View file @8af3795

1		-XX = g++
2		-
3		-
4		-PROJECT_ROOT= /data1/cmhu/vpt_ascend
5		-
6		-DEPEND_DIR = $(PROJECT_ROOT)/bin
7		-SRC_ROOT = $(PROJECT_ROOT)/src
8		-
9		-TARGET= $(PROJECT_ROOT)/bin/vpt_proj
10		-
11		-THIRDPARTY_ROOT = $(PROJECT_ROOT)/3rdparty
12		-SPDLOG_ROOT = $(THIRDPARTY_ROOT)/spdlog-1.9.2/release
13		-OPENCV_ROOT = $(THIRDPARTY_ROOT)/opencv-4.5.4/release
14		-JSON_ROOT = $(THIRDPARTY_ROOT)/jsoncpp-1.9.5/release
15		-FFMPEG_ROOT = $(THIRDPARTY_ROOT)/ffmpeg-4.2.2/release
16		-
17		-DEFS = -DENABLE_DVPP_INTERFACE
18		-
19		-include_dir=-I/usr/local/Ascend/ascend-toolkit/6.3.RC1/x86_64-linux/include \
20		- -I $(SPDLOG_ROOT)/include \
21		- -I $(SRC_ROOT)/common \
22		- -I $(OPENCV_ROOT)/include/opencv4 \
23		- -I $(JSON_ROOT)/include \
24		- -I $(FFMPEG_ROOT)/include \
25		-
26		-lib_dir=-L/usr/local/Ascend/ascend-toolkit/6.3.RC1/runtime/lib64 \
27		- -L/usr/local/Ascend/ascend-toolkit/latest/lib64 \
28		- -L/usr/local/Ascend/ascend-toolkit/latest/runtime/lib64 \
29		- -L/usr/local/Ascend/ascend-toolkit/latest/acllib/lib64 \
30		- -L/usr/local/Ascend/ascend-toolkit/6.3.RC1/runtime/lib64/stub \
31		-
32		-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 \
33		- -lplatform -lgraph_base -lqos_manager
34		-
35		-LIBS= -L $(SPDLOG_ROOT)/lib -l:libspdlog.a \
36		- -L $(DEPEND_DIR) -lvpt_det -lsycheck \
37		- -L $(OPENCV_ROOT)/lib -lopencv_video -lopencv_highgui -lopencv_imgproc -lopencv_core -lopencv_features2d -lopencv_flann\
38		- -L $(JSON_ROOT)/lib -ljsoncpp \
39		- -L $(FFMPEG_ROOT)/lib -lavformat -lavcodec -lswscale -lavutil -lavfilter -lswresample -lavdevice \
40		-
41		-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
42		-
43		-
44		-
45		-SRCS:=$(wildcard $(SRC_ROOT)/ai_platform/*.cpp) \
46		- $(wildcard $(SRC_ROOT)/decoder/interface/*.cpp) \
47		- $(wildcard $(SRC_ROOT)/decoder/dvpp/*.cpp) \
48		- $(wildcard $(SRC_ROOT)/demo/*.cpp) \
49		- $(wildcard $(SRC_ROOT)/ai_engine_module/sort/*.cpp) \
50		- $(wildcard $(SRC_ROOT)/ai_engine_module/*.cpp) \
51		- $(wildcard $(SRC_ROOT)/util/*.cpp) \
52		- $(wildcard $(SRC_ROOT)/reprocessing_module/*.cpp) \
53		-
54		-OBJS = $(patsubst %.cpp, %.o, $(notdir $(SRCS)))
55		-
56		-
57		-$(TARGET):$(OBJS)
58		- rm -f $(TARGET)
59		- $(XX) -o $@ $^ $(CXXFLAGS)
60		- rm -f *.o
61		-
62		-%.o:$(SRC_ROOT)/decoder/dvpp/%.cpp
63		- $(XX) $(CXXFLAGS) -c $<
64		-
65		-%.o:$(SRC_ROOT)/decoder/interface/%.cpp
66		- $(XX) $(CXXFLAGS) -c $<
67		-
68		-%.o:$(SRC_ROOT)/ai_platform/%.cpp
69		- $(XX) $(CXXFLAGS) -c $<
70		-
71		-%.o:$(SRC_ROOT)/ai_engine_module/sort/%.cpp
72		- $(XX) $(CXXFLAGS) -c $<
73		-
74		-%.o:$(SRC_ROOT)/ai_engine_module/%.cpp
75		- $(XX) $(CXXFLAGS) -c $<
76		-
77		-%.o:$(SRC_ROOT)/demo/%.cpp
78		- $(XX) $(CXXFLAGS) -c $<
79		-
80		-%.o:$(SRC_ROOT)/util/%.cpp
81		- $(XX) $(CXXFLAGS) -c $<
82		-
83		-%.o:$(SRC_ROOT)/reprocessing_module/%.cpp
84		- $(XX) $(CXXFLAGS) -c $<
85		-
86		-clean:
87		- rm -f *.o $(TARGET)
88	0	\ No newline at end of file

src/tsl_aiplatform_jni/AiEngineNativeInterface.cpp 0 → 100644

View file @3c2078c

	1	+#include "com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h"
	2	+#include "header.h"
	3	+#include "iostream"
	4	+#include "stl_aiplatform.h"
	5	+#include "sy_common.h"
	6	+#include "sy_errorinfo.h"
	7	+#include <map>
	8	+#include <string.h>
	9	+using namespace std;
	10	+
	11	+/**
	12	+ * */
	13	+JavaVM *g_jvm = NULL;
	14	+jclass g_jcls_vptdtJavaCallBack; //callback函数的class
	15	+jobject g_obj_vptdtJavaCallBack; //callback函数的obj
	16	+
	17	+ai_log_level getLogLevel(int logLevel);
	18	+
	19	+/*
	20	+ * Class: com_objecteye_nativeinterface_AiEngineNativeInterface
	21	+ * Method: load
	22	+ * Signature: ()I
	23	+ */
	24	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_load(JNIEnv *env, jclass jcls) {
	25	+ printf("strat VPTDTJNI_load \n");
	26	+ int ret = env->GetJavaVM(&g_jvm);
	27	+ if (ret == 0) {
	28	+ JNIEnv *g_env;
	29	+ int getEnvStatus = g_jvm->GetEnv((void **)&g_env, JNI_VERSION_1_8);
	30	+ if (getEnvStatus == JNI_OK){
	31	+ printf(" GetEnv successed \n");
	32	+ g_jcls_vptdtJavaCallBack = (jclass)env->NewGlobalRef(env->FindClass("com/objecteye/vehicle/vptdtJavaCallBack"));
	33	+ printf(" NewGlobalRef successed \n");
	34	+ jmethodID mid_vptdtJavaCallBack = env->GetMethodID(g_jcls_vptdtJavaCallBack, "<init>", "()V");
	35	+ printf(" GetMethodID successed \n");
	36	+ g_obj_vptdtJavaCallBack = env->NewGlobalRef(env->NewObject(g_jcls_vptdtJavaCallBack, mid_vptdtJavaCallBack));
	37	+ }
	38	+ ret = getEnvStatus;
	39	+ }
	40	+ printf("end VPTDTJNI_load \n");
	41	+ return ret;
	42	+}
	43	+
	44	+/*
	45	+ * Class: com_objecteye_nativeinterface_AiEngineNativeInterface
	46	+ * Method: init
	47	+ * Signature: ([Ljava/lang/Long;Lcom/objecteye/pojo/ruijin/AiEngineParam;)I
	48	+ */
	49	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_init(JNIEnv *env, jobject obj,
	50	+ jlongArray handleArray,
	51	+ jobject aiEngineParam) {
	52	+
	53	+ // getFieldID
	54	+ jclass cls_aiEngineParam = env->GetObjectClass(aiEngineParam);
	55	+ jfieldID fid_aiEngineParam_gpuid = env->GetFieldID(cls_aiEngineParam, "gpuID", "I");
	56	+ jfieldID fid_aiEngineParam_sipServerPort = env->GetFieldID(cls_aiEngineParam, "sipServerPort", "I");
	57	+ jfieldID fid_aiEngineParam_trtSerializeFileFolder = env->GetFieldID(cls_aiEngineParam, "trtSerializeFileFolder", "Ljava/lang/String;");
	58	+ jfieldID fid_aiEngineParam_modelsDir = env->GetFieldID(cls_aiEngineParam, "modelsDir", "Ljava/lang/String;");
	59	+ jfieldID fid_aiEngineParam_logLevel = env->GetFieldID(cls_aiEngineParam, "logLevel", "I");
	60	+ jfieldID fid_aiEngineParam_logPath = env->GetFieldID(cls_aiEngineParam, "logPath", "Ljava/lang/String;");
	61	+ jfieldID fid_aiEngineParam_logDays = env->GetFieldID(cls_aiEngineParam, "logDays", "I");
	62	+ jfieldID fid_aiEngineParam_logMem = env->GetFieldID(cls_aiEngineParam, "logMem", "D");
	63	+
	64	+
	65	+ // getObjectField
	66	+ jint aiEngineParam_gpuid = env->GetIntField(aiEngineParam, fid_aiEngineParam_gpuid);
	67	+ jint aiEngineParam_sipServerPort = env->GetIntField(aiEngineParam, fid_aiEngineParam_sipServerPort);
	68	+ jstring str_aiEngineParam_trtSerializeFileFolder =
	69	+ (jstring)env->GetObjectField(aiEngineParam, fid_aiEngineParam_trtSerializeFileFolder);
	70	+ const char *aiEngineParam_trtSerializeFileFolder =
	71	+ env->GetStringUTFChars(str_aiEngineParam_trtSerializeFileFolder, JNI_FALSE);
	72	+ jstring str_aiEngineParam_modelsDir =
	73	+ (jstring)env->GetObjectField(aiEngineParam, fid_aiEngineParam_modelsDir);
	74	+ const char *aiEngineParam_modelsDir =
	75	+ env->GetStringUTFChars(str_aiEngineParam_modelsDir, JNI_FALSE);
	76	+
	77	+ // log
	78	+ jstring str_aiEngineParam_logPath = (jstring)env->GetObjectField(aiEngineParam, fid_aiEngineParam_logPath);
	79	+ const char *aiEngineParam_logPath = env->GetStringUTFChars(str_aiEngineParam_logPath, JNI_FALSE);
	80	+
	81	+ jint aiEngineParam_logDays = env->GetIntField(aiEngineParam, fid_aiEngineParam_logDays);
	82	+ jdouble aiEngineParam_logMem = env->GetDoubleField(aiEngineParam, fid_aiEngineParam_logMem);
	83	+ jint aiEngineParam_logLevel = env->GetIntField(aiEngineParam, fid_aiEngineParam_logLevel);
	84	+
	85	+ // jobject to c++
	86	+ void *aiEngineHandle = nullptr;
	87	+
	88	+ tsl_aiplatform_param mAiEngineParam;
	89	+ mAiEngineParam.gpuid = aiEngineParam_gpuid;
	90	+ mAiEngineParam.sip_server_port= aiEngineParam_sipServerPort;
	91	+ mAiEngineParam.trt_serialize_file = (char *)aiEngineParam_trtSerializeFileFolder;
	92	+ mAiEngineParam.models_dir = (char *)aiEngineParam_modelsDir;
	93	+
	94	+ mAiEngineParam.log_level = getLogLevel(aiEngineParam_logLevel);
	95	+ mAiEngineParam.log_path = (char *)aiEngineParam_logPath;
	96	+ mAiEngineParam.log_days = aiEngineParam_logDays;
	97	+ mAiEngineParam.log_mem = aiEngineParam_logMem;
	98	+
	99	+ printf("-- ************* Summary ********************.\n");
	100	+ printf("-- sip server port:%d \n", (int)aiEngineParam_sipServerPort);
	101	+ printf("-- [logger]\n");
	102	+ printf("-- level :%d(int)\n", (int)aiEngineParam_logLevel);
	103	+ printf("-- path :%s(str)\n", (char *)aiEngineParam_logPath);
	104	+ printf("-- kp :%d(int)\n", (int)aiEngineParam_logDays);
	105	+ printf("-- mem :%d(int)\n", (int)aiEngineParam_logMem);
	106	+ printf("-- **********************************************.\n");
	107	+
	108	+
	109	+ // init
	110	+ int ret = tsl_aiplatform_init(&aiEngineHandle, mAiEngineParam);
	111	+ if (ret == 0) {
	112	+ jlong temp[1];
	113	+ temp[0] = (jlong)aiEngineHandle;
	114	+ env->SetLongArrayRegion(handleArray, 0, 1, temp);
	115	+ }
	116	+ env->ReleaseStringUTFChars(str_aiEngineParam_trtSerializeFileFolder, aiEngineParam_trtSerializeFileFolder);
	117	+ env->ReleaseStringUTFChars(str_aiEngineParam_logPath, aiEngineParam_logPath);
	118	+
	119	+ return ret;
	120	+}
	121	+
	122	+jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addMqConn(JNIEnv *env, jobject thisObject,
	123	+ jlong handle, jint task_type,
	124	+ jobject rabbitmq_conn) {
	125	+ // rabbitmq
	126	+ jclass cls_rabbitmq_conn = env->GetObjectClass(rabbitmq_conn);
	127	+
	128	+ jfieldID fid_aiEngineParam_rbmq_ip = env->GetFieldID(cls_rabbitmq_conn, "ip", "Ljava/lang/String;");
	129	+ jfieldID fid_aiEngineParam_rbmq_port = env->GetFieldID(cls_rabbitmq_conn, "port", "I");
	130	+
	131	+ jfieldID fid_aiEngineParam_rbmq_username = env->GetFieldID(cls_rabbitmq_conn, "username", "Ljava/lang/String;");
	132	+ jfieldID fid_aiEngineParam_rbmq_password = env->GetFieldID(cls_rabbitmq_conn, "password", "Ljava/lang/String;");
	133	+ jfieldID fid_aiEngineParam_rbmq_vhost = env->GetFieldID(cls_rabbitmq_conn, "vhost", "Ljava/lang/String;");
	134	+ jfieldID fid_aiEngineParam_rbmq_exchange = env->GetFieldID(cls_rabbitmq_conn, "exchange", "Ljava/lang/String;");
	135	+ jfieldID fid_aiEngineParam_rbmq_exchange_type =
	136	+ env->GetFieldID(cls_rabbitmq_conn, "exchangeType", "Ljava/lang/String;");
	137	+ jfieldID fid_aiEngineParam_rbmq_queue = env->GetFieldID(cls_rabbitmq_conn, "queue", "Ljava/lang/String;");
	138	+ jfieldID fid_aiEngineParam_rbmq_routingKey = env->GetFieldID(cls_rabbitmq_conn, "routingKey", "Ljava/lang/String;");
	139	+
	140	+ jfieldID fid_aiEngineParam_rbmq_durable_exchange = env->GetFieldID(cls_rabbitmq_conn, "durable_exchange", "Z");
	141	+ jfieldID fid_aiEngineParam_rbmq_durable_queue = env->GetFieldID(cls_rabbitmq_conn, "durable_queue", "Z");
	142	+
	143	+ jstring str_rbmq_ip = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_ip);
	144	+ const char *str_rbmq_ip_c = env->GetStringUTFChars(str_rbmq_ip, JNI_FALSE);
	145	+ jint int_rbmq_port = env->GetIntField(rabbitmq_conn, fid_aiEngineParam_rbmq_port);
	146	+ jstring str_rbmq_username = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_username);
	147	+ const char *str_rbmq_username_c = env->GetStringUTFChars(str_rbmq_username, JNI_FALSE);
	148	+ jstring str_rbmq_password = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_password);
	149	+ const char *str_rbmq_password_c = env->GetStringUTFChars(str_rbmq_password, JNI_FALSE);
	150	+ jstring str_rbmq_vhost = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_vhost);
	151	+ const char *str_rbmq_vhost_c = env->GetStringUTFChars(str_rbmq_vhost, JNI_FALSE);
	152	+ jstring str_rbmq_exchange = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_exchange);
	153	+ const char *str_rbmq_exchange_c = env->GetStringUTFChars(str_rbmq_exchange, JNI_FALSE);
	154	+ jstring str_rbmq_exchange_type = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_exchange_type);
	155	+ const char *str_rbmq_exchange_type_c = env->GetStringUTFChars(str_rbmq_exchange_type, JNI_FALSE);
	156	+ jstring str_rbmq_queue = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_queue);
	157	+ const char *str_rbmq_queue_c = env->GetStringUTFChars(str_rbmq_queue, JNI_FALSE);
	158	+ jstring str_rbmq_routingKey = (jstring)env->GetObjectField(rabbitmq_conn, fid_aiEngineParam_rbmq_routingKey);
	159	+ const char *str_rbmq_routingKey_c = env->GetStringUTFChars(str_rbmq_routingKey, JNI_FALSE);
	160	+
	161	+ jboolean bool_rbmq_durable_exchange = env->GetBooleanField(rabbitmq_conn, fid_aiEngineParam_rbmq_durable_exchange);
	162	+ jboolean bool_rbmq_durable_queue = env->GetBooleanField(rabbitmq_conn, fid_aiEngineParam_rbmq_durable_queue);
	163	+
	164	+ rabbitmq_conn_params_t mq_conn_params;
	165	+ {
	166	+
	167	+ strcpy(mq_conn_params.ip, str_rbmq_ip_c);
	168	+ strcpy(mq_conn_params.uname, str_rbmq_username_c);
	169	+ strcpy(mq_conn_params.passwd, str_rbmq_password_c);
	170	+ strcpy(mq_conn_params.vhost, str_rbmq_vhost_c);
	171	+ strcpy(mq_conn_params.exchange, str_rbmq_exchange_c);
	172	+ strcpy(mq_conn_params.exchange_type, str_rbmq_exchange_type_c);
	173	+ strcpy(mq_conn_params.queue, str_rbmq_queue_c);
	174	+ strcpy(mq_conn_params.routing_key, str_rbmq_routingKey_c);
	175	+ mq_conn_params.port = int_rbmq_port;
	176	+ mq_conn_params.durable_queue = bool_rbmq_durable_queue;
	177	+ mq_conn_params.durable_exchange = bool_rbmq_durable_exchange;
	178	+ }
	179	+
	180	+ env->ReleaseStringUTFChars(str_rbmq_ip, str_rbmq_ip_c);
	181	+ env->ReleaseStringUTFChars(str_rbmq_username, str_rbmq_username_c);
	182	+ env->ReleaseStringUTFChars(str_rbmq_password, str_rbmq_password_c);
	183	+ env->ReleaseStringUTFChars(str_rbmq_vhost, str_rbmq_vhost_c);
	184	+ env->ReleaseStringUTFChars(str_rbmq_exchange, str_rbmq_exchange_c);
	185	+ env->ReleaseStringUTFChars(str_rbmq_exchange_type, str_rbmq_exchange_type_c);
	186	+ env->ReleaseStringUTFChars(str_rbmq_queue, str_rbmq_queue_c);
	187	+ env->ReleaseStringUTFChars(str_rbmq_routingKey, str_rbmq_routingKey_c);
	188	+
	189	+ 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 "
	190	+ "exchange_type is %s queue is %s routing key is %s durable_exchange is %d durable_queue is %d\n",
	191	+ (int)task_type, mq_conn_params.ip, mq_conn_params.port, mq_conn_params.uname, mq_conn_params.passwd,
	192	+ mq_conn_params.vhost, mq_conn_params.exchange, mq_conn_params.exchange_type, mq_conn_params.queue,
	193	+ mq_conn_params.routing_key, mq_conn_params.durable_exchange, mq_conn_params.durable_queue);
	194	+
	195	+ int status = 0;
	196	+ void aiEngineHanle = (void )handle;
	197	+ if (0 != (status = add_mq_conn(aiEngineHanle, static_cast<mq_type_t>(task_type), mq_conn_params)))
	198	+ fprintf(stderr, "add mq conn failed.\n");
	199	+ return status;
	200	+}
	201	+
	202	+
	203	+// 请求视频流
	204	+bool gb28181_request_stream_callback(const char *task_id){
	205	+
	206	+ printf("request stream. taskId :%s.\n", task_id);
	207	+
	208	+ //java回调----------------------------------------
	209	+ void *p;
	210	+ // printf("1 \n");
	211	+ g_jvm->AttachCurrentThread(&p, NULL);
	212	+ // printf("2 \n");
	213	+ JNIEnv callBack_env = (JNIEnv )p;
	214	+
	215	+ jint ret = 0;
	216	+ if(callBack_env != nullptr){
	217	+ jmethodID mid_requestStreamhCallback = callBack_env->GetMethodID(g_jcls_vptdtJavaCallBack, "vptdtEventJavaCallBack", "(Ljava/lang/String;)I");
	218	+ // printf("3 \n");
	219	+ if(mid_requestStreamhCallback != nullptr){
	220	+ // printf("4 \n");
	221	+ ret = (jint)callBack_env->CallIntMethod(g_obj_vptdtJavaCallBack, mid_requestStreamhCallback, callBack_env->NewStringUTF(task_id));
	222	+ }
	223	+ // printf("5 \n");
	224	+ }
	225	+ g_jvm->DetachCurrentThread();
	226	+
	227	+ printf("request stream. taskId :%s ret: %d \n", task_id, ret);
	228	+
	229	+ if(ret == 0){
	230	+ return false;
	231	+ }
	232	+
	233	+ printf("request stream end .\n");
	234	+
	235	+ return true;
	236	+}
	237	+
	238	+
	239	+/*
	240	+ * Class: com_objecteye_nativeinterface_AiEngineNativeInterface
	241	+ * Method: addTask
	242	+ * Signature: (JLcom/objecteye/pojo/ruijin/TaskParam;)I
	243	+ */
	244	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addTask(JNIEnv *env, jobject obj,
	245	+ jlong handle,
	246	+ jobject taskParam) {
	247	+ int code = 0;
	248	+
	249	+ // getFieldID
	250	+ jclass cls_taskParam = env->GetObjectClass(taskParam);
	251	+ jfieldID fid_taskParam_ipcUrl = env->GetFieldID(cls_taskParam, "ipcUrl", "Ljava/lang/String;");
	252	+ jfieldID fid_taskParam_algorConfigParams =
	253	+ env->GetFieldID(cls_taskParam, "algorConfigParams", "Ljava/util/ArrayList;");
	254	+ jfieldID fid_taskParam_algorCounts = env->GetFieldID(cls_taskParam, "algorCounts", "I");
	255	+ jfieldID fid_taskParam_taskId = env->GetFieldID(cls_taskParam, "taskId", "Ljava/lang/String;");
	256	+
	257	+ jfieldID fid_taskParam_dec_type = env->GetFieldID(cls_taskParam, "decType", "I");
	258	+ jfieldID fid_taskParam_port = env->GetFieldID(cls_taskParam, "port", "I");
	259	+ jfieldID fid_taskParam_protocal = env->GetFieldID(cls_taskParam, "protocal", "I");
	260	+
	261	+ // getObjectField
	262	+ jstring str_taskParam_ipcUrl = (jstring)env->GetObjectField(taskParam, fid_taskParam_ipcUrl);
	263	+ const char *taskParam_ipcUrl = env->GetStringUTFChars(str_taskParam_ipcUrl, JNI_FALSE);
	264	+ jint taskParam_algorCounts = env->GetIntField(taskParam, fid_taskParam_algorCounts);
	265	+ jstring str_taskParam_taskId = (jstring)env->GetObjectField(taskParam, fid_taskParam_taskId);
	266	+ const char *taskParam_taskId = env->GetStringUTFChars(str_taskParam_taskId, JNI_FALSE);
	267	+ jobject taskParam_algorConfigParams = env->GetObjectField(taskParam, fid_taskParam_algorConfigParams);
	268	+
	269	+ jint taskParam_dec_type = env->GetIntField(taskParam, fid_taskParam_dec_type);
	270	+ jint taskParam_port = env->GetIntField(taskParam, fid_taskParam_port);
	271	+ jint taskParam_protocal = env->GetIntField(taskParam, fid_taskParam_protocal);
	272	+
	273	+ jclass cls_syRectParam = env->FindClass("com/objecteye/pojo/common/SyRectParam");
	274	+ jfieldID fid_syRectParam_left = env->GetFieldID(cls_syRectParam, "left", "I");
	275	+ jfieldID fid_syRectParam_top = env->GetFieldID(cls_syRectParam, "top", "I");
	276	+ jfieldID fid_syRectParam_width = env->GetFieldID(cls_syRectParam, "width", "I");
	277	+ jfieldID fid_syRectParam_height = env->GetFieldID(cls_syRectParam, "height", "I");
	278	+
	279	+ // java to C++
	280	+ task_param mTaskParam;
	281	+ mTaskParam.ipc_url = taskParam_ipcUrl;
	282	+ mTaskParam.algor_counts = taskParam_algorCounts;
	283	+ mTaskParam.task_id = taskParam_taskId;
	284	+ mTaskParam.algor_config_params = new algor_config_param[mTaskParam.algor_counts];
	285	+ mTaskParam.dec_type = taskParam_dec_type;
	286	+ mTaskParam.port = taskParam_port;
	287	+ mTaskParam.protocal = taskParam_protocal;
	288	+ mTaskParam.gb28181_request_stream_callback = gb28181_request_stream_callback;
	289	+
	290	+ map<int, jstring> snapshot_little_AlgorConfigParamResSnapshotFolderMap;
	291	+ map<int, char *> psnapshot_little_AlgorConfigParamResSnapshotFolderMap;
	292	+ map<int, jstring> snapshot_AlgorConfigParamResSnapshotFolderMap;
	293	+ map<int, char *> psnapshot_AlgorConfigParamResSnapshotFolderMap;
	294	+ map<int, jstring> snapshot_AlgorConfigParamResVideoFolderMap;
	295	+ map<int, char *> psnapshot_AlgorConfigParamResVideoFolderMap;
	296	+
	297	+ jclass cls_arraylist = env->FindClass("java/util/ArrayList");
	298	+ // method in class ArrayList
	299	+ jmethodID mid_arraylist_get = env->GetMethodID(cls_arraylist, "get", "(I)Ljava/lang/Object;");
	300	+
	301	+ for (size_t i = 0; i < taskParam_algorCounts; i++) {
	302	+ jobject obj_algorConfigParam = env->CallObjectMethod(taskParam_algorConfigParams, mid_arraylist_get, i);
	303	+ jclass cls_algorConfigParam = env->GetObjectClass(obj_algorConfigParam);
	304	+
	305	+ jfieldID fid_algorConfigParam_algorType = env->GetFieldID(cls_algorConfigParam, "algorType", "I");
	306	+ jint algorConfigParam_algorType = env->GetIntField(obj_algorConfigParam, fid_algorConfigParam_algorType);
	307	+
	308	+ jfieldID fid_algorConfigParam_algorInitParam =
	309	+ env->GetFieldID(cls_algorConfigParam, "algorInitParam", "Ljava/lang/Object;");
	310	+ jobject algorConfigParam_algorInitParam =
	311	+ env->GetObjectField(obj_algorConfigParam, fid_algorConfigParam_algorInitParam);
	312	+
	313	+ jclass cls_AlgorConfigParam = env->GetObjectClass(algorConfigParam_algorInitParam);
	314	+
	315	+ /* assign public variables. */
	316	+ auto algor_basic_param = new algor_basic_config_param_t;
	317	+ {
	318	+ jfieldID fid_ssAlgorConfigParam_algorRect =
	319	+ env->GetFieldID(cls_AlgorConfigParam, "algor_valid_rect", "Lcom/objecteye/pojo/common/SyRectParam;");
	320	+ jobject ssAlgorConfigParam_algorRect =
	321	+ env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_algorRect);
	322	+
	323	+ jint ssAlgorConfigParam_algorRect_left = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_left);
	324	+ jint ssAlgorConfigParam_algorRect_top = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_top);
	325	+ jint ssAlgorConfigParam_algorRect_width = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_width);
	326	+ jint ssAlgorConfigParam_algorRect_height = env->GetIntField(ssAlgorConfigParam_algorRect, fid_syRectParam_height);
	327	+
	328	+ jfieldID fid_ssAlgorConfigParam_snapshotLittleFolder =
	329	+ env->GetFieldID(cls_AlgorConfigParam, "result_folder_little", "Ljava/lang/String;");
	330	+ jfieldID fid_ssAlgorConfigParam_snapshotFolder =
	331	+ env->GetFieldID(cls_AlgorConfigParam, "result_folder", "Ljava/lang/String;");
	332	+ jfieldID fid_ssAlgorConfigParam_videoFolder =
	333	+ env->GetFieldID(cls_AlgorConfigParam, "video_folder", "Ljava/lang/String;"); //视频存储地址
	334	+
	335	+ snapshot_little_AlgorConfigParamResSnapshotFolderMap[i] =
	336	+ (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_snapshotLittleFolder);
	337	+ psnapshot_little_AlgorConfigParamResSnapshotFolderMap[i] =
	338	+ (char *)env->GetStringUTFChars(snapshot_little_AlgorConfigParamResSnapshotFolderMap[i], JNI_FALSE);
	339	+ snapshot_AlgorConfigParamResSnapshotFolderMap[i] =
	340	+ (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_snapshotFolder);
	341	+ psnapshot_AlgorConfigParamResSnapshotFolderMap[i] =
	342	+ (char *)env->GetStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[i], JNI_FALSE);
	343	+ snapshot_AlgorConfigParamResVideoFolderMap[i] =
	344	+ (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_videoFolder);
	345	+ psnapshot_AlgorConfigParamResVideoFolderMap[i] =
	346	+ (char *)env->GetStringUTFChars(snapshot_AlgorConfigParamResVideoFolderMap[i], JNI_FALSE);
	347	+
	348	+ auto algor_init_config_param = new algor_init_config_param_t;
	349	+
	350	+
	351	+ algor_basic_param->algor_valid_rect.top_ = ssAlgorConfigParam_algorRect_top;
	352	+ algor_basic_param->algor_valid_rect.left_ = ssAlgorConfigParam_algorRect_left;
	353	+ algor_basic_param->algor_valid_rect.width_ = ssAlgorConfigParam_algorRect_width;
	354	+ algor_basic_param->algor_valid_rect.height_ = ssAlgorConfigParam_algorRect_height;
	355	+
	356	+ algor_basic_param->result_folder = psnapshot_AlgorConfigParamResSnapshotFolderMap[i];
	357	+ algor_basic_param->result_folder_little = psnapshot_little_AlgorConfigParamResSnapshotFolderMap[i];
	358	+ algor_basic_param->video_folder = psnapshot_AlgorConfigParamResVideoFolderMap[i];
	359	+
	360	+ algor_init_config_param->basic_param = algor_basic_param;
	361	+ mTaskParam.algor_config_params[i].algor_init_config_param = algor_init_config_param;
	362	+ mTaskParam.algor_config_params[i].algor_type = static_cast<algorithm_type_t>(algorConfigParam_algorType);
	363	+ }
	364	+
	365	+ switch (static_cast<algorithm_type_t>(algorConfigParam_algorType)) {
	366	+ case algorithm_type_t::FACE_SNAPSHOT:
	367	+ // printf("FACE_SNAPSHOT result_folder: %s result_folder_little: %s \n", algor_basic_param->result_folder, algor_basic_param->result_folder_little);
	368	+ case algorithm_type_t::HUMAN_SNAPSHOT:
	369	+ case algorithm_type_t::VEHICLE_SNAPSHOT:
	370	+ case algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT: {
	371	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F");
	372	+ jfieldID fid_snap_frame_interval = env->GetFieldID(cls_AlgorConfigParam, "snap_frame_interval", "I");
	373	+ jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	374	+ jfloat j_snap_frame_interval = env->GetFloatField(algorConfigParam_algorInitParam, fid_snap_frame_interval);
	375	+
	376	+ typedef algor_config_param_snapshot algor_config_param_type;
	377	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	378	+ auto algor_param =
	379	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	380	+ algor_param->threshold = (float)j_threshold;
	381	+ algor_param->snap_frame_interval = (int)j_snap_frame_interval;
	382	+ } break;
	383	+
	384	+ //农村违法分析
	385	+ case algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET:
	386	+ case algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN:
	387	+ case algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE:
	388	+ case algorithm_type_t::NONMOTOR_VEHICLE_REFIT:
	389	+ case algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS:
	390	+ case algorithm_type_t::NONMOTOR_IN_VEHICLELANE:
	391	+ case algorithm_type_t::NONMOTOR_CEOSSPARKLINE:
	392	+ case algorithm_type_t::NONMOTOR_WRONGDIRECTION:
	393	+ case algorithm_type_t::PERSON_IN_VEHICLELANE:
	394	+ case algorithm_type_t::PERSON_CROSS:
	395	+ case algorithm_type_t::PERSON_RUNNING_REDLIGHTS:
	396	+ case algorithm_type_t::TRICYCLE_MANNED:
	397	+ case algorithm_type_t::VEHICLE_WRONGDIRECTION:
	398	+ case algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND:
	399	+ case algorithm_type_t::VEHICLE_NOTGIVEWAY:
	400	+ case algorithm_type_t::VEHICLE_NOTDECELERATION:
	401	+ case algorithm_type_t::TRUCK_MANNED: {
	402	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "hs_threshold", "I");
	403	+ jint j_hs_threshold = env->GetIntField(algorConfigParam_algorInitParam, fid);
	404	+ fid = env->GetFieldID(cls_AlgorConfigParam, "m_frame", "I");
	405	+ jint j_m_frame = env->GetIntField(algorConfigParam_algorInitParam, fid);
	406	+ fid = env->GetFieldID(cls_AlgorConfigParam, "n_frame", "I");
	407	+ jint j_n_frame = env->GetIntField(algorConfigParam_algorInitParam, fid);
	408	+ fid = env->GetFieldID(cls_AlgorConfigParam, "obj_min_width", "I");
	409	+ jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid);
	410	+ fid = env->GetFieldID(cls_AlgorConfigParam, "obj_min_height", "I");
	411	+ jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid);
	412	+ fid = env->GetFieldID(cls_AlgorConfigParam, "obj_confidence_threshold", "F");
	413	+ jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	414	+ std::printf("%s:%d i is %d mn is [%d %d] threshold is %d\n", __FILE__, __LINE__, i, (int)j_m_frame,
	415	+ (int)j_n_frame, (int)j_hs_threshold);
	416	+
	417	+ typedef algor_config_param_manned_incident algor_config_param_type;
	418	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	419	+ auto algor_param =
	420	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	421	+
	422	+ algor_param->m = (int)j_m_frame;
	423	+ algor_param->n = (int)j_n_frame;
	424	+ algor_param->hs_count_threshold = (int)j_hs_threshold;
	425	+
	426	+ algor_param->obj_min_width = (int)j_min_width;
	427	+ algor_param->obj_min_height = (int)j_min_height;
	428	+ algor_param->obj_confidence_threshold = (float)j_confidence_threshold;
	429	+ } break;
	430	+
	431	+
	432	+ case algorithm_type_t::HUMAN_GATHER: {
	433	+
	434	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "frame_stride", "I");
	435	+ jint j_frame_stride = env->GetIntField(algorConfigParam_algorInitParam, fid);
	436	+
	437	+ fid = env->GetFieldID(cls_AlgorConfigParam, "human_count_threshold", "I");
	438	+ jint j_human_count_thre = env->GetIntField(algorConfigParam_algorInitParam, fid);
	439	+
	440	+ typedef algor_config_param_human_gather algor_config_param_type;
	441	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	442	+ auto algor_param =
	443	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	444	+ algor_param->frame_stride = (int)j_frame_stride;
	445	+ algor_param->human_count_threshold = (int)j_human_count_thre;
	446	+ } break;
	447	+ //221026byzsh--------------------------------------------------------------------------------------------
	448	+ case algorithm_type_t::ROAD_WORK_DET: {
	449	+
	450	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "frame_stride", "I");
	451	+ jint j_frame_stride = env->GetIntField(algorConfigParam_algorInitParam, fid);
	452	+
	453	+ fid = env->GetFieldID(cls_AlgorConfigParam, "rblock_count_threshold", "I");
	454	+ jint j_rblock_count_thre = env->GetIntField(algorConfigParam_algorInitParam, fid);
	455	+
	456	+ typedef algor_config_param_road_work algor_config_param_type;
	457	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	458	+ auto algor_param =
	459	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	460	+ algor_param->frame_stride = (int)j_frame_stride;
	461	+ algor_param->rblock_count_threshold = (int)j_rblock_count_thre;
	462	+ } break;
	463	+ //--------------------------------------------------------------------------------------------------------
	464	+
	465	+ //230220byzsh--------------------------------------------------------------------------------------------
	466	+ case algorithm_type_t::VIDEO_TIMING_SNAPSHOT: {
	467	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "frame_stride", "I");
	468	+ jint j_frame_stride = env->GetIntField(algorConfigParam_algorInitParam, fid);
	469	+ typedef algor_config_param_road_work algor_config_param_type;
	470	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	471	+ auto algor_param =
	472	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	473	+ algor_param->frame_stride = (int)j_frame_stride;
	474	+ printf("VIDEO_TIMING_SNAPSHOT j_frame_stride: %d \n", algor_param->frame_stride);
	475	+
	476	+ } break;
	477	+ //--------------------------------------------------------------------------------------------------------
	478	+
	479	+ case algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION: {
	480	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F");
	481	+ jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	482	+
	483	+ fid = env->GetFieldID(cls_AlgorConfigParam, "m_frame", "I");
	484	+ jint j_m_frame = env->GetIntField(algorConfigParam_algorInitParam, fid);
	485	+
	486	+ fid = env->GetFieldID(cls_AlgorConfigParam, "n_frame", "I");
	487	+ jint j_n_frame = env->GetIntField(algorConfigParam_algorInitParam, fid);
	488	+
	489	+ // std::printf("%s:%d i is %d mn is [%d %d] threshold is %f\n", __FILE__, __LINE__, i, (int)j_m_frame,
	490	+ // (int)j_n_frame, (float)j_threshold);
	491	+
	492	+ typedef algor_config_param_takeaway_member_classification algor_config_param_type;
	493	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	494	+ auto algor_param =
	495	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	496	+
	497	+ // std::printf("%s:%d i is %d CKPT:2\n", __FILE__, __LINE__, i);
	498	+
	499	+ algor_param->m = (int)j_m_frame;
	500	+ algor_param->n = (int)j_n_frame;
	501	+ algor_param->threshold = (float)j_threshold;
	502	+
	503	+ std::printf("%s:%d i is %d mn is [%d %d] threshold is %f\n", __FILE__, __LINE__, i, algor_param->m,
	504	+ algor_param->n, algor_param->threshold);
	505	+ } break;
	506	+ case algorithm_type_t::PEDESTRIAN_FIGHT: {
	507	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F");
	508	+ jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	509	+
	510	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I");
	511	+ jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid);
	512	+
	513	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I");
	514	+ jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid);
	515	+
	516	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F");
	517	+ jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	518	+
	519	+ // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, (float)j_threshold);
	520	+
	521	+ typedef algor_config_param_pedestrian_fight algor_config_param_type;
	522	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	523	+ auto algor_param =
	524	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	525	+
	526	+ algor_param->threshold = (float)j_threshold;
	527	+ algor_param->pedestrian_min_width = (int)j_min_width;
	528	+ algor_param->pedestrian_min_height = (int)j_min_height;
	529	+ algor_param->pedestrian_confidence_threshold = (float)j_confidence_threshold;
	530	+
	531	+ } break;
	532	+ case algorithm_type_t::PEDESTRIAN_FALL: {
	533	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F");
	534	+ jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	535	+
	536	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I");
	537	+ jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid);
	538	+
	539	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I");
	540	+ jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid);
	541	+
	542	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F");
	543	+ jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	544	+
	545	+ // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, (float)j_threshold);
	546	+
	547	+ typedef algor_config_param_pedestrian_fall algor_config_param_type;
	548	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	549	+ auto algor_param =
	550	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	551	+
	552	+ algor_param->threshold = (float)j_threshold;
	553	+ algor_param->pedestrian_min_width = (int)j_min_width;
	554	+ algor_param->pedestrian_min_height = (int)j_min_height;
	555	+ algor_param->pedestrian_confidence_threshold = (float)j_confidence_threshold;
	556	+
	557	+ // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, algor_param->threshold);
	558	+ } break;
	559	+
	560	+ case algorithm_type_t::SMOKING_DET:
	561	+ case algorithm_type_t::CALL_PHONE_DET:
	562	+ case algorithm_type_t::NO_SAFETY_HELMET:
	563	+ case algorithm_type_t::NO_REFLECTIVE_CLOTHING: {
	564	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F");
	565	+ jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	566	+
	567	+ fid = env->GetFieldID(cls_AlgorConfigParam, "m_frame", "I");
	568	+ jint j_m_frame = env->GetIntField(algorConfigParam_algorInitParam, fid);
	569	+
	570	+ fid = env->GetFieldID(cls_AlgorConfigParam, "n_frame", "I");
	571	+ jint j_n_frame = env->GetIntField(algorConfigParam_algorInitParam, fid);
	572	+
	573	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I");
	574	+ jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid);
	575	+
	576	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I");
	577	+ jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid);
	578	+
	579	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F");
	580	+ jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	581	+
	582	+ std::printf("[%s:%d] tereshold %.2f mn [%d %d] minimum wh [%d %d] minimum_threshold %.2f\n", __FILE__, __LINE__,
	583	+ (float)j_threshold, (int)j_m_frame, (int)j_n_frame, (int)j_min_width, (int)j_min_height,
	584	+ (float)j_confidence_threshold);
	585	+
	586	+ using algor_config_param_type = algor_config_param_pedestrian_safety_detector_basic;
	587	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	588	+ auto algor_param =
	589	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	590	+
	591	+ algor_param->m = (int)j_m_frame;
	592	+ algor_param->n = (int)j_n_frame;
	593	+ algor_param->conf_threshold = (float)j_threshold;
	594	+ algor_param->pedestrian_min_width = (int)j_min_width;
	595	+ algor_param->pedestrian_min_height = (int)j_min_height;
	596	+ algor_param->pedestrian_confidence_threshold = (float)j_confidence_threshold;
	597	+
	598	+ // std::printf("%s:%d i is %d threshold is %f\n", __FILE__, __LINE__, i, algor_param->threshold);
	599	+ } break;
	600	+
	601	+ case algorithm_type_t::VEHICLE_RETROGRADE:
	602	+ case algorithm_type_t::PEDESTRIAN_RETROGRADE: {
	603	+
	604	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "px1", "I");
	605	+ jint j_px1 = env->GetIntField(algorConfigParam_algorInitParam, fid);
	606	+
	607	+ fid = env->GetFieldID(cls_AlgorConfigParam, "py1", "I");
	608	+ jint j_py1 = env->GetIntField(algorConfigParam_algorInitParam, fid);
	609	+
	610	+ fid = env->GetFieldID(cls_AlgorConfigParam, "px2", "I");
	611	+ jint j_px2 = env->GetIntField(algorConfigParam_algorInitParam, fid);
	612	+
	613	+ fid = env->GetFieldID(cls_AlgorConfigParam, "py2", "I");
	614	+ jint j_py2 = env->GetIntField(algorConfigParam_algorInitParam, fid);
	615	+
	616	+ fid = env->GetFieldID(cls_AlgorConfigParam, "direction", "I");
	617	+ jint j_direction = env->GetIntField(algorConfigParam_algorInitParam, fid);
	618	+
	619	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I");
	620	+ jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid);
	621	+
	622	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I");
	623	+ jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid);
	624	+
	625	+ fid = env->GetFieldID(cls_AlgorConfigParam, "threshold", "F");
	626	+ jfloat j_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	627	+
	628	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F");
	629	+ jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	630	+
	631	+ std::printf(
	632	+ "[%s:%d] point [(%d, %d), (%d, %d)] direction %d threshold %.2f minimum wh [%d %d] minimum_threshold %.2f\n",
	633	+ __FILE__, __LINE__, (int)j_px1, (int)j_py1, (int)j_px2, (int)j_py2, (int)j_direction, (float)j_threshold,
	634	+ (int)j_min_width, (int)j_min_height, (float)j_confidence_threshold);
	635	+
	636	+ using algor_config_param_type = algor_config_param_retrograde_basic;
	637	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	638	+ auto algor_param =
	639	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	640	+
	641	+ algor_param->px1 = (int)j_px1;
	642	+ algor_param->px2 = (int)j_px2;
	643	+ algor_param->py1 = (int)j_py1;
	644	+ algor_param->py2 = (int)j_py2;
	645	+ algor_param->conf_threshold = (float)j_confidence_threshold;
	646	+ algor_param->minmum_width = std::max(0, (int)j_min_width);
	647	+ algor_param->minmum_height = std::max(0, (int)j_min_height);
	648	+ algor_param->direction = (int)j_direction;
	649	+ } break;
	650	+
	651	+ case algorithm_type_t::PEDESTRIAN_TRESPASS:
	652	+ case algorithm_type_t::VEHICLE_TRESPASS: {
	653	+
	654	+ jfieldID fid = env->GetFieldID(cls_AlgorConfigParam, "points_count", "I");
	655	+ jint j_points_count = env->GetIntField(algorConfigParam_algorInitParam, fid);
	656	+
	657	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_width", "I");
	658	+ jint j_min_width = env->GetIntField(algorConfigParam_algorInitParam, fid);
	659	+
	660	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_min_height", "I");
	661	+ jint j_min_height = env->GetIntField(algorConfigParam_algorInitParam, fid);
	662	+
	663	+ fid = env->GetFieldID(cls_AlgorConfigParam, "pedestrian_confidence_threshold", "F");
	664	+ jfloat j_confidence_threshold = env->GetFloatField(algorConfigParam_algorInitParam, fid);
	665	+
	666	+ using algor_config_param_type = algor_config_param_trespass_basic;
	667	+ mTaskParam.algor_config_params[i].algor_init_config_param->algor_param = new algor_config_param_type;
	668	+ auto algor_param =
	669	+ (algor_config_param_type *)mTaskParam.algor_config_params[i].algor_init_config_param->algor_param;
	670	+
	671	+ fid = env->GetFieldID(cls_AlgorConfigParam, "points", "[I");
	672	+ jintArray j_points = (jintArray)env->GetObjectField(algorConfigParam_algorInitParam, fid);
	673	+ jint points = (jint )env->GetIntArrayElements(j_points, 0);
	674	+
	675	+ for (size_t i = 0; i < (int)j_points_count; i++) {
	676	+ /*
	677	+ jobject obj_pointConfigParam = env->CallObjectMethod(j_points, mid_arraylist_points_get, i);
	678	+ jclass cls_pointConfigParam = env->GetObjectClass(obj_pointConfigParam);
	679	+ printf("33333333333");
	680	+ jfieldID fid_pointConfigParam_x = env->GetFieldID(cls_pointConfigParam, "x", "I");
	681	+ jint point_x = env->GetIntField(obj_pointConfigParam, fid_pointConfigParam_x);
	682	+
	683	+ jfieldID fid_pointConfigParam_y = env->GetFieldID(cls_pointConfigParam, "y", "I");
	684	+ jint point_y = env->GetIntField(obj_pointConfigParam, fid_pointConfigParam_y);
	685	+ */
	686	+ algor_param->points[i].x_ = (int)points[i * 2];
	687	+ algor_param->points[i].y_ = (int)points[i * 2 + 1];
	688	+ }
	689	+
	690	+ algor_param->conf_threshold = (float)j_confidence_threshold;
	691	+ algor_param->minmum_width = std::max(0, (int)j_min_width);
	692	+ algor_param->minmum_height = std::max(0, (int)j_min_height);
	693	+ algor_param->points_count = (int)j_points_count;
	694	+
	695	+ std::printf("[%s:%d] points_count %d minmum_width %df minmum_height %d conf_threshold %.2f\n", __FILE__, __LINE__,
	696	+ (int)j_points_count, (int)j_min_width, (int)j_min_height, (float)j_confidence_threshold);
	697	+
	698	+ for (size_t i = 0; i < (int)j_points_count; i++)
	699	+ printf(" i %d point (%d %d)\n", i, algor_param->points[i].x_, algor_param->points[i].y_);
	700	+ } break;
	701	+
	702	+ default: {
	703	+ fprintf(stderr, "%s:%d Add Task Failed (Invalid algorithm type). \n", __FILE__, __LINE__);
	704	+ code = -1;
	705	+ } break;
	706	+ }
	707	+ }
	708	+
	709	+ void aiEngineHanle = (void )handle;
	710	+ code = add_task(aiEngineHanle, mTaskParam);
	711	+
	712	+ if (!snapshot_little_AlgorConfigParamResSnapshotFolderMap.empty()) {
	713	+ map<int, jstring>::iterator iter = snapshot_little_AlgorConfigParamResSnapshotFolderMap.begin();
	714	+ while (iter != snapshot_little_AlgorConfigParamResSnapshotFolderMap.end()) {
	715	+ env->ReleaseStringUTFChars(snapshot_little_AlgorConfigParamResSnapshotFolderMap[iter->first],
	716	+ psnapshot_little_AlgorConfigParamResSnapshotFolderMap[iter->first]);
	717	+ env->ReleaseStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[iter->first],
	718	+ psnapshot_AlgorConfigParamResSnapshotFolderMap[iter->first]);
	719	+ iter++;
	720	+ }
	721	+ snapshot_little_AlgorConfigParamResSnapshotFolderMap.clear();
	722	+ psnapshot_little_AlgorConfigParamResSnapshotFolderMap.clear();
	723	+ snapshot_AlgorConfigParamResSnapshotFolderMap.clear();
	724	+ psnapshot_AlgorConfigParamResSnapshotFolderMap.clear();
	725	+ }
	726	+
	727	+ env->ReleaseStringUTFChars(str_taskParam_ipcUrl, taskParam_ipcUrl);
	728	+ env->ReleaseStringUTFChars(str_taskParam_taskId, taskParam_taskId);
	729	+ return code;
	730	+}
	731	+
	732	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getTaskStatus(JNIEnv *env,
	733	+ jobject thisObject,
	734	+ jlong handle,
	735	+ jstring task_id) {
	736	+ int code = -1;
	737	+ void aiEngineHanle = (void )handle;
	738	+ if (aiEngineHanle != NULL) {
	739	+ const char *p_taskId = env->GetStringUTFChars(task_id, JNI_FALSE);
	740	+ code = get_task_status(aiEngineHanle, (char *)p_taskId);
	741	+ env->ReleaseStringUTFChars(task_id, p_taskId);
	742	+ }
	743	+ return code;
	744	+}
	745	+
	746	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_pauseTask(JNIEnv *env, jobject obj,
	747	+ jlong handle,
	748	+ jstring taskId,
	749	+ jint max_timeout_ms) {
	750	+ int code = -1;
	751	+ void aiEngineHanle = (void )handle;
	752	+ const char *p_taskId = env->GetStringUTFChars(taskId, JNI_FALSE);
	753	+ code = pause_task(aiEngineHanle, (char *)p_taskId, (int)max_timeout_ms);
	754	+ env->ReleaseStringUTFChars(taskId, p_taskId);
	755	+ return code;
	756	+}
	757	+
	758	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_restartTask(
	759	+ JNIEnv *env, jobject obj, jlong handle, jstring taskId, jint max_timeout_ms) {
	760	+ int code = -1;
	761	+ void aiEngineHanle = (void )handle;
	762	+ const char *p_taskId = env->GetStringUTFChars(taskId, JNI_FALSE);
	763	+ code = restart_task(aiEngineHanle, (char *)p_taskId, (int)max_timeout_ms);
	764	+ env->ReleaseStringUTFChars(taskId, p_taskId);
	765	+ return code;
	766	+}
	767	+
	768	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_finishTask(
	769	+ JNIEnv *env, jobject obj, jlong handle, jstring taskId, jint max_timeout_ms) {
	770	+ int code = -1;
	771	+ void aiEngineHanle = (void )handle;
	772	+ const char *p_taskId = env->GetStringUTFChars(taskId, JNI_FALSE);
	773	+ code = finish_task(aiEngineHanle, (char *)p_taskId, (int)max_timeout_ms);
	774	+ env->ReleaseStringUTFChars(taskId, p_taskId);
	775	+ return code;
	776	+}
	777	+
	778	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_release(JNIEnv *env, jobject obj,
	779	+ jlong handle) {
	780	+ int error_code = -1;
	781	+ void aiEngineHanle = (void )handle;
	782	+ if (aiEngineHanle != NULL)
	783	+ error_code = tsl_aiplatform_release(&aiEngineHanle);
	784	+ return error_code;
	785	+}
	786	+
	787	+JNIEXPORT jstring JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getVersion(JNIEnv *env,
	788	+ jobject obj) {
	789	+ const char *version = get_tsl_aiplatform_version();
	790	+ return env->NewStringUTF(version);
	791	+}
	792	+
	793	+
	794	+/*
	795	+ * Class: com_objecteye_nativeinterface_AiEngineNativeInterface
	796	+ * Method: screenshot_task
	797	+ * Signature: (JLcom/objecteye/pojo/TaskParam;)I
	798	+ * added by zsh 220802
	799	+ */
	800	+JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_screenShotTask(JNIEnv *env, jobject obj,
	801	+ jlong handle,
	802	+ jobject taskParam) {
	803	+ int code = 0;
	804	+
	805	+ // getFieldID
	806	+ jclass cls_taskParam = env->GetObjectClass(taskParam);
	807	+ jfieldID fid_taskParam_ipcUrl = env->GetFieldID(cls_taskParam, "ipcUrl", "Ljava/lang/String;");
	808	+ jfieldID fid_taskParam_algorConfigParams =
	809	+ env->GetFieldID(cls_taskParam, "algorConfigParams", "Ljava/util/ArrayList;");
	810	+ jfieldID fid_taskParam_algorCounts = env->GetFieldID(cls_taskParam, "algorCounts", "I");
	811	+ jfieldID fid_taskParam_taskId = env->GetFieldID(cls_taskParam, "taskId", "Ljava/lang/String;");
	812	+
	813	+ // getObjectField
	814	+ jstring str_taskParam_ipcUrl = (jstring)env->GetObjectField(taskParam, fid_taskParam_ipcUrl);
	815	+ const char *taskParam_ipcUrl = env->GetStringUTFChars(str_taskParam_ipcUrl, JNI_FALSE);
	816	+ jint taskParam_algorCounts = env->GetIntField(taskParam, fid_taskParam_algorCounts);
	817	+ jstring str_taskParam_taskId = (jstring)env->GetObjectField(taskParam, fid_taskParam_taskId);
	818	+ const char *taskParam_taskId = env->GetStringUTFChars(str_taskParam_taskId, JNI_FALSE);
	819	+ jobject taskParam_algorConfigParams = env->GetObjectField(taskParam, fid_taskParam_algorConfigParams);
	820	+
	821	+ // java to C++
	822	+ task_param mTaskParam;
	823	+ mTaskParam.ipc_url = taskParam_ipcUrl;
	824	+ mTaskParam.algor_counts = taskParam_algorCounts;
	825	+ mTaskParam.task_id = taskParam_taskId;
	826	+ mTaskParam.algor_config_params = new algor_config_param[mTaskParam.algor_counts];
	827	+
	828	+ map<int, jstring> snapshot_AlgorConfigParamResSnapshotFolderMap;
	829	+ map<int, char *> psnapshot_AlgorConfigParamResSnapshotFolderMap;
	830	+
	831	+ jclass cls_arraylist = env->FindClass("java/util/ArrayList");
	832	+ // method in class ArrayList
	833	+ jmethodID mid_arraylist_get = env->GetMethodID(cls_arraylist, "get", "(I)Ljava/lang/Object;");
	834	+
	835	+ for (size_t i = 0; i < taskParam_algorCounts; i++) {
	836	+ jobject obj_algorConfigParam = env->CallObjectMethod(taskParam_algorConfigParams, mid_arraylist_get, i);
	837	+ jclass cls_algorConfigParam = env->GetObjectClass(obj_algorConfigParam);
	838	+
	839	+ jfieldID fid_algorConfigParam_algorType = env->GetFieldID(cls_algorConfigParam, "algorType", "I");
	840	+ jint algorConfigParam_algorType = env->GetIntField(obj_algorConfigParam, fid_algorConfigParam_algorType);
	841	+
	842	+ jfieldID fid_algorConfigParam_algorInitParam =
	843	+ env->GetFieldID(cls_algorConfigParam, "algorInitParam", "Ljava/lang/Object;"); //可去掉？
	844	+ jobject algorConfigParam_algorInitParam =
	845	+ env->GetObjectField(obj_algorConfigParam, fid_algorConfigParam_algorInitParam); //可去掉
	846	+
	847	+ jclass cls_AlgorConfigParam = env->GetObjectClass(algorConfigParam_algorInitParam);
	848	+
	849	+
	850	+ /* assign public variables. */
	851	+ {
	852	+ jfieldID fid_ssAlgorConfigParam_snapshotFolder =
	853	+ env->GetFieldID(cls_AlgorConfigParam, "result_folder", "Ljava/lang/String;");
	854	+
	855	+ snapshot_AlgorConfigParamResSnapshotFolderMap[i] =
	856	+ (jstring)env->GetObjectField(algorConfigParam_algorInitParam, fid_ssAlgorConfigParam_snapshotFolder);
	857	+ psnapshot_AlgorConfigParamResSnapshotFolderMap[i] =
	858	+ (char *)env->GetStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[i], JNI_FALSE);
	859	+
	860	+ auto algor_init_config_param = new algor_init_config_param_t;
	861	+ auto algor_basic_param = new algor_basic_config_param_t;
	862	+
	863	+ algor_basic_param->result_folder = psnapshot_AlgorConfigParamResSnapshotFolderMap[i];
	864	+
	865	+ algor_init_config_param->basic_param = algor_basic_param;
	866	+ mTaskParam.algor_config_params[i].algor_init_config_param = algor_init_config_param;
	867	+ mTaskParam.algor_config_params[i].algor_type = static_cast<algorithm_type_t>(algorConfigParam_algorType);
	868	+ }
	869	+
	870	+ }
	871	+
	872	+ void aiEngineHanle = (void )handle;
	873	+ code = screenshot_task(aiEngineHanle, mTaskParam);
	874	+
	875	+ if (!snapshot_AlgorConfigParamResSnapshotFolderMap.empty()) {
	876	+ map<int, jstring>::iterator iter = snapshot_AlgorConfigParamResSnapshotFolderMap.begin();
	877	+ while (iter != snapshot_AlgorConfigParamResSnapshotFolderMap.end()) {
	878	+ env->ReleaseStringUTFChars(snapshot_AlgorConfigParamResSnapshotFolderMap[iter->first],
	879	+ psnapshot_AlgorConfigParamResSnapshotFolderMap[iter->first]);
	880	+ iter++;
	881	+ }
	882	+ snapshot_AlgorConfigParamResSnapshotFolderMap.clear();
	883	+ psnapshot_AlgorConfigParamResSnapshotFolderMap.clear();
	884	+ }
	885	+
	886	+ env->ReleaseStringUTFChars(str_taskParam_ipcUrl, taskParam_ipcUrl);
	887	+ env->ReleaseStringUTFChars(str_taskParam_taskId, taskParam_taskId);
	888	+ return code;
	889	+}
	890	+
	891	+
	892	+ai_log_level getLogLevel(int logLevel) {
	893	+ switch (logLevel) {
	894	+ case -1:
	895	+ return AI_LOG_LEVEL_CLOSE;
	896	+ case 0:
	897	+ return AI_LOG_LEVEL_TRACE;
	898	+ case 1:
	899	+ return AI_LOG_LEVEL_DEBUG;
	900	+ case 2:
	901	+ return AI_LOG_LEVEL_INFO;
	902	+ case 3:
	903	+ return AI_LOG_LEVEL_WARNING;
	904	+ case 4:
	905	+ return AI_LOG_LEVEL_ERROR;
	906	+ }
	907	+ return AI_LOG_LEVEL_DEBUG;
	908	+}
...	...

src/tsl_aiplatform_jni/com_objecteye_nativeinterface_TSLAiEngineNativeInterface.h 0 → 100644

View file @3c2078c

	1	+/*
	2	+ * @Author: zhaoshuaihua
	3	+ * @Date: 2022-08-02 20:01:51
	4	+ * @Last Modified by: zhaoshuaihua
	5	+ * @Email: zhaoshuaihua@objecteye.com
	6	+ * @Description:
	7	+ */
	8	+/* DO NOT EDIT THIS FILE - it is machine generated */
	9	+#include <jni.h>
	10	+/* Header for class com_objecteye_nativeinterface_TSLAiEngineNativeInter */
	11	+
	12	+#ifndef _Included_com_objecteye_nativeinterface_TSLAiEngineNativeInter
	13	+#define _Included_com_objecteye_nativeinterface_TSLAiEngineNativeInter
	14	+#ifdef __cplusplus
	15	+extern "C"
	16	+{
	17	+#endif
	18	+
	19	+
	20	+ /*
	21	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	22	+ * Method: load
	23	+ * Signature: ()I
	24	+ */
	25	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_load(JNIEnv *, jclass);
	26	+ /*
	27	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	28	+ * Method: init
	29	+ * Signature: ([Ljava/lang/Long;Lcom/objecteye/pojo/ruijin/TSLAiEngineParam;)I
	30	+ */
	31	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_init(JNIEnv *, jobject, jlongArray, jobject);
	32	+
	33	+
	34	+ /*
	35	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	36	+ * Method: addMqConn
	37	+ * Signature: (JLcom/objecteye/pojo/ruijin/MqParam;)I
	38	+ */
	39	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addMqConn(JNIEnv *, jobject, jlong, jint, jobject);
	40	+
	41	+ /*
	42	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	43	+ * Method: addTask
	44	+ * Signature: (JLcom/objecteye/pojo/ruijin/TaskParam;)I
	45	+ */
	46	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_addTask(JNIEnv *, jobject, jlong, jobject);
	47	+ /*
	48	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	49	+ * Method: getTaskStatus
	50	+ * Signature: (JLjava/lang/String;)I
	51	+ */
	52	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getTaskStatus(JNIEnv *, jobject, jlong, jstring);
	53	+ /*
	54	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	55	+ * Method: pauseTask
	56	+ * Signature: (JLjava/lang/String;I)I
	57	+ */
	58	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_pauseTask(JNIEnv *, jobject, jlong, jstring, jint);
	59	+
	60	+ /*
	61	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	62	+ * Method: restartTask
	63	+ * Signature: (JLjava/lang/String;I)I
	64	+ */
	65	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_restartTask(JNIEnv *, jobject, jlong, jstring, jint);
	66	+
	67	+ /*
	68	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	69	+ * Method: finishTask
	70	+ * Signature: (JLjava/lang/String;I)I
	71	+ */
	72	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_finishTask(JNIEnv *, jobject, jlong, jstring, jint);
	73	+
	74	+ /*
	75	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	76	+ * Method: release
	77	+ * Signature: (J)I
	78	+ */
	79	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_release(JNIEnv *, jobject, jlong);
	80	+
	81	+ /*
	82	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	83	+ * Method: getVersion
	84	+ * Signature: ()Ljava/lang/String;
	85	+ */
	86	+ JNIEXPORT jstring JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_getVersion(JNIEnv *, jobject);
	87	+
	88	+ /*
	89	+ * Class: com_objecteye_nativeinterface_TSLAiEngineNativeInterface
	90	+ * Method: screenshot_task
	91	+ * Signature: (JLcom/objecteye/pojo/TaskParam;)I
	92	+ * added by zsh 220802
	93	+ */
	94	+ JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_TSLAiEngineNativeInterface_screenShotTask(JNIEnv *, jobject, jlong, jobject);
	95	+
	96	+
	97	+#ifdef __cplusplus
	98	+}
	99	+#endif
	100	+#endif
...	...