/* SPDX-License-Identifier: Apache-2.0 OR MIT */
/*
 * Copyright (c) 2018 Rockchip Electronics Co., Ltd.
 */

#define MODULE_TAG "iep"

#include <math.h>
#include <string.h>

#include "mpp_env.h"
#include "mpp_mem.h"
#include "mpp_debug.h"
#include "mpp_common.h"

#include "iep_api.h"
#include "iep.h"

#define X   (-1)

static RK_S32 enh_alpha_table[][25] = {
    //      0   1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20  21  22  23  24
    /*0*/  {X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X },
    /*1*/  {0,  8, 12, 16, 20, 24, 28,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X },
    /*2*/  {0,  4,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X,  X },
    /*3*/  {0,  X,  X,  8,  X,  X, 12,  X,  X, 16,  X,  X, 20,  X,  X, 24,  X,  X, 28,  X,  X,  X,  X,  X,  X },
    /*4*/  {0,  2,  4,  6,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28 },
    /*5*/  {0,  X,  X,  X,  X,  8,  X,  X,  X,  X, 12,  X,  X,  X,  X, 16,  X,  X,  X,  X, 20,  X,  X,  X,  X },
    /*6*/  {0,  X,  X,  4,  X,  X,  8,  X,  X, 10,  X,  X, 12,  X,  X, 14,  X,  X, 16,  X,  X, 18,  X,  X, 20 },
    /*7*/  {0,  X,  X,  X,  X,  X,  X,  8,  X,  X,  X,  X,  X,  X, 12,  X,  X,  X,  X,  X,  X, 16,  X,  X,  X },
    /*8*/  {0,  1,  2,  3,  4,  5,  6,  7,  8,  X,  9,  X, 10,  X, 11,  X, 12,  X, 13,  X, 14,  X,  15, X, 16 }
};

static const char *iep_name = "/dev/iep";

typedef struct IepCtxImpl_t {
    IepMsg      msg;
    RK_S32      fd;
    RK_S32      pid;
    IepHwCap    cap;
} IepCtxImpl;

MPP_RET iep_init(IepCtx *ctx)
{
    if (NULL == ctx) {
        mpp_err_f("invalid NULL input\n");
        return MPP_ERR_NULL_PTR;
    }

    RK_S32 fd = -1;
    IepCtxImpl *impl = NULL;

    mpp_env_get_u32("iep_debug", &iep_debug, 0);
    *ctx = NULL;

    do {
        impl = mpp_calloc(IepCtxImpl, 1);
        if (NULL == impl) {
            mpp_err_f("failed to alloc context\n");
            break;
        }

        fd = open(iep_name, O_RDWR | O_CLOEXEC);
        if (fd < 0) {
            mpp_err("can NOT find iep device %s\n", iep_name);
            break;
        }

        if (0 > ioctl(fd, IEP_QUERY_CAP, &impl->cap)) {
            iep_dbg_func("Query IEP capability failed, using default cap\n");
            IepHwCap *cap = &impl->cap;

            cap->scaling_supported = 0;
            cap->i4_deinterlace_supported = 1;
            cap->i2_deinterlace_supported = 1;
            cap->compression_noise_reduction_supported = 1;
            cap->sampling_noise_reduction_supported = 1;
            cap->hsb_enhancement_supported = 1;
            cap->cg_enhancement_supported = 1;
            cap->direct_path_supported = 1;
            cap->max_dynamic_width = 1920;
            cap->max_dynamic_height = 1088;
            cap->max_static_width = 8192;
            cap->max_static_height = 8192;
            cap->max_enhance_radius = 3;
        }

        impl->fd = fd;
        impl->pid = getpid();

        *ctx = impl;
        return MPP_OK;
    } while (0);

    if (fd > 0)
        close(fd);

    MPP_FREE(impl);

    return MPP_NOK;
}

MPP_RET iep_deinit(IepCtx ctx)
{
    if (NULL == ctx) {
        mpp_err_f("invalid NULL input\n");
        return MPP_ERR_NULL_PTR;
    }

    IepCtxImpl *impl = (IepCtxImpl *)ctx;

    if (impl->fd > 0) {
        close(impl->fd);
        impl->fd = -1;
    }

    return MPP_OK;
}

