// ncnn include
#include "wrapperncnn.h"
#include "layer.h"
#include "net.h"

#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>

#include <float.h>
#include <fstream>
#include <stdio.h>
#include <vector>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <chrono>
#include <thread>

extern "C" {

/*
  Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
 */

#include "LibApi.h"
#include "securec.h"
#include "libapi_common_svp.h"
#include "libapi_npu_process.h"
#include "libapi_npu_model.h"

#define SAMPLE_SVP_NPU_ARG_MAX_NUM  3
#define SAMPLE_SVP_NPU_IDX_TWO  2
#define SAMPLE_SVP_NPU_CMP_STR_NUM 2

static char **g_npu_cmd_argv = TD_NULL;
static td_u32 g_npu_dev_id = 0;
static td_void *g_data_buf = TD_NULL;
static size_t g_buf_size;

// // #define YOLOV5_V60 1 //YOLOv5 v6.0
// #define YOLOV5_V62                                                             \
//   1 // YOLOv5 v6.2 export  onnx model method
//     // https://github.com/shaoshengsong/yolov5_62_export_ncnn
// #if YOLOV5_V60 || YOLOV5_V62
// #define MAX_STRIDE 64
// #else
// #define MAX_STRIDE 32
// #endif

#define MAX_STRIDE 64

/*
 * function : to process abnormal case
 */
#ifndef __LITEOS__
static td_void libapi_svp_npu_handle_sig(td_s32 signo)
{
    if (signo == SIGINT || signo == SIGTERM) {
        switch (*g_npu_cmd_argv[1]) {
            case '0':
                libapi_svp_npu_acl_resnet50_handle_sig();
                break;
            case '1':
                libapi_svp_npu_acl_resnet50_handle_sig();
                break;
            default:
                break;
        }
    }
	return ;
}
#endif


/*
 * function : show usage
 */
static td_void libapi_svp_npu_usage(const td_char *prg_name)
{
    printf("Usage : %s <index>\n", prg_name);
    printf("index:\n");
    printf("\t 0) acl_resnet50.\n");
    printf("\t 1) acl_resnet50_multithread.\n");
    printf("\t 2) acl_mobilenet_v3_dynamicbatch_with_mmzcache.\n");
	return ;
}


static td_s32 libapi_svp_npu_case(int argc, char *argv[])
{
    td_s32 ret = TD_SUCCESS;

    switch (*argv[1]) {
        case '0':
            if (argc != SAMPLE_SVP_NPU_ARG_MAX_NUM - 1) {
                return TD_FAILURE;
            }
            libapi_svp_npu_acl_resnet50();
            break;
        case '1':
            if (argc != SAMPLE_SVP_NPU_ARG_MAX_NUM - 1) {
                return TD_FAILURE;
            }
            libapi_svp_npu_acl_resnet50_multithread();
            break;
        case '2':
            if (argc != SAMPLE_SVP_NPU_ARG_MAX_NUM - 1) {
                return TD_FAILURE;
            }
            libapi_svp_npu_acl_mobilenet_v3_dynamicbatch();
            break;
        default:
            ret = TD_FAILURE;
            break;
    }
    return ret;
}


static td_s32 libapi_svp_npu_init_resource(td_void)
{
    /* ACL init */
    const char *acl_config_path = "";
    aclrtRunMode run_mode;
    td_s32 ret;

    ret = aclInit(acl_config_path);
    if (ret != ACL_ERROR_NONE) {
        macro_svp_trace_err("acl init fail.\n");
        return TD_FAILURE;
    }
    macro_svp_trace_info("acl init success.\n");

    /* open device */
    ret = aclrtSetDevice(g_npu_dev_id);
    if (ret != ACL_ERROR_NONE) {
        macro_svp_trace_err("acl open device %d fail.\n", g_npu_dev_id);
        return TD_FAILURE;
    }
    macro_svp_trace_info("open device %d success.\n", g_npu_dev_id);

    /* get run mode */
    ret = aclrtGetRunMode(&run_mode);
    if ((ret != ACL_ERROR_NONE) || (run_mode != ACL_DEVICE)) {
        macro_svp_trace_err("acl get run mode fail.\n");
        return TD_FAILURE;
    }
    macro_svp_trace_info("get run mode success\n");

    return TD_SUCCESS;
}


static td_void libapi_svp_npu_destroy_resource(td_void)
{
    aclError ret;

    ret = aclrtResetDevice(g_npu_dev_id);
    if (ret != ACL_ERROR_NONE) {
        macro_svp_trace_err("reset device fail\n");
    }
    macro_svp_trace_info("end to reset device is %d\n", g_npu_dev_id);

    ret = aclFinalize();
    if (ret != ACL_ERROR_NONE) {
        macro_svp_trace_err("finalize acl fail\n");
    }
    macro_svp_trace_info("end to finalize acl\n");
	return ;
}


static td_s32 libapi_svp_npu_acl_prepare_init()
{
    td_s32 ret;

    ret = libapi_svp_npu_init_resource();
    if (ret != TD_SUCCESS) {
        libapi_svp_npu_destroy_resource();
    }

    return ret;
}


static td_void libapi_svp_npu_acl_prepare_exit(td_u32 thread_num)
{
    for (td_u32 model_index = 0; model_index < thread_num; model_index++) {
        libapi_npu_destroy_desc(model_index);
        libapi_npu_unload_model(model_index);
    }
    libapi_svp_npu_destroy_resource();
	return ;
}


static td_s32 libapi_svp_npu_fill_input_data(td_void *dev_buf, size_t buf_size)
{
    td_s32 ret;
    td_char path[PATH_MAX] = { 0 };
    size_t file_size;

    if (realpath("testyuv.sp420", path) == TD_NULL) {
        macro_svp_trace_err("Invalid file!.\n");
        return TD_FAILURE;
    }

    FILE *fp = fopen(path, "rb");
    macro_svp_check_exps_return(fp == TD_NULL, TD_FAILURE, ENUM_SVP_ERR_LEVEL_ERROR,
        "open image file failed!\n");

    ret = fseek(fp, 0L, SEEK_END);
    macro_svp_check_exps_goto(ret == -1, end, ENUM_SVP_ERR_LEVEL_ERROR, "Fseek failed!\n");
    file_size = ftell(fp);
    macro_svp_check_exps_goto(file_size == 0, end, ENUM_SVP_ERR_LEVEL_ERROR, "Ftell failed!\n");
    ret = fseek(fp, 0L, SEEK_SET);
    macro_svp_check_exps_goto(ret == -1, end, ENUM_SVP_ERR_LEVEL_ERROR, "Fseek failed!\n");

    file_size = (file_size > buf_size) ? buf_size : file_size;
    ret = fread(dev_buf, file_size, 1, fp);
    macro_svp_check_exps_goto(ret != 1, end, ENUM_SVP_ERR_LEVEL_ERROR, "Read file failed!\n");

    if (fp != TD_NULL) {
        fclose(fp);
    }
    return TD_SUCCESS;

end:
    if (fp != TD_NULL) {
        fclose(fp);
    }
    return TD_FAILURE;
}


static td_s32 libapi_svp_npu_get_input_data(td_void **data_buf, size_t *data_len, td_u32 model_index, 
                                            td_void *yuv_data_buf, size_t yuv_data_len)
{
    size_t buf_size;
    td_s32 ret;

    ret = libapi_npu_get_input_size_by_index(0, &buf_size, model_index);
    if (ret != TD_SUCCESS) {
        macro_svp_trace_err("execute get input size fail.\n");
        return TD_FAILURE;
    }

    ret = aclrtMalloc(data_buf, buf_size, ACL_MEM_MALLOC_NORMAL_ONLY);
    if (ret != ACL_ERROR_NONE) {
        macro_svp_trace_err("malloc device buffer fail. size is %zu, errorCode is %d.\n", buf_size, ret);
        return TD_FAILURE;
    }

    // for new fill function
    size_t real_size = (yuv_data_len > buf_size) ? buf_size : yuv_data_len;
    std::cout << "yuv_data_len : " + std::to_string(yuv_data_len) << std::endl;
    std::cout << "buf_size : " + std::to_string(buf_size) << std::endl;
    std::cout << "real_size : " + std::to_string(real_size) << std::endl;
    memcpy(*data_buf, yuv_data_buf, real_size);

    // ret = libapi_svp_npu_fill_input_data(*data_buf, buf_size);
    // if (ret != TD_SUCCESS) {
    //     macro_svp_trace_err("memcpy_s device buffer fail.\n");
    //     (td_void)aclrtFree(data_buf);
    //     return TD_FAILURE;
    // }

    *data_len = real_size;

    macro_svp_trace_info("get input data success\n");

    return TD_SUCCESS;
}


static td_void libapi_svp_npu_release_input_data(td_void **data_buf, size_t *data_len, td_u32 thread_num)
{
    for (td_u32 model_index = 0; model_index < thread_num; model_index++) {
        ot_unused(data_len[model_index]);
        (td_void)aclrtFree(data_buf[model_index]);
    }
	return ;
}


static td_s32 libapi_svp_npu_dataset_prepare_init(td_u32 model_index)
{
    td_s32 ret;

    ret = libapi_npu_create_input_dataset(model_index);
    if (ret != TD_SUCCESS) {
        macro_svp_trace_err("execute create input fail.\n");
        return TD_FAILURE;
    }
    ret = libapi_npu_create_output(model_index);
    if (ret != TD_SUCCESS) {
        libapi_npu_destroy_input_dataset(model_index);
        macro_svp_trace_err("execute create output fail.\n");
        return TD_FAILURE;
    }
    return TD_SUCCESS;
}


static td_void libapi_svp_npu_dataset_prepare_exit(td_u32 thread_num)
{
    for (td_u32 model_index = 0; model_index < thread_num; model_index++) {
        libapi_npu_destroy_output(model_index);
        libapi_npu_destroy_input_dataset(model_index);
    }
	return ;
}


static td_s32 libapi_svp_npu_create_input_databuf(td_void *data_buf, size_t data_len, td_u32 model_index)
{
    return libapi_npu_create_input_databuf(data_buf, data_len, model_index);
}


static td_void libapi_svp_npu_destroy_input_databuf(td_u32 thread_num)
{
    for (td_u32 model_index = 0; model_index < thread_num; model_index++) {
        libapi_npu_destroy_input_databuf(model_index);
    }
	return ;
}


// static void bgr2yuv420sp(const unsigned char *bgrdata, int width, int height,
//                          unsigned char *yptr, unsigned char *uvptr,
//                          int stride) {
// #if __ARM_NEON
//   uint8x8_t _v38 = vdup_n_u8(38);
//   uint8x8_t _v75 = vdup_n_u8(75);
//   uint8x8_t _v15 = vdup_n_u8(15);

//   uint8x8_t _v127 = vdup_n_u8(127);
//   uint8x8_t _v84_107 = vzip_u8(vdup_n_u8(84), vdup_n_u8(107)).val[0];
//   uint8x8_t _v43_20 = vzip_u8(vdup_n_u8(43), vdup_n_u8(20)).val[0];
//   uint16x8_t _v128 = vdupq_n_u16((128 << 8) + 128);
// #endif // __ARM_NEON

//   for (int y = 0; y + 1 < height; y += 2) {
//     const unsigned char *p0 = bgrdata + y * width * 3;
//     const unsigned char *p1 = bgrdata + (y + 1) * width * 3;
//     unsigned char *yptr0 = yptr + y * stride;
//     unsigned char *yptr1 = yptr + (y + 1) * stride;
//     unsigned char *uvptr0 = uvptr + (y / 2) * stride;

//     int x = 0;
// #if __ARM_NEON
//     for (; x + 7 < width; x += 8) {
//       uint8x8x3_t _bgr0 = vld3_u8(p0);
//       uint8x8x3_t _bgr1 = vld3_u8(p1);

//       uint16x8_t _y0 = vmull_u8(_bgr0.val[0], _v15);
//       uint16x8_t _y1 = vmull_u8(_bgr1.val[0], _v15);
//       _y0 = vmlal_u8(_y0, _bgr0.val[1], _v75);
//       _y1 = vmlal_u8(_y1, _bgr1.val[1], _v75);
//       _y0 = vmlal_u8(_y0, _bgr0.val[2], _v38);
//       _y1 = vmlal_u8(_y1, _bgr1.val[2], _v38);
//       uint8x8_t _y0_u8 = vqrshrun_n_s16(vreinterpretq_s16_u16(_y0), 7);
//       uint8x8_t _y1_u8 = vqrshrun_n_s16(vreinterpretq_s16_u16(_y1), 7);

//       uint16x4_t _b4 = vpaddl_u8(_bgr0.val[0]);
//       uint16x4_t _g4 = vpaddl_u8(_bgr0.val[1]);
//       uint16x4_t _r4 = vpaddl_u8(_bgr0.val[2]);
//       _b4 = vpadal_u8(_b4, _bgr1.val[0]);
//       _g4 = vpadal_u8(_g4, _bgr1.val[1]);
//       _r4 = vpadal_u8(_r4, _bgr1.val[2]);
//       uint16x4x2_t _brbr = vzip_u16(_b4, _r4);
//       uint16x4x2_t _gggg = vzip_u16(_g4, _g4);
//       uint16x4x2_t _rbrb = vzip_u16(_r4, _b4);
//       uint8x8_t _br = vshrn_n_u16(vcombine_u16(_brbr.val[0], _brbr.val[1]), 2);
//       uint8x8_t _gg = vshrn_n_u16(vcombine_u16(_gggg.val[0], _gggg.val[1]), 2);
//       uint8x8_t _rb = vshrn_n_u16(vcombine_u16(_rbrb.val[0], _rbrb.val[1]), 2);

//       // uint8x8_t _br = vtrn_u8(_bgr0.val[0], _bgr0.val[2]).val[0];
//       // uint8x8_t _gg = vtrn_u8(_bgr0.val[1], _bgr0.val[1]).val[0];
//       // uint8x8_t _rb = vtrn_u8(_bgr0.val[2], _bgr0.val[0]).val[0];

//       uint16x8_t _uv = vmlal_u8(_v128, _br, _v127);
//       _uv = vmlsl_u8(_uv, _gg, _v84_107);
//       _uv = vmlsl_u8(_uv, _rb, _v43_20);
//       uint8x8_t _uv_u8 = vqshrn_n_u16(_uv, 8);

//       vst1_u8(yptr0, _y0_u8);
//       vst1_u8(yptr1, _y1_u8);
//       vst1_u8(uvptr0, _uv_u8);

//       p0 += 24;
//       p1 += 24;
//       yptr0 += 8;
//       yptr1 += 8;
//       uvptr0 += 8;
//     }
// #endif
//     for (; x + 1 < width; x += 2) {
//       unsigned char b00 = p0[0];
//       unsigned char g00 = p0[1];
//       unsigned char r00 = p0[2];

//       unsigned char b01 = p0[3];
//       unsigned char g01 = p0[4];
//       unsigned char r01 = p0[5];

//       unsigned char b10 = p1[0];
//       unsigned char g10 = p1[1];
//       unsigned char r10 = p1[2];

//       unsigned char b11 = p1[3];
//       unsigned char g11 = p1[4];
//       unsigned char r11 = p1[5];

//       // y =  0.29900 * r + 0.58700 * g + 0.11400 * b
//       // u = -0.16874 * r - 0.33126 * g + 0.50000 * b  + 128
//       // v =  0.50000 * r - 0.41869 * g - 0.08131 * b  + 128

// #define SATURATE_CAST_UCHAR(X)                                                 \
//   (unsigned char)::std::min(::std::max((int)(X), 0), 255);
//       unsigned char y00 =
//           SATURATE_CAST_UCHAR((38 * r00 + 75 * g00 + 15 * b00 + 64) >> 7);
//       unsigned char y01 =
//           SATURATE_CAST_UCHAR((38 * r01 + 75 * g01 + 15 * b01 + 64) >> 7);
//       unsigned char y10 =
//           SATURATE_CAST_UCHAR((38 * r10 + 75 * g10 + 15 * b10 + 64) >> 7);
//       unsigned char y11 =
//           SATURATE_CAST_UCHAR((38 * r11 + 75 * g11 + 15 * b11 + 64) >> 7);

//       unsigned char b4 = (b00 + b01 + b10 + b11) / 4;
//       unsigned char g4 = (g00 + g01 + g10 + g11) / 4;
//       unsigned char r4 = (r00 + r01 + r10 + r11) / 4;

//       // unsigned char b4 = b00;
//       // unsigned char g4 = g00;
//       // unsigned char r4 = r00;

//       unsigned char u = SATURATE_CAST_UCHAR(
//           ((-43 * r4 - 84 * g4 + 127 * b4 + 128) >> 8) + 128);
//       unsigned char v = SATURATE_CAST_UCHAR(
//           ((127 * r4 - 107 * g4 - 20 * b4 + 128) >> 8) + 128);
// #undef SATURATE_CAST_UCHAR

//       yptr0[0] = y00;
//       yptr0[1] = y01;
//       yptr1[0] = y10;
//       yptr1[1] = y11;
//       uvptr0[0] = u;
//       uvptr0[1] = v;

//       p0 += 6;
//       p1 += 6;
//       yptr0 += 2;
//       yptr1 += 2;
//       uvptr0 += 2;
//     }
//   }
// }

// struct YuvStuct {
// 	ncnn::Mat im;
// 	int size;
// };
// YuvStuct g_syuv;


// static std::vector<Object> objects;
// static int img_w;
// static int img_h;
// static float scale = 1.f;
// static int wpad;
// static int hpad;
// static std::vector<Object> proposals;
// static ncnn::Mat in_pad;


// static YuvStuct libapi_ncnn_convertimg_yolov5s(cv::Mat bgr)
// {
// 	// bgr = cv::imread(jpg, 1);
// 	if (bgr.empty()) {
// 		fprintf(stderr, "bgr.empty()\n");
// 		YuvStuct syuv;
// 		return syuv;
// 	}

// 	const int target_size = 640;
// 	const float prob_threshold = 0.25f;
// 	const float nms_threshold = 0.45f;

// 	img_w = bgr.cols;
// 	img_h = bgr.rows;

// 	// letterbox pad to multiple of MAX_STRIDE
//  	int w = img_w;
//   	int h = img_h;
//   	// float scale = 1.f;
// 	if (w > h) {
//     	scale = (float)target_size / w;
//     	w = target_size;
//     	h = h * scale;
//   	} else {
//     	scale = (float)target_size / h;
//     	h = target_size;
//     	w = w * scale;
// 	}

// 	ncnn::Mat in = ncnn::Mat::from_pixels_resize(
// 		bgr.data, ncnn::Mat::PIXEL_BGR2RGB, img_w, img_h, w, h);

// 	// pad to target_size rectangle
// 	// yolov5/utils/datasets.py letterbox
//   	wpad = (w + MAX_STRIDE - 1) / MAX_STRIDE * MAX_STRIDE - w;
//   	hpad = (h + MAX_STRIDE - 1) / MAX_STRIDE * MAX_STRIDE - h;

// 	printf("w:%d,h:%d,MAX_STRIDE:%d,wpad:%d,hpad:%d，scale:%f\n", w, h, MAX_STRIDE, wpad,
//          hpad,scale);

// 	const float norm_vals[3] = {1 / 255.f, 1 / 255.f, 1 / 255.f};
// 	in_pad.substract_mean_normalize(0, norm_vals);

// 	ncnn::copy_make_border(in, in_pad, hpad / 2, hpad - hpad / 2, wpad / 2,
//                          wpad - wpad / 2, ncnn::BORDER_CONSTANT, 114.f);

// 	int imgin_w = 640, imgin_h = 640;
// 	cv::Mat a(imgin_w, imgin_h, CV_8UC3);
// 	memset(a.data, 0xFF, imgin_w * imgin_h * 3);
// 	in.to_pixels(a.data, ncnn::Mat::PIXEL_RGB2BGR);
// 	// for test
// 	cv::imwrite("in_image.png", a);
// 	// cv::imshow("in_image", a);

// 	// yuv420sp
// 	ncnn::Mat yuv(imgin_w, imgin_h / 2 * 3, 1);
// 	unsigned char *puv = (unsigned char *)yuv + imgin_w * imgin_h;
// 	bgr2yuv420sp(a.data, imgin_w, imgin_h, yuv, puv, imgin_w);
	
// 	//for test
// 	FILE *fp = fopen("testyuv.sp420", "wb");
// 	if (fp) {
// 		fwrite(yuv, imgin_w * imgin_h * 3 / 2, 1, fp);
// 		fclose(fp);
// 	}

// 	g_syuv.im = yuv;
// 	g_syuv.size = imgin_w * imgin_h / 2 * 3;

// 	return g_syuv;
// }

static cv::Mat read_img(const std::string path)
{
	cv::Mat img;
    std::ifstream file(path, std::ios::binary);
    if (!file) {
        macro_svp_trace_err("无法打开文件！\n");
        return img;
    }
    std::vector<char> data((std::istreambuf_iterator<char>(file)), (std::istreambuf_iterator<char>()));
    file.close();
    img = cv::imdecode(cv::Mat(data), cv::IMREAD_COLOR);
    if (img.empty()) {
        macro_svp_trace_err("图像解码失败！\n");
        return img;
    }
  macro_svp_trace_info("图像解码成功！\n");
	return img;
}

/* function : show the sample of npu resnet50 */
// td_void libapi_svp_npu_acl_resnet50(td_void)

UmError LibapiSvpNpuHandleSig(void)
{
    struct sigaction sa;
    (td_void)memset_s(&sa, sizeof(struct sigaction), 0, sizeof(struct sigaction));
    sa.sa_handler = libapi_svp_npu_handle_sig;
    
    sa.sa_flags = 0;
    sigaction(SIGTERM, &sa, NULL);
    return UM_OK;
}


// svp step 1
UmError LibapiSvpNpuAclPrepareInit(void)
{
	td_s32 ret;

	ret = libapi_svp_npu_acl_prepare_init();
    return ret;
}


UmError LibApiSvpNpuAclPrepareExit(void)
{
	libapi_svp_npu_acl_prepare_exit(1);
    return UM_OK;
}


// svp step 2
UmError LibApiSvpNpuLoadModel(char* om_model_path, int model_index, bool is_cached)
{
    td_char path[PATH_MAX] = { 0 };
    td_s32 ret;

    if (sizeof(om_model_path) > PATH_MAX) {
        macro_svp_trace_err("pathname too long!.\n");
        return TD_NULL;
    }

    if (realpath(om_model_path, path) == TD_NULL) {
		std::cout << om_model_path << std::endl;
		std::cout << path << std::endl;
        macro_svp_trace_err("invalid file!.\n");
        return TD_NULL;
    }

    if (is_cached == TD_TRUE) {
        ret = libapi_npu_load_model_with_mem_cached(path, model_index);
    } else {
        ret = libapi_npu_load_model_with_mem(path, model_index);
    }

    if (ret != TD_SUCCESS) {
        macro_svp_trace_err("execute load model fail, model_index is:%d.\n", model_index);
        goto acl_prepare_end1;
    }

    ret = libapi_npu_create_desc(model_index);
    if (ret != TD_SUCCESS) {
        macro_svp_trace_err("execute create desc fail.\n");
        goto acl_prepare_end2;
    }

    return TD_SUCCESS;

acl_prepare_end2:
    libapi_npu_destroy_desc(model_index);

acl_prepare_end1:
    libapi_npu_unload_model(model_index);
    return ret;
}


UmError LibApiSvpNpuUnLoadModel(int model_index)
{
	libapi_npu_destroy_desc(model_index);
    libapi_npu_unload_model(model_index);
	return UM_OK;
}


// struct YuvStuct {
// 	ncnn::Mat im;
// 	int size;
// };

// for test
struct YuvStuct {
	// ncnn::Mat im;
    cv::Mat im;
	int size;
  YuvStuct()
  {
    im = cv::Mat::zeros(640, 640, CV_8UC3);
    size = 0;
  }
};


// svp step 3
UmError _LibApiSvpNpuLoadDataset(void **data_buf, size_t *data_len, int model_index, void *yuv_data_buf, size_t yuv_data_len)
{
    td_s32 ret;

    ret = libapi_svp_npu_dataset_prepare_init(model_index);
    if (ret != TD_SUCCESS) {
        // libapi_svp_npu_acl_prepare_exit(1);
		return ret;
    }

    // if (g_data_buf==NULL)
    // {
    ret = libapi_svp_npu_get_input_data(data_buf, data_len, model_index, yuv_data_buf, yuv_data_len);
    if (ret != TD_SUCCESS) {
        macro_svp_trace_err("execute create input fail.\n");
        libapi_svp_npu_dataset_prepare_exit(1);
        // libapi_svp_npu_acl_prepare_exit(1);
        return ret;
    }
    // }
    // else
    // {
    //     // for new fill function
    //     // std::cout << "yuv_data_len : " + std::to_string(yuv_data_len) << std::endl;
    //     // std::cout << "buf_size : " + std::to_string(buf_size) << std::endl;
    //     // std::cout << "real_size : " + std::to_string(real_size) << std::endl;
    //     memcpy(data_buf, yuv_data_buf, data_len);
    // }

    std::cout << "libapi_svp_npu_create_input_databuf data_len:" + std::to_string(*data_len) << std::endl;
    std::cout << "libapi_svp_npu_create_input_databuf model_index:" + std::to_string(model_index) << std::endl;
    ret = libapi_svp_npu_create_input_databuf(*data_buf, *data_len, model_index);
    if (ret != TD_SUCCESS) {
        macro_svp_trace_err("memcpy_s device buffer fail.\n");
        libapi_svp_npu_release_input_data(data_buf, data_len, 1);
    	libapi_svp_npu_dataset_prepare_exit(1);
    	// libapi_svp_npu_acl_prepare_exit(1);
		return ret;
    }

	return ret;
}


UmError LibApiSvpNpuLoadDataset(int model_index, void *src, size_t data_len, size_t imgin_w, size_t imgin_h, int flag)
{
    UmError ret;
    cv::Mat im(imgin_h, imgin_w, flag);
    memcpy(im.data, src, data_len);
    // cv::imwrite("tmp.png", im);

    ncnn_convertimg_yolov5s_by_cvim(&im);
    YuvStuct* psyuv = (YuvStuct*)ncnn_get_syuv_param();

    ret = _LibApiSvpNpuLoadDataset(&g_data_buf, &g_buf_size, model_index, psyuv->im.data, psyuv->size);
    if (ret != UM_OK) {
        macro_svp_trace_err("_LibApiSvpNpuLoadDataset fail.\n");
        return ret;
    }
    return ret;
}


UmError LibApiSvpNpuUnloadDataset()
{
	libapi_svp_npu_destroy_input_databuf(1);
	libapi_svp_npu_release_input_data(&g_data_buf, &g_buf_size, 1);
    libapi_svp_npu_dataset_prepare_exit(1);

    ncnn_clear_objects_param();
    ncnn_clear_proposals_param();
	return UM_OK;
}


UmError LibApiSvpNpuModelExecute(int model_index)
{
	td_s32 ret;

    auto start = std::chrono::high_resolution_clock::now();
	ret = libapi_npu_model_execute(model_index);
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = end - start;
    std::cout << "libapi_npu_model_execute 程序运行时间： " << elapsed.count() << " 秒" << std::endl;
	if (ret != TD_SUCCESS) {
		macro_svp_trace_err("execute inference fail.\n");
		return ret;
	}
	
    start = std::chrono::high_resolution_clock::now();
    libapi_npu_output_model_result(model_index);
    end = std::chrono::high_resolution_clock::now();
    elapsed = end - start;
    std::cout << "libapi_npu_output_model_result 程序运行时间： " << elapsed.count() << " 秒" << std::endl;

	return UM_OK;
}


struct Object {
  cv::Rect_<float> rect;
  int label;
  float prob;
};

struct TarObject {
    int x;
    int y;
    int width;
    int height;
    int label;
    float prob;
    char text[256];
};

struct RetrunObject {
    int count;
    TarObject objects[128];
};

UmError LibApiSvpNpuGetModelExecuteResult(int model_index, void* objs /*RetrunObject*/ )
{
    UmError ret;
    printf("0\n");
    std::vector<Object> _objs = (*(std::vector<Object>*)ncnn_get_objects_param());
    std::cout << "_objs.size()" + std::to_string(_objs.size()) << std::endl;

    const char** class_names = ncnn_get_class_name();
    char text[256];
    int baseLine = 0;
    RetrunObject* src_objs = (RetrunObject*)objs;

    int src_idx = 0;
    for (int i=0; i<_objs.size(); i++)
    {
        TarObject* tar_obj = &src_objs->objects[src_idx];
        const Object src_obj = _objs.at(i);
        // printf("1\n");

        // 这里要改，模型参数变化后，要调整
        // for test
        if (src_obj.label > 1) continue;
        if (src_obj.prob < 0.0) continue;
        src_idx++;

        sprintf(text, "%s %.1f%%", class_names[src_obj.label], src_obj.prob * 100);
        cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);
        int x = src_obj.rect.x;
        int y = src_obj.rect.y - label_size.height - baseLine;
        if (y < 0) y = 0;
        if (x + label_size.width > ((cv::Mat*)ncnn_get_cur_bgr())->cols)
            x = ((cv::Mat*)ncnn_get_cur_bgr())->cols - label_size.width;
        
        // printf("2\n");
        tar_obj->x = x;
        tar_obj->y = y;
        tar_obj->width = src_obj.rect.width;
        tar_obj->height = src_obj.rect.height;
        tar_obj->label = src_obj.label;
        tar_obj->prob = src_obj.prob;
        memcpy(tar_obj->text, class_names[src_obj.label], strlen(class_names[src_obj.label]));
        // printf("3\n");
        // printf("tar_obj->x:%d tar_obj->y:%d tar_obj->width:%d tar_obj->height:%d \
        //     tar_obj->label:%d tar_obj->prob:%f tar_obj->text:%s " \
        //     tar_obj->x, tar_obj->y, tar_obj->width, tar_obj->height, \
        //     tar_obj->label, tar_obj->prob, tar_obj->text);
        printf("tar_obj->x:%d tar_obj->y:%d tar_obj->width:%d tar_obj->height:%d tar_obj->label:%d tar_obj->text:%f \n", 
            tar_obj->x, tar_obj->y, tar_obj->width, tar_obj->height, tar_obj->label, tar_obj->prob);
        // printf("4\n");
        src_objs->count = src_idx;
        // printf("5\n");

        if (src_idx==128) break;
    }
    // printf("=========================\n");
    ncnn_clear_objects_param();
    ncnn_clear_proposals_param();
    return ret;
}

