#include "basic_include.h"
#include "lib/video/dvp/cmos_sensor/csi.h"
#include "lib/video/dvp/cmos_sensor/csi_V2.h"
#include "devid.h"
#include "hal/gpio.h"
#include "osal/irq.h"
#include "osal/string.h"
#include "dev/vpp/hgvpp.h"
#include "dev/csi/hgdvp.h"
#include "lib/lcd/lcd.h"
#include "hal/jpeg.h"
#include "lib/video/vpp/vpp_dev.h"
#include "lib/video/gen/gen420_dev.h"
#include "lib/scale/scale_dev.h"
#include "basic_include.h"
#include "lib/multimedia/msi.h"
#include <sys/time.h>
#include "lib/heap/av_heap.h"
#include "lib/heap/av_psram_heap.h"
#include "hal/osd_enc.h"

uint32 motion_det_pot_check(uint8_t *old_y, uint8_t *new_y, uint8_t *copy, uint16 w, uint16 h, uint8_t blk_thd, uint8_t md_blk_num);
void md_set_pot_x_y(uint16 x, uint16 y);

#define VPP_MALLOC av_malloc
#define VPP_FREE   av_free
#define VPP_ZALLOC av_zalloc

#define VPP_PSRAM_MALLOC av_psram_malloc
#define VPP_PSRAM_FREE   av_psram_free
#define VPP_PSRAM_ZALLOC av_psram_zalloc

/***************************************
shrink:

//0: 1/2
//1: 1/3
//2: 1/4
//3: 1/6
//4: 2/3
//5: 1/1
***************************************** */
enum SHRINK_ENUM
{
    SHRINK_1_2,
    SHRINK_1_3,
    SHRINK_1_4,
    SHRINK_1_6,
    SHRINK_2_3,
    SHRINK_1_1,
};
struct vpp_cfg_s
{
    uint8_t  vpp_buf0_line_num;
    uint8_t  vpp_buf1_line_num;
    uint8_t  vpp_buf0_mode : 1, vpp_buf1_mode : 1, scale1_from_vpp : 1, scale3_from_vpp : 1, shrink : 3, mdt : 1;
    uint8_t  double_psram_for_buf1;
    uint16_t vpp_w, vpp_h;
    uint16_t vpp_scale_w, vpp_scale_h;
};

// 默认值
#ifdef SYS_APP_WALKIE_TALKIE
struct vpp_cfg_s vpp_msg = {
        .vpp_buf0_line_num     = VPP_BUF0_LINEBUF_NUM,
        .vpp_buf1_line_num     = VPP_BUF1_LINEBUF_NUM,
        .vpp_buf0_mode         = VPP_BUF0_MODE,
        .vpp_buf1_mode         = VPP_BUF1_MODE,
        .scale1_from_vpp       = SCALE1_FROM_VPPBF,
        .scale3_from_vpp       = SCALE3_FROM_VPPBF,
        .vpp_w                 = 640,
        .vpp_h                 = 480,
        .vpp_scale_w           = 0,
        .vpp_scale_h           = 0,
        .shrink                = SHRINK_1_2,
        .double_psram_for_buf1 = 1,
};
#else
struct vpp_cfg_s vpp_msg = {
        .vpp_buf0_line_num     = VPP_BUF0_LINEBUF_NUM,
        .vpp_buf1_line_num     = VPP_BUF1_LINEBUF_NUM,
        .vpp_buf0_mode         = VPP_BUF0_MODE,
        .vpp_buf1_mode         = VPP_BUF1_MODE,
        .scale1_from_vpp       = SCALE1_FROM_VPPBF,
        .scale3_from_vpp       = SCALE3_FROM_VPPBF,
        .vpp_w                 = 1280,
        .vpp_h                 = 720,
        .vpp_scale_w           = 0,
        .vpp_scale_h           = 0,
        .shrink                = SHRINK_1_2,
        .double_psram_for_buf1 = 0,
        .mdt                   = 0,
};
#endif

// uint8 motion_detect_buf[9*1024/*((IMAGE_W+31)/32)  * ((IMAGE_H+31)/32) + 3 + 4*((IMAGE_W+31)/32)*/]__attribute__ ((aligned(4)));//加3是为了防止blk数不是word对齐
uint8            *motion_detect_buf          = NULL;
uint8            *motion_detect_oldframe_buf = NULL;
uint8            *mdet_result;
uint16            motion_blk_threshold    = 0;
uint16            motion_blknum_threshold = 0;
uint8            *yuvbuf1                 = NULL;
uint8_t          *vpp_data1_psram_buf     = NULL;
uint8_t          *vpp_data2_psram_buf     = NULL;
volatile uint8_t *psram_ptr               = NULL;
volatile uint8_t *psram_user_ptr          = NULL;

uint8             *yuvbuf         = NULL;
uint8             *vpp_encode_ipf = NULL;
struct video_cfg_t video_msg;
func_done_fn       vpp_deal_dev_func_table[VPP_FUNC_DONE_NUM];
volatile uint32    vpp_deal_dev_func_arg_table[VPP_FUNC_DONE_NUM];

int32 vppdone_func_register(uint8_t id, func_done_fn func, uint32 arg)
{
    struct vpp_device *vpp_dev = (struct vpp_device *) dev_get(HG_VPP_DEVID);
    int32_t            closed  = vpp_is_closed(vpp_dev);
    if (closed)
    {
        os_printf(KERN_DEBUG "vpp is closed, func:%p, arg:%X\tclosed:%d\n", func, arg, closed);
        func(arg);
    }
    else
    {
        uint32_t flags                  = disable_irq();
        vpp_deal_dev_func_table[id]     = func;
        vpp_deal_dev_func_arg_table[id] = arg;
        enable_irq(flags);
    }

    return 0;
}

int32 vppdone_func_unregister(uint8_t id)
{
    uint32_t flags                  = disable_irq();
    vpp_deal_dev_func_table[id]     = NULL;
    vpp_deal_dev_func_arg_table[id] = 0;
    enable_irq(flags);
    return 0;
}

// 设置buf1输出的size(需要整除,否则不会修改或者异常)
uint8_t set_vpp_bu1_shrink(uint16_t w, uint16_t shrink_w)
{
    uint8_t ret = 1;
    if (!w)
    {
        return ret;
    }
    if (w * 2 / 3 == shrink_w)
    {
        vpp_msg.shrink = SHRINK_2_3;
        return 0;
    }

    uint8_t shrink_calc = w / shrink_w;
    uint8_t shrink      = vpp_msg.shrink;
    // 是倍数关系,检查是否有符合
    if (shrink_w * shrink_calc == w)
    {
        ret = 0;
        switch (shrink_calc)
        {
            case 1:
                shrink = SHRINK_1_1;
                break;
            case 2:
                shrink = SHRINK_1_2;
                break;
            case 3:
                shrink = SHRINK_1_3;
                break;
            case 4:
                shrink = SHRINK_1_4;
                break;
            case 6:
                shrink = SHRINK_1_6;
                break;
            default:
                shrink = vpp_msg.shrink;
                ret    = 1;
                break;
        }
    }
    vpp_msg.shrink = shrink;
    if (ret)
    {
        os_printf(KERN_ERR "%s err,w:%d\tshrink_w:%d\tshrink:%d\n", __FUNCTION__, w, shrink_w, shrink);
    }
    else
    {
        os_printf(KERN_INFO "%s success,w:%d\tshrink_w:%d\tshrink:%d\n", __FUNCTION__, w, shrink_w, shrink);
    }
    return ret;
}

uint8_t get_vpp_scale_w_h(uint16_t *w, uint16_t *h)
{
    uint8_t ret = 0;
    if (w)
    {
        *w = vpp_msg.vpp_scale_w;
    }

    if (h)
    {
        *h = vpp_msg.vpp_scale_h;
    }
    if (!vpp_msg.vpp_scale_w || !vpp_msg.vpp_scale_h)
    {
        ret = 1;
    }
    return ret;
}

uint8_t get_vpp_w_h(uint16_t *w, uint16_t *h)
{
    uint8_t ret = 0;
    if (w)
    {
        *w = vpp_msg.vpp_w;
    }

    if (h)
    {
        *h = vpp_msg.vpp_h;
    }
    if (!vpp_msg.vpp_w || !vpp_msg.vpp_h)
    {
        ret = 1;
    }
    return ret;
}

