#include "com_objecteye_nativeinterface_vehicle_VehicleNativeInterface.h"
#include "sy_common.h"
#include "sy_errorinfo.h"
#include "iostream"
#include "map"
#include <string>
#include <string.h>
#include <chrono>

#include "../src/village_pic_interface.h"

#include "opencv2/imgcodecs/legacy/constants_c.h"
#include "opencv2/imgproc/types_c.h"
#include <opencv2/opencv.hpp>
#include "base64.h"

//dvpp����
#include "dvpp_process.h"
#include "utils.h"
//#include "img_codec.h"

double msecond() {
    chrono::time_point<chrono::system_clock, chrono::milliseconds> tpMicro
        = chrono::time_point_cast<chrono::milliseconds>(chrono::system_clock::now());
    return tpMicro.time_since_epoch().count();
}


string Decode(const char* data, int size)
{
    const char DecodeTable[] =
    {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        62, // '+'
        0, 0, 0,
        63, // '/'
        52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // '0'-'9'
        0, 0, 0, 0, 0, 0, 0,
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
        13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // 'A'-'Z'
        0, 0, 0, 0, 0, 0,
        26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
        39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 'a'-'z'
    };

    int outSize = 0;
    int nValue;
    int i= 0;
    string outStr = "";
    while (i < size)
    {
        if (*data != '\r' && *data != '\n')
        {
            nValue = DecodeTable[*data++] << 18;
            nValue += DecodeTable[*data++] << 12;
            outStr += (nValue & 0x00FF0000) >> 16;
            outSize++;
            if (*data != '=')
            {
                nValue += DecodeTable[*data++] << 6;
                outStr += (nValue & 0x0000FF00) >> 8;
                outSize++;
                if (*data != '=')
                {
                    nValue += DecodeTable[*data++];
                    outStr += nValue & 0x000000FF;
                    outSize++;
                }
            }
            i += 4;
        }
        else
        {
            data++;
            i++;
        }
    }

    return outStr;
}


using namespace std;
#define SUCCESS 0 //�ɹ�
#define FAILED -1 //ʧ��
/**
 * ��������
 * */
sy_format getImgByteType(int type);


/**
 * ȫ�ֱ���
 * */
sy_command global_vehicle_detect_config;          		  //�Ƿ����������(һ�������)
sy_command global_vehicle_recg_config;                    //�Ƿ���������ʶ��
sy_command global_vehicle_recg_supplement_config;         //�Ƿ���������ʶ�𲹳�ʶ��(��ͷ��βlogo���ʶ��+����15����)
sy_command global_vehicle_plate_det_recg_config;          //�Ƿ��������Ƽ��ʶ��
sy_command global_vehicle_color_config;                   //�Ƿ�����������ɫʶ��
sy_command global_vehicle_pendant_det_config;             //�Ƿ�������������ʶ��
sy_command global_vehicle_illegal_config;                 //�Ƿ�������Υ����Ϊ���
sy_command global_vehicle_feature_config;                 //�Ƿ���������������ȡ
//sy_command global_vehicle_special_config;                 //�Ƿ���������Ʒ�೵��ʶ��
//sy_command global_vehicle_image_quality_config;           //�Ƿ���������ͼ��������ʶ��
sy_command global_vehicle_motor_tricycle_analysis_config; //�Ƿ�����Ħ�г��Ƿ�����/Ħ�г���ʻ���Ƿ��ͷ��/ũ�ó��Ƿ�����
//sy_command global_vehicle_motor_hs_output_config;         //�Ƿ�����Ħ�г�δ��ͷ�����ͷ������
//sy_command global_vehicle_stain_vp_config;                //�Ƿ������ڵ�����ʶ��
//sy_command global_vehicle_muck_truck_cover_config;        //�Ƿ������������Ǹ�ʶ��(ǰ�᣺����vehicle_special_config)
sy_command global_vehicle_manned_config;            //�Ƿ������������ֳ�����ʶ��
//sy_command global_vehicle_pose_config;                    //�Ƿ�����pose���   //20210618 atlas

int gpu_id;

/*
 * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface
 * Method:    va_init
 * Signature: ([JLcom/objecteye/pojo/vehicle/VehicleAnalysisParam;)I
 */
JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_init(JNIEnv *env, jobject obj, jlongArray handle, jobject vehicleAnalysisParam)
{
    //getFieldID
    //�㷨���ò���
    jclass cls_vehcileAnalysisParam = env->GetObjectClass(vehicleAnalysisParam);

    jfieldID fid_sdk_path = env->GetFieldID(cls_vehcileAnalysisParam, "sdk_path", "Ljava/lang/String;");
    jfieldID fid_gpuid = env->GetFieldID(cls_vehcileAnalysisParam, "gpuId", "I");

    jfieldID fid_aiEngineParam_logLevel = env->GetFieldID(cls_vehcileAnalysisParam, "logLevel", "I");
    jfieldID fid_aiEngineParam_logPath = env->GetFieldID(cls_vehcileAnalysisParam, "logPath", "Ljava/lang/String;");
    jfieldID fid_aiEngineParam_logDays = env->GetFieldID(cls_vehcileAnalysisParam, "logDays", "I");
    jfieldID fid_aiEngineParam_logMem = env->GetFieldID(cls_vehcileAnalysisParam, "logMem", "D");

    jstring str_sdk_path = (jstring)env->GetObjectField(vehicleAnalysisParam, fid_sdk_path);
    const char *sdk_path = env->GetStringUTFChars(str_sdk_path, JNI_FALSE);
    jint gpuid = env->GetIntField(vehicleAnalysisParam, fid_gpuid);
	
    //log
    jstring str_aiEngineParam_logPath = (jstring)env->GetObjectField(vehicleAnalysisParam, fid_aiEngineParam_logPath);
    const char* aiEngineParam_logPath = env->GetStringUTFChars(str_aiEngineParam_logPath, JNI_FALSE);
    jint aiEngineParam_logDays = env->GetIntField(vehicleAnalysisParam, fid_aiEngineParam_logDays);
    jdouble aiEngineParam_logMem = env->GetDoubleField(vehicleAnalysisParam, fid_aiEngineParam_logMem);
    jint aiEngineParam_logLevel = env->GetIntField(vehicleAnalysisParam, fid_aiEngineParam_logLevel);

    void *vaHandle = NULL;
    VillageParam param;
    param.dev_id = gpuid;
    param.sdk_path = sdk_path;
    param.log_level = aiEngineParam_logLevel;
    param.log_path = aiEngineParam_logPath;
    param.log_days = aiEngineParam_logDays;
    param.log_mem = aiEngineParam_logMem;

    printf("jni dev_id:%d \n", param.dev_id);
    printf("jni sdk_path:%s_\n", param.sdk_path.c_str());
    printf("jni log_level:%d\n", param.log_level);
    printf("jni log_path:%s\n", param.log_path.c_str());
    printf("jni log_days:%d\n", param.log_days);
    printf("jni log_mem:%ld\n", param.log_mem);

    int ret = village_pic_init(&vaHandle, param);
 	if (ret != SUCCESS) {
		printf("jni info:va_init failed.");
		return ret;
	}
	
    if (ret == SUCCESS)
    {
        global_vehicle_detect_config = SY_CONFIG_OPEN;
        global_vehicle_recg_config = SY_CONFIG_OPEN;
        global_vehicle_recg_supplement_config = SY_CONFIG_OPEN;
        global_vehicle_plate_det_recg_config = SY_CONFIG_OPEN;
        global_vehicle_pendant_det_config = SY_CONFIG_OPEN;
        global_vehicle_motor_tricycle_analysis_config = SY_CONFIG_OPEN;
        global_vehicle_manned_config = SY_CONFIG_OPEN;
        global_vehicle_illegal_config = SY_CONFIG_CLOSE;
        global_vehicle_feature_config = SY_CONFIG_CLOSE;
        global_vehicle_color_config = SY_CONFIG_CLOSE;

        jlong temp[1];
        temp[0] = (jlong)vaHandle;
        env->SetLongArrayRegion(handle, 0, 1, temp);
    }
    env->ReleaseStringUTFChars(str_sdk_path, sdk_path);
    return ret;
}



void CvBGR2NV21(cv::Mat& bgr, unsigned char* yuv) {
    int stride = (bgr.cols + 127) / 128 * 128;
    int strideH = (bgr.rows + 15) / 16 * 16;
    for (int i = 0; i < bgr.rows; i++) {
        for (int j = 0; j < bgr.cols; j++) {
            int B = bgr.at<cv::Vec3b>(i, j)[0];
            int G = bgr.at<cv::Vec3b>(i, j)[1];
            int R = bgr.at<cv::Vec3b>(i, j)[2];

            int Y = (77 * R + 150 * G + 29 * B) >> 8;
            yuv[i * stride + j] = (Y < 0) ? 0 : ((Y > 255) ? 255 : Y);
            if (i % 2 == 0 && j % 2 == 0) {
                int U = ((-44 * R - 87 * G + 131 * B) >> 8) + 128;
                int V = ((131 * R - 110 * G - 21 * B) >> 8) + 128;
                yuv[strideH * stride + i / 2 * stride + j] = (V < 0) ? 0 : ((V > 255) ? 255 : V);
                yuv[strideH * stride + i / 2 * stride + j + 1] = (U < 0) ? 0 : ((U > 255) ? 255 : U);
            }
        }
    }
}


 /*
 * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface
 * Method:     batch
 * Signature: (J[Lcom/objecteye/pojo/common/SyImgParam;II[Lcom/objecteye/pojo/vehicle/VehicleAnalysisResultParam;)I
 */