#include "libapi_ive_main.h"
#include "libapi_common_ive.h"
// 检查 MPI 初始化
UmError LibapiCommonIveCheckMpiInit()
{
    return libapi_common_ive_check_mpi_init();
}

// MPI 初始化
UmError LibapiCommonIveMpiInit()
{
    return libapi_common_ive_mpi_init();
}

// 推出 MPI
UmError LibapiCommonIveMpiExit()
{
    libapi_common_ive_mpi_exit();
    return TD_SUCCESS;
}

UmError LibApiIveCreateMMZImage(void *mmz_img, int img_type, int width, int height)
{
    return libapi_common_ive_create_image((ot_svp_img*)mmz_img, (ot_svp_img_type)img_type, width, height);
}

UmError LibApiIveDestroyMMZImage(void *mmz_img)
{
    return libapi_common_ive_destroy_image((ot_svp_img*)mmz_img);
}

UmError LibApiIveReadMMZFromOsMem(void *mmz_img, void *cv_src, int width, int height, int img_type)
{
    return libapi_common_ive_read_os_mem((ot_svp_img*)mmz_img, cv_src, width, height, (ot_svp_img_type)img_type);
}

UmError LibApiIveWriteMMZToOsMem(void *mmz_img, void *cv_tar)
{
    return libapi_common_ive_write_os_mem((ot_svp_img*)mmz_img, cv_tar);
}