uint8_t get_vpp1_w_h(uint16_t *w, uint16_t *h)
{
    uint8_t ret = 0;
    switch (vpp_msg.shrink)
    {
        case SHRINK_1_2:
            if (w)
            {
                *w = vpp_msg.vpp_w / 2;
            }
            if (h)
            {
                *h = vpp_msg.vpp_h / 2;
            }
            break;
        case SHRINK_1_3:
            if (w)
            {
                *w = vpp_msg.vpp_w / 3;
            }
            if (h)
            {
                *h = vpp_msg.vpp_h / 3;
            }
            break;
        case SHRINK_1_4:
            if (w)
            {
                *w = vpp_msg.vpp_w / 4;
            }
            if (h)
            {
                *h = vpp_msg.vpp_h / 4;
            }
            break;
        case SHRINK_1_6:
            if (w)
            {
                *w = vpp_msg.vpp_w / 6;
            }
            if (h)
            {
                *h = vpp_msg.vpp_h / 6;
            }
            break;
        case SHRINK_2_3:
            if (w)
            {
                *w = vpp_msg.vpp_w * 2 / 3;
            }
            if (h)
            {
                *h = vpp_msg.vpp_h * 2 / 3;
            }
            break;
        case SHRINK_1_1:
            if (w)
            {
                *w = vpp_msg.vpp_w;
            }
            if (h)
            {
                *h = vpp_msg.vpp_h;
            }
            break;
        default:
            os_printf("%s:%d err,shrink:%d\n", __FUNCTION__, __LINE__, vpp_msg.shrink);
            break;
    }
    if (VPP_BUF1_EN == 0)
    {
        ret = 1;
    }
    return ret;
}

uint32_t yuv_buf_line(uint8_t which)
{
    ASSERT(which == 0 || which == 1);
    uint8_t mode;
    uint8_t line_num;
    uint8_t malloc_line;
    if (which == 0)
    {
        mode     = vpp_msg.vpp_buf0_mode;
        line_num = vpp_msg.vpp_buf0_line_num;
    }
    else
    {
        mode     = vpp_msg.vpp_buf1_mode;
        line_num = vpp_msg.vpp_buf1_line_num;
    }

    if (mode == VPP_MODE_2N)
    {
        malloc_line = line_num * 2; // 2N
    }
    else
    {
        malloc_line = line_num * 2 + 16; // 16+2N
    }
    return malloc_line;
}

void *get_vpp_buf(uint8_t which)
{
    ASSERT(which == 0 || which == 1);
    if (which == 0)
    {
        return yuvbuf;
    }
    else if (which == 1)
    {
        return yuvbuf1;
    }
    return NULL;
}

void *get_vpp_psram_buf()
{
    return vpp_data1_psram_buf;
}

uint8 photo_lib2[48 * 6] __attribute__((aligned(4))) = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x80, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x0E, 0x00, 0x03, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x07, 0x80, 0x07, 0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x18, 0x00, 0x00, 0x00, 0x1C, 0x00, 0x3C, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFE, 0x00, 0x00, 0x40, 0x18, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x70, 0x00, 0x01, 0xE0, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0x08, 0x00,
        0xE0, 0x08, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x04, 0x00, 0x00, 0x00, 0x01, 0xC0, 0x06, 0x00, 0x00, 0x00, 0x03, 0x82, 0x03, 0x00, 0x00, 0x00, 0x03, 0x83, 0x81, 0x80, 0x00, 0x00, 0x07, 0x03, 0x81,
        0xC0, 0x00, 0x00, 0x0E, 0x03, 0x00, 0xE0, 0x00, 0x00, 0x1C, 0x03, 0x00, 0x70, 0x00, 0x00, 0x3C, 0x03, 0x03, 0x38, 0x00, 0x00, 0x73, 0x83, 0x07, 0x9E, 0x00, 0x00, 0xE1, 0xE3, 0x0F, 0xCF, 0x80,
        0x01, 0xC0, 0xE3, 0x1C, 0x07, 0xF0, 0x03, 0x80, 0x63, 0x60, 0x03, 0xFC, 0x06, 0x00, 0x63, 0x80, 0x00, 0xE0, 0x1C, 0x00, 0x03, 0x00, 0x00, 0x40, 0x30, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00,
        0xC3, 0x3C, 0x00, 0x00, 0x00, 0x07, 0x83, 0x0F, 0x80, 0x00, 0x00, 0x1E, 0x03, 0x03, 0xE0, 0x00, 0x00, 0xFC, 0x03, 0x01, 0xF0, 0x00, 0x00, 0xF0, 0x03, 0x00, 0xF0, 0x00, 0x00, 0x60, 0xFF, 0x00,
        0x70, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x30, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