JNIEXPORT jint JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_batch(JNIEnv *env, jobject jobj, jlong handle, jobjectArray syImgParams, jint format, jint batchSize, jobjectArray vehicleAnalysisResultParams)
{
    int ret = FAILED;
    void *vaHandle = (void *)handle;

    // ��ȡͼƬ����
	jclass cls_syImgParam = env->FindClass("com/objecteye/pojo/common/SyImgParam");
	jfieldID fid_image_str = env->GetFieldID(cls_syImgParam, "image_string", "Ljava/lang/String;");//base64�����ⲿͳһ��url��fileת��base64����
	
	sy_img batch_img[batchSize];
	cv::Mat car_images[batchSize];
    ImageData dvpp_data[batchSize];

    aclrtContext ctx;
	ACL_CALL(aclrtCreateContext(&ctx, gpu_id), ACL_ERROR_NONE, FAILED);
	ACL_CALL(aclrtSetCurrentContext(ctx), ACL_ERROR_NONE, FAILED);
	//��ʼ��dvpp
	aclrtStream stream = nullptr;
	ACL_CALL(aclrtCreateStream(&stream), ACL_ERROR_NONE, FAILED);
	
	DvppProcess* dvpp = new DvppProcess();
	dvpp->InitResource(stream);
	//Base64Utils decoder();

	
	//wh20210623
	std::shared_ptr<uint8_t> NV21data[batchSize];
		
	
	if (format != 0 && format != 1)
	{
		printf("ERROR FORMAT TYPE: %d\n", format);
		return -1;
	}

	double t1,t2,t3;
	t1 = msecond();
			
	for (size_t i = 0; i < batchSize; i++)
	{
		jobject syImgParam = env->GetObjectArrayElement(syImgParams, i);
		jstring imageString1 = (jstring)env->GetObjectField(syImgParam, fid_image_str);
		const char *image_str = env->GetStringUTFChars(imageString1, JNI_FALSE);
		string imageString  = image_str;
		
		//printf("format = %d\n", format);
		if (format == 0) //url
		{
			printf("url is not surposed \n");
		}
		else
		{
			
			string decode_str;
			//decode_str = decoder->Decode(encode_str[b].data(), encode_str[b].size());
			decode_str = Decode(imageString.data(), imageString.size());
			
			//debug========================================================
			ImageData src;
			uint32_t binFileBufferLen = decode_str.size() + 8;//�ֽ���
			uint8_t* binFileBufferData = new(std::nothrow) uint8_t[binFileBufferLen];
			
			if (binFileBufferData == nullptr) {
				ERROR_LOG("malloc binFileBufferData failed");
				return FAILED;
            }
			
                memcpy((char *)binFileBufferData, decode_str.data(), binFileBufferLen);
                int32_t ch = 0;
                ACL_CALL(acldvppJpegGetImageInfo(binFileBufferData, binFileBufferLen,
              &(src.width), &(src.height), &ch), SUCCESS, FAILED); 
                src.data.reset(binFileBufferData, [](uint8_t* p) { delete[](p); });
            src.size = binFileBufferLen;
                // printf("vpdr_api_batch:img.w=%d ,img.h=%d \n",src.width,src.height);

			
			ACL_CALL(dvpp->CvtJpegToYuv420sp(dvpp_data[i], src), SUCCESS, FAILED);

			batch_img[i].w_ = dvpp_data[i].width;//dvpp_data[b].alignWidth;
			batch_img[i].h_ = dvpp_data[i].height;//dvpp_data[b].alignHeight;
			//batch_img[i].data_ = (uint8_t*)Utils::CopyDataDeviceToLocal(dvpp_data[i].data.get(), dvpp_data[i].size);//dvpp_data[b].data.get();
		    batch_img[i].data_ = dvpp_data[i].data.get();
						
		}
	
		env->ReleaseStringUTFChars(imageString1, image_str);
	}
	t2 = msecond();
    //printf("va jni info:decode time: %.2f\n", (t2 - t1));	
	
    std::cout << "village_pic_analysis " << std::endl;

    std::vector<AnalysisResult> vec_result = village_pic_analysis(vaHandle, batch_img, batchSize);
	if (vec_result.size() <= 0 || vec_result.size() != batchSize)
	{
		printf("jni info:village_pic_analysis failed.");
		return -1;
	}
    cout << "result size:" << vec_result.size() << endl;
	
	t3 = msecond();
	
    std::cout << "struct " << std::endl;
    // getClass
    jclass cls_vehicleAnalysisResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleAnalysisResultParam");
    jclass cls_VehicleInfo = env->FindClass("com/objecteye/pojo/vehicle/VehicleInfoParam");
    jclass cls_LineInfo = env->FindClass("com/objecteye/pojo/vehicle/LineInfoParam");
    jclass cls_SegInfo = env->FindClass("com/objecteye/pojo/vehicle/SegInfoParam");

    jclass cls_VehicleDetectResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleDetectResultParam");
    jclass cls_VehicleColorResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleColorResultParam");
    jclass cls_VehicleRecgResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleRecognizeResultParam");
    //jclass cls_VehicleRecgTopnResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleRecognizeResultTopnParam");//wh20210527������topn�ӿ�
    jclass cls_VplateResult = env->FindClass("com/objecteye/pojo/vehicle/VehiclePlateResultParam");
    jclass cls_VehiclePendantDetResult = env->FindClass("com/objecteye/pojo/vehicle/VehiclePendantDetectResultParam");
    jclass cls_VehicleIllegalDetResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleIllegalDetectResultParam");
    jclass cls_VehicleFeaResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleFeatureResultParam");
    jclass cls_SyRect = env->FindClass("com/objecteye/pojo/common/SyRectParam");
    jclass cls_VplateNum = env->FindClass("com/objecteye/pojo/vehicle/VehiclePlateNumParam");
    jclass cls_VehiclePendantDetInfo = env->FindClass("com/objecteye/pojo/vehicle/VehiclePendantDetectInfoParam");
    jclass cls_VehicleIllegalDetInfo = env->FindClass("com/objecteye/pojo/vehicle/VehicleIllegalDetectInfoParam");
    jclass cls_VehicleIllegalDetDetails = env->FindClass("com/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam");
    //jclass cls_VehicleSpecialInformationParam = env->FindClass("com/objecteye/pojo/vehicle/VehicleSpecialInformationParam");
    //jclass cls_VehicleSpecialResult = env->FindClass("com/objecteye/pojo/vehicle/VehicleSpecialResultParam");
    //jclass cls_MucktruckcoverResult = env->FindClass("com/objecteye/pojo/vehicle/MucktruckcoverResultParam");
    jclass cls_MtaResult = env->FindClass("com/objecteye/pojo/vehicle/MtaResultParam");
    jclass cls_MtaDetailsParam = env->FindClass("com/objecteye/pojo/vehicle/MtaDetailsParam");
    jclass cls_StainVplateResultParam = env->FindClass("com/objecteye/pojo/vehicle/StainVplateResultParam");
    if (nullptr == cls_StainVplateResultParam)
    {
        cout << "cls_StainVplateResultParam find class error!" << endl;
    }
    
    jclass cls_MannedResultParam = env->FindClass("com/objecteye/pojo/vehicle/MannedResultParam");

    //jclass cls_VehiclePoseResultParam = env->FindClass("com/objecteye/pojo/vehicle/VehiclePoseResultParam");//wh20210601������pose���

    jclass cls_SyPoint = env->FindClass("com/objecteye/pojo/common/SyPointParam");
    
    
    //getmethodId
    jmethodID mid_vehicleAnalysisResult = env->GetMethodID(cls_vehicleAnalysisResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleInfoParam;[Lcom/objecteye/pojo/vehicle/LineInfoParam;[Lcom/objecteye/pojo/vehicle/SegInfoParam;I)V");

    jmethodID mid_VehicleInfo = env->GetMethodID(cls_VehicleInfo, "<init>", "(Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleColorResultParam;Lcom/objecteye/pojo/vehicle/VehicleRecognizeResultParam;Lcom/objecteye/pojo/vehicle/VehiclePlateResultParam;Lcom/objecteye/pojo/vehicle/VehiclePendantDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectResultParam;Lcom/objecteye/pojo/vehicle/VehicleFeatureResultParam;Lcom/objecteye/pojo/vehicle/MtaResultParam;Lcom/objecteye/pojo/vehicle/MannedResultParam;IIIFIIIIIIFII)V");	

    jmethodID mid_VehicleDetectResult = env->GetMethodID(cls_VehicleDetectResult, "<init>", "(Lcom/objecteye/pojo/common/SyRectParam;F)V");
    jmethodID mid_VehicleColorResult = env->GetMethodID(cls_VehicleColorResult, "<init>", "(FI)V");
    //jmethodID mid_VehicleRecgTopnResult = env->GetMethodID(cls_VehicleRecgTopnResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleRecognizeResultParam;I)V");//wh20210527������topn�ӿ�
    jmethodID mid_VehicleRecgResult = env->GetMethodID(cls_VehicleRecgResult, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;F)V");
    jmethodID mid_VplateResult = env->GetMethodID(cls_VplateResult, "<init>", "(Lcom/objecteye/pojo/common/SyRectParam;F[Lcom/objecteye/pojo/vehicle/VehiclePlateNumParam;FIILcom/objecteye/pojo/vehicle/StainVplateResultParam;)V");
    if (nullptr == mid_VplateResult)
    {
        cout << "mid_VplateResult GetMethodID error!" << endl;
    }
    jmethodID mid_VehiclePendantDetResult = env->GetMethodID(cls_VehiclePendantDetResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehiclePendantDetectInfoParam;I)V");
    jmethodID mid_VehicleIllegalDetResult = env->GetMethodID(cls_VehicleIllegalDetResult, "<init>", "(Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectInfoParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectInfoParam;)V");
    jmethodID mid_VehicleFeaResult = env->GetMethodID(cls_VehicleFeaResult, "<init>", "([F)V");
    jmethodID mid_SyRect = env->GetMethodID(cls_SyRect, "<init>", "(IIII)V");
    jmethodID mid_VplateNum = env->GetMethodID(cls_VplateNum, "<init>", "(Ljava/lang/String;F)V");


    jmethodID mid_VehiclePendantDetInfo = env->GetMethodID(cls_VehiclePendantDetInfo, "<init>", "(Lcom/objecteye/pojo/common/SyRectParam;IFII)V");
    jmethodID mid_VehicleIllegalDetInfo = env->GetMethodID(cls_VehicleIllegalDetInfo, "<init>", "(Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleIllegalDetectDetailsParam;)V");
    jmethodID mid_VehicleIllegalDetDetails = env->GetMethodID(cls_VehicleIllegalDetDetails, "<init>", "(IF)V");
    //jmethodID mid_VehicleSpecialInformationParam = env->GetMethodID(cls_VehicleSpecialInformationParam, "<init>", "(FI)V");
    //jmethodID mid_VehicleSpecialResult = env->GetMethodID(cls_VehicleSpecialResult, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleSpecialInformationParam;I)V");
    jmethodID mid_MtaResult = env->GetMethodID(cls_MtaResult, "<init>", "(Lcom/objecteye/pojo/vehicle/MtaDetailsParam;Lcom/objecteye/pojo/vehicle/MtaDetailsParam;Lcom/objecteye/pojo/vehicle/MtaDetailsParam;Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;)V");
    jmethodID mid_MtaDetailsParam = env->GetMethodID(cls_MtaDetailsParam, "<init>", "(IF)V");
    jmethodID mid_StainVplateResultParam = env->GetMethodID(cls_StainVplateResultParam, "<init>", "(FI)V");
    //jmethodID mid_MucktruckcoverResult = env->GetMethodID(cls_MucktruckcoverResult, "<init>", "(IF)V");
    jmethodID mid_MannedResult = env->GetMethodID(cls_MannedResultParam, "<init>", "([Lcom/objecteye/pojo/vehicle/VehicleDetectResultParam;I)V");//wh20220222
    jmethodID mid_SyPoint = env->GetMethodID(cls_SyPoint, "<init>", "(II)V");//wh20210601������pose���
    //jmethodID mid_VehiclePoseResult = env->GetMethodID(cls_VehiclePoseResultParam, "<init>", "([Lcom/objecteye/pojo/common/SyPointParam;[F[FDDD)V");

    jmethodID mid_LineInfo = env->GetMethodID(cls_LineInfo, "<init>", "([Lcom/objecteye/pojo/common/SyPointParam;I)V");		       
    jmethodID mid_SegInfo = env->GetMethodID(cls_SegInfo, "<init>", "([Lcom/objecteye/pojo/common/SyPointParam;I)V");		

    //set value to param
    std::cout << "vehicleInfoArray " << std::endl;
    
    for (size_t i = 0; i < batchSize; i++)
    {
        jobjectArray vehicleInfoArray = env->NewObjectArray(vec_result[i].info.size(), cls_VehicleInfo, NULL);
        for (int j = 0; j < vec_result[i].info.size(); j++)
        { //vehicleDetectRes
            std::cout << "vehicleDetectRes" << std::endl;
            auto vehicle_info = vec_result[i].info[j];
            jobject vehicle_detect_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.vehicle_detect_res.rect.left_, vehicle_info.vehicle_detect_res.rect.top_, vehicle_info.vehicle_detect_res.rect.width_, vehicle_info.vehicle_detect_res.rect.height_);
            jobject vehicleDetectResult = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, vehicle_detect_res_syRect_rect, vehicle_info.vehicle_detect_res.score);
            //vehicleWinDetectRes
            jobject vehicle_win_detect_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.vehicle_win_detect_res.rect.left_, vehicle_info.vehicle_win_detect_res.rect.top_, vehicle_info.vehicle_win_detect_res.rect.width_, vehicle_info.vehicle_win_detect_res.rect.height_);
            jobject vehicleWinDetectResult = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, vehicle_win_detect_res_syRect_rect, vehicle_info.vehicle_win_detect_res.score);
            //vehicleBodyDetectRes
            jobject vehicle_body_detect_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.vehicle_body_detect_res.rect.left_, vehicle_info.vehicle_body_detect_res.rect.top_, vehicle_info.vehicle_body_detect_res.rect.width_, vehicle_info.vehicle_body_detect_res.rect.height_);
            jobject vehicleBodyDetectResult = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, vehicle_body_detect_res_syRect_rect, vehicle_info.vehicle_body_detect_res.score);
            //vehicleColorRes
            jobject vehicleColorResult = NULL;
            if (global_vehicle_color_config == SY_CONFIG_OPEN)
            {
                std::cout << "vehicleColorResult" << std::endl;
                vehicleColorResult = env->NewObject(cls_VehicleColorResult, mid_VehicleColorResult, vehicle_info.vehicle_color_res.score, vehicle_info.vehicle_color_res.index);
            }

            //vehicleRecgRes   //0618 atlas�Ļ�top1�Ľӿ�
            jobject vehicleRecgResult = NULL;
            if (global_vehicle_recg_config == SY_CONFIG_OPEN)
            {
                std::cout << "vehicleRecgResult" << std::endl;
                jstring vehicleBrand = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_brand);
                jstring vehicleSubbrand = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_subbrand);
                jstring vehicleIssueYear = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_issue_year);
                jstring vehicleType = env->NewStringUTF(vehicle_info.vehicle_recg_res.vehicle_type);
                jstring freightTon = env->NewStringUTF(vehicle_info.vehicle_recg_res.freight_ton);
                vehicleRecgResult = env->NewObject(cls_VehicleRecgResult, mid_VehicleRecgResult, vehicleBrand, vehicleSubbrand, vehicleIssueYear, vehicleType, freightTon, vehicle_info.vehicle_recg_res.name_score);
            }

            //vehiclePlateDetRecgRes
            jobject vplateResult = NULL;
            jobject vehicle_plate_det_recg_res_syRect_rect = NULL;
            jobjectArray vplateNumArray = NULL;
            auto vehicle_plate_res = vehicle_info.vehicle_plate_det_recg_res;
            if (global_vehicle_plate_det_recg_config == SY_CONFIG_OPEN)
            {
                std::cout << "vehicle_plate_det_recg_res_syRect_rect" << std::endl;
                vehicle_plate_det_recg_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_plate_res.rect.left_, vehicle_plate_res.rect.top_, vehicle_plate_res.rect.width_, vehicle_plate_res.rect.height_);
                vplateNumArray = env->NewObjectArray(PLATENUM, cls_VplateNum, NULL);
                for (size_t k = 0; k < PLATENUM; k++)
                {
                    jstring character = env->NewStringUTF(vehicle_plate_res.recg[k].character);
                    jobject vplateNum = env->NewObject(cls_VplateNum, mid_VplateNum, character, vehicle_plate_res.recg[k].maxprob);
                    env->SetObjectArrayElement(vplateNumArray, k, vplateNum);
                }
            }

            jobject stain_v_plate = env->NewObject(cls_StainVplateResultParam, mid_StainVplateResultParam, vehicle_plate_res.stain_vp_result.score, vehicle_plate_res.stain_vp_result.type);
            std::cout << "vplateResult" << std::endl;
            vplateResult = env->NewObject(cls_VplateResult, mid_VplateResult, vehicle_plate_det_recg_res_syRect_rect, vehicle_plate_res.detect_score, vplateNumArray, vehicle_plate_res.num_score, vehicle_plate_res.type, vehicle_plate_res.special_type, stain_v_plate);                

            std::cout << "vplateResult end" << std::endl;

            //vehiclePendantDetRes
            jobject vehiclePendantDetResult = NULL;
            if (global_vehicle_pendant_det_config == SY_CONFIG_OPEN)
            {
                jobjectArray vehiclePendantDetInfoArray = env->NewObjectArray(vehicle_info.vehicle_pendant_det_res.size(), cls_VehiclePendantDetInfo, NULL);
                for (size_t m = 0; m < vehicle_info.vehicle_pendant_det_res.size(); m++)
                {
                    auto one_pendant_res = vehicle_info.vehicle_pendant_det_res[m];
                    jobject vehicle_pendant_det_res_vpd_res_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, one_pendant_res.rect.left_,
                                                                                        one_pendant_res.rect.top_, one_pendant_res.rect.width_, one_pendant_res.rect.height_);
                    
                    jobject vehiclePendantDetInfo = env->NewObject(cls_VehiclePendantDetInfo, mid_VehiclePendantDetInfo, vehicle_pendant_det_res_vpd_res_syRect_rect, one_pendant_res.index, one_pendant_res.confidence, one_pendant_res.driver_copilot_info, one_pendant_res.iColor);
                    
                    env->SetObjectArrayElement(vehiclePendantDetInfoArray, m, vehiclePendantDetInfo);
                }
                vehiclePendantDetResult = env->NewObject(cls_VehiclePendantDetResult, mid_VehiclePendantDetResult, vehiclePendantDetInfoArray, vehicle_info.vehicle_pendant_det_res.size());
            }

            std::cout << "vehiclePendantDetResult" << std::endl;

            //vehicleIllegalDetRes
            jobject vehicleIllegalDetResult = NULL;
            if (global_vehicle_illegal_config == SY_CONFIG_OPEN)
            {
                jobject vehicleIllegalDetDetails_driver_belt = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.belt.status, vehicle_info.vehicle_illegal_det_res.driver.belt.confidence);
                jobject vehicleIllegalDetDetails_driver_smoke = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.smoke.status, vehicle_info.vehicle_illegal_det_res.driver.smoke.confidence);
                jobject vehicleIllegalDetDetails_driver_call = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.call.status, vehicle_info.vehicle_illegal_det_res.driver.call.confidence);
                jobject vehicleIllegalDetDetails_driver_phone = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.phone.status, vehicle_info.vehicle_illegal_det_res.driver.phone.confidence);
                jobject vehicleIllegalDetDetails_driver_person = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.driver.person.status, vehicle_info.vehicle_illegal_det_res.driver.person.confidence);
                jobject vehicleIllegalDetDetails_copilot_belt = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.belt.status, vehicle_info.vehicle_illegal_det_res.copilot.belt.confidence);
                jobject vehicleIllegalDetDetails_copilot_smoke = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.smoke.status, vehicle_info.vehicle_illegal_det_res.copilot.smoke.confidence);
                jobject vehicleIllegalDetDetails_copilot_call = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.call.status, vehicle_info.vehicle_illegal_det_res.copilot.call.confidence);
                jobject vehicleIllegalDetDetails_copilot_phone = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.phone.status, vehicle_info.vehicle_illegal_det_res.copilot.phone.confidence);
                jobject vehicleIllegalDetDetails_copilot_person = env->NewObject(cls_VehicleIllegalDetDetails, mid_VehicleIllegalDetDetails, vehicle_info.vehicle_illegal_det_res.copilot.person.status, vehicle_info.vehicle_illegal_det_res.copilot.person.confidence);

                jobject vehicleIllegalDetInfo_driver = env->NewObject(cls_VehicleIllegalDetInfo, mid_VehicleIllegalDetInfo, vehicleIllegalDetDetails_driver_belt, vehicleIllegalDetDetails_driver_smoke, vehicleIllegalDetDetails_driver_phone, vehicleIllegalDetDetails_driver_call,  vehicleIllegalDetDetails_driver_person);
                jobject vehicleIllegalDetInfo_copilot = env->NewObject(cls_VehicleIllegalDetInfo, mid_VehicleIllegalDetInfo, vehicleIllegalDetDetails_copilot_belt, vehicleIllegalDetDetails_copilot_smoke, vehicleIllegalDetDetails_copilot_phone, vehicleIllegalDetDetails_copilot_call, vehicleIllegalDetDetails_copilot_person);
                vehicleIllegalDetResult = env->NewObject(cls_VehicleIllegalDetResult, mid_VehicleIllegalDetResult, vehicleIllegalDetInfo_driver, vehicleIllegalDetInfo_copilot);
            }

            //vehicleFeaRes
            jobject vehicleFeaResult = NULL;
            if (global_vehicle_feature_config == SY_CONFIG_OPEN)
            {
                jfloatArray feature = env->NewFloatArray(VA_FEATURESIZE);
                env->SetFloatArrayRegion(feature, 0, VA_FEATURESIZE, vehicle_info.vehicle_fea_res.feature);
                vehicleFeaResult = env->NewObject(cls_VehicleFeaResult, mid_VehicleFeaResult, feature);
            }

            //MtaResultParam
            jobject mtaResult = NULL;
            if (global_vehicle_motor_tricycle_analysis_config == SY_CONFIG_OPEN)
            {
                jobject mtaDetailsParam_motor_driver_helmeted = env->NewObject(cls_MtaDetailsParam, mid_MtaDetailsParam, vehicle_info.mta_res.motor_driver_helmeted.status, vehicle_info.mta_res.motor_driver_helmeted.confidence);
                jobject mtaDetailsParam_motor_manned = env->NewObject(cls_MtaDetailsParam, mid_MtaDetailsParam, vehicle_info.mta_res.motor_manned.status, vehicle_info.mta_res.motor_manned.confidence);
                jobject mtaDetailsParam_tricycle_manned = env->NewObject(cls_MtaDetailsParam, mid_MtaDetailsParam, vehicle_info.mta_res.tricycle_manned.status, vehicle_info.mta_res.tricycle_manned.confidence);
                jobject mtaDetailsParam_motor_driver_hs_rect = NULL;
                //if (global_vehicle_motor_hs_output_config == SY_CONFIG_OPEN)
                {
                    jobject mtaDetailsParam_motor_driver_hs_rect_syRect_rect = env->NewObject(cls_SyRect, mid_SyRect, vehicle_info.mta_res.motor_driver_hs_rect.rect.left_, vehicle_info.mta_res.motor_driver_hs_rect.rect.top_, vehicle_info.mta_res.motor_driver_hs_rect.rect.width_, vehicle_info.mta_res.motor_driver_hs_rect.rect.height_);
                    mtaDetailsParam_motor_driver_hs_rect = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, mtaDetailsParam_motor_driver_hs_rect_syRect_rect, vehicle_info.mta_res.motor_driver_hs_rect.score);
                }
                mtaResult = env->NewObject(cls_MtaResult, mid_MtaResult, mtaDetailsParam_motor_driver_helmeted, mtaDetailsParam_motor_manned, mtaDetailsParam_tricycle_manned, mtaDetailsParam_motor_driver_hs_rect);
            }

            //LorryMannedResultParam
            jobject MannedResult = NULL;
            if (global_vehicle_manned_config == SY_CONFIG_OPEN)
            {
                int MannedResHsCount = vehicle_info.manned_res.hs_count;

                jobjectArray hsDetectResultArray = env->NewObjectArray(MannedResHsCount, cls_VehicleDetectResult, NULL);
                for (size_t m = 0; m < MannedResHsCount; m++)
                {
                    jobject Manned_hsDetect_syRect = env->NewObject(cls_SyRect, mid_SyRect,
                                                                        vehicle_info.manned_res.hs_rect[m].rect.left_,
                                                                        vehicle_info.manned_res.hs_rect[m].rect.top_,
                                                                        vehicle_info.manned_res.hs_rect[m].rect.width_,
                                                                        vehicle_info.manned_res.hs_rect[m].rect.height_);

                    jobject Manned_hsDetect = env->NewObject(cls_VehicleDetectResult, mid_VehicleDetectResult, Manned_hsDetect_syRect, vehicle_info.manned_res.hs_rect[m].score);

                    env->SetObjectArrayElement(hsDetectResultArray, m, Manned_hsDetect);
                }

                MannedResult = env->NewObject(cls_MannedResultParam, mid_MannedResult,
                            hsDetectResultArray,
                            MannedResHsCount);
            }

            std::cout << "type" << std::endl;
            jint type = vehicle_info.type;
            jint vpt_type = vehicle_info.vpt_type;
            jint rainshed = vehicle_info.rainshed;		//是否安装雨棚， 0 有雨棚   1 无雨棚
            jfloat rainshed_prob = vehicle_info.rainshed_prob;
            jint truck_manned = vehicle_info.truck_manned;
            jint motor_manned = vehicle_info.motor_manned;
            jint human_upper_color = vehicle_info.human_upper_color;
            jint human_lower_color = vehicle_info.human_lower_color;
            jint reverse_driving = vehicle_info.reverse_driving;    // 0 正常行驶   1 逆行   -1 未知
            jint phoning = vehicle_info.phoning;        // 骑车打电话
            jfloat phoning_prob = vehicle_info.phoning_prob;
            jint cross_line = vehicle_info.cross_line;         // 压实线， 1 黄实线 2 白实线  -1 其他
            jint cross_diversion_line = vehicle_info.cross_diversion_line;   // 压导流线   1 压了  -1 未压

            jobject vehicleInfo = env->NewObject(cls_VehicleInfo, mid_VehicleInfo, vehicleDetectResult, vehicleWinDetectResult, vehicleBodyDetectResult, vehicleColorResult, vehicleRecgResult, vplateResult, vehiclePendantDetResult, vehicleIllegalDetResult, vehicleFeaResult,mtaResult, MannedResult, type, vpt_type, rainshed, rainshed_prob, truck_manned, motor_manned, human_upper_color, human_lower_color, reverse_driving, phoning, phoning_prob, cross_line, cross_diversion_line);

            std::cout << "vehicleInfo end" << std::endl;

            env->SetObjectArrayElement(vehicleInfoArray, j, vehicleInfo);

            std::cout << "SetObjectArrayElement" << std::endl;
        }

        std::cout << "line info " << std::endl;

        // 道路标志线
        jobjectArray LineInfoArray = env->NewObjectArray(vec_result[i].vec_line.size(), cls_LineInfo, NULL);
        for (int j = 0; j < vec_result[i].vec_line.size(); j++)
        {
            auto line_info = vec_result[i].vec_line[j];
            jobjectArray ptArray = env->NewObjectArray(line_info.vec_pt.size(), cls_SyPoint, NULL);
            for (int k = 0; k < line_info.vec_pt.size(); k++)
            {
                auto pt = line_info.vec_pt[k];
                jobject line_info_point = env->NewObject(cls_SyPoint, mid_SyPoint, pt.x, pt.y);
                env->SetObjectArrayElement(ptArray, k, line_info_point);
            }

            jobject one_line_info = env->NewObject(cls_LineInfo, mid_LineInfo, ptArray, line_info.line_type);

            env->SetObjectArrayElement(LineInfoArray, j, one_line_info);
        }

        std::cout << "road info " << std::endl;

        // 道路
        jobjectArray RoadInfoArray = env->NewObjectArray(vec_result[i].vec_road.size(), cls_SegInfo, NULL);
        for (int j = 0; j < vec_result[i].vec_road.size(); j++)
        {
            auto road_info = vec_result[i].vec_road[j];
            jobjectArray ptArray = env->NewObjectArray(road_info.vec_pt.size(), cls_SyPoint, NULL);
            for (int k = 0; k < road_info.vec_pt.size(); k++)
            {
                auto pt = road_info.vec_pt[k];
                jobject road_info_point = env->NewObject(cls_SyPoint, mid_SyPoint, pt.x, pt.y);
                env->SetObjectArrayElement(ptArray, k, road_info_point);
            }

            jobject one_road_info = env->NewObject(cls_SegInfo, mid_SegInfo, ptArray, road_info.seg_type);

            env->SetObjectArrayElement(RoadInfoArray, j, one_road_info);
        }

        std::cout << "add new " << std::endl;

        jobject vehicleAnalysisResult = env->NewObject(cls_vehicleAnalysisResult, mid_vehicleAnalysisResult, vehicleInfoArray, LineInfoArray, RoadInfoArray, vec_result[i].info.size());			
        env->SetObjectArrayElement(vehicleAnalysisResultParams, i, vehicleAnalysisResult);
    }

	ACL_CALL(aclrtSetCurrentContext(ctx), ACL_ERROR_NONE, FAILED);
	delete dvpp;
    dvpp = nullptr;
    (void) aclrtDestroyStream(stream);
	aclrtDestroyContext(ctx);

    return SUCCESS;
}

