#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_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); 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.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("-- [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; }