/*
 * Copyright (c) 2014 Amlogic, Inc. All rights reserved.
 *
 * This source code is subject to the terms and conditions defined in the
 * file 'LICENSE' which is part of this source code package.
 *
 * Description: c++ file
 */

#define LOG_MODULE_TAG "PQ"
#define LOG_CLASS_TAG "SSMAction"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include "SSMAction.h"
#include "CPQLog.h"
#include "CConfigFile.h"

pthread_mutex_t ssm_r_w_op_mutex = PTHREAD_MUTEX_INITIALIZER;

SSMAction *SSMAction::mInstance;
SSMHandler *SSMAction::mSSMHandler = NULL;
SSMAction *SSMAction::getInstance()
{
    if (NULL == mInstance)
        mInstance = new SSMAction();
    return mInstance;
}

SSMAction::SSMAction()
{
    m_dev_fd = -1;
    mpObserver = NULL;
}

SSMAction::~SSMAction()
{
    if (m_dev_fd > 0) {
        close(m_dev_fd);
        m_dev_fd = -1;
    }

    if (mSSMHandler != NULL) {
        delete mSSMHandler;
        mSSMHandler = NULL;
    }
}

void SSMAction::init(const char *settingDataPath, const char *whiteBalanceDataPath)
{
    //check file PATH
    mSSMDataFilePath = std::string(settingDataPath) + "/ssm_data";
    LOGD("%s: mSSMDataFilePath:%s\n", __FUNCTION__, mSSMDataFilePath.c_str());

    mSSMHandlerFilePath = std::string(settingDataPath) + "/SSMHandler";
    LOGD("%s: mSSMHandlerFilePath:%s\n", __FUNCTION__, mSSMHandlerFilePath.c_str());

    mWhiteBalanceFilePath = std::string(whiteBalanceDataPath) + "/cri_data";
    LOGD("%s: mWhiteBalanceFilePath:%s\n", __FUNCTION__, mWhiteBalanceFilePath.c_str());

    //check file exist or not
    bool ssm_data_FileExist    = isFileExist(mSSMDataFilePath.c_str());
    bool ssm_handler_FileExist = isFileExist(mSSMHandlerFilePath.c_str());
    bool cri_data_FileExist    = isFileExist(mWhiteBalanceFilePath.c_str());
    LOGD("%s, ssm_data_FileExist:%d ssm_handler_FileExist:%d cri_data_FileExist:%d\n",
        __FUNCTION__, ssm_data_FileExist, ssm_handler_FileExist, cri_data_FileExist);

    //open ssm file
    m_dev_fd = open(mSSMDataFilePath.c_str(), O_RDWR | O_SYNC | O_CREAT, S_IRUSR | S_IWUSR);
    if (m_dev_fd < 0) {
        LOGE("%s, Open %s failed error: %s\n", __FUNCTION__, mSSMDataFilePath.c_str(), strerror(errno));
        return;
    } else {
        LOGD("%s, Open %s success\n", __FUNCTION__, mSSMDataFilePath.c_str());
    }

    //open SSM handler
    mSSMHandler = SSMHandler::GetSingletonInstance(mSSMHandlerFilePath.c_str());

    //ssm check
    if (mSSMHandler != NULL) {
        SSM_status_t SSM_status = (SSM_status_t)GetSSMStatus();
        LOGD("%s, Verify SSMHeader status= %d\n", __FUNCTION__, SSM_status);
        if (DeviceMarkCheck() < 0 || SSM_status == SSM_HEADER_INVALID || !CheckTable()) {
            if (mpObserver != NULL) {
                EraseAllData();
                mpObserver->resetAllUserSettingParam();
                mSSMHandler->SSMRecreateHeader();
                RestoreDeviceMarkValues();
            } else {
                LOGE("%s: SSMActionObserver is NULL\n", __FUNCTION__);
            }
        } else {
            LOGD("%s, Verify ssm_data and ssmhandler is ok\n", __FUNCTION__);
        }
    }
}

bool SSMAction::Check(const char *settingDataPath, const char *whiteBalanceDataPath)
{
    //check file PATH
    mSSMDataFilePath = std::string(settingDataPath) + "/ssm_data";
    LOGD("%s: mSSMDataFilePath:%s\n", __FUNCTION__, mSSMDataFilePath.c_str());

    mSSMHandlerFilePath = std::string(settingDataPath) + "/SSMHandler";
    LOGD("%s: mSSMHandlerFilePath:%s\n", __FUNCTION__, mSSMHandlerFilePath.c_str());

    mWhiteBalanceFilePath = std::string(whiteBalanceDataPath) + "/cri_data";
    LOGD("%s: mWhiteBalanceFilePath:%s\n", __FUNCTION__, mWhiteBalanceFilePath.c_str());

    //check file exist or not
    bool ssm_data_FileExist    = isFileExist(mSSMDataFilePath.c_str());
    bool ssm_handler_FileExist = isFileExist(mSSMHandlerFilePath.c_str());
    bool cri_data_FileExist    = isFileExist(mWhiteBalanceFilePath.c_str());
    LOGD("%s, ssm_data_FileExist:%d ssm_handler_FileExist:%d cri_data_FileExist:%d\n",
        __FUNCTION__, ssm_data_FileExist, ssm_handler_FileExist, cri_data_FileExist);

    //open ssm file
    m_dev_fd = open(mSSMDataFilePath.c_str(), O_RDWR | O_SYNC);
    if (m_dev_fd < 0) {
        LOGE("%s, Open %s failed error: %s\n", __FUNCTION__, mSSMDataFilePath.c_str(), strerror(errno));
        return false;
    } else {
        LOGD("%s, Open %s success\n", __FUNCTION__, mSSMDataFilePath.c_str());
    }

    //open SSM handler
    mSSMHandler = SSMHandler::GetSingletonInstance(mSSMHandlerFilePath.c_str());
    if (mSSMHandler == NULL) {
        LOGE("%s, mSSMHandler is NULL\n", __FUNCTION__);
        return false;
    }

    if (!mSSMHandler->CheckHandler()) {
        LOGE("%s, Check fail\n", __FUNCTION__);
        return false;
    }

    //ssm check
    if (DeviceMarkCheck() < 0) {
        LOGD("%s, DeviceMarkCheck fail\n", __FUNCTION__);
        return false;
    }

    return true;
}

bool SSMAction::isFileExist(const char *file_name)
{
    struct stat tmp_st;
    int ret = -1;

    ret = stat(file_name, &tmp_st);
    if (ret != 0 ) {
       LOGE("%s, %s don't exist\n", __FUNCTION__, file_name);
       return false;
    } else {
       return true;
    }
}

//Mark r/w values
#define CC_DEF_CHARACTER_CHAR_VAL                   (0x8A)
static const int SSM_MARK_01_VALUE = 0x90;
static const int SSM_MARK_02_VALUE = 0xCE;
static const int SSM_MARK_03_VALUE = 0xDF;