static void dump_iep_img(IepImg *img)
{
    mpp_log("image    %p\n", img);
    mpp_log("act_w    %d\n", img->act_w);
    mpp_log("act_h    %d\n", img->act_h);
    mpp_log("x_off    %d\n", img->x_off);
    mpp_log("y_off    %d\n", img->y_off);
    mpp_log("vir_w    %d\n", img->vir_w);
    mpp_log("vir_h    %d\n", img->vir_h);
    mpp_log("format   %d\n", img->format);
    mpp_log("mem_addr %08x\n", img->mem_addr);
    mpp_log("uv_addr  %08x\n", img->uv_addr);
    mpp_log("v_addr   %08x\n", img->v_addr);
}

static RK_U32 check_yuv_enhance_param(IepCmdParamYuvEnhance *yuv_enh)
{
    RK_U32 ret = 0;
    if (yuv_enh->saturation < 0 || yuv_enh->saturation > 1.992) {
        mpp_err("Invalidate parameter, yuv_enh_saturation!\n");
        ret |= 0x0001;
    }

    if (yuv_enh->contrast < 0 || yuv_enh->contrast > 1.992) {
        mpp_err("Invalidate parameter, yuv_enh_contrast!\n");
        ret |= 0x0002;
    }

    if (yuv_enh->brightness < -32 || yuv_enh->brightness > 31) {
        mpp_err("Invalidate parameter, yuv_enh_brightness!\n");
        ret |= 0x0004;
    }

    if (yuv_enh->hue_angle < -30 || yuv_enh->hue_angle > 30) {
        mpp_err("Invalidate parameter, yuv_enh_hue_angle!\n");
        ret |= 0x0008;
    }

    if (yuv_enh->video_mode < 0 || yuv_enh->video_mode > 3) {
        mpp_err("Invalidate parameter, video_mode!\n");
        ret |= 0x0010;
    }

    if (yuv_enh->color_bar_y > 127 || yuv_enh->color_bar_u > 127 ||
        yuv_enh->color_bar_v > 127) {
        mpp_err("Invalidate parameter, color_bar_*!\n");
        ret |= 0x0020;
    }
    return ret;
}

static RK_U32 check_rgb_enhance_param(IepCmdParamRgbEnhance *rgb_enh)
{
    RK_U32 ret = 0;
    if (rgb_enh->alpha_base > 8 || rgb_enh->alpha_base < 0 ||
        rgb_enh->alpha_num  < 0 || rgb_enh->alpha_num  > 24) {
        mpp_err("Invalidate parameter, enh_alpha_base or enh_alpha_num!\n");
        ret |= 0x0001;
    }

    if (enh_alpha_table[rgb_enh->alpha_base][rgb_enh->alpha_num] == -1) {
        mpp_err("Invalidate parameter, enh_alpha_base or enh_alpha_num!\n");
        ret |= 0x0002;
    }

    if (rgb_enh->threshold > 255 || rgb_enh->threshold < 0) {
        mpp_err("Invalidate parameter, enh_threshold!\n");
        ret |= 0x0004;
    }

    if (rgb_enh->radius > 4 || rgb_enh->radius < 1) {
        mpp_err("Invalidate parameter, enh_radius!\n");
        ret |= 0x0008;
    }

    if (rgb_enh->order < IEP_RGB_ENHANCE_ORDER_CG_DDE ||
        rgb_enh->order > IEP_RGB_ENHANCE_ORDER_DDE_CG) {
        mpp_err("Invalidate parameter, rgb_contrast_enhance_mode!\n");
        ret |= 0x0010;
    }

    if (rgb_enh->mode < IEP_RGB_ENHANCE_MODE_NO_OPERATION ||
        rgb_enh->mode > IEP_RGB_ENHANCE_MODE_EDGE_ENHANCE) {
        mpp_err("Invalidate parameter, rgb_enhance_mode!\n");
        ret |= 0x0020;
    }

    if (rgb_enh->coe > 3.96875 || rgb_enh->coe < 0) {
        mpp_err("Invalidate parameter, rgb_enh_coe!\n");
        ret |= 0x0040;
    }

    return ret;
}