UmError LibApiIveWriteMMZToFile(void *mmz_img, FILE *fp)
{
    return libapi_common_ive_write_file((ot_svp_img*)mmz_img, fp);
}

UmError LibApiCanny(void* src, int width, int height, int img_type, 
    void* dst, char canny_complete)
{
    return libapi_ive_canny(src, width, height, (ot_svp_img_type)img_type, dst, canny_complete);
}


UmError LibapiSobelHandleSig()
{
    libapi_ive_sobel_handle_sig();
    return TD_SUCCESS;
}

UmError LibApiSobel()
{
    libapi_ive_sobel();
    return TD_SUCCESS;
}

UmError LibapiKcfHandleSig()
{
    return TD_SUCCESS;
}

UmError LibApiKcf()
{
    libapi_ive_kcf();
    return TD_SUCCESS;
}

// int main(int argc, char* argv[])
// {
//     remove("image.png");

//     LibapiSvpNpuHandleSig();

//     LibapiSvpNpuAclPrepareInit();

// 	const char *om_model_path = "./yolov5s_v6.2.om";
// 	UmError ret = LibApiSvpNpuLoadModel(om_model_path, 0, false);
// 	if (ret != TD_SUCCESS) {
// 		macro_svp_trace_err("LibApiSvpNpuLoadModel fail.\n");
// 		exit(0);
// 	}

