add csrc and mmdeploy module

csrc/mmdeploy/apis/java/native/mmdeploy_Detector.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_Detector */
+
+#ifndef _Included_mmdeploy_Detector
+#define _Included_mmdeploy_Detector
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_Detector
+ * Method:    create
+ * Signature: (Ljava/lang/String;Ljava/lang/String;I)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Detector_create(JNIEnv *, jobject, jstring, jstring, jint);
+
+/*
+ * Class:     mmdeploy_Detector
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_Detector_destroy(JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     mmdeploy_Detector
+ * Method:    apply
+ * Signature: (J[Lmmdeploy/Mat;[I)[Lmmdeploy/Detector/Result;
+ */
+JNIEXPORT jobjectArray JNICALL Java_mmdeploy_Detector_apply(JNIEnv *, jobject, jlong, jobjectArray,
+                                                            jintArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_Device.cpp

+#include "mmdeploy_Device.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/common.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_Device_create(JNIEnv *env, jobject, jstring name, jint index) {
+  auto device_name = env->GetStringUTFChars(name, nullptr);
+  mmdeploy_device_t device{};
+  auto ec = mmdeploy_device_create(device_name, (int)index, &device);
+  env->ReleaseStringUTFChars(name, device_name);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create device, code = {}", ec);
+    return -1;
+  }
+  return (jlong)device;
+}
+
+void Java_mmdeploy_Device_destroy(JNIEnv *, jobject, jlong device_) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_Device_destroy");
+  mmdeploy_device_destroy((mmdeploy_device_t)device_);
+}

csrc/mmdeploy/apis/java/native/mmdeploy_Device.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_Device */
+
+#ifndef _Included_mmdeploy_Device
+#define _Included_mmdeploy_Device
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_Device
+ * Method:    create
+ * Signature: (Ljava/lang/String;I)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Device_create(JNIEnv *, jobject, jstring, jint);
+
+/*
+ * Class:     mmdeploy_Device
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_Device_destroy(JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_Model.cpp

+#include "mmdeploy_Model.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/model.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_Model_create(JNIEnv *env, jobject, jstring path) {
+  auto model_path = env->GetStringUTFChars(path, nullptr);
+  mmdeploy_model_t model{};
+  auto ec = mmdeploy_model_create_by_path(model_path, &model);
+  env->ReleaseStringUTFChars(path, model_path);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create model, code = {}", ec);
+    return -1;
+  }
+  return (jlong)model;
+}
+
+void Java_mmdeploy_Model_destroy(JNIEnv *, jobject, jlong model_) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_Model_destroy");
+  mmdeploy_model_destroy((mmdeploy_model_t)model_);
+}

csrc/mmdeploy/apis/java/native/mmdeploy_Model.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_Model */
+
+#ifndef _Included_mmdeploy_Model
+#define _Included_mmdeploy_Model
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_Model
+ * Method:    create
+ * Signature: (Ljava/lang/String;)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Model_create(JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     mmdeploy_Model
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_Model_destroy(JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_PoseDetector.cpp

+#include "mmdeploy_PoseDetector.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/pose_detector.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_PoseDetector_create(JNIEnv *env, jobject, jstring modelPath, jstring deviceName,
+                                        jint device_id) {
+  auto model_path = env->GetStringUTFChars(modelPath, nullptr);
+  auto device_name = env->GetStringUTFChars(deviceName, nullptr);
+  mmdeploy_pose_detector_t pose_estimator{};
+  auto ec = mmdeploy_pose_detector_create_by_path(model_path, device_name, (int)device_id,
+                                                  &pose_estimator);
+  env->ReleaseStringUTFChars(modelPath, model_path);
+  env->ReleaseStringUTFChars(deviceName, device_name);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create pose estimator, code = {}", ec);
+    return -1;
+  }
+  return (jlong)pose_estimator;
+}
+
+void Java_mmdeploy_PoseDetector_destroy(JNIEnv *, jobject, jlong handle) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_PoseDetector_destroy");
+  mmdeploy_pose_detector_destroy((mmdeploy_pose_detector_t)handle);
+}
+
+jobjectArray Java_mmdeploy_PoseDetector_apply(JNIEnv *env, jobject thiz, jlong handle,
+                                              jobjectArray images) {
+  return With(env, images, [&](const mmdeploy_mat_t imgs[], int size) -> jobjectArray {
+    mmdeploy_pose_detection_t *results{};
+    auto ec = mmdeploy_pose_detector_apply((mmdeploy_pose_detector_t)handle, imgs, size, &results);
+    if (ec) {
+      MMDEPLOY_ERROR("failed to apply pose estimator, code = {}", ec);
+      return NULL;
+    }
+    auto result_cls = env->FindClass("mmdeploy/PoseDetector$Result");
+    auto result_ctor = env->GetMethodID(result_cls, "<init>", "([Lmmdeploy/PointF;[F)V");
+    auto array = env->NewObjectArray(size, result_cls, nullptr);
+    auto pointf_cls = env->FindClass("mmdeploy/PointF");
+    auto pointf_ctor = env->GetMethodID(pointf_cls, "<init>", "(FF)V");
+
+    for (int i = 0; i < size; ++i) {
+      auto keypoint_array = env->NewObjectArray(results[i].length, pointf_cls, nullptr);
+      for (int j = 0; j < results[i].length; ++j) {
+        auto keypointj = env->NewObject(pointf_cls, pointf_ctor, (jfloat)results[i].point[j].x,
+                                        (jfloat)results[i].point[j].y);
+        env->SetObjectArrayElement(keypoint_array, j, keypointj);
+      }
+      auto score_array = env->NewFloatArray(results[i].length);
+      env->SetFloatArrayRegion(score_array, 0, results[i].length, (jfloat *)results[i].score);
+      auto res = env->NewObject(result_cls, result_ctor, keypoint_array, score_array);
+      env->SetObjectArrayElement(array, i, res);
+    }
+    mmdeploy_pose_detector_release_result(results, size);
+    return array;
+  });
+}

