#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <semaphore.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/ioctl.h>

#include "sample_comm.h"
#include "sample_comm_aov.h"
#include "sample_comm_periph.h"
#include "sample_comm_thrd_pool.h"

#define MAX_STREAM_SIZE         (1024 * 1024 * 1024)
#define VENC_MAX_PACK_NUM        5
#define SDCARD_MOUNT_PATH       "/tmp/sd"

#define DEVICES_BIND_DONE_BASE "bind@/devices/platform/soc"
#define DEVICES_UNBIND_DONE_BASE "unbind@/devices/platform/soc"

#define SDCARD_DEVICE1 "10040000.sdhci"
#define SDCARD_DEVICE2 "10020000.sdhci"
#define SDCARD_DRIVER "/sys/bus/platform/drivers/sdhci-lotus"

#define SDCARD_ACTION_ADD           "add"
#define SDCARD_ACTION_REMOVE        "remove"

static xmedia_bool g_transfer_drv_already_load = XMEDIA_FALSE;
static xmedia_bool g_audio_already_open = XMEDIA_FALSE;

#ifdef AOV_APP_TIMESTAMP
typedef struct time_stamp {
    xmedia_u64 drv_resume_start;
    xmedia_u64 app_in;
    xmedia_u64 vpss_in;
    xmedia_u64 svp_in;
    xmedia_u64 svp_out;
    xmedia_u64 app_out;
    xmedia_u64 drv_suspend_end;
} time_stamp;

static time_stamp timestamp[15] = {0};
static xmedia_s32 test_num = -1;
#endif

static sample_aov_work_mode  g_media_work_mode = MEDIA_WORK_NORMAL;
static sample_aov_init_param g_aov_init_param = {0};
static xmedia_bool           g_venc_save_all = XMEDIA_FALSE;

static xmedia_bool             g_venc_thread = XMEDIA_FALSE;
static xmedia_bool             g_work_aov_thread = XMEDIA_FALSE;

static pthread_mutex_t g_sync_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_mutex_t g_npu_detect_mutex = PTHREAD_MUTEX_INITIALIZER;
static sem_t           g_venc_steram_save_start_sem;
static sem_t           g_venc_steram_save_stop_sem;
thread_pool_t *g_aov_thrd_pool_handle = NULL;

static xmedia_s32 g_misc_fd = 0;

sample_aov_detect_t g_aov_detect;

#ifdef SUPPORT_SENSOR_PWDN_MODE
static xmedia_bool support_sensor_pwdn_standby[VI_MAX_DEV_NUM] = {0}; 
#endif

xmedia_s32 sample_aov_system(xmedia_char *command)
{
    FILE* fp = popen(command, "w");
    if (fp == NULL)
    {
        SAMPLE_ERR("aov system command open fail \n");
        return XMEDIA_FAILURE;
    }

    pclose(fp);
    return XMEDIA_SUCCESS;
}

xmedia_s32 sample_aov_drv_audio_load()
{
    g_audio_already_open = XMEDIA_TRUE;
    return XMEDIA_SUCCESS;
}

xmedia_s32 sample_aov_drv_audio_unload()
{
    g_audio_already_open = XMEDIA_FALSE;
    return XMEDIA_SUCCESS;
}

#ifdef AOV_APP_TIMESTAMP
// precision : 10ms.
xmedia_u64 sample_aov_get_debug_timestamp()
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;

    xmedia_pm_rtc_info rtc_info = {0};
    s32Ret = xmedia_pm_get_rtc_info(&rtc_info);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_pm_get_rtc_info fail\n");
        return 0;
    }

    return (rtc_info.rtc_current_time);
}
#endif

static xmedia_s32 sample_aov_drv_sdcard_load()
{
    xmedia_s32 s32Ret = XMEDIA_SUCCESS;
    xmedia_char buf[256] = {0};

    pthread_mutex_lock(&g_sync_mutex);

    memset(buf, 0 , sizeof(buf));
    snprintf(buf, 256, "%s", SDCARD_ACTION_ADD);
    //demo板使用SDIO0连接SD卡，若硬件修改为SDIO1连接SD卡，需将SDCARD_USE_SDIO0宏修改为0
#if SDCARD_USE_SDIO0
    sample_comm_periph_drv_bind(SDCARD_DEVICE1, SDCARD_DRIVER, buf);
#else
    sample_comm_periph_drv_bind(SDCARD_DEVICE2, SDCARD_DRIVER, buf);
#endif

    s32Ret = sample_comm_periph_mount_sdcard(SDCARD_MOUNT_PATH, 2000);
    if(s32Ret != XMEDIA_SUCCESS)
    {
        SAMPLE_ERR("mount SD failed!\n");
        g_transfer_drv_already_load = XMEDIA_FALSE;
    } else {
        g_transfer_drv_already_load = XMEDIA_TRUE;
    }
    pthread_mutex_unlock(&g_sync_mutex);
    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_drv_sdcard_unload()
{
    xmedia_char buf[256] = {0};

    pthread_mutex_lock(&g_sync_mutex);

    sample_comm_periph_umount_sdcard(SDCARD_MOUNT_PATH);

    memset(buf, 0 , sizeof(buf));
    snprintf(buf, 256, "%s", SDCARD_ACTION_REMOVE);
    //demo板使用SDIO0连接SD卡，若硬件修改为SDIO1连接SD卡，需将SDCARD_USE_SDIO0宏修改为0
#if SDCARD_USE_SDIO0
    sample_comm_periph_drv_unbind(SDCARD_DEVICE1, SDCARD_DRIVER, buf);
#else
    sample_comm_periph_drv_unbind(SDCARD_DEVICE2, SDCARD_DRIVER, buf);
#endif
    g_transfer_drv_already_load = XMEDIA_FALSE;
    pthread_mutex_unlock(&g_sync_mutex);
    return XMEDIA_SUCCESS;
}

#if 0
static xmedia_s32 sample_aov_isp_set_max_exptime(xmedia_u32 isp_pipe)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_ae_exposure_attr exp_attr = {0};
    media_comm_isp_sensor_info sns_info = {0};

    media_comm_isp_get_sensor_info(isp_pipe, &sns_info);

    s32Ret = xmedia_ae_get_exposure_attr(isp_pipe, &exp_attr);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_ae_get_exposure_attr fail\n");
        return s32Ret;
    }

    exp_attr.auto_attr.exp_time_range.max = (1000 / sns_info.frame_rate) * 1000;//us
    s32Ret = xmedia_ae_set_exposure_attr(isp_pipe, &exp_attr);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_ae_get_exposure_attr fail\n");
        return s32Ret;
    }

    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_isp_set_mode(xmedia_u32 isp_pipe, aov_media_state media_state)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_isp_attr isp_attr = {0};
    media_comm_isp_sensor_info sns_info = {0};

    media_comm_isp_get_sensor_info(isp_pipe, &sns_info);

    s32Ret = xmedia_isp_get_attr(isp_pipe, &isp_attr);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_ae_get_exposure_attr fail\n");
        return s32Ret;
    }

    if (media_state == MEDIA_STATE_AOV ||  media_state == MEDIA_STATE_AOV_SAVE) {
        isp_attr.fps = (isp_attr.fps >= 30)?(sns_info.frame_rate - 5):(sns_info.frame_rate);
    } else {
        isp_attr.fps = sns_info.frame_rate;
    }
    s32Ret = xmedia_isp_set_attr(isp_pipe, &isp_attr);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_ae_get_exposure_attr fail\n");
        return s32Ret;
    }

    return XMEDIA_SUCCESS;
}
#endif

static xmedia_s32 sample_aov_sensor_resume(xmedia_u32 isp_pipe)
{
    xmedia_s32 s32Ret = XMEDIA_SUCCESS;

#ifdef SUPPORT_SENSOR_PWDN_MODE
    if(g_misc_fd != -1 && support_sensor_pwdn_standby[isp_pipe] == XMEDIA_TRUE) {
        ioctl(g_misc_fd, XMEDIA_MISC_SENSOR_PWDN_RESUME, &isp_pipe);
    }
#endif
    
    xmedia_sensor_low_power(isp_pipe, XMEDIA_FALSE);
    s32Ret = xmedia_sensor_resume(isp_pipe);
    return s32Ret;
}

#ifdef APP_STANDBY_SENSOR
static xmedia_s32 sample_aov_sensor_standby(xmedia_u32 isp_pipe)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;