// 	td_char path[PATH_MAX] = { 0 };
//     if (realpath("./test.jpg", path) == TD_NULL) {
//         macro_svp_trace_err("Invalid file!.\n");
//         exit(0);
//     }

// 	const std::string spath = path;
// 	std::cout << spath << std::endl;
// 	cv::Mat im = read_img(spath);	
//     // cv::Mat im = cv::imread("test.jpg", 1);
// 	if (im.empty())
// 	{
// 		std::cout << "im is empty" << std::endl;
// 		exit(0);
// 	}
	
//     for (int i=0; i<30; i++)
//     {
//         std::cout << std::to_string(im.total()*im.channels()) << std::endl;
//         std::cout << std::to_string(im.size().width) << std::endl;
//         std::cout << std::to_string(im.size().height) << std::endl;
//         LibApiSvpNpuLoadDataset(0, im.data, im.total()*im.channels(), im.size().width , im.size().height, CV_8UC3);
//         // ncnn_convertimg_yolov5s_by_cvim(&im);

//         // YuvStuct* psyuv = (YuvStuct*)get_syuv_param();
//         // ret = _LibApiSvpNpuLoadDataset(g_data_buf, g_buf_size, 0, psyuv->im.data, psyuv->size);
//         // if (ret != UM_OK) {
//         //     macro_svp_trace_err("LibApiSvpNpuLoadDataset fail.\n");
//         //     exit(0);
//         // }
        