/*
 * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface
 * Method:    va_release
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_release(JNIEnv *env, jobject obj, jlong handle)
{
    void *vaHandle = (void *)handle;
    if (vaHandle != NULL)
    {
        village_pic_release(&vaHandle);
    }
}

/*
 * Class:     com_objecteye_nativeinterface_vehicle_VehicleNativeInterface
 * Method:    get_village_pic_version
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_com_objecteye_nativeinterface_vehicle_VehicleNativeInterface_getVersion(JNIEnv *env, jobject obj)
{
    const char *version = get_village_pic_version();
    return env->NewStringUTF(version);
}

/**
 *  ����ͼƬ�ı����ʽ
 * */
sy_format getImgByteType(int type)
{
    sy_format syFormat;
    switch (type)
    {
    case 0:
        syFormat = SY_FORMAT_BGR888;
        break;
    case 1:
        syFormat = SY_FORMAT_BGRA888;
        break;
    case 2:
        syFormat = SY_FORMAT_GRAY8;
        break;
    case 3:
        syFormat = SY_FORMAT_YUV4420P;
        break;
    case 4:
        syFormat = SY_FORMAT_NV12;
        break;
    case 5:
        syFormat = SY_FORMAT_NV21;
        break;
    default:
        syFormat = SY_FORMAT_BGR888;
        break;
    }
    return syFormat;
}