LOOP:
    s32Ret = xmedia_isp_wait_state(isp_pipe, XMEDIA_ISP_WAIT_TYPE_FE_END, 2000);
    if (s32Ret == XMEDIA_SUCCESS) {
        s32Ret = xmedia_sensor_standby(isp_pipe);
        xmedia_sensor_low_power(isp_pipe, XMEDIA_TRUE);
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("sensor standby set fail , try again\n");
        }
        else {
            for (xmedia_s32 i = 0; i < g_aov_init_param.isp_param.isp_pipe_num; i++) {
                if(g_aov_init_param.isp_param.isp_pipe[i] == isp_pipe) {
                    g_aov_init_param.sensor_status[i] = SENSOR_STATUS_STANDBY;
                }
            }
        }
    } else {
        SAMPLE_ERR("wait isp fe state start fail %#x\n",s32Ret);
        goto LOOP;
    }

    return XMEDIA_SUCCESS;
}

// 线程执行函数
xmedia_void sensor_standby_job_func(xmedia_void *arg)
{
    xmedia_u32 isp_pipe = *(xmedia_u32 *)arg;
    sample_aov_sensor_standby(isp_pipe);
    return ;
}

xmedia_s32 start_sensor_standby_nonblocking(xmedia_s32* isp_pipe)
{
    xmedia_s32 s32Ret = 0;
    s32Ret = sample_comm_thrd_job_submit(g_aov_thrd_pool_handle, &sensor_standby_job_func, isp_pipe);
    return s32Ret;
}
#else
static xmedia_s32 sample_aov_set_sensor_mode(sample_aov_work_mode work_mode)
{
    misc_aov_state aov_state = {0};

    aov_state.en_aov_mode = (work_mode == MEDIA_WORK_AOV ? XMEDIA_TRUE : XMEDIA_FALSE);
    aov_state.frame_num = 1;

    return ioctl(g_misc_fd, XMEDIA_MISC_AOV_SET_SENSOR_MODE, (xmedia_u32)&aov_state, NULL);
}
#endif

xmedia_s32 sample_aov_ae_modify_path(xmedia_u32 isp_pipe)
{
    xmedia_s32 s32Ret = 0;
    xmedia_s32 node_cnt = 0;
    xmedia_isp_ae_route ae_route_attr = {0};

    s32Ret = xmedia_ae_get_route_attr(0, &ae_route_attr);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("get ae route fail\n");
        return s32Ret;
    }

    ae_route_attr.route_node[node_cnt].int_time = 33;
    ae_route_attr.route_node[node_cnt].sys_gain = 1024;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 33;
    ae_route_attr.route_node[node_cnt].sys_gain = 1024*2;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 5000;
    ae_route_attr.route_node[node_cnt].sys_gain = 1024*2;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 5000;
    ae_route_attr.route_node[node_cnt].sys_gain = 1024*4;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 10000;
    ae_route_attr.route_node[node_cnt].sys_gain = 1024*4;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 10000;
    ae_route_attr.route_node[node_cnt].sys_gain = 109993;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 1000 * 1000;
    ae_route_attr.route_node[node_cnt].sys_gain = 109993;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 1000 * 1000;
    ae_route_attr.route_node[node_cnt].sys_gain = 3519776;
    node_cnt++;

    ae_route_attr.route_node[node_cnt].int_time = 1000 * 1000;
    ae_route_attr.route_node[node_cnt].sys_gain = 35197760;

    ae_route_attr.total_num = node_cnt;
    s32Ret = xmedia_ae_set_route_attr(isp_pipe, &ae_route_attr);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("set ae route fail\n");
    }

    return s32Ret;
}

/****************************************************************************
**aov start processs:
*** |  delta0        |    app              |  delta1      | ****************
**   por---auxcode----drv_resume----app-----drv_suspend----set rtc_timeout---soc power off ----*
**delta0: use rtc resume set rtc_timeout; = (rtc_delta_time - rtc_last_suspend_time - rtc_timeout).*
**delta_time1: drv_suspend; = rtc_last_suspend_time - last app_end_timestamp;     *
**keep work time + suspend = rtc_timeout,should get delta0 & delta1.                                   *
****/

xmedia_s32 sample_aov_set_suspend_time()
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_pm_attr pm_attr = {0};
    xmedia_pm_rtc_info rtc_info = {0};
    xmedia_u32 app_time = 0;
    static xmedia_s32 delta_time0 = 0;
    static xmedia_s32 delta_time1 = 0;
    static xmedia_u64 app_end_timestamp = 0;
    static xmedia_bool rtc_time_amend_end = XMEDIA_FALSE;
    static xmedia_bool update_rtc_time_end = XMEDIA_FALSE;

    s32Ret = xmedia_pm_get_rtc_info(&rtc_info);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_pm_get_rtc_info fail\n");
        return XMEDIA_FAILURE;
    }

    if (rtc_time_amend_end == XMEDIA_TRUE) {
        if (delta_time0 == 0 && delta_time1 == 0) {
            delta_time0 = rtc_info.rtc_delta_time - rtc_info.rtc_last_suspend_time - g_aov_init_param.suspend_time;
            delta_time1 = rtc_info.rtc_last_suspend_time - app_end_timestamp;
            g_aov_init_param.suspend_time -= delta_time0;
        }

        app_time = rtc_info.rtc_current_time - rtc_info.rtc_delta_time;

        if ((app_time + delta_time1 + RTC_SAFE_THRESOHLD_MS) > g_aov_init_param.suspend_time || update_rtc_time_end == XMEDIA_FALSE) {
            pm_attr.rtc_attr.rtc_enable = XMEDIA_TRUE;
            pm_attr.rtc_attr.rtc_timeout = (g_aov_init_param.suspend_time / 10);//10ms 精度: /10;

            s32Ret = xmedia_pm_set_attr(&pm_attr);
            if (s32Ret != XMEDIA_SUCCESS) {
                SAMPLE_ERR("pm set fail \n");
            }

            SAMPLE_PRT("dudu debug delta0 %d delta1 %d rtc_timeout %d \n",delta_time0, delta_time1, g_aov_init_param.suspend_time);

            update_rtc_time_end = XMEDIA_TRUE;
        }
    } else {
        pm_attr.rtc_attr.rtc_enable = XMEDIA_TRUE;
        pm_attr.rtc_attr.rtc_timeout = (g_aov_init_param.suspend_time / 10);//10ms 精度: /10;

        s32Ret = xmedia_pm_set_attr(&pm_attr);
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("pm set fail \n");
        }

        app_end_timestamp = rtc_info.rtc_current_time;
        rtc_time_amend_end = XMEDIA_TRUE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_void sample_aov_suspend()
{
    sample_aov_set_suspend_time();

#ifdef AOV_APP_TIMESTAMP
    if(test_num != -1) {
        timestamp[test_num].app_out = sample_aov_get_debug_timestamp();
    }

    if (test_num == 11) {
        for (test_num = 0; test_num < 10; test_num ++) {
            SAMPLE_PRT("debug aov %d test : drv_resume_in[%lld] app_in[%lld] vpss_in[%lld] svp_in[%lld] svp_out[%lld] app_out[%lld] drv_suspend_end[%lld]\n",
            test_num, timestamp[test_num].drv_resume_start, timestamp[test_num].app_in, timestamp[test_num].vpss_in,timestamp[test_num].svp_in,
            timestamp[test_num].svp_out,timestamp[test_num].app_out,timestamp[test_num].drv_suspend_end);
        }
        sleep(20);

        test_num = -1;
        memset(timestamp, 0, sizeof (timestamp));
    }

    test_num ++;
#endif
    xmedia_pm_suspend();

#ifdef AOV_APP_TIMESTAMP
    timestamp[test_num].app_in = sample_aov_get_debug_timestamp();

    xmedia_pm_rtc_info rtc_info = {0};
    xmedia_pm_get_rtc_info(&rtc_info);

    timestamp[test_num].drv_resume_start = rtc_info.rtc_delta_time;

    if (test_num >= 1) {
        timestamp[test_num - 1].drv_suspend_end = rtc_info.rtc_last_suspend_time;
    }

#endif

#ifdef APP_STANDBY_SENSOR
    //isp driver has do sensor resume
    for (xmedia_s32 i = 0; i < g_aov_init_param.isp_param.isp_pipe_num; i++) {
        g_aov_init_param.sensor_status[i] = SENSOR_STATUS_RESUME;
    }
#endif

    return;
}