static RK_U32 check_msg_image(IepMsg *msg)
{
    RK_U32 ret = 0;
    IepMsgImg *src = &msg->src;
    IepMsgImg *dst = &msg->dst;

    if (!((src->format < IEP_FORMAT_RGB_BUTT) ||
          (src->format >= IEP_FORMAT_YUV_BASE && src->format < IEP_FORMAT_YUV_BUTT))) {
        mpp_err("Invalidate parameter, i/o format!\n");
        ret |= 0x0001;
    }

    if (src->act_w > 4096 || src->act_h > 8192) {
        mpp_err("Invalidate parameter, source image size!\n");
        ret |= 0x0002;
    }

    if (dst->act_w > 4096 || dst->act_h > 4096) {
        mpp_err("Invalidate parameter, destination image size!\n");
        ret |= 0x0004;
    }

    RK_S32 scl_fct_h = src->act_w > dst->act_w ? (src->act_w * 1000 / dst->act_w) : (dst->act_w * 1000 / src->act_w);
    RK_S32 scl_fct_v = src->act_h > dst->act_h ? (src->act_h * 1000 / dst->act_h) : (dst->act_h * 1000 / src->act_h);

    if (scl_fct_h > 16000 || scl_fct_v > 16000) {
        mpp_err("Invalidate parameter, scale factor!\n");
        ret |= 0x0008;
    }
    return ret;
}

// rr = 1.7 rg = 1 rb = 0.6
static RK_U32 cg_tab[] = {
    0x01010100, 0x03020202, 0x04030303, 0x05040404,
    0x05050505, 0x06060606, 0x07070606, 0x07070707,
    0x08080807, 0x09080808, 0x09090909, 0x0a090909,
    0x0a0a0a0a, 0x0b0a0a0a, 0x0b0b0b0b, 0x0c0b0b0b,
    0x0c0c0c0c, 0x0c0c0c0c, 0x0d0d0d0d, 0x0d0d0d0d,
    0x0e0e0d0d, 0x0e0e0e0e, 0x0e0e0e0e, 0x0f0f0f0f,
    0x0f0f0f0f, 0x10100f0f, 0x10101010, 0x10101010,
    0x11111110, 0x11111111, 0x11111111, 0x12121212,
    0x12121212, 0x12121212, 0x13131313, 0x13131313,
    0x13131313, 0x14141414, 0x14141414, 0x14141414,
    0x15151515, 0x15151515, 0x15151515, 0x16161615,
    0x16161616, 0x16161616, 0x17161616, 0x17171717,
    0x17171717, 0x17171717, 0x18181818, 0x18181818,
    0x18181818, 0x19191818, 0x19191919, 0x19191919,
    0x19191919, 0x1a1a1a19, 0x1a1a1a1a, 0x1a1a1a1a,
    0x1a1a1a1a, 0x1b1b1b1b, 0x1b1b1b1b, 0x1b1b1b1b,
    0x03020100, 0x07060504, 0x0b0a0908, 0x0f0e0d0c,
    0x13121110, 0x17161514, 0x1b1a1918, 0x1f1e1d1c,
    0x23222120, 0x27262524, 0x2b2a2928, 0x2f2e2d2c,
    0x33323130, 0x37363534, 0x3b3a3938, 0x3f3e3d3c,
    0x43424140, 0x47464544, 0x4b4a4948, 0x4f4e4d4c,
    0x53525150, 0x57565554, 0x5b5a5958, 0x5f5e5d5c,
    0x63626160, 0x67666564, 0x6b6a6968, 0x6f6e6d6c,
    0x73727170, 0x77767574, 0x7b7a7978, 0x7f7e7d7c,
    0x83828180, 0x87868584, 0x8b8a8988, 0x8f8e8d8c,
    0x93929190, 0x97969594, 0x9b9a9998, 0x9f9e9d9c,
    0xa3a2a1a0, 0xa7a6a5a4, 0xabaaa9a8, 0xafaeadac,
    0xb3b2b1b0, 0xb7b6b5b4, 0xbbbab9b8, 0xbfbebdbc,
    0xc3c2c1c0, 0xc7c6c5c4, 0xcbcac9c8, 0xcfcecdcc,
    0xd3d2d1d0, 0xd7d6d5d4, 0xdbdad9d8, 0xdfdedddc,
    0xe3e2e1e0, 0xe7e6e5e4, 0xebeae9e8, 0xefeeedec,
    0xf3f2f1f0, 0xf7f6f5f4, 0xfbfaf9f8, 0xfffefdfc,
    0x06030100, 0x1b150f0a, 0x3a322922, 0x63584e44,
    0x95887b6f, 0xcebfb0a2, 0xfffeedde, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
    0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
};