//         ret = LibApiSvpNpuModelExecute(0);
//         if (ret != UM_OK) {
//             macro_svp_trace_err("LibApiSvpNpuModelExecute fail.\n");
//             exit(0);
//         }
       
//     }

//     LibApiSvpNpuUnloadDataset();

// 	return 0;

// }

// #include <dlfcn.h> // Linux for so
// int main(int argc, char* argv[])
// {
//     remove("image.png");
//     const char* libPath = "./libLibApi.so"; 
//     void* handle = dlopen(libPath, RTLD_LAZY);
//     if (!handle) {
//         std::cerr << "无法加载动态库: " << dlerror() << std::endl; // Linux
//         // std::cerr << "无法加载动态库" << std::endl; // Windows
//         return 1;
//     }
//     // 获取函数指针
//     // LibapiSvpNpuHandleSig();
//     typedef int (*pFucLibapiSvpNpuHandleSig)();
//     pFucLibapiSvpNpuHandleSig pfucLibapiSvpNpuHandleSig = 
//         (pFucLibapiSvpNpuHandleSig)dlsym(handle, "LibapiSvpNpuHandleSig"); 
//     pfucLibapiSvpNpuHandleSig();

//     // LibapiSvpNpuAclPrepareInit();
//     typedef int (*pFucLibapiSvpNpuAclPrepareInit)();
//     pFucLibapiSvpNpuAclPrepareInit pfucLibapiSvpNpuAclPrepareInit = 
//         (pFucLibapiSvpNpuAclPrepareInit)dlsym(handle, "LibapiSvpNpuAclPrepareInit"); 
//     pfucLibapiSvpNpuAclPrepareInit();
 