static xmedia_s32 sample_aov_npu_set_work_mode(sample_aov_work_mode work_mode)
{
    xmedia_s32 s32Ret = XMEDIA_SUCCESS;
    xmedia_s32 i = 0;
    xmedia_svp_aov_attr yolov5_attr = {0};
    xmedia_bool cur_npu_mode = XMEDIA_TRUE;
    sample_aov_vpss_npu_param *npu_param = XMEDIA_NULL;

    npu_param = &(g_aov_init_param.npu_param);

    for (i = 0; i < npu_param->npu_detect_num; i++) {
        if (npu_param->en_switch_mode[i] == XMEDIA_FALSE) {
            continue;
        }
        s32Ret = xmedia_svp_task_get_attr(npu_param->npu_svp_handle[i], &yolov5_attr);
        if (XMEDIA_SUCCESS != s32Ret) {
            SAMPLE_ERR("svp get task attr fail.\n");
            return s32Ret;
        }

        cur_npu_mode = (MEDIA_WORK_AOV == work_mode) ? XMEDIA_TRUE : XMEDIA_FALSE;
        if (cur_npu_mode == yolov5_attr.aov_only_target) {
            return XMEDIA_SUCCESS;
        }

        yolov5_attr.aov_only_target = cur_npu_mode;

        s32Ret = xmedia_svp_task_set_attr(npu_param->npu_svp_handle[i], &yolov5_attr);
        if(s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("svp set task attr fail.\n");
            return XMEDIA_FAILURE;
        }
    }

    return XMEDIA_SUCCESS;
}

static xmedia_void sample_aov_venc_set_stream_save_start()
{
    sem_post(&g_venc_steram_save_start_sem);
}

static xmedia_void sample_aov_venc_get_stream_save_stop()
{
    sem_wait(&g_venc_steram_save_stop_sem);
}

static xmedia_void sample_aov_venc_set_save_all(xmedia_bool en_save)
{
    pthread_mutex_lock(&g_sync_mutex);
    g_venc_save_all = en_save;
    pthread_mutex_unlock(&g_sync_mutex);
}

static xmedia_void sample_aov_venc_get_save_all(xmedia_bool *en_save)
{
    pthread_mutex_lock(&g_sync_mutex);
    *en_save = g_venc_save_all;
    pthread_mutex_unlock(&g_sync_mutex);
}

static xmedia_s32 sample_aov_venc_stream_write(FILE* pFd, xmedia_venc_stream* venc_stream)
{
    xmedia_s32 i;
    for (i = 0; i < venc_stream->pack_count; i++) {
        fwrite(venc_stream->pack[i].vir_addr + venc_stream->pack[i].offset,
               venc_stream->pack[i].len - venc_stream->pack[i].offset, 1, pFd);
    }

    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_venc_get_transfer_path(xmedia_s32 venc_chn, xmedia_char *file_path)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_venc_chn_attr venc_chn_attr = {0};
    xmedia_char buf[256] = {0};
    struct stat file_stat = {0};
    static xmedia_s32 path_count = 0;

    s32Ret = xmedia_venc_get_chn_attr(venc_chn, &venc_chn_attr);
    if (XMEDIA_SUCCESS != s32Ret) 
    {
        SAMPLE_ERR("xmedia_venc_get_chn_attr chn[%d] failed with %#x!\n", venc_chn, s32Ret);
        return s32Ret;
    }

    switch (venc_chn_attr.venc_attr.en_type)
    {
        case PT_H264:
            snprintf(buf, 255, ""SDCARD_MOUNT_PATH"/stream_chn%d_%d%s", venc_chn, path_count, ".h264");
                break;
        case PT_H265:
            snprintf(buf, 255, ""SDCARD_MOUNT_PATH"/stream_chn%d_%d%s", venc_chn, path_count, ".h265");
                break;
        case PT_JPEG:
            snprintf(buf, 255, ""SDCARD_MOUNT_PATH"/stream_chn%d_%d%s", venc_chn, path_count, ".jpg");
            break;
        case PT_MJPEG:
            snprintf(buf, 255, ""SDCARD_MOUNT_PATH"/stream_chn%d_%d%s", venc_chn, path_count, ".mjpeg");
            break;
        default:
            SAMPLE_ERR("venc type is invail exit stream thread \n");
            return XMEDIA_FAILURE;
    }
    strcpy(file_path, buf);

    s32Ret = stat(file_path, &file_stat);
    if (s32Ret < 0) {
        SAMPLE_PRT("get stream file fail, create file.\n");
        return XMEDIA_SUCCESS;
    }

    if (file_stat.st_size > MAX_STREAM_SIZE) {
        path_count ++;
    }

    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_venc_save_stream(sample_aov_work_mode work_mode)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_s32 i = 0;
    xmedia_s32 milli_sec = 1;
    xmedia_venc_chn_status chn_stat = {0};
    xmedia_venc_stream venc_stream = {0};
    xmedia_char file_path[256] = {0};
    FILE * venc_fd[VENC_MAX_CHN_NUM] = {XMEDIA_NULL};
    sample_aov_venc_param *venc_param = XMEDIA_NULL;
    xmedia_s32 cur_frame_num = 0;
    xmedia_bool save_all_stream = XMEDIA_FALSE;

    venc_param = &(g_aov_init_param.venc_param);

    for (i = 0; i < venc_param->venc_chn_num; i++) {
        s32Ret = sample_aov_venc_get_transfer_path(venc_param->venc_chn[i], file_path);
        if (s32Ret != XMEDIA_SUCCESS)
        {
            SAMPLE_ERR("get venc type fail \n");
            return XMEDIA_FAILURE;
        }

        venc_fd[i] = fopen(file_path,"ab");
        if (venc_fd[i] == XMEDIA_NULL)
        {
            SAMPLE_ERR("open aov chn fd fail,file_path:%s,errno:%s\n", file_path, strerror(errno));
            return XMEDIA_FAILURE;
        }
    }

    memset(&venc_stream, 0, sizeof(venc_stream));
    venc_stream.pack = (xmedia_venc_pack*)malloc(sizeof(xmedia_venc_pack) * VENC_MAX_PACK_NUM);
NORMAL_SAVE:
#if 0 //暂不考虑normal buf 满再写的方案
    sample_aov_venc_get_save_all(&save_all_stream);
    if (MEDIA_WORK_AOV == work_mode && save_all_stream == XMEDIA_FALSE) {
        for (i = 0; i < venc_param->venc_chn_num; i++) {
            s32Ret = xmedia_venc_query_status(venc_param->venc_chn[i], &chn_stat);
            if (XMEDIA_SUCCESS != s32Ret)
            {
                SAMPLE_ERR("xmedia_venc_query_status chn[%d] failed with %#x!\n", venc_param->venc_chn[i], s32Ret);
            } else {
                if ((venc_param->chn_max_size[i] - chn_stat.left_stream_bytes) > venc_param->chn_threshold_size[i]) {
                    chn_stat.left_stream_frames = 0;//未达到阈值，暂时不写
                }
            }
            cur_frame_num |= chn_stat.left_stream_frames;
        }

        if (cur_frame_num == 0) {
            goto NORMAL_SAVE;
        }
    }
#endif
//获取完成当前帧
STREAM_SAVE_CONTINUE:
    for (i = 0; i < venc_param->venc_chn_num; i++) {
        s32Ret = xmedia_venc_query_status(venc_param->venc_chn[i], &chn_stat);
        if (XMEDIA_SUCCESS != s32Ret)
        {
            SAMPLE_ERR("xmedia_venc_query_status chn[%d] failed with %#x!\n", venc_param->venc_chn[i], s32Ret);
        }

        if (chn_stat.cur_packs == 0) {
            continue;
        }

        venc_stream.pack_count = chn_stat.cur_packs;

        s32Ret = xmedia_venc_get_stream(venc_param->venc_chn[i], &venc_stream, milli_sec);
        if (XMEDIA_SUCCESS != s32Ret) {
            SAMPLE_ERR("xmedia_venc_get_stream chn %d failed with %#x! \n",venc_param->venc_chn[i], s32Ret);
        }

        sample_aov_venc_stream_write(venc_fd[i], &venc_stream);

        s32Ret = xmedia_venc_release_stream(venc_param->venc_chn[i], &venc_stream);
        if (XMEDIA_SUCCESS != s32Ret) {
            SAMPLE_ERR("xmedia_venc_release_stream failed!\n");
        }

        if (chn_stat.left_stream_frames > 0) {
            chn_stat.left_stream_frames -= 1;
        }
        cur_frame_num |= chn_stat.left_stream_frames;
    }

    if (cur_frame_num != 0) {
        cur_frame_num = 0;
        goto STREAM_SAVE_CONTINUE;
    }

    sample_aov_venc_get_save_all(&save_all_stream);
    if (MEDIA_WORK_NORMAL == work_mode && XMEDIA_FALSE == save_all_stream) {
        goto NORMAL_SAVE;//normal达到阈值再写卡
    } else {
        for (i = 0; i < venc_param->venc_chn_num; i++) {
            s32Ret = xmedia_venc_query_status(venc_param->venc_chn[i], &chn_stat);
            if (XMEDIA_SUCCESS != s32Ret)
            {
                SAMPLE_ERR("xmedia_venc_query_status chn[%d] failed with %#x!\n", venc_param->venc_chn[i], s32Ret);
            }

            cur_frame_num |= chn_stat.left_stream_frames;
        }

        if (cur_frame_num != 0) {
            cur_frame_num = 0;
            goto STREAM_SAVE_CONTINUE;
        }
    }

    free(venc_stream.pack);
    venc_stream.pack = XMEDIA_NULL;
    for (i = 0; i < venc_param->venc_chn_num; i++) {
        if (venc_fd[i] != XMEDIA_NULL) {
            fflush(venc_fd[i]);
            fsync(fileno(venc_fd[i]));
            fclose(venc_fd[i]);
            venc_fd[i] = XMEDIA_NULL;
        }
    }
    if (work_mode == MEDIA_WORK_NORMAL) {
        sample_aov_venc_set_save_all(XMEDIA_FALSE);//reset
    }

    return XMEDIA_SUCCESS;
}

