/*
 * Copyright (C) 2021 Rockchip Electronics Co., Ltd.
 * Authors:
 *  Cerf Yu <cerf.yu@rock-chips.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define LOG_NDEBUG 0
#undef LOG_TAG
#define LOG_TAG "rga_im2d_slt"

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <math.h>
#include <fcntl.h>
#include <memory.h>
#include <pthread.h>

#if LIBDRM
#include "drm_alloc.h"
#include "xf86drm.h"
#endif

#include "RockchipRga.h"
#include "im2d_api/im2d.hpp"
#include "RgaUtils.h"

#include "dma_alloc.h"
#include "drm_alloc.h"

#include "slt_config.h"

enum {
    FILL_BUFF  = 0,
    EMPTY_BUFF = 1
};

typedef struct private_data {
    int id;
    const char *name;
    int mode;
    unsigned int num;

    int width;
    int height;
    int format;

    int rd_mode;
    int core;
    int priority;

    int result;
} private_data_t;

static int get_buf_size_by_w_h_f(int w, int h, int f) {
    float bpp = get_bpp_from_format(f);
    int size = 0;

    size = (int)w * h * bpp;
    return size;
}

int read_image_from_path(void *buf, const char *path, int f, int sw, int sh, int index, int mode) {
    const char *inputFilePath = "%s/in%dw%d-h%d-%s.bin";
    const char *inputFbcFilePath = "%s/in%dw%d-h%d-%s-fbc.bin";
    char filePath[100];

    snprintf(filePath, 100, (mode == IM_FBC_MODE) ? inputFbcFilePath : inputFilePath,
             path, index, sw, sh, translate_format_str(f));

    FILE *file = fopen(filePath, "rb");
    if (!file) {
        fprintf(stderr, "Could not open %s\n", filePath);
        return -EINVAL;
    }

    if (mode == IM_FBC_MODE)
        fread(buf, get_buf_size_by_w_h_f(sw, sh, f) * 1.5, 1, file);
    else
        fread(buf, get_buf_size_by_w_h_f(sw, sh, f), 1, file);

    fclose(file);

    return 0;
}

static int write_image_to_path(void *buf, const char *path, int f, int sw, int sh, int index, int mode) {
    const char *outputFilePath = "%s/out%dw%d-h%d-%s.bin";
    const char *outputFbcFilePath = "%s/out%dw%d-h%d-%s-fbc.bin";
    char filePath[100];

    snprintf(filePath, 100, (mode == IM_FBC_MODE) ? outputFbcFilePath : outputFilePath,
             path, index, sw, sh, translate_format_str(f));

    FILE *file = fopen(filePath, "wb+");
    if (!file) {
        fprintf(stderr, "Could not open %s\n", filePath);
        return false;
    } else {
        fprintf(stderr, "open %s and write ok\n", filePath);
    }

    if (mode == IM_FBC_MODE)
        fwrite(buf, get_buf_size_by_w_h_f(sw, sh, f) * 1.5, 1, file);
    else
        fwrite(buf, get_buf_size_by_w_h_f(sw, sh, f), 1, file);

    fclose(file);

    return 0;
}

#if IM2D_SLT_GRAPHICBUFFER_EN
#include <ui/GraphicBuffer.h>

/*
 *   In order to be compatible with different android versions,
 * some gralloc usage is defined here.
 *   The correct usage should be to refer to the corresponding header file:
 *   Android 12 and above: #include "hardware/gralloc_rockchip.h"
 *   Android 11 and below: #include "hardware/gralloc.h"
 */
#define GRALLOC_USAGE_PRIVATE_11                (1ULL << 56)
#define RK_GRALLOC_USAGE_WITHIN_4G              GRALLOC_USAGE_PRIVATE_11
#define RK_GRALLOC_USAGE_RGA_ACCESS             RK_GRALLOC_USAGE_WITHIN_4G