// 	const char *om_model_path = "./yolov5s_v6.2.om";
// 	// UmError ret = LibApiSvpNpuLoadModel(om_model_path, 0, false);
//     typedef int (*pFucLibApiSvpNpuLoadModel)(const char* om_model_path, int model_index, bool is_cached);
//     pFucLibApiSvpNpuLoadModel pfucLibApiSvpNpuLoadModel =  
//         (pFucLibApiSvpNpuLoadModel)dlsym(handle, "LibApiSvpNpuLoadModel"); 
//     UmError ret = pfucLibApiSvpNpuLoadModel(om_model_path, 0, false);
// 	if (ret != TD_SUCCESS) {
// 		macro_svp_trace_err("LibApiSvpNpuLoadModel fail.\n");
// 		exit(0);
// 	}

// 	td_char path[PATH_MAX] = { 0 };
//     if (realpath("./test.jpg", path) == TD_NULL) {
//         macro_svp_trace_err("Invalid file!.\n");
//         exit(0);
//     }

// 	const std::string spath = path;
// 	cv::Mat im = read_img(spath);	

// 	if (im.empty())
// 	{
// 		std::cout << "im is empty" << std::endl;
// 		exit(0);
// 	}
	
//     typedef int (*pFucLibApiSvpNpuLoadDataset)(int model_index, void *src, size_t data_len, 
//                                             size_t imgin_w, size_t imgin_h, int flag);