static xmedia_bool sample_aov_venc_get_aov_buf_full(xmedia_void)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_bool buf_full = XMEDIA_FALSE;
    xmedia_s32 i = 0;
    xmedia_venc_chn_status stat = {0};
    sample_aov_venc_param *venc_param = XMEDIA_NULL;
#if 1
    static xmedia_s32 last_frame_size[VENC_MAX_CHN_NUM] = {0};
    static xmedia_s32 cur_frame_size[VENC_MAX_CHN_NUM] = {0};
    static xmedia_s32 max_frame_size[VENC_MAX_CHN_NUM] = {0};
#endif

    venc_param = &(g_aov_init_param.venc_param);

    for (i = 0; i < venc_param->venc_chn_num; i++) {
        if (venc_param->en_aov[i] != XMEDIA_TRUE) {
            continue;
        }

        s32Ret = xmedia_venc_query_status(venc_param->venc_chn[i], &stat);
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("get buf full state venc query fail chn[%d] \n",venc_param->venc_chn[i]);
        }

        if (venc_param->chn_max_size[i] - stat.left_stream_bytes <= venc_param->chn_threshold_size[i]) {
            buf_full |= XMEDIA_TRUE;
            break;
        } else {
            buf_full |= XMEDIA_FALSE;
        }

        if (stat.left_stream_frames >= VENC_STR_BUF_DEFAULT_MAX_FRAME_COUNT) {
            buf_full |= XMEDIA_TRUE;
            break;
        } else {
            buf_full |= XMEDIA_FALSE;
        }

// update aov mode chn_threshold , use 2 * (last max size frame).
#if 1
        cur_frame_size[i] = stat.left_stream_bytes;
        last_frame_size[i] = cur_frame_size[i] - last_frame_size[i];
        max_frame_size[i] = (max_frame_size[i] > last_frame_size[i]) ? max_frame_size[i] : last_frame_size[i];
        venc_param->chn_threshold_size[i] = ((venc_param->chn_threshold_size[i] / 2) > max_frame_size[i]) ? venc_param->chn_threshold_size[i] : max_frame_size[i] * 2;
#if 0
        SAMPLE_PRT("DEBUG VENC CHN%d\n",venc_param->venc_chn[i]);
        SAMPLE_PRT("cur frame: %d\n",stat.left_stream_frames);
        SAMPLE_PRT("max_size:  %d\n", venc_param->chn_max_size[i]);
        SAMPLE_PRT("used:      %d\n",stat.left_stream_bytes);
        SAMPLE_PRT("remaining: %d\n",venc_param->chn_max_size[i]- stat.left_stream_bytes);
        SAMPLE_PRT("threshold: %d\n",venc_param->chn_threshold_size[i]);
        SAMPLE_PRT("last_frame:%d\n",last_frame_size[i]);
        SAMPLE_PRT("max_frame: %d\n",max_frame_size[i]);
#endif
        last_frame_size[i] = stat.left_stream_bytes;
#endif
    }

    return buf_full;
}

static xmedia_s32 sample_aov_venc_clear_buf(xmedia_s32 venc_chn)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_venc_recv_pic_param  recv_param = {0};
    recv_param.recv_pic_num = -1;

    s32Ret = xmedia_venc_stop_recv_frame(venc_chn);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("aov clear buf stop recv chn[%d] frame fail\n",venc_chn);
        return XMEDIA_FAILURE;
    }

    s32Ret = xmedia_venc_reset_chn(venc_chn);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("aov clear buf reset chn[%d] frame fail\n",venc_chn);
        return XMEDIA_FAILURE;
    }

    s32Ret = xmedia_venc_start_recv_frame(venc_chn, &recv_param);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("aov clear buf start recv chn[%d] frame fail\n",venc_chn);
        return XMEDIA_FAILURE;
    }
    return XMEDIA_SUCCESS;
}


static xmedia_void sample_aov_work_aov_save_resume()
{
    sample_aov_drv_sdcard_load();
    sample_aov_venc_set_stream_save_start();
}

static xmedia_void sample_aov_work_aov_save_suspend()
{
    sample_aov_venc_get_stream_save_stop();
    sample_aov_drv_sdcard_unload();
}

static xmedia_s32 sample_aov_work_normal_pipe_resume()
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_venc_recv_pic_param  recv_param = {0};
    recv_param.recv_pic_num = -1;
    xmedia_s32 i = 0;
    xmedia_s32 j = 0;

    sample_aov_isp_param *isp_param = XMEDIA_NULL;
    sample_aov_vpss_normal_only_param *vpss_param = XMEDIA_NULL;
    sample_aov_venc_param *venc_param = XMEDIA_NULL;

    isp_param  = &(g_aov_init_param.isp_param);
    vpss_param = &(g_aov_init_param.vpss_param);
    venc_param = &(g_aov_init_param.venc_param);

    //npu not only target
    sample_aov_npu_set_work_mode(MEDIA_WORK_NORMAL);

    sample_aov_drv_sdcard_load();

    // restart aov no used vpss ochn
    for (i = 0; i < vpss_param->vpss_pipe_num; i++) {
        for (j = 0; j < vpss_param->vpss_ochn_num[i]; j++) {
            s32Ret = xmedia_vpss_enable_ochn(vpss_param->vpss_pipe[i], vpss_param->vpss_ochn[i][j]);
            if (s32Ret != XMEDIA_SUCCESS) {
                SAMPLE_ERR("normal ressume enable vpss pipe %d ochn[%d] fail\n", vpss_param->vpss_pipe[i], vpss_param->vpss_ochn[i][j]);
            }
        }
    }

    // restart aov no used venc chn
    for (i = 0; i < venc_param->venc_chn_num; i++) {
        if (venc_param->en_aov[i] == XMEDIA_TRUE) {
            continue;//only restart normal chn
        }
        s32Ret = xmedia_venc_start_recv_frame(venc_param->venc_chn[i], &recv_param);
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("normal resume start recv chn[%d] fail\n",venc_param->venc_chn[i]);
        }
    }

    sample_aov_venc_set_stream_save_start();

#ifndef APP_STANDBY_SENSOR
    sample_aov_set_sensor_mode(MEDIA_WORK_NORMAL);
#endif

    for (i = 0; i < isp_param->isp_pipe_num; i++) {
        sample_aov_sensor_resume(isp_param->isp_pipe[i]);
    }

    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_work_normal_pipe_suspend()
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_s32 i = 0, j = 0;
#ifdef APP_STANDBY_SENSOR
    xmedia_s32 sensor_standby_flag = 0, need_delay = 0;
#endif

    sample_aov_isp_param *isp_param = XMEDIA_NULL;
    sample_aov_vpss_normal_only_param *vpss_param = XMEDIA_NULL;
    sample_aov_venc_param *venc_param = XMEDIA_NULL;

    isp_param  = &(g_aov_init_param.isp_param);
    vpss_param = &(g_aov_init_param.vpss_param);
    venc_param = &(g_aov_init_param.venc_param);