static void setup_cg_tab(double cg_rate, RK_U32 *base)
{
    RK_S32 i;

    for (i = 0; i < 64; i++) {
        RK_U32 rgb_0 = 4 * i;
        RK_U32 rgb_1 = 4 * i + 1;
        RK_U32 rgb_2 = 4 * i + 2;
        RK_U32 rgb_3 = 4 * i + 3;

        /// need modify later
        RK_U32 cg_0 = pow(rgb_0, cg_rate);
        RK_U32 cg_1 = pow(rgb_1, cg_rate);
        RK_U32 cg_2 = pow(rgb_2, cg_rate);
        RK_U32 cg_3 = pow(rgb_3, cg_rate);

        if (cg_0 > 255) cg_0 = 255;
        if (cg_1 > 255) cg_1 = 255;
        if (cg_2 > 255) cg_2 = 255;
        if (cg_3 > 255) cg_3 = 255;

        RK_U32 tab_0 = (RK_U32)cg_0;
        RK_U32 tab_1 = (RK_U32)cg_1;
        RK_U32 tab_2 = (RK_U32)cg_2;
        RK_U32 tab_3 = (RK_U32)cg_3;

        RK_U32 conf_value = (tab_3 << 24) + (tab_2 << 16) + (tab_1 << 8) + tab_0;
        base[i] = conf_value;
    }
}