csrc/mmdeploy/apis/java/native/mmdeploy_PoseDetector.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_PoseDetector */
+
+#ifndef _Included_mmdeploy_PoseDetector
+#define _Included_mmdeploy_PoseDetector
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_PoseDetector
+ * Method:    create
+ * Signature: (Ljava/lang/String;Ljava/lang/String;I)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_PoseDetector_create(JNIEnv *, jobject, jstring, jstring,
+                                                          jint);
+
+/*
+ * Class:     mmdeploy_PoseDetector
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_PoseDetector_destroy(JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     mmdeploy_PoseDetector
+ * Method:    apply
+ * Signature: (J[Lmmdeploy/Mat;)[Lmmdeploy/PoseDetector/Result;
+ */
+JNIEXPORT jobjectArray JNICALL Java_mmdeploy_PoseDetector_apply(JNIEnv *, jobject, jlong,
+                                                                jobjectArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_PoseTracker.cpp

+#include "mmdeploy_PoseTracker.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/pose_tracker.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_PoseTracker_create(JNIEnv *env, jobject, jlong detModel, jlong poseModel,
+                                       jlong context) {
+  mmdeploy_pose_tracker_t pose_tracker{};
+  auto ec = mmdeploy_pose_tracker_create((mmdeploy_model_t)detModel, (mmdeploy_model_t)poseModel,
+                                         (mmdeploy_context_t)context, &pose_tracker);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create pose tracker, code = {}", ec);
+    return -1;
+  }
+  return (jlong)pose_tracker;
+}
+
+void Java_mmdeploy_PoseTracker_destroy(JNIEnv *, jobject, jlong handle) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_PoseTracker_destroy");
+  mmdeploy_pose_tracker_destroy((mmdeploy_pose_tracker_t)handle);
+}
+
+jobject param_cpp_to_java(JNIEnv *env, mmdeploy_pose_tracker_param_t *params) {
+  auto param_cls = env->FindClass("mmdeploy/PoseTracker$Params");
+  auto param_ctor = env->GetMethodID(param_cls, "<init>", "(IIFFFIFIFFF[FIFIIFF[F)V");
+
+  jfloatArray keypointSigmas = env->NewFloatArray(params->keypoint_sigmas_size);
+  env->SetFloatArrayRegion(keypointSigmas, 0, params->keypoint_sigmas_size,
+                           (jfloat *)params->keypoint_sigmas);
+  jfloatArray smoothParams = env->NewFloatArray(3);
+  env->SetFloatArrayRegion(smoothParams, 0, 3, (jfloat *)params->smooth_params);
+
+  auto param = env->NewObject(
+      param_cls, param_ctor, (jint)params->det_interval, (jint)params->det_label,
+      (jfloat)params->det_thr, (jfloat)params->det_min_bbox_size, (jfloat)params->det_nms_thr,
+      (jint)params->pose_max_num_bboxes, (jfloat)params->pose_kpt_thr,
+      (jint)params->pose_min_keypoints, (jfloat)params->pose_bbox_scale,
+      (jfloat)params->pose_min_bbox_size, (jfloat)params->pose_nms_thr, keypointSigmas,
+      (jint)params->keypoint_sigmas_size, (jfloat)params->track_iou_thr,
+      (jint)params->track_max_missing, (jint)params->track_history_size,
+      (jfloat)params->std_weight_position, (jfloat)params->std_weight_velocity, smoothParams);
+  return param;
+}
+
+void param_java_to_cpp(JNIEnv *env, mmdeploy_pose_tracker_param_t *params, jobject customParam) {
+  auto param_cls = env->FindClass("mmdeploy/PoseTracker$Params");
+  auto param_ctor = env->GetMethodID(param_cls, "<init>", "(IIFFFIFIFFF[FIFIIFF[F)V");
+
+  jfieldID fieldID_detInterval = env->GetFieldID(param_cls, "detInterval", "I");
+  jint detInterval = env->GetIntField(customParam, fieldID_detInterval);
+  params->det_interval = (int)detInterval;
+  jfieldID fieldID_detLabel = env->GetFieldID(param_cls, "detLabel", "I");
+  jint detLabel = env->GetIntField(customParam, fieldID_detLabel);
+  params->det_label = (int)detLabel;
+  jfieldID fieldID_detThr = env->GetFieldID(param_cls, "detThr", "F");
+  jfloat detThr = env->GetFloatField(customParam, fieldID_detThr);
+  params->det_thr = (float)detThr;
+  jfieldID fieldID_detMinBboxSize = env->GetFieldID(param_cls, "detMinBboxSize", "F");
+  jfloat detMinBboxSize = env->GetFloatField(customParam, fieldID_detMinBboxSize);
+  params->det_min_bbox_size = (float)detMinBboxSize;
+  jfieldID fieldID_detNmsThr = env->GetFieldID(param_cls, "detNmsThr", "F");
+  jfloat detNmsThr = env->GetFloatField(customParam, fieldID_detNmsThr);
+  params->det_nms_thr = (float)detNmsThr;
+  jfieldID fieldID_poseMaxNumBboxes = env->GetFieldID(param_cls, "poseMaxNumBboxes", "I");
+  jint poseMaxNumBboxes = env->GetIntField(customParam, fieldID_poseMaxNumBboxes);
+  params->pose_max_num_bboxes = (int)poseMaxNumBboxes;
+  jfieldID fieldID_poseKptThr = env->GetFieldID(param_cls, "poseKptThr", "F");
+  jfloat poseKptThr = env->GetFloatField(customParam, fieldID_poseKptThr);
+  params->pose_kpt_thr = (float)poseKptThr;
+  jfieldID fieldID_poseMinKeypoints = env->GetFieldID(param_cls, "poseMinKeypoints", "I");
+  jint poseMinKeypoints = env->GetIntField(customParam, fieldID_poseMinKeypoints);
+  params->pose_min_keypoints = (int)poseMinKeypoints;
+  jfieldID fieldID_poseBboxScale = env->GetFieldID(param_cls, "poseBboxScale", "F");
+  jfloat poseBboxScale = env->GetFloatField(customParam, fieldID_poseBboxScale);
+  params->pose_bbox_scale = (float)poseBboxScale;
+  jfieldID fieldID_poseMinBboxSize = env->GetFieldID(param_cls, "poseMinBboxSize", "F");
+  jfloat poseMinBboxSize = env->GetFloatField(customParam, fieldID_poseMinBboxSize);
+  params->pose_min_bbox_size = (float)poseMinBboxSize;
+  jfieldID fieldID_poseNmsThr = env->GetFieldID(param_cls, "poseNmsThr", "F");
+  jfloat poseNmsThr = env->GetFloatField(customParam, fieldID_poseNmsThr);
+  params->pose_nms_thr = (float)poseNmsThr;
+  jfieldID fieldID_keypointSigmas = env->GetFieldID(param_cls, "keypointSigmas", "[F");
+  auto keypointSigmasObj = env->GetObjectField(customParam, fieldID_keypointSigmas);
+  float *keypointSigmas =
+      (float *)env->GetFloatArrayElements((jfloatArray)keypointSigmasObj, nullptr);
+  params->keypoint_sigmas = keypointSigmas;
+  env->ReleaseFloatArrayElements((jfloatArray)keypointSigmasObj, keypointSigmas, JNI_ABORT);
+  jfieldID fieldID_keypointSigmasSize = env->GetFieldID(param_cls, "keypointSigmasSize", "I");
+  jint keypointSigmasSize = env->GetIntField(customParam, fieldID_keypointSigmasSize);
+  params->keypoint_sigmas_size = keypointSigmasSize;
+  jfieldID fieldID_trackIouThr = env->GetFieldID(param_cls, "trackIouThr", "F");
+  jfloat trackIouThr = env->GetFloatField(customParam, fieldID_trackIouThr);
+  params->track_iou_thr = trackIouThr;
+  jfieldID fieldID_trackMaxMissing = env->GetFieldID(param_cls, "trackMaxMissing", "I");
+  jint trackMaxMissing = env->GetIntField(customParam, fieldID_trackMaxMissing);
+  params->track_max_missing = trackMaxMissing;
+  jfieldID fieldID_trackHistorySize = env->GetFieldID(param_cls, "trackHistorySize", "I");
+  jint trackHistorySize = env->GetIntField(customParam, fieldID_trackHistorySize);
+  params->track_history_size = trackHistorySize;
+  jfieldID fieldID_stdWeightPosition = env->GetFieldID(param_cls, "stdWeightPosition", "F");
+  jfloat stdWeightPosition = env->GetFloatField(customParam, fieldID_stdWeightPosition);
+  params->std_weight_position = stdWeightPosition;
+  jfieldID fieldID_stdWeightVelocity = env->GetFieldID(param_cls, "stdWeightVelocity", "F");
+  jfloat stdWeightVelocity = env->GetFloatField(customParam, fieldID_stdWeightVelocity);
+  params->std_weight_velocity = stdWeightVelocity;
+  jfieldID fieldID_smoothParams = env->GetFieldID(param_cls, "smoothParams", "[F");
+  auto smoothParamsObj = env->GetObjectField(customParam, fieldID_smoothParams);
+  float *smoothParams = (float *)env->GetFloatArrayElements((jfloatArray)smoothParamsObj, nullptr);
+  params->smooth_params[0] = smoothParams[0];
+  params->smooth_params[1] = smoothParams[1];
+  params->smooth_params[2] = smoothParams[2];
+  env->ReleaseFloatArrayElements((jfloatArray)smoothParamsObj, smoothParams, JNI_ABORT);
+}
+
+jobject Java_mmdeploy_PoseTracker_setDefaultParams(JNIEnv *env, jobject) {
+  mmdeploy_pose_tracker_param_t params{};
+  mmdeploy_pose_tracker_default_params(&params);
+  return param_cpp_to_java(env, &params);
+}
+
+jlong Java_mmdeploy_PoseTracker_createState(JNIEnv *env, jobject, jlong pipeline,
+                                            jobject paramsObject) {
+  mmdeploy_pose_tracker_state_t state{};
+  mmdeploy_pose_tracker_param_t params{};
+  param_java_to_cpp(env, &params, paramsObject);
+  auto ec = mmdeploy_pose_tracker_create_state((mmdeploy_pose_tracker_t)pipeline, &params, &state);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create pose tracker state, code = {}", ec);
+    return -1;
+  }
+  return (jlong)state;
+}
+
+void Java_mmdeploy_PoseTracker_destroyState(JNIEnv *, jobject, jlong state) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_PoseTracker_destroy");
+  mmdeploy_pose_tracker_destroy_state((mmdeploy_pose_tracker_state_t)state);
+}
+
+jobjectArray Java_mmdeploy_PoseTracker_apply(JNIEnv *env, jobject thiz, jlong handle,
+                                             jlongArray states, jobjectArray frames,
+                                             jintArray detects, jintArray counts) {
+  return With(env, frames, [&](const mmdeploy_mat_t imgs[], int size) -> jobjectArray {
+    mmdeploy_pose_tracker_target_t *results{};
+    int *result_count{};
+    auto states_array = env->GetLongArrayElements(states, nullptr);
+    auto detects_array = env->GetIntArrayElements(detects, nullptr);
+    auto ec = mmdeploy_pose_tracker_apply((mmdeploy_pose_tracker_t)handle,
+                                          (mmdeploy_pose_tracker_state_t *)states_array, imgs,
+                                          (int32_t *)detects_array, size, &results, &result_count);
+    if (ec) {
+      MMDEPLOY_ERROR("failed to apply pose tracker, code = {}", ec);
+      return NULL;
+    }
+    auto result_cls = env->FindClass("mmdeploy/PoseTracker$Result");
+    auto result_ctor =
+        env->GetMethodID(result_cls, "<init>", "([Lmmdeploy/PointF;[FLmmdeploy/Rect;I)V");
+    auto total = std::accumulate(result_count, result_count + size, 0);
+    auto array = env->NewObjectArray(total, result_cls, nullptr);
+    auto pointf_cls = env->FindClass("mmdeploy/PointF");
+    auto pointf_ctor = env->GetMethodID(pointf_cls, "<init>", "(FF)V");
+    auto rect_cls = env->FindClass("mmdeploy/Rect");
+    auto rect_ctor = env->GetMethodID(rect_cls, "<init>", "(FFFF)V");
+    for (int i = 0; i < total; ++i) {
+      auto keypoint_array = env->NewObjectArray(results[i].keypoint_count, pointf_cls, nullptr);
+      for (int j = 0; j < results[i].keypoint_count; ++j) {
+        auto keypointj = env->NewObject(pointf_cls, pointf_ctor, (jfloat)results[i].keypoints[j].x,
+                                        (jfloat)results[i].keypoints[j].y);
+        env->SetObjectArrayElement(keypoint_array, j, keypointj);
+      }
+      auto score_array = env->NewFloatArray(results[i].keypoint_count);
+      env->SetFloatArrayRegion(score_array, 0, results[i].keypoint_count,
+                               (jfloat *)results[i].scores);
+      auto rect = env->NewObject(rect_cls, rect_ctor, (jfloat)results[i].bbox.left,
+                                 (jfloat)results[i].bbox.top, (jfloat)results[i].bbox.right,
+                                 (jfloat)results[i].bbox.bottom);
+      auto target_id = results[i].target_id;
+      auto res = env->NewObject(result_cls, result_ctor, keypoint_array, score_array, rect,
+                                (int)target_id);
+      env->SetObjectArrayElement(array, i, res);
+    }
+    auto counts_array = env->GetIntArrayElements(counts, nullptr);
+    for (int i = 0; i < size; ++i) {
+      counts_array[i] = result_count[i];
+    }
+    env->ReleaseIntArrayElements(counts, counts_array, 0);
+    env->ReleaseLongArrayElements(states, states_array, 0);
+    env->ReleaseIntArrayElements(detects, detects_array, 0);
+    mmdeploy_pose_tracker_release_result(results, result_count, size);
+    return array;
+  });
+}