uint8 ele_lib[13][64] __attribute__((aligned(4))) = {
        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xF0, 0x0F, 0xF8, 0x1E, 0x3C, 0x3C, 0x3C, 0x3C, 0x1E,
         0x38, 0x1E, 0x78, 0x0E, 0x78, 0x0E, 0x78, 0x0E, 0x78, 0x0E, 0x78, 0x0E, 0x78, 0x0E, 0x78, 0x0E, 0x78, 0x0E, 0x78, 0x0E, 0x38, 0x1E,
         0x3C, 0x1E, 0x3C, 0x1C, 0x1E, 0x3C, 0x1F, 0xF8, 0x07, 0xF0, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"0",0*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xE0, 0x01, 0xE0, 0x03, 0xE0, 0x07, 0xE0, 0x1F, 0xE0,
         0x1D, 0xE0, 0x19, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0,
         0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"1",1*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xF0, 0x1F, 0xFC, 0x3E, 0x3C, 0x3C, 0x1E, 0x78, 0x1E,
         0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1C, 0x00, 0x3C, 0x00, 0x3C, 0x00, 0x78, 0x00, 0xF0, 0x00, 0xE0, 0x01, 0xE0, 0x03, 0xC0, 0x07, 0x80,
         0x0F, 0x00, 0x1E, 0x00, 0x3E, 0x00, 0x3F, 0xFE, 0x3F, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"2",2*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0xF0, 0x0F, 0xFC, 0x1E, 0x3C, 0x3C, 0x1E, 0x38, 0x1E,
         0x18, 0x1E, 0x00, 0x1E, 0x00, 0x1C, 0x00, 0x7C, 0x03, 0xF0, 0x03, 0xF8, 0x00, 0x7C, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x1E, 0x18, 0x0E,
         0x78, 0x1E, 0x3C, 0x1E, 0x3E, 0x3C, 0x1F, 0xFC, 0x0F, 0xF0, 0x01, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"3",3*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x78, 0x00, 0x78, 0x00, 0xF8, 0x01, 0xF8,
         0x01, 0xF8, 0x03, 0xF8, 0x07, 0xB8, 0x0F, 0x38, 0x0E, 0x38, 0x1E, 0x38, 0x3C, 0x38, 0x38, 0x38, 0x78, 0x38, 0xFF, 0xFF, 0xFF, 0xFF,
         0xFF, 0xFF, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"4",4*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xFC, 0x1F, 0xFC, 0x1C, 0x00, 0x1C, 0x00, 0x1C, 0x00,
         0x3C, 0x00, 0x38, 0x00, 0x3F, 0xE0, 0x3F, 0xF8, 0x7C, 0x7C, 0x78, 0x3C, 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x0E, 0x00, 0x0E, 0x30, 0x1E,
         0x70, 0x1E, 0x78, 0x1E, 0x78, 0x7C, 0x3F, 0xF8, 0x1F, 0xF0, 0x07, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"5",5*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0xF0, 0x01, 0xE0, 0x03, 0xC0, 0x03, 0xC0,
         0x07, 0x80, 0x0F, 0x00, 0x0F, 0x00, 0x1F, 0xF8, 0x1F, 0xFC, 0x3E, 0x1E, 0x3C, 0x0F, 0x78, 0x0F, 0x78, 0x0F, 0x78, 0x0F, 0x78, 0x0F,
         0x78, 0x0F, 0x3C, 0x0F, 0x3E, 0x1E, 0x1F, 0xFC, 0x0F, 0xF8, 0x01, 0xE0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"6",6*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0x7F, 0xFF, 0x00, 0x0F, 0x00, 0x1E, 0x00, 0x1C,
         0x00, 0x3C, 0x00, 0x38, 0x00, 0x78, 0x00, 0x70, 0x00, 0xF0, 0x00, 0xE0, 0x01, 0xE0, 0x01, 0xE0, 0x01, 0xC0, 0x03, 0xC0, 0x03, 0xC0,
         0x03, 0x80, 0x07, 0x80, 0x07, 0x80, 0x07, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"7",7*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xF0, 0x1F, 0xF8, 0x3C, 0x3C, 0x38, 0x1E, 0x38, 0x1E,
         0x38, 0x1E, 0x38, 0x1E, 0x3C, 0x3C, 0x3E, 0x7C, 0x0F, 0xF0, 0x1F, 0xF8, 0x3E, 0x7C, 0x7C, 0x1E, 0x78, 0x1E, 0x70, 0x0E, 0x70, 0x0E,
         0x78, 0x0E, 0x78, 0x1E, 0x7C, 0x3E, 0x3F, 0xFC, 0x1F, 0xF8, 0x03, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"8",8*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xF0, 0x1F, 0xF8, 0x3E, 0x7C, 0x78, 0x3E, 0x78, 0x1E,
         0x70, 0x1E, 0x70, 0x1E, 0x70, 0x1E, 0x70, 0x1E, 0x78, 0x3C, 0x7C, 0x7C, 0x3F, 0xFC, 0x1F, 0xF8, 0x00, 0xF0, 0x00, 0xF0, 0x01, 0xE0,
         0x01, 0xE0, 0x03, 0xC0, 0x03, 0xC0, 0x07, 0x80, 0x07, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"9",9*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x0C, 0x00, 0x1C, 0x00, 0x38,
         0x00, 0x30, 0x00, 0x70, 0x00, 0x60, 0x00, 0xE0, 0x00, 0xC0, 0x01, 0xC0, 0x03, 0x80, 0x03, 0x80, 0x07, 0x00, 0x06, 0x00, 0x0E, 0x00,
         0x0C, 0x00, 0x1C, 0x00, 0x18, 0x00, 0x38, 0x00, 0x70, 0x00, 0x70, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*"/",11*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0xC0, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*":",12*/
        /* (16 X 32 , 楷体, 加粗 )*/

        {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, /*" ",10*/
                                                                                                                                  /* (16 X 32 , 楷体, 加粗 )*/

};

uint32_t water2_change_ipf(uint16_t srcw, uint16_t srch, uint8_t *bittable, uint16_t bitw, uint16_t bith, uint16_t x, uint16_t y, uint8_t *outbuf)
{
    int      i, j, k;
    int      l_ofset;
    int      r_ofset;
    uint32_t count = 0; // 压缩长度
    int      len;       // 已计算长度
    int      img_w = srcw;
    int      img_h = srch;             // 1280x720图像
    int      bt_w = bitw, bt_h = bith; // 256x32 bit表
    int      pos_x = x;                // 水平居中放置
    int      pos_y = y;                // 垂直居中放置
    uint8_t *ptr;
    uint8_t *optr;
    int      wobuf = 0;
    uint8_t  lb;
    ptr  = (uint8_t *) bittable;
    optr = outbuf;
    len  = pos_y * img_w + pos_x;

    r_ofset = len % 0xfffe;
    l_ofset = len / 0xfffe;
    count   = l_ofset * 6;
    if (optr != NULL)
    {
        for (i = 0; i < l_ofset; i++)
        {
            optr[wobuf++] = 0xff;
            optr[wobuf++] = 0xff;
            optr[wobuf++] = 0xfd;
            optr[wobuf++] = 0xff;
            optr[wobuf++] = 0x00;
            optr[wobuf++] = 0x00;
        }
    }

    for (j = 0; j < bt_h; j++)
    {
        lb = 0;
        for (i = 0; i < bt_w; i++)
        {
            if (ptr[i / 8] & BIT(7 - i % 8))
            { // 1
                if (lb == 0)
                { // 之前有透明度,透明度数据写0
                    if (r_ofset > 2)
                    {
                        count += 6;
                        if (optr != NULL)
                        {
                            optr[wobuf++] = 0xff;
                            optr[wobuf++] = 0xff;
                            optr[wobuf++] = (r_ofset - 1) & 0xff;
                            optr[wobuf++] = ((r_ofset - 1) & 0xff00) >> 8;
                            optr[wobuf++] = 0x00;
                            optr[wobuf++] = 0x00;
                        }
                    }
                    else
                    {
                        count += (r_ofset * 2);
                        if (optr != NULL)
                        {
                            for (k = 0; k < r_ofset; k++)
                            {
                                optr[wobuf++] = 0x00;
                                optr[wobuf++] = 0x00;
                            }
                        }
                    }

                    r_ofset = 1;
                }
                else
                {
                    r_ofset++;
                    if (r_ofset == 0xfffe)
                    {
                        count += 6;
                        if (optr != NULL)
                        {
                            optr[wobuf++] = 0xff;
                            optr[wobuf++] = 0xff;
                            optr[wobuf++] = (r_ofset - 1) & 0xff;
                            optr[wobuf++] = ((r_ofset - 1) & 0xff00) >> 8;
                            optr[wobuf++] = 0xff;
                            optr[wobuf++] = 0xff;
                        }
                        r_ofset = 0;
                    }
                }
                lb = 1;
            }
            else
            { // 0
                if (lb == 1)
                { // 之前无透明度,无透明度数据写0xff,因为是ff,所以都得按格式写
                    count += 6;
                    if (optr != NULL)
                    {
                        optr[wobuf++] = 0xff;
                        optr[wobuf++] = 0xff;
                        optr[wobuf++] = (r_ofset - 1) & 0xff;
                        optr[wobuf++] = ((r_ofset - 1) & 0xff00) >> 8;
                        optr[wobuf++] = 0xff;
                        optr[wobuf++] = 0xff;
                    }
                    r_ofset = 1;
                }
                else
                {
                    r_ofset++;
                    if (r_ofset == 0xfffe)
                    {
                        count += 6;
                        if (optr != NULL)
                        {
                            optr[wobuf++] = 0xff;
                            optr[wobuf++] = 0xff;
                            optr[wobuf++] = (r_ofset - 1) & 0xff;
                            optr[wobuf++] = ((r_ofset - 1) & 0xff00) >> 8;
                            optr[wobuf++] = 0x00;
                            optr[wobuf++] = 0x00;
                        }
                        r_ofset = 0;
                    }
                }
                lb = 0;
            }
        }
        ptr = ptr + bt_w / 8;
        if (lb == 0)
        { // 保持着透明度
            r_ofset += (img_w - bt_w);

            l_ofset = r_ofset / 0xfffe;
            r_ofset = r_ofset % 0xfffe;
            count += (l_ofset * 6);

            if (optr != NULL)
            {
                for (k = 0; k < l_ofset; k++)
                {
                    optr[wobuf++] = 0xff;
                    optr[wobuf++] = 0xff;
                    optr[wobuf++] = 0xfd;
                    optr[wobuf++] = 0xff;
                    optr[wobuf++] = 0x00;
                    optr[wobuf++] = 0x00;
                }
            }

            len += img_w;
        }
        else
        { // 最后一bit不是透明色
            count += 6;
            if (optr != NULL)
            {
                optr[wobuf++] = 0xff;
                optr[wobuf++] = 0xff;
                optr[wobuf++] = (r_ofset - 1) & 0xff;
                optr[wobuf++] = ((r_ofset - 1) & 0xff00) >> 8;
                optr[wobuf++] = 0xff;
                optr[wobuf++] = 0xff;
            }

            r_ofset = (img_w - bt_w);

            len += img_w;
        }
    }

    r_ofset += (img_w * img_h) - len;
    l_ofset = r_ofset / 0xfffe;
    r_ofset = r_ofset % 0xfffe;
    count += (l_ofset * 6);
    count += 6;

    if (optr != NULL)
    {
        for (i = 0; i < l_ofset; i++)
        {
            optr[wobuf++] = 0xff;
            optr[wobuf++] = 0xff;
            optr[wobuf++] = 0xfd;
            optr[wobuf++] = 0xff;
            optr[wobuf++] = 0x00;
            optr[wobuf++] = 0x00;
        }

        optr[wobuf++] = 0xff;
        optr[wobuf++] = 0xff;
        optr[wobuf++] = (r_ofset - 1) & 0xff;
        optr[wobuf++] = ((r_ofset - 1) & 0xff00) >> 8;
        optr[wobuf++] = 0x00;
        optr[wobuf++] = 0x00;
    }

    printf("count:%d\r\n", count);

    return count;
}

void set_time_watermark(struct vpp_device *vpp_dev, uint16 year, uint16 month, uint16 day, uint16 hour, uint16 min, uint16 sec)
{
    vpp_set_watermark0_idx(vpp_dev, 0, year / 1000);
    vpp_set_watermark0_idx(vpp_dev, 1, (year / 100) % 10);
    vpp_set_watermark0_idx(vpp_dev, 2, (year / 10) % 10);
    vpp_set_watermark0_idx(vpp_dev, 3, year % 10);

    vpp_set_watermark0_idx(vpp_dev, 4, 10);

    vpp_set_watermark0_idx(vpp_dev, 5, month / 10);
    vpp_set_watermark0_idx(vpp_dev, 6, month % 10);

    vpp_set_watermark0_idx(vpp_dev, 7, 10);

    vpp_set_watermark0_idx(vpp_dev, 8, day / 10);
    vpp_set_watermark0_idx(vpp_dev, 9, day % 10);

    vpp_set_watermark0_idx(vpp_dev, 10, 12);

    vpp_set_watermark0_idx(vpp_dev, 11, hour / 10);
    vpp_set_watermark0_idx(vpp_dev, 12, hour % 10);
    vpp_set_watermark0_idx(vpp_dev, 13, 11);
    vpp_set_watermark0_idx(vpp_dev, 14, min / 10);
    vpp_set_watermark0_idx(vpp_dev, 15, min % 10);
    vpp_set_watermark0_idx(vpp_dev, 16, 11);
    vpp_set_watermark0_idx(vpp_dev, 17, sec / 10);
    vpp_set_watermark0_idx(vpp_dev, 18, sec % 10);
}

void vpp_reset()
{
    struct vpp_device *vpp_dev;
    vpp_dev = (struct vpp_device *) dev_get(HG_VPP_DEVID);

    vpp_close(vpp_dev);

    os_printf("fv\r\n");

    vpp_open(vpp_dev);
}

void vpp_video_recfg(uint32 dev, uint32_t w, uint32_t h, uint8_t input_from)
{
    struct vpp_device *p_vpp = (struct vpp_device *) dev;

    vpp_set_video_size(p_vpp, w, h);
    vpp_msg.vpp_w = w;
    vpp_msg.vpp_h = h;
#if VPP_BUF1_EN
    uint32_t buf1w = 0, buf1h = 0;
    uint8_t  shrink = vpp_msg.shrink; // 0: 1/2
                                      // 1: 1/3
                                      // 2: 1/4
                                      // 3: 1/6
                                      // 4: 2/3
                                      // 5: 1/1

    switch (shrink)
    {
        case 0:
            buf1w = w / 2;
            buf1h = h / 2;
            break;

        case 1:
            buf1w = w / 3;
            buf1h = h / 3;
            break;

        case 2:
            buf1w = w / 4;
            buf1h = h / 4;
            break;

        case 3:
            buf1w = w / 6;
            buf1h = h / 6;
            break;

        case 4:
            buf1w = (w * 2) / 3;
            buf1h = (h * 2) / 3;
            break;

        case 5:
            buf1w = w;
            buf1h = h;
            break;

        default:
            _os_printf("buf1 shrink no this cfg\r\n");
            break;
    }

    // buf1的配置
    {
        uint32_t malloc_line;
        if (vpp_msg.vpp_buf1_mode == VPP_MODE_2N)
        {
            malloc_line = vpp_msg.vpp_buf1_line_num * 2; // 2N
        }
        else
        {
            malloc_line = vpp_msg.vpp_buf1_line_num * 2 + 16; // 16+2N
        }
        vpp_set_buf1_count(p_vpp, vpp_msg.vpp_buf1_line_num);
        vpp_set_buf1_shrink(p_vpp, vpp_msg.shrink);

        vpp_set_buf1_y_addr(p_vpp, (uint32) yuvbuf1);
        vpp_set_buf1_u_addr(p_vpp, (uint32) yuvbuf1 + buf1w * malloc_line);
        vpp_set_buf1_v_addr(p_vpp, (uint32) yuvbuf1 + buf1w * malloc_line + buf1w * (malloc_line / 4));
    }
    vpp_set_buf1_en(p_vpp, 1);

#endif

    // buf0的配置
    {
        uint32_t malloc_line;
        if (vpp_msg.vpp_buf0_mode == VPP_MODE_2N)
        {
            malloc_line = vpp_msg.vpp_buf0_line_num * 2; // 2N
        }
        else
        {
            malloc_line = vpp_msg.vpp_buf0_line_num * 2 + 16; // 16+2N
        }
        vpp_set_buf0_count(p_vpp, vpp_msg.vpp_buf0_line_num);
        vpp_set_buf0_en(p_vpp, 1);

        vpp_set_buf0_y_addr(p_vpp, (uint32) yuvbuf);
        vpp_set_buf0_u_addr(p_vpp, (uint32) yuvbuf + w * malloc_line);
        vpp_set_buf0_v_addr(p_vpp, (uint32) yuvbuf + w * malloc_line + w * (malloc_line / 4));
    }

#if DET_EN
    vpp_set_motion_calbuf(p_vpp, (uint32_t) motion_detect_buf);
    vpp_set_motion_range(p_vpp, 0, 0, w, h);                                       // 检测图像范围,blk大小为32*32个像素点
    vpp_set_motion_blk_threshold(p_vpp, 20);                                       // 检测对应的blk移动的阀值
    vpp_set_motion_frame_threshold(p_vpp, ((w + 31) / 32) * ((h + 31) / 32) / 20); // 检测多少个blk超过阀值，再触发移动检测中断
#endif
    vpp_set_mode(p_vpp, VPP_INPUT_FORMAT);
    vpp_set_input_interface(p_vpp, input_from);
}

uint32            autorc[64] __attribute__((aligned(256)));
volatile uint8    done_num     = 0;
volatile uint8    done_percent = 0; // 0 ~ 100
volatile uint32_t vpp_md_cnt   = 0; // 有移动，则关闭
scale3_kick_fn    scale3_kick_func;

void vpp_hsie_isr(uint32 irq, uint32 dev, uint32 param)
{
}

void vpp_vsie_isr(uint32 irq, uint32 dev, uint32 param)
{
    // uint8_t itk;
    //struct vpp_device *p_vpp = (struct vpp_device *) dev;
    //_os_printf("V");

    if (vpp_deal_dev_func_table[VPP_IFP_EN_CTRL])
    {
        vpp_deal_dev_func_table[VPP_IFP_EN_CTRL](vpp_deal_dev_func_arg_table[VPP_IFP_EN_CTRL]);
    }

    if (video_msg.video_num == 1)
    {
        video_msg.video_type_vpp = ISP_VIDEO_0;
    }
    else if (video_msg.video_num == 2)
    {
        if (video_msg.video_type_cur == ISP_VIDEO_0)
        {
            video_msg.video_type_vpp = ISP_VIDEO_1;
        }
        else
        {
            video_msg.video_type_vpp = ISP_VIDEO_0;
        }
    }
    else if (video_msg.video_num == 3)
    {
        if (video_msg.video_type_cur == ISP_VIDEO_0)
        {
            if (video_msg.video_type_last == ISP_VIDEO_1)
            {
                video_msg.video_type_vpp = ISP_VIDEO_2;
            }
            else
            {
                video_msg.video_type_vpp = ISP_VIDEO_1;
            }
        }
        else
        {
            video_msg.video_type_vpp = ISP_VIDEO_0;
        }
    }

    done_num     = 0;
    done_percent = 0;
}

void vpp_data_done(uint32 irq, uint32 high, uint32 param)
{

    done_num++;
    done_percent = (done_num * 16 * 100) / high;

    // printf("D");
}

uint8_t vpp_video_type_map(uint8_t stype)
{
    uint8_t video_type;
    if (video_msg.video_num == 3)
    {
        if ((video_msg.video_type_vpp + FSTYPE_YUV_P0) == stype)
        { // 如果vpp已经处理当前数据流中，那则返回错误，防止误匹配
            return 0;
        }

        if (video_msg.video_type_cur == ISP_VIDEO_0)
        { // 当前完成的是摄像头0
            if (video_msg.video_type_last == ISP_VIDEO_1)
            {
                video_type = ISP_VIDEO_2; // 即将要处理的是摄像头2
            }
            else
            {
                video_type = ISP_VIDEO_1; // 即将要处理的是摄像头1
            }
        }
        else
        {                             // 当前完成的是摄像头1/2
            video_type = ISP_VIDEO_0; // 即将要处理的是摄像头0
        }
    }
    else if (video_msg.video_num == 2)
    {
        if ((video_msg.video_type_vpp + FSTYPE_YUV_P0) == stype)
        { // 如果vpp已经处理当前数据流中，那则返回错误，防止误匹配
            return 0;
        }

        if (video_msg.video_type_cur == ISP_VIDEO_0)
        {                             // 当前完成的是摄像头0
            video_type = ISP_VIDEO_1; // 即将要处理的是摄像头1
        }
        else
        {
            video_type = ISP_VIDEO_0; // 即将要处理的是摄像头0
        }
    }
    else
    {
        video_type = ISP_VIDEO_0;
    }

    if ((video_type + FSTYPE_YUV_P0) != stype)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

void vpp_set_time(struct vpp_device *p_vpp, uint32_t time_val)
{
    struct tm *time_info;
    time_info     = gmtime((const time_t*)&time_val);
    uint32_t year = time_info->tm_year + 1900;
    uint32_t mon  = time_info->tm_mon + 1;
    uint32_t day  = time_info->tm_mday;
    uint32_t hour = time_info->tm_hour;
    uint32_t min  = time_info->tm_min;
    uint32_t sec  = time_info->tm_sec;
    set_time_watermark(p_vpp, year, mon, day, hour, min, sec);
}

void vpp_frame_done(uint32 irq, uint32 dev, uint32 param)
{
    static uint32_t md_isr_cnt = 0;
    //	static uint32_t  done_num=0;
    //	static uint32_t  detnum=0;
    uint8_t         itk        = 0;
    int32_t         ret        = 0;
    uint16_t        w, h;
    uint16_t        detw, deth;
    uint32_t        loc;
    uint16_t        buf1w = 0, buf1h = 0;
    uint8_t        *ptr_cache;
    _os_printf(KERN_DEBUG "F");
    static time_t      last_time_val = 0;
    struct vpp_device *p_vpp         = (struct vpp_device *) dev;
    struct timeval     ptimeval;
    gettimeofday(&ptimeval, NULL);
    time_t time_val = (time_t) ptimeval.tv_sec;

    if ((motion_detect_buf != NULL) && (motion_detect_oldframe_buf != NULL))
    { // det enable
        if (vpp_md_cnt != md_isr_cnt)
        {
            detw = (vpp_msg.vpp_w + 31) / 32;
            deth = (vpp_msg.vpp_h + 31) / 32;
            loc  = motion_det_pot_check(motion_detect_oldframe_buf, motion_detect_buf + 4 * ((vpp_msg.vpp_w + 31) / 32), mdet_result, detw, deth, 30, 20);
            if (loc != 0xffffffff)
            {
                md_set_pot_x_y((loc % detw) * 32, (loc / detw) * 32);
            }
        }
        memcpy(motion_detect_oldframe_buf, motion_detect_buf + 4 * ((vpp_msg.vpp_w + 31) / 32), ((vpp_msg.vpp_w + 31) / 32) * ((vpp_msg.vpp_h + 31) / 32));
    }

    if (last_time_val != time_val)
    {
        vpp_set_time(p_vpp, time_val);
        last_time_val = time_val;
    }

    if (video_msg.video_num > 1)
    {
        if (video_msg.video_type_cur != ISP_VIDEO_0)
        { // 上次完成是副镜头，这次要处理主镜头
            if (video_msg.dvp_type == 1)
            {
                vpp_video_recfg(dev, video_msg.dvp_iw, video_msg.dvp_ih, VPP_INPUT_FROM);
            }
            else if (video_msg.csi0_type == 1)
            {
                vpp_video_recfg(dev, video_msg.csi0_iw, video_msg.csi0_ih, VPP_INPUT_FROM);
            }
            else if (video_msg.csi1_type == 1)
            {
                vpp_video_recfg(dev, video_msg.csi1_iw, video_msg.csi1_ih, VPP_INPUT_FROM);
            }
        }
        else
        { // 上次完成是主镜头，这次要处理副镜头
            if (video_msg.dvp_type == 2)
            {
                vpp_video_recfg(dev, video_msg.dvp_iw, video_msg.dvp_ih, VPP_INPUT_FROM);
            }
            else if (video_msg.csi0_type == 2)
            {
                vpp_video_recfg(dev, video_msg.csi0_iw, video_msg.csi0_ih, VPP_INPUT_FROM);
            }
            else if (video_msg.csi1_type == 2)
            {
                vpp_video_recfg(dev, video_msg.csi1_iw, video_msg.csi1_ih, VPP_INPUT_FROM);
            }
        }
    }

    for (itk = 0; itk < VPP_FUNC_DONE_NUM; itk++)
    {
        if (vpp_deal_dev_func_table[itk])
        {
            ret = vpp_deal_dev_func_table[itk](vpp_deal_dev_func_arg_table[itk]);
            if (ret)
            {
                vpp_deal_dev_func_table[itk]     = NULL;
                vpp_deal_dev_func_arg_table[itk] = 0;
            }
        }
    }

    if (scale3_kick_func)
    {
        scale3_kick_func();
    }
    if (vpp_msg.double_psram_for_buf1)
    {
        uint8_t shrink = vpp_msg.shrink; // 0: 1/2
                                         // 1: 1/3
                                         // 2: 1/4
                                         // 3: 1/6
                                         // 4: 2/3
                                         // 5: 1/1

        w = vpp_msg.vpp_w;
        h = vpp_msg.vpp_h;
        switch (shrink)
        {
            case 0:
                buf1w = w / 2;
                buf1h = h / 2;
                break;

            case 1:
                buf1w = w / 3;
                buf1h = h / 3;
                break;

            case 2:
                buf1w = w / 4;
                buf1h = h / 4;
                break;

            case 3:
                buf1w = w / 6;
                buf1h = h / 6;
                break;

            case 4:
                buf1w = (w * 2) / 3;
                buf1h = (h * 2) / 3;
                break;

            case 5:
                buf1w = w;
                buf1h = h;
                break;

            default:
                _os_printf("buf1 shrink no this cfg\r\n");
                break;
        }

        ptr_cache      = (uint8_t*)psram_user_ptr;
        psram_user_ptr = psram_ptr;
        psram_ptr      = ptr_cache;

		vpp_set_buf1_shrink(p_vpp, shrink);
	    vpp_set_psram_ycnt(p_vpp, buf1w, buf1h);
    	vpp_set_psram_uvcnt(p_vpp, buf1w, buf1h);	
		
        vpp_set_buf1_y_addr(p_vpp, (uint32) psram_ptr);
        vpp_set_buf1_u_addr(p_vpp, (uint32) psram_ptr + buf1w * buf1h);
        vpp_set_buf1_v_addr(p_vpp, (uint32) psram_ptr + buf1w * buf1h + buf1w * buf1h / 4);
    }
	
	md_isr_cnt = vpp_md_cnt;
}
volatile uint8 itp_done = 0;
void           vpp_itp_done(uint32 irq, uint32 dev, uint32 param)
{
    os_printf("ITP_finish..\r\n");
    itp_done = 1;
}

void vpp_itp_error(uint32 irq, uint32 dev, uint32 param)
{
    os_printf("ITP_ER..\r\n");
}

void vpp_lib_error(uint32 irq, uint32 dev, uint32 param)
{
    //	dvp_vpp_reset();
    os_printf("LIB_ER..\r\n");
}

void vpp_ipf_error(uint32 irq, uint32 dev, uint32 param)
{
    //	vpp_reset();
    os_printf("IPF ERR..\r\n");
    //	outbuff_isr[0] = 0xff;
}

void vpp_md_find(uint32 irq, uint32 dev, uint32 param)
{
    //_os_printf("MDHP..");
    //_os_printf(KERN_DEBUG"?");
    vpp_md_cnt++;
}

void vpp_itp_save_only(struct vpp_device *p_vpp, uint16_t w, uint16_t h, uint32_t psram_adr)
{
    vpp_set_itp_y_addr(p_vpp, psram_adr);
    vpp_set_itp_u_addr(p_vpp, psram_adr + w * h);
    vpp_set_itp_v_addr(p_vpp, psram_adr + w * h + w * h / 4);
    vpp_set_itp_auto_close(p_vpp, 0);
    vpp_set_itp_enable(p_vpp, 1);
}

// uint8 yuv_staic_buf[1280*32 + 1280*16]__attribute__ ((aligned(4),section(".usersram2.src")));;
bool vpp_cfg(uint32_t w, uint32_t h, uint8_t input_from)
{
    vpp_msg.vpp_w = w;
    vpp_msg.vpp_h = h;
    if (!w || !h)
    {
        os_printf(KERN_ERR "vpp_cfg err:w=%d,h=%d\r\n", w, h);
        return FALSE;
    }
#if IPF_EN
    uint32_t             len;
#endif	
    struct vpp_device   *vpp_dev;
    vpp_dev = (struct vpp_device *) dev_get(HG_VPP_DEVID);

#if IPF_EN
    struct osdenc_device *osdenc_dev;
    osdenc_dev = (struct osdenc_device *) dev_get(HG_OSD_ENC_DEVID);
    osd_enc_open(osdenc_dev);
    osd_enc_tran_config(osdenc_dev, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000);
#endif

#if SCEN_EN
    vpp_set_video_size(vpp_dev, w * 2, h * 2);
#else
    os_printf("csi dvp_size_set\r\n");
    vpp_set_video_size(vpp_dev, w, h);
#endif

    vpp_set_ycbcr(vpp_dev, YUV_MODE);

#if (ONLY_Y == 1)
    vpp_dis_uv_mode(vpp_dev, 1, 1);
#endif

    vpp_set_threshold(vpp_dev, 0x00000000, 0x00ffffff);

    vpp_set_sram_buf_mode(vpp_dev, vpp_msg.vpp_buf0_mode, vpp_msg.vpp_buf1_mode);
    vpp_set_scale_buf_select(vpp_dev, vpp_msg.scale1_from_vpp, vpp_msg.scale3_from_vpp);

#if VPP_BUF1_EN
    uint32_t buf1w = 0, buf1h = 0;
    uint8_t  shrink = vpp_msg.shrink; // 0: 1/2
                                      // 1: 1/3
                                      // 2: 1/4
                                      // 3: 1/6
                                      // 4: 2/3
                                      // 5: 1/1

    switch (shrink)
    {
        case 0:
            buf1w = w / 2;
            buf1h = h / 2;
            break;

        case 1:
            buf1w = w / 3;
            buf1h = h / 3;
            break;

        case 2:
            buf1w = w / 4;
            buf1h = h / 4;
            break;

        case 3:
            buf1w = w / 6;
            buf1h = h / 6;
            break;

        case 4:
            buf1w = (w * 2) / 3;
            buf1h = (h * 2) / 3;
            break;

        case 5:
            buf1w = w;
            buf1h = h;
            break;

        default:
            _os_printf("buf1 shrink no this cfg\r\n");
            break;
    }
#if (PSRAM_FRAME_SAVE == 0)
    // buf1的配置
    {
        uint32_t malloc_line;
        if (vpp_msg.vpp_buf1_mode == VPP_MODE_2N)
        {
            malloc_line = vpp_msg.vpp_buf1_line_num * 2; // 2N
        }
        else
        {
            malloc_line = vpp_msg.vpp_buf1_line_num * 2 + 16; // 16+2N
        }

        if (yuvbuf1 == NULL)
        {
            yuvbuf1 = VPP_MALLOC(buf1w * malloc_line + buf1w * (malloc_line / 2));
            if (yuvbuf1 == NULL)
            {
                _os_printf("no room yuvbuf1\r\n");
                return FALSE;
            }
        }
        vpp_set_buf1_y_addr(vpp_dev, (uint32) yuvbuf1);
        vpp_set_buf1_u_addr(vpp_dev, (uint32) yuvbuf1 + buf1w * malloc_line);
        vpp_set_buf1_v_addr(vpp_dev, (uint32) yuvbuf1 + buf1w * malloc_line + buf1w * (malloc_line / 4));
        vpp_set_buf1_count(vpp_dev, vpp_msg.vpp_buf1_line_num);
    }
#else
    uint16_t p_w, p_h;
    p_w = buf1w;
    p_h = buf1h;
    //	vpp_set_sram_buf_mode(vpp_dev,1,1);
    //	vpp_set_scale_buf_select(vpp_dev,1,1);
    vpp_set_nosram_buf_enable(vpp_dev, 2);
    //	vpp_set_nosram_buf1_enable(vpp_dev,1);

    vpp_set_psram_ycnt(vpp_dev, p_w, p_h);
    vpp_set_psram_uvcnt(vpp_dev, p_w, p_h);

    //	vpp_set_psram1_ycnt(vpp_dev,w/2,h/2);
    //	vpp_set_psram1_uvcnt(vpp_dev,w/2,h/2);

    //	vpp_set_buf1_y_addr(vpp_dev,(uint32)psram_all_frame_buf1);
    //	vpp_set_buf1_u_addr(vpp_dev,(uint32)psram_all_frame_buf1+w*h/4);
    //	vpp_set_buf1_v_addr(vpp_dev,(uint32)psram_all_frame_buf1+w*h/4+w*h/16);
    if (vpp_data1_psram_buf)
    {
        VPP_PSRAM_FREE(vpp_data1_psram_buf);
        vpp_data1_psram_buf = NULL;
    }
    vpp_data1_psram_buf = (uint8_t *) VPP_PSRAM_MALLOC(p_w * p_h * 3 / 2);
    ASSERT(vpp_data1_psram_buf);
    if (vpp_msg.double_psram_for_buf1)
    {
        vpp_data2_psram_buf = (uint8_t *) VPP_PSRAM_MALLOC(p_w * p_h * 3 / 2);
        ASSERT(vpp_data2_psram_buf);
        psram_ptr      = vpp_data1_psram_buf;
        psram_user_ptr = vpp_data2_psram_buf;
    }

    vpp_set_buf1_y_addr(vpp_dev, (uint32) vpp_data1_psram_buf);
    vpp_set_buf1_u_addr(vpp_dev, (uint32) vpp_data1_psram_buf + p_w * p_h);
    vpp_set_buf1_v_addr(vpp_dev, (uint32) vpp_data1_psram_buf + p_w * p_h + p_w * p_h / 4);
#endif
    vpp_set_buf1_shrink(vpp_dev, vpp_msg.shrink);
    vpp_set_buf1_en(vpp_dev, 1);
#endif
    // buf0 的配置
    {
        uint32_t malloc_line;
        if (vpp_msg.vpp_buf0_mode == VPP_MODE_2N)
        {
            malloc_line = vpp_msg.vpp_buf0_line_num * 2; // 2N
        }
        else
        {
            malloc_line = vpp_msg.vpp_buf0_line_num * 2 + 16; // 16+2N
        }

        if (yuvbuf == NULL)
        {
            yuvbuf = (uint8_t *) VPP_MALLOC(w * malloc_line + w * (malloc_line / 2));
            if (yuvbuf == NULL)
            {
                _os_printf("no room yuvbuf0\r\n");
                return FALSE;
            }
        }
        vpp_set_buf0_count(vpp_dev, vpp_msg.vpp_buf0_line_num);
        vpp_set_buf0_en(vpp_dev, 1);
#if (ONLY_Y == 1)
        vpp_set_buf0_y_addr(vpp_dev, (uint32) psram_buf);
#else
        vpp_set_buf0_y_addr(vpp_dev, (uint32) yuvbuf);
        vpp_set_buf0_u_addr(vpp_dev, (uint32) yuvbuf + w * malloc_line);
        vpp_set_buf0_v_addr(vpp_dev, (uint32) yuvbuf + w * malloc_line + w * (malloc_line / 4));
#endif
    }

    vpp_set_water0_color(vpp_dev, 0xff, 0x80, 0x80);
    vpp_set_water0_bitmap(vpp_dev, (uint32) ele_lib);
    vpp_set_water0_locate(vpp_dev, 8, 16);
    vpp_set_water0_contrast(vpp_dev, 0);
    vpp_set_watermark0_charsize_and_num(vpp_dev, 16, 32, 19);
    vpp_set_watermark0_mode(vpp_dev, 1);

    struct timeval ptimeval;
    gettimeofday(&ptimeval, NULL);
    time_t time_val = (time_t) ptimeval.tv_sec;
    vpp_set_time(vpp_dev, time_val);

    vpp_set_water0_rc(vpp_dev, 0);
    vpp_set_watermark0_auto_rc_sram_adr(vpp_dev, (uint32_t) autorc);
    vpp_set_watermark0_auto_rc_threshold(vpp_dev, 16 * 32 * 128, 16 * 32 * 32);
    vpp_set_watermark_auto_rc_mode(vpp_dev, 0); // double sensor
    vpp_set_watermark0_auto_rc(vpp_dev, 1, 0x00, 0x80, 0x80);

#if IPF_EN
    len            = water2_change_ipf(w, h, photo_lib2, 48, 48, 100, 300, NULL);
    vpp_encode_ipf = (uint8_t *) VPP_MALLOC(len);
    water2_change_ipf(w, h, photo_lib2, 48, 48, 100, 300, vpp_encode_ipf);
    vpp_set_ifp_addr(vpp_dev, (uint32_t) vpp_encode_ipf);
#endif

#if 0	
	vpp_set_water1_color(vpp_dev,0xff,0x80,0x80);
	vpp_set_water1_bitmap(vpp_dev,(uint32)photo_lib2);
	vpp_set_water1_locate(vpp_dev,45,30);
	vpp_set_water1_contrast(vpp_dev,0);
//	vpp_set_watermark1_size(vpp_dev,224,48);
	vpp_set_watermark1_size(vpp_dev,48,48);
	vpp_set_watermark1_mode(vpp_dev,0);
	vpp_set_water1_rc(vpp_dev,0);
#endif

    // vpp_request_irq(vpp_dev, HSIE_ISR, (vpp_irq_hdl) &vpp_hsie_isr, (uint32) vpp_dev);
    vpp_request_irq(vpp_dev, VSIE_ISR, (vpp_irq_hdl) &vpp_vsie_isr, (uint32) vpp_dev);
    vpp_request_irq(vpp_dev, FRAME_DONE_ISR, (vpp_irq_hdl) &vpp_frame_done, (uint32) vpp_dev);
    vpp_request_irq(vpp_dev, SCIE_ISR, (vpp_irq_hdl) &vpp_data_done, h);
    vpp_request_irq(vpp_dev, LOVIE_ISR, (vpp_irq_hdl) &vpp_lib_error, (uint32) vpp_dev);
    vpp_request_irq(vpp_dev, IPF_OV_ISR, (vpp_irq_hdl) &vpp_ipf_error, (uint32) vpp_dev);
    vpp_request_irq(vpp_dev, MDPIE_ISR, (vpp_irq_hdl) &vpp_md_find, (uint32) vpp_dev);
    vpp_request_irq(vpp_dev, ITP_OV_ISR, (vpp_irq_hdl) &vpp_itp_error, (uint32) vpp_dev);
    vpp_request_irq(vpp_dev, ITP_DONE_ISR, (vpp_irq_hdl) &vpp_itp_done, (uint32) vpp_dev);

#if DET_EN
    motion_detect_buf = (uint8_t *) VPP_MALLOC(((w + 31) / 32) * ((h + 31) / 32) + 4 * ((w + 31) / 32));

    if ((motion_detect_buf == NULL))
    {
        goto det_module_end;
    }

    vpp_set_motion_calbuf(vpp_dev, (uint32_t) motion_detect_buf);
    vpp_set_motion_range(vpp_dev, 0, 0, w, h);   // 检测图像范围,blk大小为32*32个像素点
    vpp_set_motion_blk_threshold(vpp_dev, 10);   // 检测对应的blk移动的阀值
    vpp_set_motion_frame_threshold(vpp_dev, 10); // 检测多少个blk超过阀值，再触发移动检测中断

    if (vpp_msg.mdt)
    {
        // 申请空间,支持返回移动的区域坐标
        motion_detect_oldframe_buf = (uint8_t *) VPP_MALLOC(((w + 31) / 32) * ((h + 31) / 32));
        mdet_result                = (uint8_t *) VPP_MALLOC(((w + 31) / 32) * ((h + 31) / 32));
        if (mdet_result == NULL || motion_detect_oldframe_buf == NULL)
        {
            VPP_FREE(motion_detect_oldframe_buf);
            VPP_FREE(mdet_result);
            motion_detect_oldframe_buf = NULL;
            mdet_result                = NULL;
        }
        else
        {
            motion_blk_threshold    = 10;
            motion_blknum_threshold = 10;
            memset(motion_detect_oldframe_buf, 0, ((w + 31) / 32) * ((h + 31) / 32));
        }
    }

    vpp_set_motion_det_enable(vpp_dev, 1);
det_module_end:
#endif
    vpp_set_mode(vpp_dev, VPP_INPUT_FORMAT);
    vpp_set_input_interface(vpp_dev, input_from);

    vpp_set_watermark0_enable(vpp_dev, 1);
    //	vpp_set_watermark1_enable(vpp_dev,1);

#if IPF_EN
    vpp_set_ifp_en(vpp_dev, 1);
#endif

    vpp_msg.vpp_scale_w = VPP_SCALE_WIDTH;
    vpp_msg.vpp_scale_h = VPP_SCALE_HIGH;

    vpp_open(vpp_dev);
    return TRUE;
}

void set_vpp_scale_w_h(uint8_t en, uint16_t w, uint16_t h)
{
    struct scale_device *scale_dev;
    uint8_t             *vpp_buf = get_vpp_buf(0);
    if (vpp_buf)
    {
        vpp_msg.vpp_scale_w = w;
        vpp_msg.vpp_scale_h = h;
        if (en)
        {
            scale_dev = (struct scale_device *) dev_get(HG_SCALE1_DEVID);
            scale_from_vpp(scale_dev, (uint32_t) vpp_buf, vpp_msg.vpp_w, vpp_msg.vpp_h, w, h);
        }
    }
}

bool vpp_cfg_release()
{
    struct vpp_device *p_vpp = (struct vpp_device *) dev_get(HG_VPP_DEVID);
    vpp_close(p_vpp);
    if (yuvbuf)
    {
        VPP_FREE(yuvbuf);
        yuvbuf = NULL;
    }
#if VPP_BUF1_EN
    if (yuvbuf1)
    {
        VPP_FREE(yuvbuf1);
        yuvbuf1 = NULL;
    }
#endif

    if (vpp_encode_ipf)
    {
        VPP_FREE(vpp_encode_ipf);
        vpp_encode_ipf = NULL;
    }

    if (motion_detect_buf)
    {
        VPP_FREE(motion_detect_buf);
        motion_detect_buf = NULL;
    }

    if (vpp_data1_psram_buf)
    {
        VPP_PSRAM_FREE(vpp_data1_psram_buf);
        vpp_data1_psram_buf = NULL;
    }

    if (vpp_data2_psram_buf)
    {
        VPP_PSRAM_FREE(vpp_data2_psram_buf);
        vpp_data2_psram_buf = NULL;
    }
    return TRUE;
}

int8_t vpp_dev_open()
{
    struct vpp_device *vpp_dev;
    vpp_dev = (struct vpp_device *) dev_get(HG_VPP_DEVID);
    vpp_open(vpp_dev);
    return 0;
}

/**************************************************检测移动侦测接口***************************************************** */
struct mdt_coord_msg mdet_msg[4];
uint32               mdxy;

uint32 motion_det_pot_check(uint8_t *old_y, uint8_t *new_y, uint8_t *copy, uint16 w, uint16 h, uint8_t blk_thd, uint8_t md_blk_num)
{
    uint16   i, j;
    uint16   mw, mh;
    //	uint16 mwc,mhc;
    uint16   bx, by;
    //	uint16 bmx,bmy;
    //	uint16 bxc,byc;
    uint32   local_base = 0;
    //	uint32 check_local;
    //	uint32 mov_cnt_max;
    //	uint32 mov_cnt;
    //	uint8_t turnaround;
    uint16   i1, j1;
    uint8_t  mloop;
    //	uint8_t mxj;
    uint8_t  potd;
    uint8_t  mask;
    uint16_t mx0, mx1;
    uint16_t my0, my1;
    uint16_t mapdt_loc[4][6];
    uint16_t mapdt_num;
    uint8_t  result_cnt[4];
    uint32_t result_loc[4];
    //	uint8_t xad,yad;
    uint16   mvblk = 0;
    uint8_t  x0m, x1m, y0m, y1m;

    for (j = 0; j < h; j++)
    {
        for (i = 0; i < w; i++)
        {
            if (abs(old_y[i + j * w] - new_y[i + j * w]) >= blk_thd)
            {
                old_y[i + j * w] = 255;
                mvblk++;
            }
            else
            {
                old_y[i + j * w] = 0;
            }
        }
    }

    if (mvblk < md_blk_num)
    {
        return 0xffffffff;
    }
    memcpy(copy, old_y, w * h);

    memset(mapdt_loc, 0xff, 4 * 6 * 2);
    memset(result_cnt, 0, 4);
    memset(result_loc, 0, 4 * 4);
    mapdt_num = 0;
    for (j1 = 0; j1 < h - 1; j1++)
    {
        for (i1 = 0; i1 < w - 1; i1++)
        {
            potd = 0;
            for (j = 0; j < 2; j++)
            {
                for (i = 0; i < 2; i++)
                {

                    if (old_y[i1 + j1 * w + i + j * w] == 255)
                    {
                        potd++;
                        if (potd == 4)
                        {
                            mask = 1;
                            for (mloop = 0; mloop < 4; mloop++)
                            {
                                if (mapdt_loc[mloop][0] != 0xffff)
                                { // 有座标
                                    mx0 = mapdt_loc[mloop][2];
                                    mx1 = mapdt_loc[mloop][3];
                                    my0 = mapdt_loc[mloop][4];
                                    my1 = mapdt_loc[mloop][5];

                                    if (mx0 > 3)
                                    {
                                        x0m = mx0 - 3;
                                    }
                                    else
                                    {
                                        x0m = 0;
                                    }

                                    if ((mx1 + 3) > w)
                                    {
                                        x1m = w - 1;
                                    }
                                    else
                                    {
                                        x1m = mx1 + 3;
                                    }

                                    if (my0 > 3)
                                    {
                                        y0m = my0 - 3;
                                    }
                                    else
                                    {
                                        y0m = 0;
                                    }

                                    if ((my1 + 3) > h)
                                    {
                                        y1m = h - 1;
                                    }
                                    else
                                    {
                                        y1m = my1 + 3;
                                    }

                                    if (((i1 + i) >= x0m) && ((i1 + i) <= x1m) && ((j1 + j) >= y0m) && ((j1 + j) <= y1m))
                                    {
                                        mask = 0;
                                    }
                                }
                            }

                            if (mask == 1)
                            {
                                for (mloop = 0; mloop < 4; mloop++)
                                {
                                    if (mapdt_loc[mloop][0] == 0xffff)
                                    {
                                        mapdt_loc[mloop][0] = i1 + i;
                                        mapdt_loc[mloop][1] = j1 + j;

                                        if (mapdt_loc[mloop][0] > 3)
                                        {
                                            mx0 = mapdt_loc[mloop][0] - 3;
                                        }
                                        else
                                        {
                                            mx0 = 0;
                                        }

                                        if ((mapdt_loc[mloop][0] + 3) > w)
                                        {
                                            mx1 = w - 1;
                                        }
                                        else
                                        {
                                            mx1 = mapdt_loc[mloop][0] + 3;
                                        }

                                        if (mapdt_loc[mloop][1] > 3)
                                        {
                                            my0 = mapdt_loc[mloop][1] - 3;
                                        }
                                        else
                                        {
                                            my0 = 0;
                                        }

                                        if ((mapdt_loc[mloop][1] + 3) > h)
                                        {
                                            my1 = h - 1;
                                        }
                                        else
                                        {
                                            my1 = mapdt_loc[mloop][1] + 3;
                                        }

                                        mapdt_loc[mloop][2] = mx0;
                                        mapdt_loc[mloop][3] = mx1;
                                        mapdt_loc[mloop][4] = my0;
                                        mapdt_loc[mloop][5] = my1;

                                        break;
                                    }
                                }
                                if (mapdt_loc[3][0] != 0xffff)
                                {
                                    goto mdt_end;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

mdt_end:
    for (mloop = 0; mloop < 4; mloop++)
    {
        if (mapdt_loc[mloop][0] != 0xffff)
        {
            bx   = mapdt_loc[mloop][2];
            by   = mapdt_loc[mloop][4];
            mw   = mapdt_loc[mloop][3] - mapdt_loc[mloop][2];
            mh   = mapdt_loc[mloop][5] - mapdt_loc[mloop][4];
            potd = 0;
            for (j = 0; j < mh; j++)
            {
                for (i = 0; i < mw; i++)
                {
                    if (old_y[bx + by * w + i + j * w] == 0xff)
                    {
                        potd++;
                    }
                }
            }
            result_cnt[mloop] = potd;
            // printf("(%d  %d===>%d  %d pot:%d)\r\n",bx,by,mw,mh,potd);
            if (potd < 7)
            {
                result_loc[mloop] = (mapdt_loc[mloop][0] - 1) + (mapdt_loc[mloop][1] - 1) * w;
            }
            else
            {
                result_loc[mloop] = mapdt_loc[mloop][0] + mapdt_loc[mloop][1] * w;
            }
        }
    }

    for (i = 0; i < 4; i++)
    {
        if (mapdt_loc[i][0] != 0xffff)
        {
            mdet_msg[i].blkmv_cnt = result_cnt[i];
            mdet_msg[i].x0        = mapdt_loc[i][2];
            mdet_msg[i].x1        = mapdt_loc[i][3];
            mdet_msg[i].y0        = mapdt_loc[i][4];
            mdet_msg[i].y1        = mapdt_loc[i][5];
            mdet_msg[i].x         = mapdt_loc[i][0];
            mdet_msg[i].y         = mapdt_loc[i][1];
        }
        else
        {
            mdet_msg[i].blkmv_cnt = 0;
        }
    }

    if (result_loc[0] != 0)
    {
        for (i = 0; i < 4; i++)
        {
            if (local_base < result_loc[i])
            {
                local_base = result_loc[i];
                //				printf("local_base:%d\r\n",local_base);
            }
        }

        return local_base;
    }
    else
    {
        return 0xffffffff;
    }
}

void md_set_pot_x_y(uint16 x, uint16 y)
{
    mdxy = ((y & 0xffff) << 16 | (x & 0xffff));
}

// 获取绝对位置
uint32 md_get_pot_x_y()
{
    return mdxy;
}

// 获取相对位置
uint32 md_get_relative_pot_x_y(uint16_t r_w, uint16_t r_h, uint16_t *gx, uint16_t *gy)
{
    uint16_t x = (r_w * (mdxy & 0xffff) / vpp_msg.vpp_w) & 0xffff;
    uint16_t y = (r_h * (mdxy >> 16) / vpp_msg.vpp_h) & 0xffff;
    if (gx)
    {
        *gx = x;
    }
    if (gy)
    {
        *gy = y;
    }
    return y << 16 | x;
}

uint32 md_get_relative_pot_x0_y0_x1_y1(uint8_t num, uint16_t r_w, uint16_t r_h, uint16_t *gx0, uint16_t *gy0, uint16_t *gx1, uint16_t *gy1)
{
    uint16_t x0 = (r_w * (mdet_msg[num].x0 * 32) / vpp_msg.vpp_w) & 0xffff;
    uint16_t y0 = (r_h * (mdet_msg[num].y0 * 32) / vpp_msg.vpp_h) & 0xffff;
    uint16_t x1 = (r_w * (mdet_msg[num].x1 * 32) / vpp_msg.vpp_w) & 0xffff;
    uint16_t y1 = (r_h * (mdet_msg[num].y1 * 32) / vpp_msg.vpp_h) & 0xffff;
    if (mdet_msg[num].blkmv_cnt == 0)
    {
        if (gx0)
        {
            *gx0 = 0;
        }
        if (gy0)
        {
            *gy0 = 0;
        }
        if (gx1)
        {
            *gx1 = 1;
        }
        if (gy1)
        {
            *gy1 = 1;
        }

        return 1;
    }
    if (gx0)
    {
        *gx0 = x0;
    }
    if (gy0)
    {
        *gy0 = y0;
    }
    if (gx1)
    {
        *gx1 = x1;
    }
    if (gy1)
    {
        *gy1 = y1;
    }
    return 0;
}