#ifdef APP_STANDBY_SENSOR
    for (i = 0; i < isp_param->isp_pipe_num; i++) {
        start_sensor_standby_nonblocking(&isp_param->isp_pipe[i]);
        sensor_standby_flag |= 1 << i;
    }
#else
    sample_aov_set_sensor_mode(MEDIA_WORK_AOV);
#endif

#ifdef IVE_DETECT_SUPPORT
    for (i = 0; i < isp_param->isp_pipe_num; i++) {
        g_aov_detect.ive_param[i].is_first_frm = XMEDIA_TRUE;
    }
#endif

    sample_aov_venc_set_save_all(XMEDIA_TRUE);

    sample_aov_venc_get_stream_save_stop();

    // stop aov no used venc chn, clear aov chn
    for (i = 0; i < venc_param->venc_chn_num; i++) {
        if (venc_param->en_aov[i] != XMEDIA_TRUE) {
            s32Ret = xmedia_venc_stop_recv_frame(venc_param->venc_chn[i]);
            if (s32Ret != XMEDIA_SUCCESS) {
                SAMPLE_ERR("normal suspend stop recv chn[%d] fail\n",venc_param->venc_chn[i]);
            }
        } else {
            sample_aov_venc_clear_buf(venc_param->venc_chn[i]);
        }
    }

    // stop aov no used vpss ochn
    for (i = 0; i < vpss_param->vpss_pipe_num; i++) {
        for (j = 0; j < vpss_param->vpss_ochn_num[i]; j++) {
            s32Ret = xmedia_vpss_disable_ochn(vpss_param->vpss_pipe[i], vpss_param->vpss_ochn[i][j]);
            if (s32Ret != XMEDIA_SUCCESS) {
                SAMPLE_ERR("normal suspend disable vpss pipe %d ochn[%d] fail\n", vpss_param->vpss_pipe[i], vpss_param->vpss_ochn[i][j]);
            }
        }
    }

    // npu only target
    sample_aov_npu_set_work_mode(MEDIA_WORK_AOV);

    sample_aov_drv_sdcard_unload();

#ifdef APP_STANDBY_SENSOR
    j = 0;
    while(sensor_standby_flag != 0) {
        need_delay = 1;
        for (i = 0; i < isp_param->isp_pipe_num; i++) {
            if(g_aov_init_param.sensor_status[i] == SENSOR_STATUS_STANDBY) {
                sensor_standby_flag &= ~(1 << i);
                need_delay = 0;
            }
        }
        
        //print alert 
        if(++j % 10000 == 0) {
            SAMPLE_ERR("Maybe something error in sensor standby!!!\n");
        }

        if(need_delay)
            usleep(500);
    }
#endif

    return XMEDIA_SUCCESS;
}


#ifdef IVE_DETECT_SUPPORT
static xmedia_s32 sample_aov_ive_mmz_alloc(xmedia_u64 *pu64_phy_addr, xmedia_void **pp_vir_addr,
                                          const xmedia_char *str_mmb, const xmedia_char *str_zone,
                                          xmedia_u32 u32_len)
{
    *pu64_phy_addr = xmedia_mmz_alloc(str_zone, str_mmb, u32_len);
    if (*pu64_phy_addr == 0) {
        return XMEDIA_FAILURE;
    }

    *pp_vir_addr = xmedia_mmz_map(*pu64_phy_addr, u32_len, 0);
    if (*pp_vir_addr == XMEDIA_NULL) {
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_ive_mmz_free(xmedia_u64 u64_phy_addr, xmedia_void *p_vir_addr)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;

    if (u64_phy_addr == 0 || p_vir_addr == XMEDIA_NULL) {
        SAMPLE_ERR("sys_mmz_free fail.\n");
        return XMEDIA_FAILURE;
    }

    s32Ret = xmedia_mmz_unmap(p_vir_addr);
    if (s32Ret != XMEDIA_SUCCESS) {
        return XMEDIA_FAILURE;
    }

    return xmedia_mmz_free(u64_phy_addr);
}

static xmedia_s32 sample_aov_ive_create_image(xmedia_ive_image_s* pst_img, xmedia_u32 u32width, xmedia_u32 u32height)
{
    xmedia_u32 u32size = 0;
    xmedia_s32 s32Ret = XMEDIA_FAILURE;

    if (XMEDIA_NULL == pst_img) {
        SAMPLE_ERR("create_image is NULL.\n");
        return XMEDIA_FAILURE;
    }

    pst_img->u32width = u32width;
    pst_img->u32height = u32height;
    pst_img->au32stride[0] = (pst_img->u32width + (8 - pst_img->u32width % 8) % 8);

    u32size = pst_img->au32stride[0] * pst_img->u32height;
    s32Ret = sample_aov_ive_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], "ive_img", XMEDIA_NULL, u32size);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("Mmz Alloc fail,Error(%#x)\n", s32Ret);
        return s32Ret;
    }

    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_ive_create_mem_info(xmedia_ive_mem_info_s* pst_mem_info, xmedia_u32 u32size)
{
    xmedia_s32 s32Ret;

    if (NULL == pst_mem_info)
    {
        SAMPLE_ERR("pst_mem_info is null\n");
        return XMEDIA_FAILURE;
    }

    pst_mem_info->u32size = u32size;
    s32Ret = sample_aov_ive_mmz_alloc(&pst_mem_info->u64phyaddr, (xmedia_void**)&pst_mem_info->u64viraddr, "ive_mem", XMEDIA_NULL, u32size);
    if (s32Ret != XMEDIA_SUCCESS)
    {
        SAMPLE_ERR("Mmz Alloc fail,Error(%#x)\n", s32Ret);
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}


static xmedia_s32 sample_aov_ive_dma_image(xmedia_video_frame_info *pst_frame_info,xmedia_ive_dst_image_s *pst_dst,xmedia_bool b_instant)
{
    xmedia_s32 s32Ret;
    xmedia_ive_handle h_ive_handle;
    xmedia_ive_src_data_s st_src_data;
    xmedia_ive_dst_data_s st_dst_data;
    xmedia_ive_dma_ctrl_s st_ctrl = {XMEDIA_IVE_DMA_MODE_DIRECT_COPY,0};
    xmedia_bool b_finish = XMEDIA_FALSE;
    xmedia_bool b_block = XMEDIA_TRUE;

    //fill src
    st_src_data.u64phyaddr = pst_frame_info->frame.addr.y_phy_addr;
    st_src_data.u32width   = pst_frame_info->frame.width;
    st_src_data.u32height  = pst_frame_info->frame.height;
    st_src_data.u32stride  = pst_frame_info->frame.stride.y_stride;

    //fill dst
    st_dst_data.u64phyaddr = pst_dst->au64phyaddr[0];
    st_dst_data.u32width   = pst_dst->u32width;
    st_dst_data.u32height  = pst_dst->u32height;
    st_dst_data.u32stride  = pst_dst->au32stride[0];

    s32Ret = xmedia_ive_dma(&h_ive_handle,&st_src_data,&st_dst_data,&st_ctrl,b_instant);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("xmedia_ive_dma failed! \n");
        return s32Ret;
    }

    if (XMEDIA_TRUE == b_instant)
    {
        s32Ret = xmedia_ive_query(h_ive_handle,&b_finish,b_block);
        while(ERR_CODE_IVE_QUERY_TIMEOUT == s32Ret)
        {
            usleep(100);
            s32Ret = xmedia_ive_query(h_ive_handle,&b_finish,b_block);
        }
        if (XMEDIA_SUCCESS != s32Ret) {
            SAMPLE_ERR("xmedia_ive_query failed! \n");
            return s32Ret;
        }
    }

    return XMEDIA_SUCCESS;
}