sp<GraphicBuffer> GraphicBuffer_Init(int width, int height,int format, bool use_rga2, bool cacheable) {
    uint64_t usage = 0;

    if (cacheable)
        usage |= GRALLOC_USAGE_SW_READ_OFTEN;

    if (use_rga2)
        usage |= RK_GRALLOC_USAGE_WITHIN_4G;

    sp<GraphicBuffer> gb(new GraphicBuffer(width, height, format, 0, usage));

    if (gb->initCheck()) {
        /*
         * The lower version of gralloc (gralloc-0.3) does not support 64-bit usage,
         * so it needs to be truncated externally to 32-bit. And don't need 4G usage.
         */
        printf("graphicbuffer re-alloc 32-bit usage\n");
        gb = sp<GraphicBuffer>(new GraphicBuffer(width, height, format, (int)usage));
        if (gb->initCheck()) {
            printf("GraphicBuffer check error : %s\n",strerror(errno));
            return NULL;
        }
    }

    return gb;
}

/* Write data to buffer or init buffer. */
int GraphicBuffer_Fill(sp<GraphicBuffer> gb, int width, int height,int format, int flag, int index, int mode) {
    int ret = 0;
       char* buf = NULL;
    size_t buf_size;
    ret = gb->lock(GRALLOC_USAGE_SW_READ_OFTEN, (void**)&buf);
    if (ret) {
        printf("lock buffer error : %s\n",strerror(errno));
        return -1;
    }

    buf_size = width * height * get_bpp_from_format(format);
    if (mode == IM_FBC_MODE)
        buf_size = buf_size * 1.5;

    if(flag) {
        memset(buf, index, buf_size);
    } else {
        ret = read_image_from_path(buf, IM2D_SLT_DEFAULT_INPUT_PATH, format, width, height, index, mode);
        if (ret != 0) {
            printf ("open file %s \n", "fault");
            memset(buf, index, buf_size);
            ret = -1;
            goto unlock;
        }
    }

unlock:
    ret = gb->unlock();
       if (ret) {
        printf("unlock buffer error : %s\n",strerror(errno));
        return -1;
    }

    return ret;
}
#endif