int SSMAction::SaveBurnWriteCharaterChar(int rw_val)
{
    int value = rw_val;
    return SSMWriteNTypes(SSM_RSV_W_CHARACTER_CHAR_START, 1, &value, 0);
}

int SSMAction::ReadBurnWriteCharaterChar()
{
    int tmp_val = 0;

    if (SSMReadNTypes(SSM_RSV_W_CHARACTER_CHAR_START, 1, &tmp_val, 0) < 0) {
        return -1;
    }

    return tmp_val;
}

int SSMAction::DeviceMarkCheck()
{
    int i = 0, failed_count = 0;
    int mark_offset[3] = { 0, 0, 0 };
    unsigned char mark_values[3] = { 0, 0, 0 };
    int tmp_ch = 0;

    //read temp one byte
    SSMReadNTypes(0, 1, &tmp_ch, 0);

    mark_offset[0] = SSM_MARK_01_START;
    mark_offset[1] = SSM_MARK_02_START;
    mark_offset[2] = SSM_MARK_03_START;

    mark_values[0] = SSM_MARK_01_VALUE;
    mark_values[1] = SSM_MARK_02_VALUE;
    mark_values[2] = SSM_MARK_03_VALUE;

    if (ReadBurnWriteCharaterChar() != CC_DEF_CHARACTER_CHAR_VAL) {
        SaveBurnWriteCharaterChar(CC_DEF_CHARACTER_CHAR_VAL);
    }

    failed_count = 0;
    for (i = 0; i < 3; i++) {
        tmp_ch = 0;
        if (SSMReadNTypes(mark_offset[i], 1, &tmp_ch, 0) < 0) {
            LOGE("%s, Read Mark failed\n", __FUNCTION__);
            break;
        }

        if ((unsigned char)tmp_ch != mark_values[i]) {
            failed_count += 1;
            LOGE("%s, Mark[%d]'s offset = %d, Mark[%d]'s Value = %d, read value = %d\n",
                 __FUNCTION__, i, mark_offset[i], i, mark_values[i], tmp_ch);
        }
    }

    if (failed_count >= 3) {
        return -1;
    }

    return 0;
}

int SSMAction::RestoreDeviceMarkValues()
{
    int i;
    int mark_offset[3] = {
        (int) SSM_MARK_01_START,
        (int) SSM_MARK_02_START,
        (int) SSM_MARK_03_START,
    };

    int mark_values[3] = {SSM_MARK_01_VALUE, SSM_MARK_02_VALUE, SSM_MARK_03_VALUE};

    for (i = 0; i < 3; i++) {
        if (SSMWriteNTypes(mark_offset[i], 1, &mark_values[i], 0) < 0) {
            LOGD("SSMRestoreDeviceMarkValues Write Mark failed.\n");
            break;
        }
    }

    if (i < 3) {
        return -1;
    }

    return 0;
}

int SSMAction::WriteBytes(int offset, int size, int *buf)
{
    int wr_size;

    if (lseek(m_dev_fd, offset, SEEK_SET) == -1) {
        LOGE("%s seek faile\n", __FUNCTION__);
    }

    wr_size = write(m_dev_fd, buf, size);
    if (wr_size < 0) {
        LOGE("write error = %s\n", strerror(errno));
    }

    return 0;
}
int SSMAction::ReadBytes(int offset, int size, int *buf)
{
    int rd_size;

    if (lseek(m_dev_fd, offset, SEEK_SET) == -1) {
        LOGE("%s seek faile\n", __FUNCTION__);
    }

    rd_size = read(m_dev_fd, buf, size);
    if (rd_size < 0) {
        LOGE("read error = %s\n", strerror(errno));
    }

    return 0;
}
int SSMAction::EraseAllData()
{
    int ret;

    ret = ftruncate(m_dev_fd, 0);
    if (ret < 0) {
        LOGE("ftruncate error = %s\n", strerror(errno));
    }

    lseek(m_dev_fd, 0, SEEK_SET);

    return 0;
}

int SSMAction::GetSSMActualAddr(int id)
{
    return mSSMHandler->SSMGetActualAddr(id);
}

int SSMAction::GetSSMActualSize(int id)
{
    return mSSMHandler->SSMGetActualSize(id);
}

int SSMAction::GetSSMStatus(void)
{
    return (int)mSSMHandler->SSMVerify();
}

int SSMAction::SSMWriteNTypes(int id, int data_len, int *data_buf, int offset)
{
    //LOGD("%s: id = %d, len = %d, offset = %d\n", __FUNCTION__, id, data_len, offset);
    pthread_mutex_lock(&ssm_r_w_op_mutex);
    if (data_buf == NULL) {
        LOGE("data_buf is NULL.\n");
        pthread_mutex_unlock(&ssm_r_w_op_mutex);
        return -1;
    }

    if (0 == data_len) {
        pthread_mutex_unlock(&ssm_r_w_op_mutex);
        return -1;
    }

    unsigned int actualAddr = mSSMHandler->SSMGetActualAddr(id) + offset;
    //LOGD("%s: actualAddr = %u, data = %d.\n", __FUNCTION__, actualAddr, *data_buf);
    if (WriteBytes(actualAddr, data_len, data_buf) < 0) {
        LOGE("device WriteNBytes error.\n");
        pthread_mutex_unlock(&ssm_r_w_op_mutex);
        return -1;
    }
    pthread_mutex_unlock(&ssm_r_w_op_mutex);
    return 0;
}

int SSMAction::SSMReadNTypes(int id, int data_len, int *data_buf, int offset)
{
    //LOGD("%s: id = %d, len = %d, offset = %d\n", __FUNCTION__, id, data_len, offset);
    pthread_mutex_lock(&ssm_r_w_op_mutex);
    if (data_buf == NULL) {
        LOGE("data_buf is NULL.\n");
        pthread_mutex_unlock(&ssm_r_w_op_mutex);
        return -1;
    }

    if (0 == data_len) {
        pthread_mutex_unlock(&ssm_r_w_op_mutex);
        return -1;
    }

    unsigned int actualAddr = mSSMHandler->SSMGetActualAddr(id) + offset;
    if (ReadBytes(actualAddr, data_len, data_buf) < 0) {
        LOGE("device ReadNBytes error.\n");
        pthread_mutex_unlock(&ssm_r_w_op_mutex);
        return -1;
    }
    pthread_mutex_unlock(&ssm_r_w_op_mutex);

    //LOGD("%s: actualAddr = %u, data = %d.\n", __FUNCTION__, actualAddr, *data_buf);
    return 0;
}

bool SSMAction::SSMRecovery()
{
    bool ret = true;

    //erase ssm data
    EraseAllData();

    //recovery ssm data from db
    if (mpObserver != NULL) {
        mpObserver->resetAllUserSettingParam();
        ret = mSSMHandler->SSMRecreateHeader();
        RestoreDeviceMarkValues();
    } else {
        LOGE("%s: mpObserver is NULL\n", __FUNCTION__);
    }

    return ret;
}