//     typedef int (*pFucLibApiSvpNpuModelExecute)(int model_index);

//     typedef int (*pFucLibApiSvpNpuGetModelExecuteResult)(int model_index, void* retrunObject);
    
//     typedef int (*pFucLibApiSvpNpuUnloadDataset)();  

//     typedef int (*pFucLibApiSvpNpuUnLoadModel)(int model_index);

//     for (int i=0; i<2; i++)
//     {
//         //LibApiSvpNpuLoadDataset(0, im.data, im.total()*im.channels(), im.size().width , im.size().height , CV_8UC3);
        
//         pFucLibApiSvpNpuLoadDataset pfucLibApiSvpNpuLoadDataset = 
//             (pFucLibApiSvpNpuLoadDataset)dlsym(handle, "LibApiSvpNpuLoadDataset"); 
//         UmError ret = pfucLibApiSvpNpuLoadDataset(0, im.data, im.total()*im.channels(), 
//             im.size().width , im.size().height , CV_8UC3);
    
//         //ret = LibApiSvpNpuModelExecute(0);
//         pFucLibApiSvpNpuModelExecute pfucLibApiSvpNpuModelExecute = 
//             (pFucLibApiSvpNpuModelExecute)dlsym(handle, "LibApiSvpNpuModelExecute"); 
//         pfucLibApiSvpNpuModelExecute(0);
//         if (ret != UM_OK) {
//             macro_svp_trace_err("LibApiSvpNpuModelExecute fail.\n");
//             exit(0);
//         }