/******************************************************************************/
void *pthread_rga_run(void *args) {
    int ret = 0, time = 0;
    unsigned int num;
    int srcWidth,srcHeight,srcFormat;
    int dstWidth,dstHeight,dstFormat;

    char *src_va, *dst_va;
#if IM2D_SLT_DRM_BUFFER_EN
    struct drm_object drm_src, drm_dst;
#elif IM2D_SLT_GRAPHICBUFFER_EN
    sp<GraphicBuffer> src_buf;
    sp<GraphicBuffer> dst_buf;
#elif IM2D_SLT_RK_DMA_HEAP_EN
    int src_fd, dst_fd;
    rga_buffer_handle_t src_handle, dst_handle;
#endif

    rga_buffer_t src;
    rga_buffer_t dst;
    im_rect src_rect;
    im_rect dst_rect;

    private_data_t *data = (private_data_t *)args;

    num = data->num;

    srcWidth = data->width;
    srcHeight = data->height;
    srcFormat = data->format;

    dstWidth = data->width;
    dstHeight = data->height;
    dstFormat = data->format;

    memset(&src, 0x0, sizeof(src));
    memset(&dst, 0x0, sizeof(dst));
    memset(&src_rect, 0x0, sizeof(src_rect));
    memset(&dst_rect, 0x0, sizeof(dst_rect));

    do {
        time++;

#if IM2D_SLT_DRM_BUFFER_EN
        if (data->rd_mode != IM_FBC_MODE) {
            drm_src.drm_buf = (uint8_t *)drm_buf_alloc(srcWidth, srcHeight, get_bpp_from_format(srcFormat) * 8,
                                                       &drm_src.drm_buffer_fd, &drm_src.drm_buffer_handle,
                                                       &drm_src.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);
            drm_dst.drm_buf = (uint8_t *)drm_buf_alloc(dstWidth, dstHeight, get_bpp_from_format(dstFormat) * 8,
                                                       &drm_dst.drm_buffer_fd, &drm_dst.drm_buffer_handle,
                                                       &drm_dst.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);

            src_va = (char *)drm_src.drm_buf;
            dst_va = (char *)drm_dst.drm_buf;

            ret = read_image_from_path(src_va, IM2D_SLT_DEFAULT_INPUT_PATH,
                                       srcFormat, srcWidth, srcHeight, 0, data->rd_mode);
            if (ret != 0) {
                printf ("ID[%d] %s open file %s \n", data->id, data->name, "fault");
                goto NORMAL_ERR;
            }

            memset(dst_va, 0xff, dstWidth * dstHeight * get_bpp_from_format(dstFormat));
        } else {
            drm_src.drm_buf = (uint8_t *)drm_buf_alloc(srcWidth, srcHeight * 1.5, get_bpp_from_format(srcFormat) * 8,
                                                       &drm_src.drm_buffer_fd, &drm_src.drm_buffer_handle,
                                                       &drm_src.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);
            drm_dst.drm_buf = (uint8_t *)drm_buf_alloc(dstWidth, dstHeight * 1.5, get_bpp_from_format(dstFormat) * 8,
                                                       &drm_dst.drm_buffer_fd, &drm_dst.drm_buffer_handle,
                                                       &drm_dst.actual_size, IM2D_SLT_BUFFER_PHY_EN ? ROCKCHIP_BO_CONTIG : 0);

            src_va = (char *)drm_src.drm_buf;
            dst_va = (char *)drm_dst.drm_buf;

            ret = read_image_from_path(src_va, IM2D_SLT_DEFAULT_INPUT_PATH,
                                       srcFormat, srcWidth, srcHeight, 0, data->rd_mode);
            if (ret != 0) {
                printf ("ID[%d] %s open file %s \n", data->id, data->name, "fault");
                goto NORMAL_ERR;
            }

            memset(dst_va, 0xff, dstWidth * dstHeight * 1.5 * get_bpp_from_format(dstFormat));
        }

        src = wrapbuffer_fd(drm_src.drm_buffer_fd, srcWidth, srcHeight, srcFormat);
        dst = wrapbuffer_fd(drm_dst.drm_buffer_fd, dstWidth, dstHeight, dstFormat);
        if (src.width == 0 || dst.width == 0) {
            printf("%s", imStrError());
            goto NORMAL_ERR;
        }
#elif IM2D_SLT_GRAPHICBUFFER_EN
        if (data->rd_mode == IM_FBC_MODE) {
            src_buf = GraphicBuffer_Init(srcWidth, srcHeight * 1.5, srcFormat,
                                         data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
            dst_buf = GraphicBuffer_Init(dstWidth, dstHeight * 1.5, dstFormat,
                                         data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
        } else {
            src_buf = GraphicBuffer_Init(srcWidth, srcHeight, srcFormat,
                                         data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
            dst_buf = GraphicBuffer_Init(dstWidth, dstHeight, dstFormat,
                                         data->core == IM_SCHEDULER_RGA2_CORE0 ? true : false, IM2D_SLT_BUFFER_CACHEABLE);
        }
        if (src_buf == NULL || dst_buf == NULL) {
            printf("GraphicBuff init error!\n");
            goto NORMAL_ERR;
        }

        if(-1 == GraphicBuffer_Fill(src_buf, srcWidth, srcHeight, srcFormat, FILL_BUFF, 0, data->rd_mode)) {
            printf("%s, src write Graphicbuffer error!\n", __FUNCTION__);
            goto NORMAL_ERR;
        }
        if(-1 == GraphicBuffer_Fill(dst_buf, dstWidth, dstHeight, dstFormat, EMPTY_BUFF, 0xff, data->rd_mode)) {
            printf("%s, dst write Graphicbuffer error!\n", __FUNCTION__);
            goto NORMAL_ERR;
        }

        src = wrapbuffer_GraphicBuffer(src_buf);
        src = wrapbuffer_fd(src.fd, srcWidth, srcHeight, srcFormat);
        dst = wrapbuffer_GraphicBuffer(dst_buf);
        dst = wrapbuffer_fd(dst.fd, dstWidth, dstHeight, dstFormat);
        /* If it is in fbc mode, because the height of the alloc memory
         * is modified, it needs to be corrected here */
        if (data->rd_mode == IM_FBC_MODE) {
            src.height  = srcHeight;
            src.hstride = srcHeight;
            dst.height  = dstHeight;
            dst.hstride = dstHeight;
        }
        if (src.width == 0 || dst.width == 0) {
            printf("%s", imStrError());
        }
#elif IM2D_SLT_RK_DMA_HEAP_EN
        ret = dma_buf_alloc(srcWidth, srcHeight, srcFormat, &src_fd, (void **)&src_va);
        if (ret < 0) {
            printf("ID[%d] %s alloc src dma_buf failed!\n", data->id, data->name);
            goto NORMAL_ERR;
        }

        ret = dma_buf_alloc(dstWidth, dstHeight, dstFormat, &dst_fd, (void **)&dst_va);
        if (ret < 0) {
            printf("ID[%d] %s alloc dst dma_buf failed!\n", data->id, data->name);
            goto NORMAL_ERR;
        }

        dma_sync_device_to_cpu(src_fd);
        dma_sync_device_to_cpu(dst_fd);

        ret = read_image_from_path(src_va, IM2D_SLT_DEFAULT_INPUT_PATH,
                                    srcFormat, srcWidth, srcHeight, 0, data->rd_mode);
        if (ret != 0) {
            printf ("ID[%d] %s open file %s \n", data->id, data->name, "fault");
            goto NORMAL_ERR;
        }

        memset(dst_va, 0xff, dstWidth * dstHeight * get_bpp_from_format(dstFormat));

        dma_sync_cpu_to_device(src_fd);
        dma_sync_cpu_to_device(dst_fd);

        src_handle = importbuffer_fd(src_fd, srcWidth, srcHeight, srcFormat);
        if (src_handle <= 0) {
            printf("ID[%d] %s import src dma_buf failed!\n", data->id, data->name);
            goto NORMAL_ERR;
        }
        dst_handle = importbuffer_fd(dst_fd, dstWidth, dstHeight, dstFormat);
        if (dst_handle <= 0) {
            printf("ID[%d] %s import dst dma_buf failed!\n", data->id, data->name);
            releasebuffer_handle(src_handle);
            goto NORMAL_ERR;
        }

        src = wrapbuffer_handle(src_handle, srcWidth, srcHeight, srcFormat);
        dst = wrapbuffer_handle(dst_handle, dstWidth, dstHeight, dstFormat);
        if (src.width == 0 || dst.width == 0) {
            printf("%s", imStrError());

            releasebuffer_handle(src_handle);
            releasebuffer_handle(dst_handle);
            goto NORMAL_ERR;
        }
#endif

        ret = imcheck(src, dst, src_rect, dst_rect);
        if (ret != IM_STATUS_NOERROR) {
            printf("ID[%d]: %s check %d time error! %s", data->id, data->name, time, imStrError((IM_STATUS)ret));

            goto NORMAL_ERR;
        }

        imconfig(IM_CONFIG_SCHEDULER_CORE, data->core);
        imconfig(IM_CONFIG_PRIORITY, data->priority);

        src.rd_mode = data->rd_mode;
        dst.rd_mode = data->rd_mode;

        ret = imcopy(src, dst);
        if (ret == IM_STATUS_SUCCESS) {
            printf("ID[%d]: %s imcopy %d time success!\n", data->id, data->name, time);

#if IM2D_SLT_GRAPHICBUFFER_EN
            ret = src_buf->lock(GRALLOC_USAGE_SW_READ_OFTEN, (void**)&src_va);
            if (ret) {
                printf("lock src_buf error : %s\n",strerror(errno));
                goto NORMAL_ERR;
            }

            ret = dst_buf->lock(GRALLOC_USAGE_SW_READ_OFTEN, (void**)&dst_va);
            if (ret) {
                printf("lock dst_buf error : %s\n",strerror(errno));
                goto NORMAL_ERR;
            }
#elif IM2D_SLT_RK_DMA_HEAP_EN
            dma_sync_device_to_cpu(src_fd);
            dma_sync_device_to_cpu(dst_fd);
#endif

            ret = memcmp(src_va, dst_va, dst.wstride * dst.hstride * get_bpp_from_format(dst.format));
            if (ret < 0) {
                printf("ID[%d]: %s check buffer %d time error!\n", data->id, data->name, time);
                printf("src: %x %x %x %x\n", (int)src_va[0], (int)src_va[1], (int)src_va[2], (int)src_va[3]);
                printf("dst: %x %x %x %x\n", (int)dst_va[0], (int)dst_va[1], (int)dst_va[2], (int)dst_va[3]);
                write_image_to_path(dst_va, IM2D_SLT_DEFAULT_OUTPUT_PATH,
                                    dst.format, dst.wstride, dst.hstride, data->id + 1, dst.rd_mode);
                write_image_to_path(src_va, IM2D_SLT_DEFAULT_OUTPUT_PATH,
                                    src.format, src.wstride, src.hstride, data->id + 2, src.rd_mode);

                goto CHECK_ERR;
            } else {
                printf("ID[%d]: %s check buffer %d time success!\n", data->id, data->name, time);
            }

#if IM2D_SLT_GRAPHICBUFFER_EN
            ret = src_buf->unlock();
            if (ret) {
                printf("unlock src_buf error : %s\n",strerror(errno));
                goto NORMAL_ERR;
            }

            ret = dst_buf->unlock();
            if (ret) {
                printf("unlock dst_buf error : %s\n",strerror(errno));
                goto NORMAL_ERR;
            }
#endif
        } else {
            printf("ID[%d]: %s run %d time error!, %s\n", data->id, data->name, time, imStrError((IM_STATUS)ret));
            goto NORMAL_ERR;
        }

#if IM2D_SLT_DRM_BUFFER_EN
        drm_buf_destroy(drm_src.drm_buffer_fd, drm_src.drm_buffer_handle,
                        drm_src.drm_buf, drm_src.actual_size);
        drm_buf_destroy(drm_dst.drm_buffer_fd, drm_dst.drm_buffer_handle,
                        drm_dst.drm_buf, drm_dst.actual_size);
#elif IM2D_SLT_RK_DMA_HEAP_EN
        releasebuffer_handle(src_handle);
        releasebuffer_handle(dst_handle);

        dma_buf_free(srcWidth, srcHeight, srcFormat, &src_fd, (void *)src_va);
        dma_buf_free(dstWidth, dstHeight, dstFormat, &dst_fd, (void *)dst_va);
#endif
    } while (data->mode && --num);

#if IM2D_SLT_THREAD_EN
    data->result = 0;
    pthread_exit(NULL);

NORMAL_ERR:
    data->result = -1;
    pthread_exit(NULL);
CHECK_ERR:
    data->result = -2;
    pthread_exit(NULL);
#else
    data->result = 0;
    return NULL;

NORMAL_ERR:
    data->result = -1;
    return NULL;
CHECK_ERR:
    data->result = -2;
    return NULL;
#endif
}

int main() {
    int pthread_num = 0;
    pthread_t tdSyncID[IM2D_SLT_THREAD_MAX];
    private_data_t data[IM2D_SLT_THREAD_MAX];

    memset(&data, 0x0, sizeof(private_data_t) * IM2D_SLT_THREAD_MAX);
    printf("-------------------------------------------------\n");

#if IM2D_SLT_TEST_RGA3_0_EN
    pthread_num++;
    data[pthread_num].id = pthread_num;
    data[pthread_num].name = "RGA3_core0";
    data[pthread_num].mode = IM2D_SLT_WHILE_EN;
    data[pthread_num].num = IM2D_SLT_WHILE_NUM;
    data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
    data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
    data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
    data[pthread_num].rd_mode = IM_RASTER_MODE;
    data[pthread_num].core = IM_SCHEDULER_RGA3_CORE0;
    data[pthread_num].priority = 1;
#endif

#if IM2D_SLT_TEST_RGA3_1_EN
    pthread_num++;
    data[pthread_num].id = pthread_num;
    data[pthread_num].name = "RGA3_core1";
    data[pthread_num].mode = IM2D_SLT_WHILE_EN;
    data[pthread_num].num = IM2D_SLT_WHILE_NUM;
    data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
    data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
    data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
    data[pthread_num].rd_mode = IM_RASTER_MODE;
    data[pthread_num].core = IM_SCHEDULER_RGA3_CORE1;
    data[pthread_num].priority = 1;
#endif

#if IM2D_SLT_TEST_RGA2_EN
    pthread_num++;
    data[pthread_num].id = pthread_num;
    data[pthread_num].name = "RGA2";
    data[pthread_num].mode = IM2D_SLT_WHILE_EN;
    data[pthread_num].num = IM2D_SLT_WHILE_NUM;
    data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
    data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
    data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
    data[pthread_num].rd_mode = IM_RASTER_MODE;
    data[pthread_num].core = IM_SCHEDULER_RGA2_CORE0;
    data[pthread_num].priority = 1;
#endif

#if IM2D_SLT_TEST_RGA3_0_FBC_EN
    pthread_num++;
    data[pthread_num].id = pthread_num;
    data[pthread_num].name = "RGA3_core0_fbc";
    data[pthread_num].mode = IM2D_SLT_WHILE_EN;
    data[pthread_num].num = IM2D_SLT_WHILE_NUM;
    data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
    data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
    data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
    data[pthread_num].rd_mode = IM_FBC_MODE;
    data[pthread_num].core = IM_SCHEDULER_RGA3_CORE0;
    data[pthread_num].priority = 1;
#endif

#if IM2D_SLT_TEST_RGA3_1_FBC_EN
    pthread_num++;
    data[pthread_num].id = pthread_num;
    data[pthread_num].name = "RGA3_core1_fbc";
    data[pthread_num].mode = IM2D_SLT_WHILE_EN;
    data[pthread_num].num = IM2D_SLT_WHILE_NUM;
    data[pthread_num].width = IM2D_SLT_DEFAULT_WIDTH;
    data[pthread_num].height = IM2D_SLT_DEFAULT_HEIGHT;
    data[pthread_num].format = IM2D_SLT_DEFAULT_FORMAT;
    data[pthread_num].rd_mode = IM_FBC_MODE;
    data[pthread_num].core = IM_SCHEDULER_RGA3_CORE1;
    data[pthread_num].priority = 1;
#endif

#if IM2D_SLT_THREAD_EN
    for (int i = 1; i <= pthread_num; i++) {
        pthread_create(&tdSyncID[i], NULL, pthread_rga_run, (void *)(&data[i]));
        printf("creat Sync pthread[0x%lx] = %d, id = %d\n", tdSyncID[i], i, data[i].id);
    }

    for (int i = 1; i <= pthread_num; i++) {
        pthread_join(tdSyncID[i], NULL);
        if (data[i].result < 0) {
            printf("ID[%d] case '%s' is faile!\n", data[i].id, data[i].name);
            printf("-------------------------------------------------\n");
            printf("im2d api slt fail!\n");
            return -1;
        }
    }

    printf("-------------------------------------------------\n");
    printf("im2d api slt success!\n");

    return 0;
#else
    (void)(tdSyncID);

    for (int i = 1; i <= pthread_num; i++) {
        pthread_rga_run((void *)(&data[i]));
        printf("ID[%d] %s run end!\n", data[i].id, data[i].name);
        if (data[i].result < 0) {
            printf("ID[%d] case '%s' is faile!\n", data[i].id, data[i].name);
            return -1;
        }
    }

    printf("-------------------------------------------------\n");
    printf("im2d api slt success!\n");

    return 0;
#endif
}