/*
 *******************************************************************************
 *                                   INCLUDE
 *******************************************************************************
 */
#include "IVE.h"
#include "Logger.h"
#include "util/Math.h"
#include <hi_mpi_sys.h>
#include <hi_mpi_vb.h>

namespace Video
{
namespace MPP5
{
/*
 *******************************************************************************
 *                                  CONSTANTS
 *******************************************************************************
 */

#define HI__IVE_IMAGE_CHN_ONE 1
#define HI__IVE_IMAGE_CHN_TWO 2
#define HI__IVE_IMAGE_CHN_THREE 3
#define HI__IVE_IMAGE_CHN_FOUR 4
#define HI__IVE_MAX_CCL_REGION_NUM 254
#define HI__IVE_DIV_TWO 2
#define HI_SAMPLE_POINT_IDX_ZERO 0
#define HI_SAMPLE_POINT_IDX_ONE 1
#define HI_SAMPLE_POINT_IDX_TWO 2
#define HI_SAMPLE_POINT_IDX_THREE 3

#define HI_SAMPLE_RESIZE_MAX_TILE_METRIC_8BIT 2032
#define HI_SAMPLE_RESIZE_MAX_TILE_METRIC_16BIT 1016
#define HI_SAMPLE_RESIZE_TILE_ADJUST 2
#define HI_SAMPLE_RESIZE_ASSIST_UNIT_SIZE 48
#define HI_SAMPLE_RESIZE_CBCR_NUM_2 2
#define HI_SAMPLE_RESIZE_CBCR_NUM_3 3

#define HI_IVE_ALIGN 16

/*
 *******************************************************************************
 *                                    MACROS
 *******************************************************************************
 */
#define _convert_ptr_to_addr(type, addr) ((type)(hi_uintptr_t)(addr))
#define _convert_addr_to_ptr(type, addr) ((type*)(hi_uintptr_t)(addr))

/*
 *******************************************************************************
 *                                   TYPEDEFS
 *******************************************************************************
 */
struct _img_loop_info
{
    uint32_t ele_size;
    uint32_t loop_c;
    uint32_t loop_h[HI_SVP_IMG_ADDR_NUM];
};
typedef struct _img_loop_info _img_loop_info_t;

/*
 *******************************************************************************
 *                                  LOCAL FUNCTIONS
 *******************************************************************************
 */
static void _ive_get_loop_info(const hi_svp_img* img, _img_loop_info_t* loop_info)
{
    loop_info->ele_size  = 1;
    loop_info->loop_c    = 1;
    loop_info->loop_h[0] = img->height;
    switch (img->type)
    {
    case HI_SVP_IMG_TYPE_U8C1:
    case HI_SVP_IMG_TYPE_S8C1:
        break;

    case HI_SVP_IMG_TYPE_YUV420SP:
        loop_info->ele_size  = 1;
        loop_info->loop_c    = HI__IVE_IMAGE_CHN_TWO;
        loop_info->loop_h[1] = img->height / HI__IVE_DIV_TWO;
        break;

    case HI_SVP_IMG_TYPE_YUV422SP:
        loop_info->loop_c    = HI__IVE_IMAGE_CHN_TWO;
        loop_info->loop_h[1] = img->height;
        break;

    case HI_SVP_IMG_TYPE_U8C3_PACKAGE:
        loop_info->ele_size = (uint32_t)(sizeof(uint8_t) + sizeof(uint16_t));
        break;

    case HI_SVP_IMG_TYPE_U8C3_PLANAR:
        loop_info->loop_c                        = HI__IVE_IMAGE_CHN_THREE;
        loop_info->loop_h[1]                     = img->height;
        loop_info->loop_h[HI__IVE_IMAGE_CHN_TWO] = img->height;
        break;

    case HI_SVP_IMG_TYPE_S16C1:
    case HI_SVP_IMG_TYPE_U16C1:
        loop_info->ele_size = (uint32_t)sizeof(uint16_t);
        break;

    case HI_SVP_IMG_TYPE_U32C1:
    case HI_SVP_IMG_TYPE_S32C1:
        loop_info->ele_size = (uint32_t)sizeof(uint32_t);
        break;

    case HI_SVP_IMG_TYPE_S64C1:
    case HI_SVP_IMG_TYPE_U64C1:
        loop_info->ele_size = (uint32_t)sizeof(uint64_t);
        break;

    default:
        break;
    }
}

#define HI_SAMPLE_ADDR_IDX_ZERO 0
#define HI_SAMPLE_ADDR_IDX_ONE 1
#define HI_SAMPLE_ADDR_IDX_TWO 2
#define HI_MAX_LOOP_IMG_H 3

static int _ive_set_image_addr(hi_svp_img* img, const _img_loop_info_t* loop_info, hi_bool is_mmz_cached)
{
    uint32_t c;
    int      size = 0;
    int      rc;
    hi_void* virt_addr = HI_NULL;

    for (c = 0; (c < loop_info->loop_c) && (c < HI_MAX_LOOP_IMG_H) && (c < HI_SVP_IMG_STRIDE_NUM); c++)
    {
        size += img->stride[0] * loop_info->loop_h[c] * loop_info->ele_size;
        img->stride[c] = img->stride[0];
    }

    if (is_mmz_cached)
    {
        rc = hi_mpi_sys_mmz_alloc_cached((hi_phys_addr_t*)&img->phys_addr[0], (hi_void**)&virt_addr, HI_NULL, HI_NULL,
                                         size);
    }
    else
    {
        rc = hi_mpi_sys_mmz_alloc((hi_phys_addr_t*)&img->phys_addr[0], (hi_void**)&virt_addr, HI_NULL, HI_NULL, size);
    }

    if (rc != HI_SUCCESS)
    {
        logger().error("IVE: mmz malloc FAIL: %d(%08X)", rc, (uint32_t)rc);
        return rc;
    }

    img->virt_addr[HI_SAMPLE_ADDR_IDX_ZERO] = _convert_ptr_to_addr(uint64_t, virt_addr);

    if (img->type != HI_SVP_IMG_TYPE_U8C3_PACKAGE)
    {
        for (c = 1; (c < loop_info->loop_c) && (c < HI_MAX_LOOP_IMG_H) && (c < HI_SVP_IMG_STRIDE_NUM); c++)
        {
            img->phys_addr[c] = img->phys_addr[c - 1] + img->stride[c - 1] * img->height;
            img->virt_addr[c] = img->virt_addr[c - 1] + img->stride[c - 1] * img->height;
        }
    }
    else
    {
        img->virt_addr[HI_SAMPLE_ADDR_IDX_ONE] = img->virt_addr[HI_SAMPLE_ADDR_IDX_ZERO] + 1;
        img->virt_addr[HI_SAMPLE_ADDR_IDX_TWO] = img->virt_addr[HI_SAMPLE_ADDR_IDX_ONE] + 1;
        img->phys_addr[HI_SAMPLE_ADDR_IDX_ONE] = img->phys_addr[HI_SAMPLE_ADDR_IDX_ZERO] + 1;
        img->phys_addr[HI_SAMPLE_ADDR_IDX_TWO] = img->phys_addr[HI_SAMPLE_ADDR_IDX_ONE] + 1;
    }

    return size;
}

static int _ive_img_init(hi_svp_img* img, hi_svp_img_type type, uint32_t width, uint32_t height)
{
    int              rc = 0;
    _img_loop_info_t loop_info;

    img->type      = type;
    img->width     = width;
    img->height    = height;
    img->stride[0] = Util::Math::alignup(width, HI_IVE_ALIGN);

    switch (type)
    {
    case HI_SVP_IMG_TYPE_U8C1:
    case HI_SVP_IMG_TYPE_S8C1:
    case HI_SVP_IMG_TYPE_YUV420SP:
    case HI_SVP_IMG_TYPE_YUV422SP:
    case HI_SVP_IMG_TYPE_S16C1:
    case HI_SVP_IMG_TYPE_U16C1:
    case HI_SVP_IMG_TYPE_U8C3_PACKAGE:
    case HI_SVP_IMG_TYPE_S32C1:
    case HI_SVP_IMG_TYPE_U32C1:
    case HI_SVP_IMG_TYPE_S64C1:
    case HI_SVP_IMG_TYPE_U64C1:
        _ive_get_loop_info(img, &loop_info);
        rc = _ive_set_image_addr(img, &loop_info, HI_FALSE);
        break;

    case HI_SVP_IMG_TYPE_YUV420P:
        break;

    case HI_SVP_IMG_TYPE_YUV422P:
        break;

    case HI_SVP_IMG_TYPE_S8C2_PACKAGE:
        break;

    case HI_SVP_IMG_TYPE_S8C2_PLANAR:
        break;

    case HI_SVP_IMG_TYPE_U8C3_PLANAR:
        break;

    default:
        break;
    }

    return rc;
}

static uint32_t _ive_resize_get_tile_metric(uint32_t src_metric, uint32_t dst_metric, hi_svp_img_type img_type)
{
    int      tmp_metric = HI_SAMPLE_RESIZE_MAX_TILE_METRIC_8BIT;
    uint32_t src_tile_num, scale, dst_tmp_tile, src_tmp_tile, tile_remainder;
    switch (img_type)
    {
    case HI_SVP_IMG_TYPE_YUV420SP:
    case HI_SVP_IMG_TYPE_YUV422SP:
    case HI_SVP_IMG_TYPE_U8C3_PLANAR:
    case HI_SVP_IMG_TYPE_U8C1:
    case HI_SVP_IMG_TYPE_S8C1:
        tmp_metric = HI_SAMPLE_RESIZE_MAX_TILE_METRIC_8BIT;
        break;

    case HI_SVP_IMG_TYPE_U16C1:
    case HI_SVP_IMG_TYPE_S16C1:

        tmp_metric = HI_SAMPLE_RESIZE_MAX_TILE_METRIC_16BIT;
        break;

    default:
        break;
    }

    scale = (src_metric / dst_metric) + ((src_metric % dst_metric == 0) ? 0 : 1);
    if (dst_metric < src_metric)
    {
        src_tile_num   = (src_metric / tmp_metric) + ((src_metric % tmp_metric == 0) ? 0 : 1);
        dst_tmp_tile   = dst_metric / src_tile_num;
        src_tmp_tile   = src_metric / src_tile_num + ((src_metric % src_tile_num == 0) ? 0 : 1);
        tile_remainder = (tmp_metric - src_tmp_tile) / scale;
        tmp_metric     = (dst_tmp_tile + tile_remainder) & ~0x1;
        if (tile_remainder == 0)
        {
            tmp_metric -= HI_SAMPLE_RESIZE_TILE_ADJUST;
        }
    }
    else if (dst_metric == src_metric || scale == 1)
    {
        tmp_metric -= HI_SAMPLE_RESIZE_TILE_ADJUST;
    }
    return (uint32_t)tmp_metric;
}

static uint32_t _ive_resize_get_tile_num(uint32_t width, uint32_t height, uint32_t tile_w, uint32_t tile_h)
{
    uint32_t x_num, y_num;
    if ((tile_w == 0) || (tile_h == 0))
        return 0;

    x_num = (width / tile_w) + ((width % tile_w) == 0 ? 0 : 1);
    y_num = (height / tile_h) + ((height % tile_h) == 0 ? 0 : 1);
    return (x_num * y_num);
}

#define HI_SAMPLE_RESIZE_CBCR_NUM_2 2
static uint32_t _ive_resize_get_yuv420sp_tile_num(uint32_t src_width, uint32_t dst_width, uint32_t src_height,
                                                  uint32_t dst_height)
{
    uint32_t j, tile_width, tile_height;
    uint32_t num = 0;

    tile_width = _ive_resize_get_tile_metric(src_width, dst_width, HI_SVP_IMG_TYPE_YUV420SP);
    for (j = 0; j < HI_SAMPLE_RESIZE_CBCR_NUM_2; j++)
    {
        tile_height = _ive_resize_get_tile_metric(src_height >> j, dst_height >> j, HI_SVP_IMG_TYPE_YUV420SP);
        num += _ive_resize_get_tile_num(dst_width, dst_height >> j, tile_width, tile_height);
    }

    return num;
}

static uint32_t _ive_resize_get_yuv422sp_tile_num(uint32_t src_width, uint32_t dst_width, uint32_t src_height,
                                                  uint32_t dst_height)
{
    uint32_t j, tile_width, tile_height;
    uint32_t num = 0;

    tile_width  = _ive_resize_get_tile_metric(src_width, dst_width, HI_SVP_IMG_TYPE_YUV422SP);
    tile_height = _ive_resize_get_tile_metric(src_height, dst_height, HI_SVP_IMG_TYPE_YUV422SP);

    for (j = 0; j < HI_SAMPLE_RESIZE_CBCR_NUM_2; j++)
        num += _ive_resize_get_tile_num(dst_width, dst_height, tile_width, tile_height);

    return num;
}

static uint32_t _ive_resize_get_u8c3_planar_tile_num(uint32_t src_width, uint32_t dst_width, uint32_t src_height,
                                                     uint32_t dst_height)
{
    uint32_t j, tile_width, tile_height;
    uint32_t num = 0;

    tile_width  = _ive_resize_get_tile_metric(src_width, dst_width, HI_SVP_IMG_TYPE_U8C3_PLANAR);
    tile_height = _ive_resize_get_tile_metric(src_height, dst_height, HI_SVP_IMG_TYPE_U8C3_PLANAR);
    for (j = 0; j < HI_SAMPLE_RESIZE_CBCR_NUM_3; j++)
        num += _ive_resize_get_tile_num(dst_width, dst_height, tile_width, tile_height);

    return num;
}

static uint32_t _ive_resize_get_u8c1_tile_num(uint32_t src_width, uint32_t dst_width, uint32_t src_height,
                                              uint32_t dst_height)
{
    uint32_t tile_width, tile_height;
    uint32_t num = 0;

    tile_width  = _ive_resize_get_tile_metric(src_width, dst_width, HI_SVP_IMG_TYPE_U8C1);
    tile_height = _ive_resize_get_tile_metric(src_height, dst_height, HI_SVP_IMG_TYPE_U8C1);
    num         = _ive_resize_get_tile_num(dst_width, dst_height, tile_width, tile_height);
    return num;
}

static uint32_t _ive_resize_get_u16c1_tile_num(uint32_t src_width, uint32_t dst_width, uint32_t src_height,
                                               uint32_t dst_height)
{
    uint32_t tile_width, tile_height;
    uint32_t num = 0;

    tile_width  = _ive_resize_get_tile_metric(src_width, dst_width, HI_SVP_IMG_TYPE_U16C1);
    tile_height = _ive_resize_get_tile_metric(src_height, dst_height, HI_SVP_IMG_TYPE_U16C1);
    num         = _ive_resize_get_tile_num(dst_width, dst_height, tile_width, tile_height);
    return num;
}

static int _ive_resize_get_assist_buf_size(const hi_svp_src_img src[], const hi_svp_dst_img dst[], int count)
{
    int i;
    int num = 0;
    for (i = 0; i < count; i++)
    {
        switch (src[i].type)
        {
        case HI_SVP_IMG_TYPE_YUV420SP:
            num += _ive_resize_get_yuv420sp_tile_num(src[i].width, dst[i].width, src[i].height, dst[i].height);
            break;

        case HI_SVP_IMG_TYPE_YUV422SP:
            num += _ive_resize_get_yuv422sp_tile_num(src[i].width, dst[i].width, src[i].height, dst[i].height);
            break;

        case HI_SVP_IMG_TYPE_U8C3_PLANAR:
            num += _ive_resize_get_u8c3_planar_tile_num(src[i].width, dst[i].width, src[i].height, dst[i].height);
            break;

        case HI_SVP_IMG_TYPE_U8C1:
        case HI_SVP_IMG_TYPE_S8C1:
            num += _ive_resize_get_u8c1_tile_num(src[i].width, dst[i].width, src[i].height, dst[i].height);
            break;

        case HI_SVP_IMG_TYPE_U16C1:
        case HI_SVP_IMG_TYPE_S16C1:
            num += _ive_resize_get_u16c1_tile_num(src[i].width, dst[i].width, src[i].height, dst[i].height);
            break;

        default:
            break;
        }
    }

    return num * HI_SAMPLE_RESIZE_ASSIST_UNIT_SIZE;
}

static int _ive_mem_info_init(hi_svp_mem_info* mem_info, hi_u32 size)
{
    int      rc        = HI_ERR_IVE_NULL_PTR;
    hi_void* virt_addr = HI_NULL;

    mem_info->size = size;
    rc = hi_mpi_sys_mmz_alloc((hi_phys_addr_t*)&mem_info->phys_addr, (hi_void**)&virt_addr, HI_NULL, HI_NULL, size);
    if (rc != HI_SUCCESS)
        return rc;

    mem_info->virt_addr = _convert_ptr_to_addr(uint64_t, virt_addr);
    return rc;
}

static int _ive_img_load(hi_svp_img* img, uint8_t* pData)
{
    uint8_t*         ptr_tmp = HI_NULL;
    uint16_t         c, h;
    int              rc        = 0;
    _img_loop_info_t loop_info = {0};
    int              index     = 0;

    _ive_get_loop_info(img, &loop_info);
    for (c = 0; (c < loop_info.loop_c) && (c < HI_SVP_IMG_STRIDE_NUM) && (c < HI_SVP_IMG_ADDR_NUM); c++)
    {
        ptr_tmp = _convert_addr_to_ptr(uint8_t, img->virt_addr[c]);
        if (!ptr_tmp)
        {
            rc = HI_ERR_IVE_BAD_ADDR;
            goto exit;
        }

        for (h = 0; h < loop_info.loop_h[c]; h++)
        {
            int bytes = img->width * loop_info.ele_size;
            memcpy(ptr_tmp, &pData[index], bytes);
            index += bytes;
            ptr_tmp += img->stride[c] * loop_info.ele_size;
        }
    }

exit:
    return rc;
}

static int _ive_img_store(hi_svp_img* img, uint8_t* pBuffer)
{
    uint16_t         c, h;
    uint8_t*         ptr_tmp   = HI_NULL;
    int              rc        = 0;
    _img_loop_info_t loop_info = {0};
    int              index     = 0;

    if (img->phys_addr == 0 || img->virt_addr == 0)
        return HI_ERR_BAD_ADDR;

    _ive_get_loop_info(img, &loop_info);
    for (c = 0; (c < loop_info.loop_c) && (c < HI_SVP_IMG_STRIDE_NUM) && (c < HI_SVP_IMG_ADDR_NUM); c++)
    {
        ptr_tmp = _convert_addr_to_ptr(uint8_t, img->virt_addr[c]);
        if (!ptr_tmp)
        {
            rc = HI_ERR_IVE_BAD_ADDR;
            goto exit;
        }

        for (h = 0; h < loop_info.loop_h[c]; h++)
        {
            int bytes = img->width * loop_info.ele_size;
            memcpy(&pBuffer[index], ptr_tmp, bytes);
            index += bytes;

            ptr_tmp += img->stride[c] * loop_info.ele_size;
        }
    }

exit:
    return rc;
}

#define _mmz_free(phys, virt) \
    do \
    { \
        if (((phys) != 0) && ((virt) != 0)) \
        { \
            hi_mpi_sys_mmz_free((hi_phys_addr_t)(phys), (hi_void*)(hi_uintptr_t)(virt)); \
            (phys) = 0; \
            (virt) = 0; \
        } \
    } while (0)

static void _ive_img_free(hi_svp_img* img)
{
    _mmz_free(img->phys_addr[0], img->virt_addr[0]);
}

static void _ive_mem_info_free(hi_svp_mem_info* info)
{
    _mmz_free(info->phys_addr, info->virt_addr);
}

/*
 *******************************************************************************
 *                                CLASS DEFINE
 *******************************************************************************
 */
VideoFrame::Ptr MPP5::IVE::resize(VideoFrame::Ptr from, uint32_t width, uint32_t height)
{
    return VideoFrame::Ptr();
}
}
}