csrc/mmdeploy/apis/java/native/mmdeploy_PoseTracker.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_PoseTracker */
+
+#ifndef _Included_mmdeploy_PoseTracker
+#define _Included_mmdeploy_PoseTracker
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_PoseTracker
+ * Method:    create
+ * Signature: (JJJ)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_PoseTracker_create(JNIEnv *, jobject, jlong, jlong, jlong);
+
+/*
+ * Class:     mmdeploy_PoseTracker
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_PoseTracker_destroy(JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     mmdeploy_PoseTracker
+ * Method:    createState
+ * Signature: (JLmmdeploy/PoseTracker/Params;)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_PoseTracker_createState(JNIEnv *, jobject, jlong, jobject);
+
+/*
+ * Class:     mmdeploy_PoseTracker
+ * Method:    destroyState
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_PoseTracker_destroyState(JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     mmdeploy_PoseTracker
+ * Method:    setDefaultParams
+ * Signature: ()Lmmdeploy/PoseTracker/Params;
+ */
+JNIEXPORT jobject JNICALL Java_mmdeploy_PoseTracker_setDefaultParams(JNIEnv *, jobject);
+
+/*
+ * Class:     mmdeploy_PoseTracker
+ * Method:    apply
+ * Signature: (J[J[Lmmdeploy/Mat;[I[I)[Lmmdeploy/PoseTracker/Result;
+ */
+JNIEXPORT jobjectArray JNICALL Java_mmdeploy_PoseTracker_apply(JNIEnv *, jobject, jlong, jlongArray,
+                                                               jobjectArray, jintArray, jintArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_Profiler.cpp

+#include "mmdeploy_Profiler.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/common.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_Profiler_create(JNIEnv *env, jobject, jstring path) {
+  auto profiler_path = env->GetStringUTFChars(path, nullptr);
+  mmdeploy_profiler_t profiler{};
+  auto ec = mmdeploy_profiler_create(profiler_path, &profiler);
+  env->ReleaseStringUTFChars(path, profiler_path);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create profiler, code = {}", ec);
+    return -1;
+  }
+  return (jlong)profiler;
+}
+
+void Java_mmdeploy_Profiler_destroy(JNIEnv *, jobject, jlong profiler_) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_Profiler_destroy");
+  mmdeploy_profiler_destroy((mmdeploy_profiler_t)profiler_);
+}