static xmedia_s32 sample_aov_ive_init(xmedia_void)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_u8 u8WndSz = 0;
    xmedia_s32 i = 0, j = 0;
    
    memset(&g_aov_detect, 0, sizeof(sample_aov_detect_t));

    s32Ret = xmedia_md_init();
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("ive md init fail.\n");
        return XMEDIA_FAILURE;
    }

    for (i = 0; i < g_aov_init_param.isp_param.isp_pipe_num; i++) {
        g_aov_detect.ive_param[i].stMdAttr.en_alg_mode = XMEDIA_MD_ALG_MODE_REF;
        g_aov_detect.ive_param[i].stMdAttr.en_sad_mode = XMEDIA_IVE_SAD_MODE_MB_8X8;
        g_aov_detect.ive_param[i].stMdAttr.en_sad_out_ctrl = XMEDIA_IVE_SAD_OUT_CTRL_THRESH;
        g_aov_detect.ive_param[i].stMdAttr.u16_sad_thr = 1600;
        g_aov_detect.ive_param[i].stMdAttr.u32_width = NPU_CHN_WIDTH;
        g_aov_detect.ive_param[i].stMdAttr.u32_height = NPU_CHN_HEIGHT;
        g_aov_detect.ive_param[i].stMdAttr.st_add_ctrl.u0q16x = 32768;
        g_aov_detect.ive_param[i].stMdAttr.st_add_ctrl.u0q16y = 32768;
        g_aov_detect.ive_param[i].stMdAttr.st_ccl_ctrl.en_mode = XMEDIA_IVE_CCL_MODE_4C;
        u8WndSz = ( 1 << (2 + g_aov_detect.ive_param[i].stMdAttr.en_sad_mode));
        g_aov_detect.ive_param[i].stMdAttr.st_ccl_ctrl.u16_init_area_thr = 180;
        g_aov_detect.ive_param[i].stMdAttr.st_ccl_ctrl.u16_step = u8WndSz;
        g_aov_detect.ive_param[i].is_first_frm = XMEDIA_TRUE;
        g_aov_detect.ive_param[i].md_chn = i;

        for (j = 0; j < AOV_IVE_MD_IMAGE_NUM; j++) {
            s32Ret = sample_aov_ive_create_image(&g_aov_detect.ive_param[i].astImg[j], NPU_CHN_WIDTH, NPU_CHN_HEIGHT);
            if (s32Ret != XMEDIA_SUCCESS) {
                SAMPLE_ERR("ive create img fail.\n");
                goto ive_err0;
            }
        }
    
        s32Ret = sample_aov_ive_create_mem_info(&g_aov_detect.ive_param[i].stBlob, sizeof(xmedia_ive_ccblob_s));
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("ive create mem fail.\n");
            goto ive_err1;
        }

        s32Ret = xmedia_md_create_chn(g_aov_detect.ive_param[i].md_chn, &(g_aov_detect.ive_param[i].stMdAttr));
        if (XMEDIA_SUCCESS != s32Ret) {
            goto ive_err2;
        }
    }

    return XMEDIA_SUCCESS;

ive_err2:
    xmedia_md_exit();
ive_err1:
    for (i = 0; i < g_aov_init_param.isp_param.isp_pipe_num; i++) {
        if(g_aov_detect.ive_param[i].stBlob.u64phyaddr != 0 &&
                g_aov_detect.ive_param[i].stBlob.u64viraddr != XMEDIA_NULL)
            sample_aov_ive_mmz_free(g_aov_detect.ive_param[i].stBlob.u64phyaddr, (xmedia_void *)(xmedia_ulong)g_aov_detect.ive_param[i].stBlob.u64viraddr);
    }
ive_err0:
    for (i = 0; i < g_aov_init_param.isp_param.isp_pipe_num; i++) {
        for (j = 0; j < AOV_IVE_MD_IMAGE_NUM; j++) {
            if(g_aov_detect.ive_param[i].astImg[j].au64phyaddr[0] != 0 &&
                    g_aov_detect.ive_param[i].astImg[j].au64viraddr[0] != XMEDIA_NULL)
            sample_aov_ive_mmz_free(g_aov_detect.ive_param[i].astImg[j].au64phyaddr[0], (xmedia_void *)(xmedia_ulong)g_aov_detect.ive_param[i].astImg[j].au64viraddr[0]);
        }
    }

    return XMEDIA_FAILURE;
}

static xmedia_s32 sample_aov_ive_exit(xmedia_void)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_s32 i = 0, j = 0;

    for (i = 0; i < g_aov_init_param.isp_param.isp_pipe_num; i++) {
        s32Ret = xmedia_md_destroy_chn(g_aov_detect.ive_param[i].md_chn);
        if (XMEDIA_SUCCESS != s32Ret) {
            SAMPLE_ERR("xmedia_md_destroy_chn fail.\n");
        }

        sample_aov_ive_mmz_free(g_aov_detect.ive_param[i].stBlob.u64phyaddr, (xmedia_void *)(xmedia_ulong)g_aov_detect.ive_param[i].stBlob.u64viraddr);

        for (j = 0; j < AOV_IVE_MD_IMAGE_NUM; j++) {
            sample_aov_ive_mmz_free(g_aov_detect.ive_param[i].astImg[j].au64phyaddr[0], (xmedia_void *)(xmedia_ulong)g_aov_detect.ive_param[i].astImg[j].au64viraddr[0]);
        }
    }

    xmedia_md_exit();

    return XMEDIA_SUCCESS;
}

static xmedia_bool sample_aov_svp_ive_detect(xmedia_video_frame_info *video_frame, aov_ive_param *ive_param)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_ive_ccblob_s *pst_blob = XMEDIA_NULL;
    
    if(ive_param == XMEDIA_NULL)
    {
        SAMPLE_ERR("input ive_param is NULL!\n");
        return XMEDIA_FALSE;
    }

    s32Ret = sample_aov_ive_dma_image(video_frame, &ive_param->astImg[ive_param->cur_idx], XMEDIA_TRUE);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("aov_ive_dma_image, ret = 0x%x\n", s32Ret);
        return XMEDIA_FALSE;
    }

    if (XMEDIA_TRUE == ive_param->is_first_frm) {
        ive_param->is_first_frm = XMEDIA_FALSE;
        goto CHANGE_IDX;
    }

    s32Ret = xmedia_md_process(ive_param->md_chn, &ive_param->astImg[ive_param->cur_idx], &ive_param->astImg[1 - ive_param->cur_idx],
                                XMEDIA_NULL, &ive_param->stBlob);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("xmedia_md_process, ret = 0x%x\n", s32Ret);
        return XMEDIA_FALSE;
    }

    pst_blob = (xmedia_ive_ccblob_s*)(xmedia_ulong)ive_param->stBlob.u64viraddr;
    if (pst_blob->u8_region_num > 0) {
        goto CHANGE_IDX;
    } else {
        return XMEDIA_FALSE;
    }

CHANGE_IDX: //Change reference and current frame index
    ive_param->cur_idx = 1 - ive_param->cur_idx;

    return XMEDIA_TRUE;
}
#endif

xmedia_void normal_job_func(xmedia_void *arg)
{
    xmedia_s32 milli_sec = 2000;
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_video_frame_info video_frame = {0};
    xmedia_svp_task_input task_input = {0};
    xmedia_s32 i = 0, index;
    sample_aov_vpss_npu_param *npu_param = XMEDIA_NULL;
    sample_aov_normal_npu_notice npu_notice = XMEDIA_NULL;
    xmedia_svp_aov_detect_output svp_result;
    sample_aov_isp_param *isp_param = XMEDIA_NULL;

    isp_param = &(g_aov_init_param.isp_param);
    
    index = *(xmedia_s32*)arg;
    if(index >= isp_param->isp_pipe_num)
    {
        SAMPLE_ERR("invalid index(%d)!!!\n", index);
        return;
    }

    npu_param = &(g_aov_init_param.npu_param);
    npu_notice = g_aov_init_param.npu_notice_callback;

    s32Ret = xmedia_vpss_acquire_ochn_frame(npu_param->vpss_pipe[index], npu_param->vpss_ochn[index], &video_frame, milli_sec);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("Warning, acquire pipe[%d] vpss ochn[%d] frame fail ret = 0x%x\n", npu_param->vpss_pipe[index], npu_param->vpss_ochn[index], s32Ret);
        goto END;
    }
    
    task_input.frame_num = 1;
    task_input.frame = &video_frame;

    s32Ret = xmedia_svp_task_process(npu_param->npu_svp_handle[index], &task_input, &svp_result);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_svp_process failed with %#x!\n", s32Ret);
        svp_result.is_exist = XMEDIA_FALSE;
    }
    
    s32Ret = xmedia_vpss_release_ochn_frame(npu_param->vpss_pipe[index], npu_param->vpss_ochn[index], &video_frame);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_vpss_release_ochn_frame failed with %#x!\n", s32Ret);
    }

    if(svp_result.is_exist == XMEDIA_FALSE)
        g_aov_detect.svp_detect_none_cnt[index]++;
    else
        g_aov_detect.svp_detect_none_cnt[index] = 0;

    if(g_aov_detect.svp_detect_none_cnt[index] >= NPU_NORMAL_STATE_CONTINUE_COUNT) {
        if (npu_notice != NULL) {
            npu_notice(MEDIA_WORK_AOV);
            for (i = 0; i < isp_param->isp_pipe_num; i++) {
                g_aov_detect.svp_detect_none_cnt[i] = 0;
            }
        } else {
            SAMPLE_ERR("npu notice callback not register \n");
        }
    }
    