int SSMAction::SSMRestoreDefault(int id, bool resetAll)
{
    int i = 0, tmp_val = 0;
    int offset_r = 0, offset_g = 0, offset_b = 0, gain_r = 1024, gain_g = 1024, gain_b = 1024;
    int8_t std_buf[6] = { 0, 0, 0, 0, 0, 0 };
    int8_t warm_buf[6] = { 0, 0, -8, 0, 0, 0 };
    int8_t cold_buf[6] = { -8, 0, 0, 0, 0, 0 };
    int lvdsssc_buf[3] = {0, 0, 0};

    if (resetAll || VPP_DATA_POS_RGB_GAIN_R_START == id)
        SSMSaveRGBGainRStart(0, gain_r);

    if (resetAll || VPP_DATA_POS_RGB_GAIN_G_START == id)
        SSMSaveRGBGainGStart(0, gain_g);

    if (resetAll || VPP_DATA_POS_RGB_GAIN_B_START == id)
        SSMSaveRGBGainBStart(0, gain_b);

    if (resetAll || VPP_DATA_POS_RGB_POST_OFFSET_R_START == id)
        SSMSaveRGBPostOffsetRStart(0, offset_r);

    if (resetAll || VPP_DATA_POS_RGB_POST_OFFSET_G_START== id)
        SSMSaveRGBPostOffsetGStart(0, offset_g);

    if (resetAll || VPP_DATA_POS_RGB_POST_OFFSET_B_START == id)
        SSMSaveRGBPostOffsetBStart(0, offset_b);

    if (resetAll || VPP_DATA_RGB_START == id) {
        for (i = 0; i < 6; i++) {
            SSMSaveRGBValueStart(i + VPP_COLOR_TEMPERATURE_MODE_STANDARD * 6, std_buf[i]); //0~5
            SSMSaveRGBValueStart(i + VPP_COLOR_TEMPERATURE_MODE_WARM * 6, warm_buf[i]); //6~11
            SSMSaveRGBValueStart(i + VPP_COLOR_TEMPERATURE_MODE_COLD * 6, cold_buf[i]); //12~17
        }
    }

    for (i = SOURCE_INVALID; i < SOURCE_MAX; i++) {//invalid souce setting also need clear when restore default
        if (resetAll || VPP_DATA_COLOR_SPACE_START == id) {
            if (i == SOURCE_TYPE_HDMI) {
                SSMSaveColorSpaceStart ( VPP_COLOR_SPACE_AUTO);
            }
        }

        tmp_val = 50;
        if (resetAll || VPP_DATA_POS_BRIGHTNESS_START == id)
            SSMSaveBrightness(i, tmp_val);

        if (resetAll || VPP_DATA_POS_CONTRAST_START == id)
            SSMSaveContrast(i, tmp_val);

        if (resetAll || VPP_DATA_POS_SATURATION_START == id)
            SSMSaveSaturation(i, tmp_val);

        if (resetAll || VPP_DATA_POS_HUE_START == id)
            SSMSaveHue(i, tmp_val);

        if (resetAll || VPP_DATA_POS_SHARPNESS_START == id)
            SSMSaveSharpness(i, tmp_val);

        tmp_val = VPP_PICTURE_MODE_STANDARD;
        if (resetAll || VPP_DATA_POS_PICTURE_MODE_START == id)
            SSMSavePictureMode(i, tmp_val);

        tmp_val = VPP_DISPLAY_MODE_169;
        if (resetAll || VPP_DATA_POS_DISPLAY_MODE_START == id)
            SSMSaveDisplayMode(i, tmp_val);

        tmp_val = VPP_NOISE_REDUCTION_MODE_AUTO;
        if (resetAll || VPP_DATA_POS_NOISE_REDUCTION_START == id)
            SSMSaveNoiseReduction(i, tmp_val);

        tmp_val = VPP_GAMMA_CURVE_DEFAULT;
        if (resetAll || VPP_DATA_GAMMA_VALUE_START == id)
            SSMSaveGammaValue(i, tmp_val);

        tmp_val = 1;
        if (resetAll || CUSTOMER_DATA_POS_AUTO_ASPECT == id)
            SSMSaveAutoAspect(i, tmp_val);

        tmp_val = 0;
        if (resetAll || CUSTOMER_DATA_POS_43_STRETCH == id)
            SSMSave43Stretch(i, tmp_val);

        tmp_val = DYNAMIC_CONTRAST_MID;
        if (resetAll || VPP_DATA_DNLP_MODE_START == id)
            SSMSaveDnlpMode(i, tmp_val);

        tmp_val = 0;
        if (resetAll || VPP_DATA_DNLP_GAIN_START == id)
            SSMSaveDnlpGainValue(i, tmp_val);
    }

    if (resetAll || VPP_DATA_POS_DDR_SSC_START == id)
        SSMSaveDDRSSC(0);

    if (resetAll || VPP_DATA_POS_LVDS_SSC_START == id)
        SSMSaveLVDSSSC(0, 12, lvdsssc_buf);

    if (resetAll || VPP_DATA_EYE_PROTECTION_MODE_START == id)
       SSMSaveEyeProtectionMode(0);

    return 0;
}