csrc/mmdeploy/apis/java/native/mmdeploy_Profiler.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_Profiler */
+
+#ifndef _Included_mmdeploy_Profiler
+#define _Included_mmdeploy_Profiler
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_Profiler
+ * Method:    create
+ * Signature: (Ljava/lang/String;)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Profiler_create(JNIEnv *, jobject, jstring);
+
+/*
+ * Class:     mmdeploy_Profiler
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_Profiler_destroy(JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_Restorer.cpp

+#include "mmdeploy_Restorer.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/restorer.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_Restorer_create(JNIEnv *env, jobject, jstring modelPath, jstring deviceName,
+                                    jint device_id) {
+  auto model_path = env->GetStringUTFChars(modelPath, nullptr);
+  auto device_name = env->GetStringUTFChars(deviceName, nullptr);
+  mmdeploy_restorer_t restorer{};
+  auto ec = mmdeploy_restorer_create_by_path(model_path, device_name, (int)device_id, &restorer);
+  env->ReleaseStringUTFChars(modelPath, model_path);
+  env->ReleaseStringUTFChars(deviceName, device_name);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create restorer, code = {}", ec);
+    return -1;
+  }
+  return (jlong)restorer;
+}
+
+void Java_mmdeploy_Restorer_destroy(JNIEnv *, jobject, jlong handle) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_Restorer_destroy");
+  mmdeploy_restorer_destroy((mmdeploy_restorer_t)handle);
+}
+
+jobjectArray Java_mmdeploy_Restorer_apply(JNIEnv *env, jobject thiz, jlong handle,
+                                          jobjectArray images) {
+  return With(env, images, [&](const mmdeploy_mat_t imgs[], int size) -> jobjectArray {
+    mmdeploy_mat_t *results{};
+    auto ec = mmdeploy_restorer_apply((mmdeploy_restorer_t)handle, imgs, size, &results);
+    if (ec) {
+      MMDEPLOY_ERROR("failed to apply restorer, code = {}", ec);
+      return NULL;
+    }
+    const char *java_enum_format[] = {"BGR", "RGB", "GRAYSCALE", "NV12", "NV21", "BGRA"};
+    const char *java_enum_type[] = {"FLOAT", "HALF", "INT8", "INT32"};
+    auto result_cls = env->FindClass("mmdeploy/Restorer$Result");
+    auto result_ctor = env->GetMethodID(result_cls, "<init>", "(Lmmdeploy/Mat;)V");
+    auto array = env->NewObjectArray(size, result_cls, nullptr);
+    auto mat_cls = env->FindClass("mmdeploy/Mat");
+    auto mat_ctor =
+        env->GetMethodID(mat_cls, "<init>", "(IIILmmdeploy/PixelFormat;Lmmdeploy/DataType;[B)V");
+    auto format_cls = env->FindClass("mmdeploy/PixelFormat");
+    auto type_cls = env->FindClass("mmdeploy/DataType");
+
+    mmdeploy_mat_t *current_result = results;
+    for (int i = 0; i < size; ++i) {
+      auto test_format = current_result->format;
+      auto jdata = env->NewByteArray(current_result->width * current_result->height *
+                                     current_result->channel);
+      env->SetByteArrayRegion(
+          jdata, 0, current_result->width * current_result->height * current_result->channel,
+          (const jbyte *)(current_result->data));
+      jfieldID format_id = env->GetStaticFieldID(
+          format_cls, java_enum_format[current_result->format], "Lmmdeploy/PixelFormat;");
+      jobject format = env->GetStaticObjectField(format_cls, format_id);
+      jfieldID type_id = env->GetStaticFieldID(type_cls, java_enum_type[current_result->type],
+                                               "Lmmdeploy/DataType;");
+      jobject type = env->GetStaticObjectField(type_cls, type_id);
+      auto result_mat = env->NewObject(mat_cls, mat_ctor, (jint)(current_result->height),
+                                       (jint)(current_result->width),
+                                       (jint)(current_result->channel), format, type, jdata);
+      auto res = env->NewObject(result_cls, result_ctor, result_mat);
+      env->SetObjectArrayElement(array, i, res);
+      current_result++;
+    }
+    mmdeploy_restorer_release_result(results, size);
+    return array;
+  });
+}

csrc/mmdeploy/apis/java/native/mmdeploy_Restorer.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_Restorer */
+
+#ifndef _Included_mmdeploy_Restorer
+#define _Included_mmdeploy_Restorer
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_Restorer
+ * Method:    create
+ * Signature: (Ljava/lang/String;Ljava/lang/String;I)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Restorer_create(JNIEnv *, jobject, jstring, jstring, jint);
+
+/*
+ * Class:     mmdeploy_Restorer
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_Restorer_destroy(JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     mmdeploy_Restorer
+ * Method:    apply
+ * Signature: (J[Lmmdeploy/Mat;)[Lmmdeploy/Restorer/Result;
+ */
+JNIEXPORT jobjectArray JNICALL Java_mmdeploy_Restorer_apply(JNIEnv *, jobject, jlong, jobjectArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_RotatedDetector.cpp

+#include "mmdeploy_RotatedDetector.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/rotated_detector.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_RotatedDetector_create(JNIEnv *env, jobject, jstring modelPath,
+                                           jstring deviceName, jint device_id) {
+  auto model_path = env->GetStringUTFChars(modelPath, nullptr);
+  auto device_name = env->GetStringUTFChars(deviceName, nullptr);
+  mmdeploy_rotated_detector_t rotated_detector{};
+  auto ec = mmdeploy_rotated_detector_create_by_path(model_path, device_name, (int)device_id,
+                                                     &rotated_detector);
+  env->ReleaseStringUTFChars(modelPath, model_path);
+  env->ReleaseStringUTFChars(deviceName, device_name);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create rotated detector, code = {}", ec);
+    return -1;
+  }
+  return (jlong)rotated_detector;
+}
+
+void Java_mmdeploy_RotatedDetector_destroy(JNIEnv *, jobject, jlong handle) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_RotatedDetector_destroy");
+  mmdeploy_rotated_detector_destroy((mmdeploy_rotated_detector_t)handle);
+}
+
+jobjectArray Java_mmdeploy_RotatedDetector_apply(JNIEnv *env, jobject thiz, jlong handle,
+                                                 jobjectArray images, jintArray counts) {
+  return With(env, images, [&](const mmdeploy_mat_t imgs[], int size) -> jobjectArray {
+    mmdeploy_rotated_detection_t *results{};
+    int *result_count{};
+    auto ec = mmdeploy_rotated_detector_apply((mmdeploy_rotated_detector_t)handle, imgs, size,
+                                              &results, &result_count);
+    if (ec) {
+      MMDEPLOY_ERROR("failed to apply rotated detector, code = {}", ec);
+      return NULL;
+    }
+    auto result_cls = env->FindClass("mmdeploy/RotatedDetector$Result");
+    auto result_ctor = env->GetMethodID(result_cls, "<init>", "(IF[F)V");
+    auto total = std::accumulate(result_count, result_count + size, 0);
+    auto array = env->NewObjectArray(total, result_cls, nullptr);
+
+    for (int i = 0; i < total; ++i) {
+      jfloatArray rbbox = env->NewFloatArray(5);
+      env->SetFloatArrayRegion(rbbox, 0, 5, (jfloat *)results[i].rbbox);
+      auto res = env->NewObject(result_cls, result_ctor, (jint)results[i].label_id,
+                                (jfloat)results[i].score, rbbox);
+      env->SetObjectArrayElement(array, i, res);
+    }
+    auto counts_array = env->GetIntArrayElements(counts, nullptr);
+    for (int i = 0; i < size; ++i) {
+      counts_array[i] = result_count[i];
+    }
+    env->ReleaseIntArrayElements(counts, counts_array, 0);
+    mmdeploy_rotated_detector_release_result(results, result_count);
+    return array;
+  });
+}