END:
    g_aov_detect.detect_complete_flag[index] = 1;
}

static xmedia_void sample_aov_npu_normal_proc()
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_s32 i = 0, detect_flag = 0, need_delay = 0;
    static xmedia_s32 index[AOV_SUPPORT_MAX_SENSOR_NUM];
    sample_aov_isp_param *isp_param = XMEDIA_NULL;

    isp_param = &(g_aov_init_param.isp_param);

    for (i = 0; i < isp_param->isp_pipe_num; i++) {
        index[i] = i;
        g_aov_detect.detect_complete_flag[i] = 0;
        s32Ret = sample_comm_thrd_job_submit(g_aov_thrd_pool_handle, &normal_job_func, &index[i]);
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("submit normal job[%d] failed!!!\n", i);
            continue;
        }
        detect_flag |= 1 << i;
    }
    
    while(detect_flag != 0) {
        need_delay = 1;
        for (i = 0; i < isp_param->isp_pipe_num; i++) {
            if(g_aov_detect.detect_complete_flag[i] == 1) {
                detect_flag &= ~(1 << i);
                g_aov_detect.detect_complete_flag[i] = 0;
                need_delay = 0;
            }
        }
        if(need_delay)
            usleep(500);
    }
}

xmedia_void aov_job_func(xmedia_void *arg)
{
    xmedia_s32 milli_sec = 2000;
    sample_aov_isp_param *isp_param = XMEDIA_NULL;
    sample_aov_vpss_npu_param *npu_param = XMEDIA_NULL;
    xmedia_s32 index = 0, s32Ret = XMEDIA_FAILURE;
    xmedia_svp_task_input task_input = {0};
    xmedia_video_frame_info video_frame = {0};
#ifdef IVE_DETECT_SUPPORT
    xmedia_bool ive_detect = XMEDIA_TRUE;
#endif

    npu_param = &(g_aov_init_param.npu_param);
    isp_param = &(g_aov_init_param.isp_param);

    index = *(xmedia_s32*)arg;
    if(index >= isp_param->isp_pipe_num)
    {
        SAMPLE_ERR("invalid index(%d)!!!\n", index);
        return;
    }

#ifdef APP_STANDBY_SENSOR
    sample_aov_sensor_standby(isp_param->isp_pipe[index]);
#endif

#ifdef AOV_APP_TIMESTAMP
    timestamp[test_num].vpss_in = sample_aov_get_debug_timestamp();
#endif

    s32Ret = xmedia_vpss_acquire_ochn_frame(npu_param->vpss_pipe[index], npu_param->vpss_ochn[index], &video_frame, milli_sec);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("Warning, acquire pipe[%d] vpss ochn[%d] frame fail ret = 0x%x\n", npu_param->vpss_pipe[index], npu_param->vpss_ochn[index], s32Ret);
        g_aov_detect.svp_result[index].is_exist = XMEDIA_FALSE;
        goto END;
    }

#ifdef AOV_APP_TIMESTAMP
    timestamp[test_num].svp_in = sample_aov_get_debug_timestamp();
#endif

    task_input.frame_num = 1;
    task_input.frame = &video_frame;

#ifdef IVE_DETECT_SUPPORT
    ive_detect = sample_aov_svp_ive_detect(&video_frame, &g_aov_detect.ive_param[index]);
    if (g_aov_detect.ive_param[index].is_first_frm == XMEDIA_TRUE) {
        g_aov_detect.ive_param[index].is_first_frm = XMEDIA_FALSE;
    }

    if (ive_detect == XMEDIA_FALSE) {
        g_aov_detect.svp_result[index].is_exist = XMEDIA_FALSE;
    }
    else
#endif
    {
        s32Ret = xmedia_svp_task_process(npu_param->npu_svp_handle[index], &task_input, &g_aov_detect.svp_result[index]);
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("xmedia_svp_process failed with %#x!\n", s32Ret);
            g_aov_detect.svp_result[index].is_exist = XMEDIA_FALSE;
        }
    }

    s32Ret = xmedia_vpss_release_ochn_frame(npu_param->vpss_pipe[index], npu_param->vpss_ochn[index], &video_frame);
    if (s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("xmedia_vpss_release_ochn_frame failed with %#x!\n", s32Ret);
    }

#ifdef IVE_DETECT_SUPPORT
    if(g_aov_detect.svp_result[index].is_exist == XMEDIA_TRUE)
        g_aov_detect.ive_param[index].is_first_frm = XMEDIA_TRUE;
#endif

END:
    g_aov_detect.detect_complete_flag[index] = 1;
}

static xmedia_void sample_aov_npu_aov_proc(xmedia_bool *is_exist)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_s32 i = 0, detect_flag = 0, need_delay = 0;
    static xmedia_s32 index[AOV_SUPPORT_MAX_SENSOR_NUM];
    sample_aov_isp_param *isp_param = XMEDIA_NULL;
   
    *is_exist = XMEDIA_FALSE;

    isp_param = &(g_aov_init_param.isp_param);

    for (i = 0; i < isp_param->isp_pipe_num; i++) {
        index[i] = i;
        g_aov_detect.detect_complete_flag[i] = 0;
        s32Ret = sample_comm_thrd_job_submit(g_aov_thrd_pool_handle, &aov_job_func, &index[i]);
        if (s32Ret != XMEDIA_SUCCESS) {
            SAMPLE_ERR("submit aov job[%d] failed!!!\n", i);
            continue;
        }
        detect_flag |= 1 << i;
    }

    while(detect_flag != 0)
    {
        need_delay = 1;
        for (i = 0; i < isp_param->isp_pipe_num; i++) {
            if(g_aov_detect.detect_complete_flag[i] == 1)
            {
                *is_exist |= g_aov_detect.svp_result[i].is_exist;
                detect_flag &= ~(1 << i);
                need_delay = 0;
            }
        }
        if(need_delay)
            usleep(500);
    }

#ifdef AOV_APP_TIMESTAMP
    timestamp[test_num].svp_out = sample_aov_get_debug_timestamp();
#endif

    return ;
}

static xmedia_void* sample_aov_venc_stream_thread(xmedia_void* p)
{
    sample_aov_work_mode work_mode = MEDIA_WORK_NORMAL;

VENC_THREAD_IDEL:
    sem_wait(&g_venc_steram_save_start_sem);
    sample_comm_aov_get_work_mode(&work_mode);

    if (g_venc_thread == XMEDIA_FALSE) {
        return XMEDIA_NULL;
    }

    sample_aov_venc_save_stream(work_mode);

    sem_post(&g_venc_steram_save_stop_sem);

    goto VENC_THREAD_IDEL;

    return XMEDIA_NULL;
}

static xmedia_void* sample_aov_work_thread(xmedia_void* p)
{
    xmedia_bool goal_is_exist = XMEDIA_FALSE;
    xmedia_bool venc_buf_full = XMEDIA_FALSE;
    xmedia_bool first_aov_state = XMEDIA_TRUE;
    sample_aov_work_mode work_mode = MEDIA_WORK_NORMAL;

    sample_aov_normal_npu_notice npu_notice = XMEDIA_NULL;
    sample_aov_normal_resume normal_resume = XMEDIA_NULL;
    sample_aov_normal_suspend normal_suspend = XMEDIA_NULL;

    npu_notice = g_aov_init_param.npu_notice_callback;
    normal_resume = g_aov_init_param.normal_resume_callback;
    normal_suspend = g_aov_init_param.normal_suspend_callback;


    while(g_work_aov_thread) {
        sample_comm_aov_get_work_mode(&work_mode);
        if (work_mode == MEDIA_WORK_NORMAL) {
            //normal npu set results only.
            sample_aov_npu_normal_proc();
        } else {
            if (first_aov_state != XMEDIA_TRUE) {
                //aov get npu goal state.
                sample_aov_npu_aov_proc(&goal_is_exist);
                if (goal_is_exist == XMEDIA_TRUE) {
                    //goal is exist switch normal. resume normal pipe only.
                    sample_comm_aov_set_work_mode(MEDIA_WORK_NORMAL);
                    sample_aov_work_normal_pipe_resume();

                    if (npu_notice != XMEDIA_NULL) {
                        npu_notice(MEDIA_WORK_NORMAL);
                    } else {
                        SAMPLE_ERR("npu notice callback not register \n");
                    }

                    if (normal_resume != XMEDIA_NULL)
                    {
                        normal_resume();
                    }
                    first_aov_state = XMEDIA_TRUE;
                    continue;
                } else {
                    //goal is nit exist, get venc buf state .
                    venc_buf_full = sample_aov_venc_get_aov_buf_full();
                    if (venc_buf_full == XMEDIA_TRUE) {
                        sample_aov_work_aov_save_resume();
                        sample_aov_work_aov_save_suspend();
                    } else {
                    }
                }
            }else {
                //normal switch aov first. suspend normal pipe.
                if (normal_suspend != XMEDIA_NULL)
                {
                    normal_suspend();
                }
                sample_aov_work_normal_pipe_suspend();
                first_aov_state = XMEDIA_FALSE;
            }
            sample_aov_suspend();
        }
    }

    return XMEDIA_NULL;
}