//         RetrunObject objs;
//         pFucLibApiSvpNpuGetModelExecuteResult pfucLibApiSvpNpuGetModelExecuteResult = 
//             (pFucLibApiSvpNpuGetModelExecuteResult)dlsym(handle, "LibApiSvpNpuGetModelExecuteResult"); 
//         pfucLibApiSvpNpuGetModelExecuteResult(0, &objs);

//         //LibApiSvpNpuUnloadDataset();
//         pFucLibApiSvpNpuUnloadDataset pfucLibApiSvpNpuUnloadDataset = 
//             (pFucLibApiSvpNpuUnloadDataset)dlsym(handle, "LibApiSvpNpuUnloadDataset"); 
//         pfucLibApiSvpNpuUnloadDataset();
//     }

//     pFucLibApiSvpNpuUnLoadModel pfucLibApiSvpNpuUnLoadModel = 
//             (pFucLibApiSvpNpuUnLoadModel)dlsym(handle, "LibApiSvpNpuUnLoadModel"); 
//     pfucLibApiSvpNpuUnLoadModel(0);
    
// 	return 0;

// }
static void myThreadFunction(int arg) {
    while (true)
    {
        std::cout << "1" << std::endl;
        sleep(1);
    }

}


int main(int argc, char* argv[])
{

    std::thread t(myThreadFunction, 100); // 启动一个新线程来执行myThreadFunction，并传递参数100
    t.join(); // 等待线程完成执行。这将会阻塞当前线程，直到指定线程完成执行。
    return 0;


    // // LibapiSobelHandleSig();
    // // LibApiSobel();
    // // remove("image.png");
    // td_char path[PATH_MAX] = { 0 };
    // if (realpath("./test.jpg", path) == TD_NULL) {
    //     macro_svp_trace_err("Invalid file!.\n");
    //     exit(0);
    // }

    // LibapiCommonIveMpiInit();

	// const std::string spath = path;
	// std::cout << spath << std::endl;
	// cv::Mat im = read_img(spath);	
    // int width = im.size().width;
    // int height = im.size().height;
    // std::cout << std::to_string(im.size().width) << std::endl;
    // std::cout << std::to_string(im.size().height) << std::endl;
    // cv::Mat gray;
    // cv::cvtColor(im, gray, cv::COLOR_BGR2GRAY);

    // ot_svp_img img;
    // char img_type = 0x0;
    // cv::Mat blackImage = cv::Mat::zeros(cv::Size(640, 480), CV_8UC1);
    

    // LibApiIveCreateMMZImage(&img, img_type, width, height);
    
    // LibApiIveReadMMZFromOsMem(&img, gray.data, width, height, img_type);
    
    // auto start = std::chrono::high_resolution_clock::now();
    // LibApiIveWriteMMZToOsMem(&img, blackImage.data);
    // auto end = std::chrono::high_resolution_clock::now();

    // LibApiIveDestroyMMZImage(&img);
    

    // cv::imwrite("dst1111.jpg", blackImage);

    // // LibApiCanny(gray.data, width, height, img_type, blackImage.data, '1');

    // // libapi_ive_gmm2();
    

    
    // std::chrono::duration<double> elapsed = end - start;
    // std::cout << "canny 程序运行时间： " << elapsed.count() << " 秒" << std::endl;
    // cv::imwrite("dst1111.jpg", blackImage);

    // LibapiCommonIveMpiExit();
}
}