csrc/mmdeploy/apis/java/native/mmdeploy_RotatedDetector.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_RotatedDetector */
+
+#ifndef _Included_mmdeploy_RotatedDetector
+#define _Included_mmdeploy_RotatedDetector
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_RotatedDetector
+ * Method:    create
+ * Signature: (Ljava/lang/String;Ljava/lang/String;I)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_RotatedDetector_create(JNIEnv *, jobject, jstring, jstring,
+                                                             jint);
+
+/*
+ * Class:     mmdeploy_RotatedDetector
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_RotatedDetector_destroy(JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     mmdeploy_RotatedDetector
+ * Method:    apply
+ * Signature: (J[Lmmdeploy/Mat;[I)[Lmmdeploy/RotatedDetector/Result;
+ */
+JNIEXPORT jobjectArray JNICALL Java_mmdeploy_RotatedDetector_apply(JNIEnv *, jobject, jlong,
+                                                                   jobjectArray, jintArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_Scheduler.cpp

+#include "mmdeploy_Scheduler.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/common.h"
+#include "mmdeploy/apis/c/mmdeploy/executor.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_Scheduler_createThreadPool(JNIEnv *env, jobject, jint numThreads) {
+  mmdeploy_scheduler_t scheduler = mmdeploy_executor_create_thread_pool((int)numThreads);
+  return (jlong)scheduler;
+}
+
+jlong Java_mmdeploy_Scheduler_createThread(JNIEnv *env, jobject) {
+  mmdeploy_scheduler_t scheduler = mmdeploy_executor_create_thread();
+  return (jlong)scheduler;
+}
+
+void Java_mmdeploy_Scheduler_destroy(JNIEnv *, jobject, jlong scheduler_) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_Scheduler_destroy");
+  mmdeploy_scheduler_destroy((mmdeploy_scheduler_t)scheduler_);
+}