xmedia_void sample_comm_aov_init(sample_aov_init_param *aov_init_param)
{
    memcpy(&g_aov_init_param, aov_init_param, sizeof(sample_aov_init_param));
    pthread_mutex_init(&g_sync_mutex, NULL);
    pthread_mutex_init(&g_npu_detect_mutex, NULL);
    sem_init(&g_venc_steram_save_start_sem, 0, 1);
    sem_init(&g_venc_steram_save_stop_sem, 0, 0);
    for (xmedia_s32 i = 0; i < g_aov_init_param.isp_param.isp_pipe_num; i++) {
        sample_aov_ae_modify_path(g_aov_init_param.isp_param.isp_pipe[i]);
#ifdef APP_STANDBY_SENSOR
        g_aov_init_param.sensor_status[i] = SENSOR_STATUS_START;
#endif
    }

    g_aov_thrd_pool_handle = sample_comm_thrd_pool_init(g_aov_init_param.isp_param.isp_pipe_num, g_aov_init_param.isp_param.isp_pipe_num * 2);

    sample_aov_drv_sdcard_load();

#ifdef IVE_DETECT_SUPPORT
    sample_aov_ive_init();
#endif

}

xmedia_void sample_comm_aov_exit(xmedia_void)
{
#ifdef IVE_DETECT_SUPPORT
    sample_aov_ive_exit();
#endif

    if(g_aov_thrd_pool_handle)
    {
        sample_comm_thrd_pool_destroy(g_aov_thrd_pool_handle);
        g_aov_thrd_pool_handle = NULL;
    }

    sem_destroy(&g_venc_steram_save_start_sem);
    sem_destroy(&g_venc_steram_save_stop_sem);
    pthread_mutex_lock(&g_sync_mutex);
    pthread_mutex_unlock(&g_sync_mutex);
    pthread_mutex_destroy(&g_sync_mutex);
    pthread_mutex_lock(&g_npu_detect_mutex);
    pthread_mutex_unlock(&g_npu_detect_mutex);
    pthread_mutex_destroy(&g_npu_detect_mutex);
}

xmedia_void sample_comm_aov_set_work_mode(sample_aov_work_mode work_mode)
{
    pthread_mutex_lock(&g_sync_mutex);
    g_media_work_mode = work_mode;
    if (work_mode == MEDIA_WORK_AOV) {
        SAMPLE_ERR("--------->debug switch to aov<------\n");

    } else {
        SAMPLE_ERR("--------->debug switch to normal<--------\n");
    }
    pthread_mutex_unlock(&g_sync_mutex);
}

xmedia_void sample_comm_aov_get_work_mode(sample_aov_work_mode *work_mode)
{
    pthread_mutex_lock(&g_sync_mutex);
    *work_mode = g_media_work_mode;
    pthread_mutex_unlock(&g_sync_mutex);
}

xmedia_s32 sample_comm_aov_npu_init(xmedia_void)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;

    s32Ret = xmedia_tde_init();
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("tde init fail");
        return s32Ret;
    }

    s32Ret = xmedia_svp_init();
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("svp init fail");
        return s32Ret;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 sample_comm_aov_npu_create(xmedia_s32 *handle, xmedia_svp_task_cfg *task_cfg)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;
    xmedia_svp_aov_attr yolov5_attr = {0};

    s32Ret = xmedia_svp_task_create(handle, *task_cfg);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("------------- svp create fail--please check your npu model name & path.\n");
        return s32Ret;
    }

    s32Ret = xmedia_svp_task_get_attr(*handle, &yolov5_attr);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("svp get task attr fail.\n");
        xmedia_svp_task_destroy(*handle);
        xmedia_svp_uninit();
        return s32Ret;
    }

    yolov5_attr.aov_only_target = XMEDIA_FALSE;

    s32Ret = xmedia_svp_task_set_attr(*handle, &yolov5_attr);
    if(s32Ret != XMEDIA_SUCCESS) {
        SAMPLE_ERR("svp set task attr fail.\n");
        xmedia_svp_task_destroy(*handle);
        return XMEDIA_FAILURE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 sample_comm_aov_npu_destroy(xmedia_s32 handle)
{
    xmedia_s32 s32Ret = XMEDIA_FAILURE;

    s32Ret = xmedia_svp_task_destroy(handle);
    if (XMEDIA_SUCCESS != s32Ret) {
        SAMPLE_ERR("svp destroy error\n");
    }

    return s32Ret;
}

xmedia_void sample_comm_aov_npu_exit(xmedia_void)
{
    xmedia_svp_uninit();
    xmedia_tde_exit();
}

xmedia_s32 sample_comm_aov_venc_thread_create(xmedia_void)
{
    pthread_attr_t venc_thread_creat;
    pthread_t venc_thread;

    if (g_venc_thread == XMEDIA_TRUE) {
        SAMPLE_ERR("venc get stream thread already create \n");
        return XMEDIA_SUCCESS;
    }

    g_venc_thread = XMEDIA_TRUE;

    pthread_attr_init(&venc_thread_creat);
    pthread_attr_setdetachstate(&venc_thread_creat, PTHREAD_CREATE_DETACHED);
    return pthread_create(&venc_thread, &venc_thread_creat, sample_aov_venc_stream_thread, XMEDIA_NULL);
}

xmedia_s32 sample_comm_aov_venc_thread_destroy(xmedia_void)
{
    if (XMEDIA_TRUE == g_venc_thread) {
        g_venc_thread = XMEDIA_FALSE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 sample_comm_aov_work_thread_create(xmedia_void)
{
    pthread_attr_t work_aov_creat;
    pthread_t work_aov_thraed;

    if (g_work_aov_thread == XMEDIA_TRUE) {
        SAMPLE_ERR("venc get stream thread already create \n");
        return XMEDIA_SUCCESS;
    }

    g_work_aov_thread = XMEDIA_TRUE;

    pthread_attr_init(&work_aov_creat);
    pthread_attr_setdetachstate(&work_aov_creat, PTHREAD_CREATE_DETACHED);
    return pthread_create(&work_aov_thraed, &work_aov_creat, sample_aov_work_thread, XMEDIA_NULL);
}

xmedia_s32 sample_comm_aov_work_thread_destroy(xmedia_void)
{
    if (XMEDIA_TRUE == g_work_aov_thread) {
        g_work_aov_thread = XMEDIA_FALSE;
    }

    return XMEDIA_SUCCESS;
}

xmedia_s32 sample_comm_aov_misc_init(misc_aov_isp_info *isp_info)
{
    if(isp_info == XMEDIA_NULL) {
        SAMPLE_ERR("invalid input parameter!\n");
        return XMEDIA_FAILURE;
    }

    if(isp_info->isp_pipe_num == 0) {
        SAMPLE_ERR("invalid isp_pipe_num!\n");
        return XMEDIA_FAILURE;
    }

#ifdef SUPPORT_SENSOR_PWDN_MODE
    for(xmedia_s32 i = 0; i < isp_info->isp_pipe_num; i++) {
        support_sensor_pwdn_standby[i] = isp_info->support_sensor_pwdn_standby[i];
    }
#endif

    g_misc_fd = open("/dev/misc", O_RDONLY);
    if(g_misc_fd == -1) {
        SAMPLE_ERR("open /dev/misc failed, errno:%d %s\n", errno, strerror(errno));
        return XMEDIA_FAILURE;
    }
    return ioctl(g_misc_fd, XMEDIA_MISC_AOV_INIT, (xmedia_u32)isp_info, NULL);
}

xmedia_s32 sample_comm_aov_get_misc_fd(xmedia_void)
{
    return g_misc_fd;
}