//PQ mode
int SSMAction::SSMSavePictureMode(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_PICTURE_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadPictureMode(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;

    ret = SSMReadNTypes(VPP_DATA_POS_PICTURE_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveLastPictureMode(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_LAST_PICTURE_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadLastPictureMode(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;

    ret = SSMReadNTypes(VPP_DATA_POS_LAST_PICTURE_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//Color Temperature
int SSMAction::SSMSaveColorTemperature(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_COLOR_TEMPERATURE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadColorTemperature(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_COLOR_TEMPERATURE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveColorDemoMode(unsigned char rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_POS_COLOR_DEMO_MODE_START, 1, &tmp_val);
}

int SSMAction::SSMReadColorDemoMode(unsigned char *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_COLOR_DEMO_MODE_START, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveColorBaseMode(unsigned char rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_POS_COLOR_BASE_MODE_START, 1, &tmp_val);
}

int SSMAction::SSMReadColorBaseMode(unsigned char *rw_val)
{
    int tmp_val = 0;
    int ret = 0;

    ret = SSMReadNTypes(VPP_DATA_POS_COLOR_BASE_MODE_START, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveColorGamutMode(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_COLORGAMUT_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadColorGamutMode(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_COLORGAMUT_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveRGBGainRStart(int offset, unsigned int rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_POS_RGB_GAIN_R_START, 4, &tmp_val, offset);
}

int SSMAction::SSMReadRGBGainRStart(int offset, unsigned int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;

    ret = SSMReadNTypes(VPP_DATA_POS_RGB_GAIN_R_START, 4, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveRGBGainGStart(int offset, unsigned int rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_POS_RGB_GAIN_G_START, 4, &tmp_val, offset);
}

int SSMAction::SSMReadRGBGainGStart(int offset, unsigned int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_RGB_GAIN_G_START, 4, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveRGBGainBStart(int offset, unsigned int rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_POS_RGB_GAIN_B_START, 4, &tmp_val, offset);
}

int SSMAction::SSMReadRGBGainBStart(int offset, unsigned int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_RGB_GAIN_B_START, 4, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveRGBPostOffsetRStart(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_RGB_POST_OFFSET_R_START, 4, &rw_val, offset);
}

int SSMAction::SSMReadRGBPostOffsetRStart(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_RGB_POST_OFFSET_R_START, 4, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveRGBPostOffsetGStart(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_RGB_POST_OFFSET_G_START, 4, &rw_val, offset);
}

int SSMAction::SSMReadRGBPostOffsetGStart(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_RGB_POST_OFFSET_G_START, 4, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveRGBPostOffsetBStart(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_RGB_POST_OFFSET_B_START, 4, &rw_val, offset);
}

int SSMAction::SSMReadRGBPostOffsetBStart(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_RGB_POST_OFFSET_B_START, 4, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMReadRGBOGOValue(int offset, int size, unsigned char data_buf[])
{
    int tmp_off = 0, val = 0, max = 0, ret = -1;

    val = offset + size;
    max = SSM_CR_RGBOGO_LEN + SSM_CR_RGBOGO_CHKSUM_LEN;
    if (val > max) {
        LOGE("Out of max_size!!!\n");
        return ret;
    }

    tmp_off = SSM_RGBOGO_FILE_OFFSET + offset;

    ret = ReadDataFromFile(mWhiteBalanceFilePath.c_str(), tmp_off, size, data_buf);

    return ret;
}

int SSMAction::SSMSaveRGBOGOValue(int offset, int size, unsigned char data_buf[])
{
    int tmp_off = 0, val = 0, max = 0, ret = -1;

    val = offset + size;
    max = SSM_CR_RGBOGO_LEN + SSM_CR_RGBOGO_CHKSUM_LEN;
    if (val > max) {
        LOGE("Out of max_size!!!\n");
        return ret;
    }

    tmp_off = SSM_RGBOGO_FILE_OFFSET + offset;

    ret = SaveDataToFile(mWhiteBalanceFilePath.c_str(), tmp_off, size, data_buf);

    return ret;
}

int SSMAction::SSMSaveRGBValueStart(int offset, int8_t rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_RGB_START, 1, &tmp_val, offset);
}

int SSMAction::SSMReadRGBValueStart(int offset, int8_t *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_RGB_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveColorSpaceStart(unsigned char rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_COLOR_SPACE_START, 1, &tmp_val);
}

int SSMAction::SSMReadColorSpaceStart(unsigned char *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_COLOR_SPACE_START, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::ReadDataFromFile(const char *file_name, int offset, int nsize, unsigned char data_buf[])
{
    int device_fd = -1;
    int ret = 0;
    int bytesRead = 0;

    if (data_buf == NULL) {
        LOGE("data_buf is NULL!!!\n");
        return -1;
    }

    if (file_name == NULL) {
        LOGE("%s is NULL!\n",file_name);
        return -1;
    }

    //device_fd = open(file_name, O_RDONLY);
    device_fd = open(file_name, O_RDWR | O_SYNC | O_CREAT, S_IRUSR | S_IWUSR);
    if (device_fd < 0) {
        LOGE("open file \"%s\" error(%s).\n", file_name, strerror(errno));
        return -1;
    }

    if ( lseek(device_fd, offset, SEEK_SET) < 0 ) {
        LOGE("lseek file \"%s\" error(%s).\n", file_name, strerror(errno));
        ret = -1;
    } else if ( (bytesRead = read(device_fd, data_buf, nsize)) <= 0 ) {
        //LOGE("read file \"%s\" bytesRead[%d] error(%s).\n", file_name, bytesRead, strerror(errno));
        ret = -1;
    }

    close(device_fd);
    device_fd = -1;

    return ret;
}

int SSMAction::SaveDataToFile(const char *file_name, int offset, int nsize, unsigned char data_buf[])
{
    int device_fd = -1;
    int wr_size;

    if (data_buf == NULL) {
        LOGE("%s, data_buf is NULL!!!\n", __FUNCTION__);
        return -1;
    }

    if (file_name == NULL) {
        LOGE("%s IS NULL!\n",file_name);
        return -1;
    }

    device_fd = open(file_name, O_RDWR | O_SYNC);
    if (device_fd < 0) {
        LOGE("open file \"%s\" error(%s).\n", file_name, strerror(errno));
        return -1;
    }

    if (lseek(device_fd, offset, SEEK_SET) < 0) {
        LOGE("lseek file \"%s\" error(%s).\n", file_name, strerror(errno));
        close(device_fd);
        return -1;
    }

    wr_size = write(device_fd, data_buf, nsize);
    if (wr_size < 0) {
        LOGE("write error = %s\n", strerror(errno));
    }

    fsync(device_fd);

    close(device_fd);
    device_fd = -1;

    return 0;
}


//Brightness
int SSMAction::SSMSaveBrightness(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_BRIGHTNESS_START, 1, &rw_val, offset);
}


int SSMAction::SSMReadBrightness(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_BRIGHTNESS_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}


//constract
int SSMAction::SSMSaveContrast(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_CONTRAST_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadContrast(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_CONTRAST_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//saturation
int SSMAction::SSMSaveSaturation(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_SATURATION_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadSaturation(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_SATURATION_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//hue
int SSMAction::SSMSaveHue(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_HUE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadHue(int offset, int *rw_val)
{
    int ret = 0;
    int tmp_val = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_HUE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//Sharpness
int SSMAction::SSMSaveSharpness(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_SHARPNESS_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadSharpness(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_SHARPNESS_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}


//NoiseReduction
int SSMAction::SSMSaveNoiseReduction(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_NOISE_REDUCTION_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadNoiseReduction(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_NOISE_REDUCTION_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//SmoothPlus
int SSMAction::SSMSaveSmoothPlus(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_SMOOTH_PLUS_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadSmoothPlus(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_SMOOTH_PLUS_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//Gamma
int SSMAction::SSMSaveGammaValue(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_GAMMA_VALUE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadGammaValue(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_GAMMA_VALUE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//EdgeEnhance
int SSMAction::SSMSaveEdgeEnhanceStatus(int offset, int rw_val)
{
    return SSMWriteNTypes(CUSTOMER_DATA_POS_EDGE_ENHANCER, 1, &rw_val, offset);
}



int SSMAction::SSMReadEdgeEnhanceStatus(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(CUSTOMER_DATA_POS_EDGE_ENHANCER, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//mpeg NR
int SSMAction::SSMSaveMpegNoiseReduction(int offset, int rw_val)
{
    return SSMWriteNTypes(CUSTOMER_DATA_POS_MPEG_NOISE_REDUCTION, 1, &rw_val, offset);
}

int SSMAction::SSMReadMpegNoiseReduction(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(CUSTOMER_DATA_POS_MPEG_NOISE_REDUCTION, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//Dynamic contrast
int SSMAction::SSMSaveDynamicContrast(int offset, int rw_val)
{
    return SSMWriteNTypes(CUSTOMER_DATA_POS_DYNAMIC_CONTRAST, 1, &rw_val, offset);
}

int SSMAction::SSMReadDynamicContrast(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(CUSTOMER_DATA_POS_DYNAMIC_CONTRAST, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

//Dynamic Backlight
int SSMAction::SSMSaveDynamicBacklightMode(int rw_val)
{
    return SSMWriteNTypes(CUSTOMER_DATA_POS_DYNAMIC_BACKLIGHT, 1, &rw_val);
}

int SSMAction::SSMReadDynamicBacklightMode(int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(CUSTOMER_DATA_POS_DYNAMIC_BACKLIGHT, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveDnlpMode(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_DNLP_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadDnlpMode(int offset, int *rw_val)
{
    int ret = 0;
    int tmp_val = 0;
    ret = SSMReadNTypes(VPP_DATA_DNLP_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveDnlpGainValue(int offset __unused, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_DNLP_GAIN_START, 1, &rw_val);
}

int SSMAction::SSMReadDnlpGainValue(int offset __unused, int *rw_val)

{
    int ret = 0;
    int tmp_val = 0;
    ret = SSMReadNTypes(VPP_DATA_DNLP_GAIN_START, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveEyeProtectionMode(int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_EYE_PROTECTION_MODE_START, 1, &rw_val);
}

int SSMAction::SSMReadEyeProtectionMode(int *rw_val)
{
    int ret = 0;
    int tmp_val = 0;
    ret = SSMReadNTypes(VPP_DATA_EYE_PROTECTION_MODE_START, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveDDRSSC(unsigned char rw_val)
{
    int tmp_val = rw_val;
    return SSMWriteNTypes(VPP_DATA_POS_DDR_SSC_START, 1, &tmp_val);
}

int SSMAction::SSMReadDDRSSC(unsigned char *rw_val)
{
    int tmp_val;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_DDR_SSC_START, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveLVDSSSC(int offset, int size, int *rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_LVDS_SSC_START, size, rw_val, offset);
}

int SSMAction::SSMReadLVDSSSC(int offset, int size, int *rw_val)
{
    return SSMReadNTypes(VPP_DATA_POS_LVDS_SSC_START, size, rw_val, offset);
}

int SSMAction::SSMSaveDisplayMode(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_DISPLAY_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadDisplayMode(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_DISPLAY_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMReadBackLightVal(int *rw_val)
{
    int tmp_ret = 0;
    int ret = 0;

    ret = SSMReadNTypes(VPP_DATA_POS_BACKLIGHT_START, 1, &tmp_ret);
    *rw_val = tmp_ret;

    return ret;
}

int SSMAction::SSMSaveBackLightVal(int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_BACKLIGHT_START, 1, &rw_val);
}

int SSMAction::SSMSaveAutoAspect(int offset, int rw_val) {
    return SSMWriteNTypes(CUSTOMER_DATA_POS_AUTO_ASPECT, 1, &rw_val, offset);
}

int SSMAction::SSMReadAutoAspect(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(CUSTOMER_DATA_POS_AUTO_ASPECT, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSave43Stretch(int offset, int rw_val) {
    return SSMWriteNTypes(CUSTOMER_DATA_POS_43_STRETCH, 1, &rw_val, offset);
}

int SSMAction::SSMRead43Stretch(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(CUSTOMER_DATA_POS_43_STRETCH, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMEdidRestoreDefault(int rw_val) {
    int ret = 0;
    ret |= SSMWriteNTypes(CUSTOMER_DATA_POS_HDMI1_EDID_START, 1, &rw_val);
    ret |= SSMWriteNTypes(CUSTOMER_DATA_POS_HDMI2_EDID_START, 1, &rw_val);
    ret |= SSMWriteNTypes(CUSTOMER_DATA_POS_HDMI3_EDID_START, 1, &rw_val);
    ret |= SSMWriteNTypes(CUSTOMER_DATA_POS_HDMI4_EDID_START, 1, &rw_val);
    return ret;
}

int SSMAction::SSMHdcpSwitcherRestoreDefault(int rw_val) {
    return SSMWriteNTypes(CUSTOMER_DATA_POS_HDMI_HDCP_SWITCHER_START, 1, &rw_val);
}

int SSMAction::SSMSColorRangeModeRestoreDefault(int rw_val) {
    return SSMWriteNTypes(CUSTOMER_DATA_POS_HDMI_COLOR_RANGE_START, 1, &rw_val);
}

int SSMAction::SSMSaveLocalContrastMode(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_LOCAL_CONTRAST_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadLocalContrastMode(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_LOCAL_CONTRAST_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveDeblockMode(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_DEBLOCK_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadDeblockMode(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_DEBLOCK_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveDemoSquitoMode(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_DEMOSQUITO_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadDemoSquitoMode(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_DEMOSQUITO_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveMcDiMode(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_MCDI_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadMcDiMode(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_MCDI_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMReadAipqEnableVal(int *rw_val)
{
    int tmp_ret = 0;
    int ret = 0;

    ret = SSMReadNTypes(VPP_DATA_POS_AIPQ_ENABLE_START, 1, &tmp_ret);
    *rw_val = tmp_ret;

    return ret;
}

int SSMAction::SSMSaveAipqEnableVal(int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_AIPQ_ENABLE_START, 1, &rw_val);
}

int SSMAction::SSMReadAiSrMode(int *rw_val)
{
    int tmp_ret = 0;
    int ret = 0;

    ret = SSMReadNTypes(VPP_DATA_POS_AISR_MODE_START, 1, &tmp_ret);
    *rw_val = tmp_ret;

    return ret;
}

int SSMAction::SSMSaveAiSrMode(int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_AISR_MODE_START, 1, &rw_val);
}

int SSMAction::SSMSaveHdrTmoVal(int offset, int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_HDR_TMO_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadHdrTmoVal(int offset, int *rw_val)
{
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_HDR_TMO_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveMemcMode(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_MEMC_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadMemcMode(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_MEMC_MODE_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveMemcDeblurLevel(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_MEMC_DEBLUR_LEVEL_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadMemcDeblurLevel(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_MEMC_DEBLUR_LEVEL_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveMemcDeJudderLevel(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_MEMC_DEJUDDER_LEVEL_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadMemcDeJudderLevel(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_MEMC_DEJUDDER_LEVEL_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveBlackStretch(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_BLACK_STRETCH_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadBlackStretch(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_BLACK_STRETCH_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveWhiteStretch(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_WHITE_STRETCH_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadWhiteStretch(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_WHITE_STRETCH_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveBlueStretch(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_BLUE_STRETCH_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadBlueStretch(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_BLUE_STRETCH_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveChromaCoring(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_CHROMA_CORING_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadChromaCoring(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_CHROMA_CORING_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

int SSMAction::SSMSaveLocalDimming(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_LOCAL_DIMMING_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadLocalDimming(int offset, int *rw_val) {
    int tmp_val = 0;
    int ret = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_LOCAL_DIMMING_START, 1, &tmp_val, offset);
    *rw_val = tmp_val;

    return ret;
}

bool SSMAction::SetPictureMode(int PictureMode, int src, int timming)
{
    PictureModeInfo Data;
    Data.PictureMode = PictureMode;

    int offset = (src * MAX_PQ_TIMMING_INDEX + timming) * sizeof(PictureModeInfo);
    Data.Flag = offset + sizeof(int);

    if (SSMWriteNTypes(VPP_DATA_POS_PQ_MODE_START, sizeof(PictureModeInfo), (int *)&Data, offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetPictureMode(int *PictureMode, int src, int timming)
{
    PictureModeInfo Data;
    int offset = (src * MAX_PQ_TIMMING_INDEX + timming) * sizeof(PictureModeInfo);
    int offset_flag = offset + sizeof(int);

    if (SSMReadNTypes(VPP_DATA_POS_PQ_MODE_START, sizeof(PictureModeInfo), (int *)&Data, offset) < 0) {
        return false;
    }

    if (Data.Flag != offset_flag) {
        return false;
    }

    *PictureMode = Data.PictureMode;

    return true;
}

bool SSMAction::SetLastPictureMode(int PictureMode, int src, int timming)
{
    PictureModeInfo Data;
    Data.PictureMode = PictureMode;

    int offset = (src * MAX_PQ_TIMMING_INDEX + timming) * sizeof(PictureModeInfo);
    Data.Flag = offset + sizeof(int);

    if (SSMWriteNTypes(VPP_DATA_POS_LAST_PQ_MODE_START, sizeof(PictureModeInfo), (int *)&Data, offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetLastPictureMode(int *PictureMode, int src, int timming)
{
    PictureModeInfo Data;
    int offset = (src * MAX_PQ_TIMMING_INDEX + timming) * sizeof(PictureModeInfo);
    int offset_flag = offset + sizeof(int);

    if (SSMReadNTypes(VPP_DATA_POS_LAST_PQ_MODE_START, sizeof(PictureModeInfo), (int *)&Data, offset) < 0) {
        return false;
    }

    if (Data.Flag != offset_flag) {
        return false;
    }

    *PictureMode = Data.PictureMode;

    return true;
}

bool SSMAction::SetPictureModeData(vpp_pictur_mode_para_t *pData, int src, int timming, int pqmode)
{
    if (MAX_PICTUREMODE_PARAM_SIZE < (sizeof(vpp_pictur_mode_para_t) + sizeof(int))) {
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_PICTUREMODE_INDEX + timming * MAX_PICTUREMODE_INDEX + pqmode) * MAX_PICTUREMODE_PARAM_SIZE;
    int flag_offset = offset + sizeof(vpp_pictur_mode_para_t);

    if (SSMWriteNTypes(VPP_DATA_POS_PICTURE_MODE_PARAM_START, sizeof(vpp_pictur_mode_para_t), (int *)pData, offset) < 0) {
        return false;
    }

    if (SSMWriteNTypes(VPP_DATA_POS_PICTURE_MODE_PARAM_START, sizeof(int), (int *)&flag_offset, flag_offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetPictureModeData(vpp_pictur_mode_para_t *pData, int src, int timming, int pqmode)
{
    if (MAX_PICTUREMODE_PARAM_SIZE < (sizeof(vpp_pictur_mode_para_t) + sizeof(int))) {
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_PICTUREMODE_INDEX + timming * MAX_PICTUREMODE_INDEX + pqmode) * MAX_PICTUREMODE_PARAM_SIZE;
    int flag_offset = offset + sizeof(vpp_pictur_mode_para_t);

    int Flag = 0;
    if (SSMReadNTypes(VPP_DATA_POS_PICTURE_MODE_PARAM_START, sizeof(int), (int *)&Flag, flag_offset) < 0) {
        return false;
    }

    if (Flag != flag_offset) {
        return false;
    }

    if (SSMReadNTypes(VPP_DATA_POS_PICTURE_MODE_PARAM_START, sizeof(vpp_pictur_mode_para_t), (int *)pData, offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::SetColorTemperatureData(tcon_rgb_ogo_t *pData, int src, int timming, int level)
{
    if (MAX_COLORTEMP_PARAM_SIZE < (sizeof(tcon_rgb_ogo_t) + sizeof(int))) {
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_COLORTEMP_INDEX + timming * MAX_COLORTEMP_INDEX + level) * MAX_COLORTEMP_PARAM_SIZE;
    int flag_offset = offset + sizeof(tcon_rgb_ogo_t);

    if (SSMWriteNTypes(VPP_DATA_POS_COLOR_TEMP_PARAM_START, sizeof(tcon_rgb_ogo_t), (int *)pData, offset) < 0) {
        return false;
    }

    if (SSMWriteNTypes(VPP_DATA_POS_COLOR_TEMP_PARAM_START, sizeof(int), (int *)&flag_offset, flag_offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetColorTemperatureData(tcon_rgb_ogo_t *pData, int src, int timming, int level)
{
    if (MAX_COLORTEMP_PARAM_SIZE < (sizeof(tcon_rgb_ogo_t) + sizeof(int))) {
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_COLORTEMP_INDEX + timming * MAX_COLORTEMP_INDEX + level) * MAX_COLORTEMP_PARAM_SIZE;
    int flag_offset = offset + sizeof(tcon_rgb_ogo_t);

    int Flag = 0;
    if (SSMReadNTypes(VPP_DATA_POS_COLOR_TEMP_PARAM_START, sizeof(int), (int *)&Flag, flag_offset) < 0) {
        return false;
    }

    if (Flag != flag_offset) {
        return false;
    }

    if (SSMReadNTypes(VPP_DATA_POS_COLOR_TEMP_PARAM_START, sizeof(tcon_rgb_ogo_t), (int *)pData, offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::SetWhitebalanceGammaData(WB_GAMMA_TABLE *pData, int src, int timming, int level, int mode)
{
    if (MAX_WB_GAMMA_PARAM_SIZE < (sizeof(WB_GAMMA_TABLE) + sizeof(int))) {
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX +
                timming * MAX_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX + level * WB_GAMMA_MODE_MAX + mode) * MAX_WB_GAMMA_PARAM_SIZE;
    int flag_offset = offset + sizeof(WB_GAMMA_TABLE);

    if (SSMWriteNTypes(VPP_DATA_POS_WB_GAMMA_PARAM_START, sizeof(WB_GAMMA_TABLE), (int *)pData, offset) < 0) {
        return false;
    }

    if (SSMWriteNTypes(VPP_DATA_POS_WB_GAMMA_PARAM_START, sizeof(int), (int *)&flag_offset, flag_offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetWhitebalanceGammaData(WB_GAMMA_TABLE *pData, int src, int timming, int level, int mode)
{
    if (MAX_WB_GAMMA_PARAM_SIZE < (sizeof(WB_GAMMA_TABLE) + sizeof(int))) {
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX +
                timming * MAX_COLORTEMP_INDEX * WB_GAMMA_MODE_MAX + level * WB_GAMMA_MODE_MAX + mode) * MAX_WB_GAMMA_PARAM_SIZE;
    int flag_offset = offset + sizeof(WB_GAMMA_TABLE);

    int Flag = 0;
    if (SSMReadNTypes(VPP_DATA_POS_WB_GAMMA_PARAM_START, sizeof(int), (int *)&Flag, flag_offset) < 0) {
        return false;
    }

    if (Flag != flag_offset) {
        return false;
    }

    if (SSMReadNTypes(VPP_DATA_POS_WB_GAMMA_PARAM_START, sizeof(WB_GAMMA_TABLE), (int *)pData, offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::SetColorCustomizeData(TABLE_CMS *pData, int mode, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    if (MAX_COLORCUSTOMIZE_CM_PARAM_SIZE < (sizeof(TABLE_CMS) + sizeof(int))) {
        LOGE("%s, size out of range!!!\n", __FUNCTION__);
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_PICTUREMODE_INDEX +
                 timming * MAX_PICTUREMODE_INDEX + mode) * MAX_COLORCUSTOMIZE_CM_PARAM_SIZE;
    int flag_offset = offset + sizeof(TABLE_CMS);

    if (SSMWriteNTypes(VPP_DATA_POS_COLORCUSTOMIZE_CM_START, sizeof(TABLE_CMS), (int *)pData, offset) < 0) {
        return false;
    }

    if (SSMWriteNTypes(VPP_DATA_POS_COLORCUSTOMIZE_CM_START, sizeof(int), (int *)&flag_offset, flag_offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetColorCustomizeData(TABLE_CMS *pData, int mode, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    if (MAX_COLORCUSTOMIZE_CM_PARAM_SIZE < (sizeof(TABLE_CMS) + sizeof(int))) {
        LOGE("%s, size out of range!!!\n", __FUNCTION__);
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_PICTUREMODE_INDEX +
                 timming * MAX_PICTUREMODE_INDEX + mode) * MAX_COLORCUSTOMIZE_CM_PARAM_SIZE;
    int flag_offset = offset + sizeof(TABLE_CMS);

    int Flag = 0;
    if (SSMReadNTypes(VPP_DATA_POS_COLORCUSTOMIZE_CM_START, sizeof(int), (int *)&Flag, flag_offset) < 0) {
        return false;
    }

    if (Flag != flag_offset) {
        return false;
    }

    if (SSMReadNTypes(VPP_DATA_POS_COLORCUSTOMIZE_CM_START, sizeof(TABLE_CMS), (int *)pData, offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::SetColorCustomizeDataBy3DLut(TABLE_CMS_3DLUT *pData, int mode, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    if (MAX_COLORCUSTOMIZE_3DLUT_PARAM_SIZE < (sizeof(TABLE_CMS_3DLUT) + sizeof(int))) {
        LOGE("%s, size out of range!!!\n", __FUNCTION__);
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_PICTUREMODE_INDEX +
                 timming * MAX_PICTUREMODE_INDEX + mode) * MAX_COLORCUSTOMIZE_3DLUT_PARAM_SIZE;
    int flag_offset = offset + sizeof(TABLE_CMS_3DLUT);

    if (SSMWriteNTypes(VPP_DATA_POS_COLORCUSTOMIZE_3DLUT_START, sizeof(TABLE_CMS_3DLUT), (int *)pData, offset) < 0) {
        return false;
    }

    if (SSMWriteNTypes(VPP_DATA_POS_COLORCUSTOMIZE_3DLUT_START, sizeof(int), (int *)&flag_offset, flag_offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetColorCustomizeDataBy3DLut(TABLE_CMS_3DLUT *pData, int mode, int src, int timming)
{
    if (pData == NULL) {
        return false;
    }

    if (MAX_COLORCUSTOMIZE_3DLUT_PARAM_SIZE < (sizeof(TABLE_CMS_3DLUT) + sizeof(int))) {
        LOGE("%s, size out of range!!!\n", __FUNCTION__);
        return false;
    }

    int offset = (src * MAX_PQ_TIMMING_INDEX * MAX_PICTUREMODE_INDEX +
                 timming * MAX_PICTUREMODE_INDEX + mode) * MAX_COLORCUSTOMIZE_3DLUT_PARAM_SIZE;
    int flag_offset = offset + sizeof(TABLE_CMS_3DLUT);

    int Flag = 0;
    if (SSMReadNTypes(VPP_DATA_POS_COLORCUSTOMIZE_3DLUT_START, sizeof(int), (int *)&Flag, flag_offset) < 0) {
        return false;
    }

    if (Flag != flag_offset) {
        return false;
    }

    if (SSMReadNTypes(VPP_DATA_POS_COLORCUSTOMIZE_3DLUT_START, sizeof(TABLE_CMS_3DLUT), (int *)pData, offset) < 0) {
        return false;
    }

    return true;
}

int SSMAction::SSMSaveWhitebalanceGammaMode(int offset, int rw_val) {
    return SSMWriteNTypes(VPP_DATA_POS_WB_GAMMA_MODE_START, 1, &rw_val, offset);
}

int SSMAction::SSMReadWhitebalanceGammaMode(int offset, int *rw_val) {
    return SSMReadNTypes(VPP_DATA_POS_WB_GAMMA_MODE_START, 1, rw_val, offset);
}

int SSMAction::SSMSaveFilmMakerMode(int rw_val)
{
    return SSMWriteNTypes(VPP_DATA_POS_FMM_MODE_START, 1, &rw_val);
}

int SSMAction::SSMReadFilmMakerMode(int *rw_val)
{
    int ret = 0;
    int tmp_val = 0;
    ret = SSMReadNTypes(VPP_DATA_POS_FMM_MODE_START, 1, &tmp_val);
    *rw_val = tmp_val;

    return ret;
}

bool SSMAction::CheckTable(void)
{
    vpp_pictur_mode_para_t Picture;
    if (!GetPictureModeData(&Picture, 0, 0, 0)) {
        return false;
    }

    tcon_rgb_ogo_t ColorTemp;
    if (!GetColorTemperatureData(&ColorTemp, 0, 0, 0)) {
        return false;
    }

    WB_GAMMA_TABLE GammaOffset;
    if (!GetWhitebalanceGammaData(&GammaOffset, 0, 0, 0, 0)) {
        return false;
    }

    TABLE_CMS cms;
    if (!GetColorCustomizeData(&cms, 0, 0, 0)) {
        return false;
    }

    TABLE_CMS_3DLUT cms3dlut;
    if (!GetColorCustomizeDataBy3DLut(&cms3dlut, 0, 0, 0)) {
        return false;
    }

    return true;
}

bool SSMAction::CriDataGetWhitebalanceRGBGainOffsetData(tcon_rgb_ogo_t *pData, int level)
{
    USUC usuc;
    USUC ret;

    usuc.c[0] = 0x55;
    usuc.c[1] = 0xAA;

    int tmp_off =  (SSM_RGBOGO_FILE_OFFSET + (CRI_DATE_RGBOGO_LEN * level));
    int Label_offset = tmp_off + CRI_DATE_RGBOGO_LEN - 2;

    if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), Label_offset, 2, ret.c) < 0) {
        return false;
    }

    if ((usuc.c[0] != ret.c[0]) || (usuc.c[1] != ret.c[1])) {
        return false;
    }

    if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), tmp_off, sizeof(tcon_rgb_ogo_t), (unsigned char *)pData) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::CriDataSetWhitebalanceRGBGainOffsetData(tcon_rgb_ogo_t *pData, int level)
{
    USUC ret;
    ret.c[0] = 0x55;
    ret.c[1] = 0xAA;

    int tmp_off =  (SSM_RGBOGO_FILE_OFFSET + (CRI_DATE_RGBOGO_LEN * level));
    int Label_offset = tmp_off + CRI_DATE_RGBOGO_LEN - 2;

    if (SaveDataToFile(mWhiteBalanceFilePath.c_str(), tmp_off, sizeof(tcon_rgb_ogo_t), (unsigned char *)pData) < 0) {
        return false;
    }

    if (SaveDataToFile(mWhiteBalanceFilePath.c_str(), Label_offset, 2, ret.c) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::CriDataGetWhitebalanceGammaData(WB_GAMMA_TABLE_DATA *pData, int level, int mode)
{
    USUC usuc;
    USUC ret;

    usuc.c[0] = 0x55;
    usuc.c[1] = 0xAA;

    int tmp_off =  CRI_DATA_WB_GAMMA_OFFSET + (CRI_DATE_WB_GAMMA_LEN * (level * WB_GAMMA_MODE_MAX + mode));
    int Label_offset = tmp_off + CRI_DATE_WB_GAMMA_LEN - 2;

    if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), Label_offset, 2, ret.c) < 0) {
        return false;
    }

    if ((usuc.c[0] != ret.c[0]) || (usuc.c[1] != ret.c[1])) {
        return false;
    }

    if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), tmp_off, sizeof(WB_GAMMA_TABLE_DATA), (unsigned char *)pData) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::CriDataSetWhitebalanceGammaData(WB_GAMMA_TABLE_DATA *pData, int level, int mode)
{
    USUC ret;
    ret.c[0] = 0x55;
    ret.c[1] = 0xAA;

    int tmp_off =  CRI_DATA_WB_GAMMA_OFFSET + (CRI_DATE_WB_GAMMA_LEN * (level * WB_GAMMA_MODE_MAX + mode));
    int Label_offset = tmp_off + CRI_DATE_WB_GAMMA_LEN - 2;

    if (SaveDataToFile(mWhiteBalanceFilePath.c_str(), tmp_off, sizeof(WB_GAMMA_TABLE_DATA), (unsigned char *)pData) < 0) {
        return false;
    }

    if (SaveDataToFile(mWhiteBalanceFilePath.c_str(), Label_offset, 2, ret.c) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::SetGammaDataTable(tcon_gamma_table_t *pData, int level, int channel)
{
    if (pData == NULL)
        return false;

    int offset =  CRI_DATA_GAMMA_OFFSET + ((level * MAX_CH + channel) * CRI_DATE_GAMMA_LEN);
    int flag_offset = offset + CRI_DATE_GAMMA_LEN - sizeof(int);

    if (SaveDataToFile(mWhiteBalanceFilePath.c_str(), offset, sizeof(tcon_gamma_table_t), (unsigned char *)pData) < 0) {
        return false;
    }

    if (SaveDataToFile(mWhiteBalanceFilePath.c_str(), flag_offset, sizeof(int), (unsigned char *)&flag_offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetGammaDataTable(tcon_gamma_table_t *pData, int level, int channel)
{
    if (pData == NULL)
        return false;

    int offset =  CRI_DATA_GAMMA_OFFSET + ((level * MAX_CH + channel) * CRI_DATE_GAMMA_LEN);
    int flag_offset = offset + CRI_DATE_GAMMA_LEN - sizeof(int);

    int Flag = 0;
    if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), flag_offset, sizeof(int), (unsigned char *)&Flag) < 0) {
        return false;
    }

    if (Flag != flag_offset) {
        return false;
    }

    if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), offset, sizeof(tcon_gamma_table_t), (unsigned char *)pData) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::ClearGammaDataTable(int level, int channel)
{
    int offset =  CRI_DATA_GAMMA_OFFSET + ((level * MAX_CH + channel) * CRI_DATE_GAMMA_LEN);
    int flag_offset = offset + CRI_DATE_GAMMA_LEN - sizeof(int);

    int Flag = 0;
    if (SaveDataToFile(mWhiteBalanceFilePath.c_str(), flag_offset, sizeof(int), (unsigned char *)&Flag) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetSsmDataParam(void *pData, int id, int iSize, int offset, bool FlagCheck)
{
    if (pData == NULL) {
        return false;
    }

    if (FlagCheck) {
        int Flag = 0;
        int FlagOffset = offset + iSize;
        if (SSMReadNTypes(id, sizeof(int), (int *)&Flag, FlagOffset) < 0) {
            return false;
        }
        if ((Flag != FlagOffset) && (Flag != 1)) {
            return false;
        }
    }

    if (SSMReadNTypes(id, iSize, (int *)pData, offset) < 0) {
        return false;
    }

    return true;
}

bool SSMAction::GetCriDataParam(void *pData, int iSize, int offset, bool FlagCheck, int Flagoffset, int FlagSize)
{
    if (pData == NULL) {
        return false;
    }

    if (FlagCheck) {
        if (FlagSize == sizeof(unsigned short)) {
            USUC usuc;
            USUC ret;
            usuc.c[0] = 0x55;
            usuc.c[1] = 0xAA;
            if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), Flagoffset, FlagSize, ret.c) < 0) {
                return false;
            }
            if ((usuc.c[0] != ret.c[0]) || (usuc.c[1] != ret.c[1])) {
                return false;
            }
        } else if (FlagSize == sizeof(int)) {
            int Flag = 0;
            if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), Flagoffset, FlagSize, (unsigned char *)&Flag) < 0) {
                return false;
            }
            if (Flag != Flagoffset) {
                return false;
            }
        } else {
            LOGE("%s, FlagSize out of range!!!\n", __FUNCTION__);
            return false;
        }
    }

    if (ReadDataFromFile(mWhiteBalanceFilePath.c_str(), offset, iSize, (unsigned char *)pData) < 0) {
        return false;
    }

    return true;
}