csrc/mmdeploy/apis/java/native/mmdeploy_Scheduler.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_Scheduler */
+
+#ifndef _Included_mmdeploy_Scheduler
+#define _Included_mmdeploy_Scheduler
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_Scheduler
+ * Method:    createThreadPool
+ * Signature: (I)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Scheduler_createThreadPool(JNIEnv *, jclass, jint);
+
+/*
+ * Class:     mmdeploy_Scheduler
+ * Method:    createThread
+ * Signature: ()J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Scheduler_createThread(JNIEnv *, jclass);
+
+/*
+ * Class:     mmdeploy_Scheduler
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_Scheduler_destroy(JNIEnv *, jobject, jlong);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_Segmentor.cpp

+#include "mmdeploy_Segmentor.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/segmentor.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_Segmentor_create(JNIEnv *env, jobject, jstring modelPath, jstring deviceName,
+                                     jint device_id) {
+  auto model_path = env->GetStringUTFChars(modelPath, nullptr);
+  auto device_name = env->GetStringUTFChars(deviceName, nullptr);
+  mmdeploy_segmentor_t segmentor{};
+  auto ec = mmdeploy_segmentor_create_by_path(model_path, device_name, (int)device_id, &segmentor);
+  env->ReleaseStringUTFChars(modelPath, model_path);
+  env->ReleaseStringUTFChars(deviceName, device_name);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create segmentor, code = {}", ec);
+    return -1;
+  }
+  return (jlong)segmentor;
+}
+
+void Java_mmdeploy_Segmentor_destroy(JNIEnv *, jobject, jlong handle) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_Segmentor_destroy");
+  mmdeploy_segmentor_destroy((mmdeploy_segmentor_t)handle);
+}
+
+jobjectArray Java_mmdeploy_Segmentor_apply(JNIEnv *env, jobject thiz, jlong handle,
+                                           jobjectArray images) {
+  return With(env, images, [&](const mmdeploy_mat_t imgs[], int size) -> jobjectArray {
+    mmdeploy_segmentation_t *results{};
+    auto ec = mmdeploy_segmentor_apply((mmdeploy_segmentor_t)handle, imgs, size, &results);
+    if (ec) {
+      MMDEPLOY_ERROR("failed to apply segmentor, code = {}", ec);
+      return NULL;
+    }
+
+    auto result_cls = env->FindClass("mmdeploy/Segmentor$Result");
+    auto result_ctor = env->GetMethodID(result_cls, "<init>", "(III[I[F)V");
+    auto array = env->NewObjectArray(size, result_cls, nullptr);
+    jintArray jmask;
+    jfloatArray jscore;
+    for (int i = 0; i < size; ++i) {
+      int *mask = results[i].mask;
+      float *score = results[i].score;
+      if (results[i].mask) {
+        jmask = env->NewIntArray(results[i].height * results[i].width);
+        env->SetIntArrayRegion(jmask, 0, results[i].width * results[i].height, (const jint *)mask);
+      } else {
+        jmask = env->NewIntArray(0);
+        env->SetIntArrayRegion(jmask, 0, 0, nullptr);
+      }
+      if (results[i].score) {
+        jscore = env->NewFloatArray(results[i].classes * results[i].height * results[i].width);
+        env->SetFloatArrayRegion(jscore, 0,
+                                 results[i].classes * results[i].height * results[i].width,
+                                 (const jfloat *)score);
+      } else {
+        jscore = env->NewFloatArray(0);
+        env->SetFloatArrayRegion(jscore, 0, 0, nullptr);
+      }
+      auto res = env->NewObject(result_cls, result_ctor, (jint)results[i].height,
+                                (jint)results[i].width, (jint)results[i].classes, jmask, jscore);
+      env->SetObjectArrayElement(array, i, res);
+    }
+    mmdeploy_segmentor_release_result(results, size);
+    return array;
+  });
+}

csrc/mmdeploy/apis/java/native/mmdeploy_Segmentor.h

+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class mmdeploy_Segmentor */
+
+#ifndef _Included_mmdeploy_Segmentor
+#define _Included_mmdeploy_Segmentor
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     mmdeploy_Segmentor
+ * Method:    create
+ * Signature: (Ljava/lang/String;Ljava/lang/String;I)J
+ */
+JNIEXPORT jlong JNICALL Java_mmdeploy_Segmentor_create(JNIEnv *, jobject, jstring, jstring, jint);
+
+/*
+ * Class:     mmdeploy_Segmentor
+ * Method:    destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_mmdeploy_Segmentor_destroy(JNIEnv *, jobject, jlong);
+
+/*
+ * Class:     mmdeploy_Segmentor
+ * Method:    apply
+ * Signature: (J[Lmmdeploy/Mat;)[Lmmdeploy/Segmentor/Result;
+ */
+JNIEXPORT jobjectArray JNICALL Java_mmdeploy_Segmentor_apply(JNIEnv *, jobject, jlong,
+                                                             jobjectArray);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