MPP_RET iep_control(IepCtx ctx, IepCmd cmd, void *param)
{
    if (NULL == ctx) {
        mpp_err_f("invalid NULL input\n");
        return MPP_ERR_NULL_PTR;
    }

    MPP_RET ret = MPP_OK;
    IepCtxImpl *impl = (IepCtxImpl *)ctx;
    IepMsg *msg = &impl->msg;

    switch (cmd) {
    case IEP_CMD_INIT : {
        memset(msg, 0, sizeof(*msg));
    } break;
    case IEP_CMD_SET_SRC : {
        IepMsgImg *src = &msg->src;

        mpp_assert(param);
        // NOTE: only update which is used
        memcpy(&msg->src, param, sizeof(IepImg));

        if ((src->format == IEP_FORMAT_YCbCr_420_P
             || src->format == IEP_FORMAT_YCbCr_420_SP
             || src->format == IEP_FORMAT_YCbCr_422_P
             || src->format == IEP_FORMAT_YCbCr_422_SP
             || src->format == IEP_FORMAT_YCrCb_420_P
             || src->format == IEP_FORMAT_YCrCb_420_SP
             || src->format == IEP_FORMAT_YCrCb_422_P
             || src->format == IEP_FORMAT_YCrCb_422_SP) &&
            msg->dein_mode == IEP_DEI_MODE_DISABLE) {
            msg->dein_mode = IEP_DEI_MODE_BYPASS;
        }
        if (iep_debug & IEP_DBG_IMAGE) {
            mpp_log("setup src\n");
            dump_iep_img((IepImg *)param);
        }
    } break;
    case IEP_CMD_SET_DST : {
        mpp_assert(param);
        // NOTE: only update which is used
        memcpy(&msg->dst, param, sizeof(IepImg));

        if (iep_debug & IEP_DBG_IMAGE) {
            mpp_log("setup dst\n");
            dump_iep_img((IepImg *)param);
        }
    } break;
    case IEP_CMD_SET_DEI_CFG : {
        IepCmdParamDeiCfg *dei_cfg = (IepCmdParamDeiCfg *)param;

        if (NULL == param) {
            msg->dein_high_fre_en   = 0;
            msg->dein_mode          = IEP_DEI_MODE_I2O1;
            msg->field_order        = IEP_DEI_FLD_ORDER_BOT_FIRST;
            msg->dein_ei_mode       = 0;
            msg->dein_ei_sel        = 0;
            msg->dein_ei_radius     = 0;
            msg->dein_ei_smooth     = 0;
            msg->dein_high_fre_fct  = 0;
        } else {
            msg->dein_high_fre_en   = dei_cfg->dei_high_freq_en;
            msg->dein_mode          = dei_cfg->dei_mode;
            msg->field_order        = dei_cfg->dei_field_order;
            msg->dein_ei_mode       = dei_cfg->dei_ei_mode;
            msg->dein_ei_sel        = dei_cfg->dei_ei_sel;
            msg->dein_ei_radius     = dei_cfg->dei_ei_radius;
            msg->dein_ei_smooth     = dei_cfg->dei_ei_smooth;
            msg->dein_high_fre_fct  = dei_cfg->dei_high_freq_fct;
        }
        switch (msg->dein_mode) {
        case IEP_DEI_MODE_DISABLE : {
            msg->dein_mode = IEP_DEI_MODE_BYPASS;
        } break;
        case IEP_DEI_MODE_I2O1 :
        case IEP_DEI_MODE_I4O1 :
        case IEP_DEI_MODE_I4O2 : {
            // for avoid hardware error we need to config src1 and dst1
            if (!msg->src1.mem_addr)
                memcpy(&msg->src1, &msg->src, sizeof(msg->src));
            if (!msg->dst1.mem_addr)
                memcpy(&msg->dst1, &msg->dst, sizeof(msg->dst));
        } break;
        default : {
        } break;
        }
    } break;
    case IEP_CMD_SET_DEI_SRC1 : {
        mpp_assert(param);
        // NOTE: only update which is used
        memcpy(&msg->src1, param, sizeof(IepImg));
        if (iep_debug & IEP_DBG_IMAGE) {
            mpp_log("setup src1\n");
            dump_iep_img((IepImg *)param);
        }
    } break;
    case IEP_CMD_SET_DEI_DST1 : {
        mpp_assert(param);
        // NOTE: only update which is used
        memcpy(&msg->dst1, param, sizeof(IepImg));
        if (iep_debug & IEP_DBG_IMAGE) {
            mpp_log("setup dst1\n");
            dump_iep_img((IepImg *)param);
        }
    } break;
    case IEP_CMD_SET_YUV_ENHANCE : {
        IepCmdParamYuvEnhance *yuv_enh = (IepCmdParamYuvEnhance *)param;

        if (NULL == yuv_enh) {
            msg->yuv_enhance_en = 1;

            msg->sat_con_int = 0x80;
            msg->contrast_int = 0x80;
            // hue_angle = 0
            msg->cos_hue_int = 0x00;
            msg->sin_hue_int = 0x80;

            msg->yuv_enh_brightness = 0x00;

            msg->video_mode = IEP_VIDEO_MODE_NORMAL_VIDEO;

            msg->color_bar_u = 0;
            msg->color_bar_v = 0;
            msg->color_bar_y = 0;
            break;
        }

        if (check_yuv_enhance_param(yuv_enh)) {
            ret = MPP_NOK;
            break;
        }

        if (msg->src.format >= 1 && msg->src.format <= 5 &&
            msg->dst.format >= 1 && msg->dst.format <= 5) {
            mpp_err("Invalidate parameter, contradition between in/out format and yuv enhance\n");
            ret = MPP_NOK;
            break;
        }

        msg->yuv_enhance_en = 1;

        msg->sat_con_int = (RK_S32)(yuv_enh->saturation * yuv_enh->contrast * 128);
        msg->contrast_int = (RK_S32)(yuv_enh->contrast * 128);
        msg->cos_hue_int = (RK_S32)(cos(yuv_enh->hue_angle) * 128.0);
        msg->sin_hue_int = (RK_S32)(sin(yuv_enh->hue_angle) * 128.0);
        msg->yuv_enh_brightness = yuv_enh->brightness >= 0 ?
                                  yuv_enh->brightness :
                                  (yuv_enh->brightness + 64);

        msg->video_mode  = yuv_enh->video_mode;
        msg->color_bar_y = yuv_enh->color_bar_y;
        msg->color_bar_u = yuv_enh->color_bar_u;
        msg->color_bar_v = yuv_enh->color_bar_v;
    } break;
    case IEP_CMD_SET_RGB_ENHANCE : {
        RK_U32 i;
        IepCmdParamRgbEnhance *rgb_enh = (IepCmdParamRgbEnhance *)param;

        if (NULL == rgb_enh) {
            msg->rgb_color_enhance_en       = 1;
            msg->rgb_enh_coe                = 32;
            msg->rgb_contrast_enhance_mode  = IEP_RGB_ENHANCE_MODE_DETAIL_ENHANCE;
            msg->rgb_cg_en                  = 0;
            msg->enh_threshold              = 255;
            msg->enh_alpha                  = 8;
            msg->enh_radius                 = 3;

            for (i = 0; i < MPP_ARRAY_ELEMS(cg_tab); i++)
                msg->cg_tab[i] = cg_tab[i];

            break;
        }

        if (check_rgb_enhance_param(rgb_enh)) {
            ret = MPP_NOK;
            break;
        }

        if ((msg->src.format & IEP_FORMAT_YUV_BASE) &&
            (msg->dst.format & IEP_FORMAT_YUV_BASE)) {
            mpp_err("Invalidate parameter, contradition between in/out format and yuv enhance\n");
            ret = MPP_NOK;
            break;
        }

        msg->rgb_color_enhance_en       = 1;
        msg->rgb_enh_coe                = (RK_U32)(rgb_enh->coe * 32);
        msg->rgb_contrast_enhance_mode  = rgb_enh->order;
        msg->rgb_cg_en                  = rgb_enh->cg_en;
        msg->rgb_enhance_mode           = rgb_enh->mode;

        msg->enh_threshold = rgb_enh->threshold;
        msg->enh_alpha     =
            enh_alpha_table[rgb_enh->alpha_base][rgb_enh->alpha_num];
        msg->enh_radius    = rgb_enh->radius - 1;

        if (rgb_enh->cg_en) {
            setup_cg_tab(rgb_enh->cg_rb, msg->cg_tab);
            setup_cg_tab(rgb_enh->cg_rg, msg->cg_tab + 64);
            setup_cg_tab(rgb_enh->cg_rb, msg->cg_tab + 128);
        }
    } break;
    case IEP_CMD_SET_SCALE : {
        IepCmdParamScale *scale = (IepCmdParamScale *)param;

        msg->scale_up_mode = (scale) ? (scale->scale_alg) : (IEP_SCALE_ALG_CATROM);
    } break;
    case IEP_CMD_SET_COLOR_CONVERT : {
        IepCmdParamColorConvert *color_cvt = (IepCmdParamColorConvert *)param;

        if (NULL == color_cvt) {
            msg->rgb2yuv_mode       = IEP_COLOR_MODE_BT601_L;
            msg->yuv2rgb_mode       = IEP_COLOR_MODE_BT601_L;
            msg->rgb2yuv_clip_en    = 0;
            msg->yuv2rgb_clip_en    = 0;
            msg->global_alpha_value = 0;
            msg->dither_up_en       = 1;
            msg->dither_down_en     = 1;
            break;
        }

        if (color_cvt->dither_up_en && msg->src.format != IEP_FORMAT_RGB_565) {
            mpp_err("Invalidate parameter, contradiction between dither up enable and source image format!\n");
            ret = MPP_NOK;
            break;
        }

        if (color_cvt->dither_down_en && msg->dst.format != IEP_FORMAT_RGB_565) {
            mpp_err("Invalidate parameter, contradiction between dither down enable and destination image format!\n");
            ret = MPP_NOK;
            break;
        }

        msg->rgb2yuv_mode       = color_cvt->rgb2yuv_mode;
        msg->yuv2rgb_mode       = color_cvt->yuv2rgb_mode;
        msg->rgb2yuv_clip_en    = color_cvt->rgb2yuv_input_clip;
        msg->yuv2rgb_clip_en    = color_cvt->yuv2rgb_input_clip;
        msg->global_alpha_value = color_cvt->global_alpha_value;
        msg->dither_up_en       = color_cvt->dither_up_en;
        msg->dither_down_en     = color_cvt->dither_down_en;
    } break;
    case IEP_CMD_RUN_SYNC : {
        check_msg_image(msg);

        int ops_ret = ioctl(impl->fd, IEP_SET_PARAMETER, msg);
        if (ops_ret < 0)
            mpp_err("pid %d ioctl IEP_SET_PARAMETER failure\n", impl->pid);

        // NOTE: force result sync to avoid iep task queue full
        ops_ret = ioctl(impl->fd, IEP_GET_RESULT_SYNC, 0);
        if (ops_ret)
            mpp_err("pid %d get result failure\n", impl->pid);

        ret = (MPP_RET)ops_ret;
    } break;
    case IEP_CMD_QUERY_CAP : {
        if (param)
            *(IepHwCap **)param = &impl->cap;
        else
            mpp_err("Can NOT query to NULL output\n");
    } break;
    default : {
        mpp_err("invalid command %d\n", cmd);
        ret = MPP_NOK;
    } break;
    }

    return ret;
}

static iep_com_ops iep_ops = {
    .init = iep_init,
    .deinit = iep_deinit,
    .control = iep_control,
    .reset = NULL,
    .release = NULL,
};

iep_com_ctx* rockchip_iep_api_alloc_ctx(void)
{
    iep_com_ctx *com_ctx = (iep_com_ctx *)calloc(sizeof(*com_ctx), 1);
    void *iep_ctx = calloc(sizeof(sizeof(void*)), 1);

    mpp_assert(com_ctx && iep_ctx);

    com_ctx->ops = &iep_ops;
    com_ctx->priv = iep_ctx;

    return com_ctx;
}

void rockchip_iep_api_release_ctx(iep_com_ctx *com_ctx)
{
    if (com_ctx->priv) {
        free(com_ctx->priv);
        com_ctx->priv = NULL;
    }

    free(com_ctx);
}