csrc/mmdeploy/apis/java/native/mmdeploy_TextDetector.cpp

+#include "mmdeploy_TextDetector.h"
+
+#include <numeric>
+
+#include "mmdeploy/apis/c/mmdeploy/text_detector.h"
+#include "mmdeploy/apis/java/native/common.h"
+#include "mmdeploy/core/logger.h"
+
+jlong Java_mmdeploy_TextDetector_create(JNIEnv *env, jobject, jstring modelPath, jstring deviceName,
+                                        jint device_id) {
+  auto model_path = env->GetStringUTFChars(modelPath, nullptr);
+  auto device_name = env->GetStringUTFChars(deviceName, nullptr);
+  mmdeploy_text_detector_t text_detector{};
+  auto ec = mmdeploy_text_detector_create_by_path(model_path, device_name, (int)device_id,
+                                                  &text_detector);
+  env->ReleaseStringUTFChars(modelPath, model_path);
+  env->ReleaseStringUTFChars(deviceName, device_name);
+  if (ec) {
+    MMDEPLOY_ERROR("failed to create text_detector, code = {}", ec);
+    return -1;
+  }
+  return (jlong)text_detector;
+}
+
+void Java_mmdeploy_TextDetector_destroy(JNIEnv *, jobject, jlong handle) {
+  MMDEPLOY_DEBUG("Java_mmdeploy_TextDetector_destroy");
+  mmdeploy_text_detector_destroy((mmdeploy_text_detector_t)handle);
+}
+
+jobjectArray Java_mmdeploy_TextDetector_apply(JNIEnv *env, jobject thiz, jlong handle,
+                                              jobjectArray images, jintArray counts) {
+  return With(env, images, [&](const mmdeploy_mat_t imgs[], int size) -> jobjectArray {
+    mmdeploy_text_detection_t *results{};
+    int *result_count{};
+    auto ec = mmdeploy_text_detector_apply((mmdeploy_text_detector_t)handle, imgs, size, &results,
+                                           &result_count);
+    if (ec) {
+      MMDEPLOY_ERROR("failed to apply detector, code = {}", ec);
+      return NULL;
+    }
+    auto result_cls = env->FindClass("mmdeploy/TextDetector$Result");
+    auto result_ctor = env->GetMethodID(result_cls, "<init>", "([Lmmdeploy/PointF;F)V");
+    auto total = std::accumulate(result_count, result_count + size, 0);
+    auto array = env->NewObjectArray(total, result_cls, nullptr);
+    auto point_cls = env->FindClass("mmdeploy/PointF");
+    auto point_ctor = env->GetMethodID(point_cls, "<init>", "(FF)V");
+
+    for (int i = 0; i < total; ++i) {
+      jobjectArray bbox = env->NewObjectArray(4, point_cls, nullptr);
+      for (int j = 0; j < 4; ++j) {
+        auto point = env->NewObject(point_cls, point_ctor, (jfloat)results[i].bbox[j].x,
+                                    (jfloat)results[i].bbox[j].y);
+        env->SetObjectArrayElement(bbox, j, point);
+      }
+      auto res = env->NewObject(result_cls, result_ctor, bbox, (jfloat)results[i].score);
+      env->SetObjectArrayElement(array, i, res);
+    }
+    auto counts_array = env->GetIntArrayElements(counts, nullptr);
+    for (int i = 0; i < size; ++i) {
+      counts_array[i] = result_count[i];
+    }
+    env->ReleaseIntArrayElements(counts, counts_array, 0);
+    mmdeploy_text_detector_release_result(results, result_count, size);
+    return array;
+  });
+}