/*
 * Copyright (c) 2019 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:
 */
#define LOG_MODULE_TAG "PQ"
#define LOG_CLASS_TAG "PqService"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sstream>

#include "PqService.h"
#include "PQType.h"
#include "CPQLog.h"
#include "CPQControl.h"
#include "pqcmd.h"

#ifdef __cplusplus
extern "C" {
#endif

PqService *mInstance = NULL;
PqService *PqService::GetInstance() {
    if (mInstance == NULL) {
        mInstance = new PqService();
    }

    return mInstance;
}

PqService::PqService() {
    init_pq_logging();
    mpPQcontrol = CPQControl::GetInstance();
    mpPQcontrol->CPQControlInit();
    mpPQcontrol->setObserver(this);
}

PqService::~PqService() {
    if (mpPQcontrol != NULL) {
        mpPQcontrol->CPQControlUnInit();
        delete mpPQcontrol;
        mpPQcontrol = NULL;
    }
}

int PqService::PqServiceHandleMessage()
{
    while (1) {
        usleep(500*1000);
    }
    return 0;
}

int PqService::SplitCommand(const char *commandData, std::vector<std::string> &result)
{
  int split_cnt = 0;
  std::istringstream iss(commandData);
  std::string sub;
  while (std::getline(iss, sub, '.')) {
    result.push_back(sub);
    split_cnt++;
  }

  return split_cnt;
}

int PqService::SetCmd(pq_module_param_t param)
{
    int ret = 0;
    int moduleId = param.moduleId;

    if (((moduleId >= PQ_MODULE_CMD_START) && (moduleId <= PQ_MODULE_CMD_MAX))
        || ((moduleId >= PQ_FACTORY_CMD_START) || (moduleId <= PQ_FACTORY_CMD_MAX))) {
        int paramData[32] = {0};
        int i = 0;
        source_input_param_t param;
        tvin_cutwin_t overscan;
        tcon_rgb_ogo_t tcon_rgbogo;
        pq_module_demo_aisr_axis_t axis;
        memset(&param, 0, sizeof(source_input_param_t));
        memset(&overscan, 0, sizeof(tvin_cutwin_t));
        memset(&tcon_rgbogo, 0, sizeof(tcon_rgb_ogo_t));
        memset(&axis, 0, sizeof(pq_module_demo_aisr_axis_t));

        for (i = 0; i < param.paramLength; i++) {
            paramData[i] = param.paramBuf[i];
        }

        switch (moduleId) {
        case PQ_SET_PICTURE_MODE:
            ret = mpPQcontrol->SetPQMode(paramData[0], paramData[1]);
            if (paramData[1] == 1) {
                ret |= mpPQcontrol->SaveLastPQMode(paramData[0]);
            }
            break;
        case PQ_SET_COLOR_TEMPERATURE_MODE:
            ret = mpPQcontrol->SetColorTemperature(paramData[0], paramData[1]);
            break;
        case PQ_SET_BRIGHTNESS:
            ret = mpPQcontrol->SetBrightness(paramData[0], paramData[1]);
            break;
        case PQ_SET_CONTRAST:
            ret = mpPQcontrol->SetContrast(paramData[0], paramData[1]);
            break;
        case PQ_SET_SATURATION:
            ret = mpPQcontrol->SetSaturation(paramData[0], paramData[1]);
            break;
        case PQ_SET_HUE:
            ret = mpPQcontrol->SetHue(paramData[0], paramData[1]);
            break;
        case PQ_SET_SHARPNESS:
            ret = mpPQcontrol->SetSharpness(paramData[0], paramData[1]);
            break;
        case PQ_SET_NOISE_REDUCTION_MODE:
            ret = mpPQcontrol->SetNoiseReductionMode(paramData[0], paramData[1]);
            break;
        case PQ_SET_EYE_PROTECTION_MODE:
            ret = mpPQcontrol->SetEyeProtectionMode((tv_source_input_t)paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_SET_GAMMA:
            ret = mpPQcontrol->SetGammaValue((vpp_gamma_curve_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_DISPLAY_MODE:
            ret = mpPQcontrol->SetDisplayMode((vpp_display_mode_t)paramData[1], paramData[2]);
            break;
        case PQ_SAVE_DISPLAY_MODE:
            ret = mpPQcontrol->SaveDisplayModeBySrc(paramData[0], paramData[1]);
            break;
        case PQ_SET_BACKLIGHT:
            ret = mpPQcontrol->SetBacklight(paramData[0], paramData[1]);
            break;
        case PQ_SET_DYNAMICBACKLIGHT:
            ret = mpPQcontrol->SetDynamicBacklight((Dynamic_backlight_status_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_LOCALCONTRAST:
            ret = mpPQcontrol->SetLocalContrastMode((local_contrast_mode_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_CM:
            ret = mpPQcontrol->SetColorBaseMode((vpp_color_basemode_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_SOURCE_CHANNEL:
            ret = mpPQcontrol->SetCurrentSource((tv_source_input_t)paramData[0]);
            break;
        case PQ_SET_COLORGAMUT:
            ret = mpPQcontrol->SetColorGamutMode(paramData[0], paramData[1]);
            break;
        case PQ_SET_DYNAMICCONTRAST:
            ret = mpPQcontrol->SetDnlpMode((Dynamic_contrast_mode_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_RECOVERYPQ:
            ret = mpPQcontrol->SSMRecovery();
            break;
        case PQ_SET_MEMCMODE:
            ret = mpPQcontrol->SetMemcMode(paramData[0], paramData[1]);
            break;
        case PQ_SET_MEMC_DEBLUR:
            ret = mpPQcontrol->SetMemcDeBlurLevel(paramData[0], paramData[1]);
            break;
        case PQ_SET_MEMC_DEJUDDER:
            ret = mpPQcontrol->SetMemcDeJudderLevel(paramData[0], paramData[1]);
            break;
        case PQ_SET_DECONTOUR:
            ret = mpPQcontrol->SetSmoothPlusMode(paramData[0], paramData[1]);
            break;
        case PQ_SET_DEBLOCK:
            ret = mpPQcontrol->SetDeblockMode((vpp_deblock_mode_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_DEMOSQUITO:
            ret = mpPQcontrol->SetDemoSquitoMode((vpp_demosquito_mode_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_BLACKSTRETCH:
            ret = mpPQcontrol->SetBlackStretch(paramData[0], paramData[1]);
            break;
        case PQ_SET_WHITESTRETCH:
            ret = mpPQcontrol->SetWhiteStretch(paramData[0], paramData[1]);
            break;
        case PQ_SET_BLUESTRETCH:
            ret = mpPQcontrol->SetBlueStretch(paramData[0], paramData[1]);
            break;
        case PQ_SET_AIPQ:
            ret = mpPQcontrol->SetAipqEnable(paramData[0]);
            break;
        case PQ_SET_AISR:
            ret = mpPQcontrol->SetAiSrMode((aisr_mode_e)paramData[0], paramData[1]);
            break;
        case PQ_SET_LDIM:
            ret = mpPQcontrol->SetLocalDimming(paramData[0], paramData[1]);
            break;
        case PQ_SET_MPEGNR:
            ret = mpPQcontrol->SetMpegNr((vpp_pq_level_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_PICTURE_UI_CLEAR:
            mpPQcontrol->ResetPictureUiSetting();
            break;
        case PQ_SET_COLOR_CUSTOMIZE:
            ret = mpPQcontrol->SetColorCustomize((vpp_cms_color_t)paramData[0], (vpp_cms_type_t)paramData[1], paramData[2], paramData[3]);
            if (paramData[0] == VPP_COLOR_9_YELLOW)
                mpPQcontrol->SetColorCustomize(VPP_COLOR_9_YELLOW_GREEN, (vpp_cms_type_t)paramData[1], paramData[2], paramData[3]);
            else if (paramData[0] == VPP_COLOR_9_CYAN)
                mpPQcontrol->SetColorCustomize(VPP_COLOR_9_BLUE_GREEN, (vpp_cms_type_t)paramData[1], paramData[2], paramData[3]);
            break;
        case PQ_SET_COLOR_CUSTOMIZE_3DLUT:
            ret = mpPQcontrol->SetColorCustomizeBy3DLut((vpp_cms_6color_t)paramData[0], (vpp_cms_type_t)paramData[1], paramData[2], paramData[3]);
            break;
        case PQ_RESET_COLOR_CUSTOMIZE:
            ret = mpPQcontrol->ResetColorCustomize((vpp_cms_method_t)paramData[0]);
            break;
        case PQ_SET_WB_GAMMA_DATA:
            ret = mpPQcontrol->SetWhitebalanceGamma(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_SET_SUPERRESOLUTION:
            ret = mpPQcontrol->SetSuperResolution(paramData[0], paramData[1]);
            break;
        case PQ_SET_COLOR_CUSTOMIZE_ENABLE:
            ret = mpPQcontrol->SetColorCustomizeEnable(paramData[0]);
            break;
        case PQ_SET_WB_GAMMA_ENABLE:
            ret = mpPQcontrol->SetWbGammaEnable(paramData[0]);
            break;
        case PQ_SET_WB_GAMMA_MODE:
            ret = mpPQcontrol->SetWbGammaMode(paramData[0]);
            break;
        case PQ_SET_HDR_TONE_MAPPING_MODE:
            ret = mpPQcontrol->SetHdrToneMappingMode((hdr_tmo_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_FILM_MAKER_MODE:
            ret = mpPQcontrol->SetFilmMakerMode((pq_film_maker_mode_t)paramData[0], paramData[1]);
            break;
        case PQ_SET_LOAD_PQ:
            ret = mpPQcontrol->LoadPQSettings();
        case PQ_SET_DEMO_STATE:
            ret = mpPQcontrol->SetPQModuleDemoState((pq_module_demo_t)paramData[0], (pq_module_demo_state_t)paramData[1]);
            break;
        case PQ_SET_AISR_DEMO_WIN:
            ret = mpPQcontrol->SetPQModuleDemoAisrWin((pq_module_demo_aisr_win_t)paramData[0]);
            break;
        case PQ_SET_AISR_DEMO_AXIS:
            axis.xstart = paramData[0];
            axis.ystart = paramData[1];
            axis.xend = paramData[2];
            axis.yend = paramData[3];
            ret = mpPQcontrol->SetPQModuleDemoAisrAxis(axis);
            break;

        //Factory cmd
        case PQ_FACTORY_RESET_PICTURE_MODE:
            ret = mpPQcontrol->FactoryResetPQMode();
            break;
        case PQ_FACTORY_RESET_COLOR_TEMPERATURE_MODE:
            ret = mpPQcontrol->FactoryResetColorTemp();
            break;
        case PQ_FACTORY_SET_COLOR_TEMPERATURE_MODE:
            ret = mpPQcontrol->SetColorTemperature(paramData[0], paramData[1]);
            break;
        case PQ_FACTORY_SET_BRIGHTNESS:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactorySetPQMode_Brightness(param, paramData[3], paramData[4]);
            break;
        case PQ_FACTORY_SET_CONTRAST:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactorySetPQMode_Contrast(param, paramData[3], paramData[4]);
            break;
        case PQ_FACTORY_SET_SATURATION:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactorySetPQMode_Saturation(param, paramData[3], paramData[4]);
            break;
        case PQ_FACTORY_SET_HUE:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactorySetPQMode_Hue(param, paramData[3], paramData[4]);
            break;
        case PQ_FACTORY_SET_SHARPNESS:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactorySetPQMode_Sharpness(param, paramData[3], paramData[4]);
            break;
        case PQ_FACTORY_SET_OVERSCAN:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];

            overscan.hs = (unsigned short)paramData[4];
            overscan.he = (unsigned short)paramData[5];
            overscan.vs = (unsigned short)paramData[6];
            overscan.ve = (unsigned short)paramData[7];

            ret = mpPQcontrol->FactorySetOverscanParams(param, (vpp_display_mode_t)paramData[3], overscan);
            break;
        case PQ_FACTORY_SET_WB_RED_GAIN:
            ret = mpPQcontrol->FactorySetWhiteBalanceRedGain(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_FACTORY_SET_WB_GREEN_GAIN:
            ret = mpPQcontrol->FactorySetWhiteBalanceGreenGain(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_FACTORY_SET_WB_BLUE_GAIN:
            ret = mpPQcontrol->FactorySetWhiteBalanceBlueGain(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_FACTORY_SET_WB_RED_OFFSET:
            ret = mpPQcontrol->FactorySetWhiteBalanceRedPostOffset(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_FACTORY_SET_WB_GREEN_OFFSET:
            ret = mpPQcontrol->FactorySetWhiteBalanceGreenPostOffset(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_FACTORY_SET_WB_BLUE_OFFSET:
            ret = mpPQcontrol->FactorySetWhiteBalanceBluePostOffset(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_FACTORY_SET_RGB_PATTERN:
            ret = mpPQcontrol->FactorySetRGBPattern(paramData[0], paramData[1], paramData[2]);
            break;
        case PQ_FACTORY_SET_GRAY_PATTERN:
            ret = mpPQcontrol->FactorySetGrayPattern(paramData[0]);
            break;
        case PQ_FACTORY_SET_NOLINE_PARAMS: {
            noline_params_t noline_params;
            int type;
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            type = (int)paramData[3];
            noline_params.osd0 = (int)paramData[4];
            noline_params.osd25 = (int)paramData[5];
            noline_params.osd50 = (int)paramData[6];
            noline_params.osd75 = (int)paramData[7];
            noline_params.osd100 = (int)paramData[8];
            ret = mpPQcontrol->FactorySetNolineParams(param, type, noline_params);
        }
            break;
        case PQ_FACTORY_SET_COLOR_PARAMS:
            tcon_rgbogo.en = paramData[1];
            tcon_rgbogo.r_pre_offset = paramData[2];
            tcon_rgbogo.g_pre_offset = paramData[3];
            tcon_rgbogo.b_pre_offset = paramData[4];
            tcon_rgbogo.r_gain = paramData[5];
            tcon_rgbogo.g_gain = paramData[6];
            tcon_rgbogo.b_gain = paramData[7];
            tcon_rgbogo.r_post_offset = paramData[8];
            tcon_rgbogo.g_post_offset = paramData[9];
            tcon_rgbogo.b_post_offset = paramData[10];
            ret = mpPQcontrol->FactorySetRGBGainOffset((vpp_color_temperature_mode_t)paramData[0], tcon_rgbogo);
            break;
        case PQ_FACTORY_SET_DEC_LUMA_PARAMS:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactorySetDecodeLumaParams(param, paramData[3], paramData[4]);
            break;
        case PQ_FACTORY_SET_Sharpness_Params:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactorySetSharpnessParams(param, (sharpness_timing_t)paramData[3], paramData[4], paramData[5]);
            break;

        case PQ_FACTORY_SET_PQ_ENABLE:
            ret = mpPQcontrol->FactorySetPQEn(paramData[0], paramData[1]);
            break;

        case PQ_FACTORY_SET_WB_GAMMA_DATA:
            ret = mpPQcontrol->FactorySetWhitebalanceGamma(paramData[0], paramData[1], paramData[2], paramData[3]);
            break;

        case PQ_FACTORY_SET_PICTURE_MODE:
            ret = mpPQcontrol->FactorySetPictureMode(paramData[0], paramData[1], paramData[2]);
            break;

        default:
            break;
        }
    } else {
        LOGE("%s: invalid PQ cmd: %d\n", __FUNCTION__, moduleId);
        ret = -1;
    }

    return ret;
}

void PqService::GetCmd(pq_module_param_t param, char *retbuf)
{
    int ret = 0;
    int moduleId = param.moduleId;

    if (((moduleId >= PQ_MODULE_CMD_START) && (moduleId <= PQ_MODULE_CMD_MAX))
        || ((moduleId >= PQ_FACTORY_CMD_START) || (moduleId <= PQ_FACTORY_CMD_MAX))) {
        int paramData[32] = {0};
        int i = 0;
        int mode = 0;
        source_input_param_t param;
        tvin_cutwin_t overscan;
        tvpq_rgb_ogo_t rgbogo;
        tcon_rgb_ogo_t tcon_rgbogo;
        vpp_single_color_param_cm_t cms_cm;
        vpp_single_color_param_3dlut_t cms_3dlut;
        tvpq_databaseinfo_t ver_info;
        pq_module_demo_aisr_axis_t axis;
        vdin_sig_info_t vdin_sig_info;
        memset(&param, 0, sizeof(source_input_param_t));
        memset(&overscan, 0, sizeof(tvin_cutwin_t));
        memset(&rgbogo, 0, sizeof(tvpq_rgb_ogo_t));
        memset(&tcon_rgbogo, 0, sizeof(tcon_rgb_ogo_t));
        memset(&cms_cm, 0, sizeof(vpp_single_color_param_cm_t));
        memset(&cms_3dlut, 0, sizeof(vpp_single_color_param_3dlut_t));
        memset(&ver_info, 0, sizeof(tvpq_databaseinfo_t));
        memset(&axis, 0, sizeof(pq_module_demo_aisr_axis_t));
        memset(&vdin_sig_info, 0, sizeof(vdin_sig_info_t));

        for (i = 0; i < param.paramLength; i++) {
            paramData[i] = param.paramBuf[i];
        }

        switch (moduleId) {
        case PQ_GET_PICTURE_MODE:
            ret = mpPQcontrol->GetPQMode();
            break;
        case PQ_GET_LAST_PICTURE_MODE:
            ret = mpPQcontrol->GetLastPQMode();
            break;
        case PQ_GET_COLOR_TEMPERATURE_MODE:
            ret = mpPQcontrol->GetColorTemperature();
            break;
        case PQ_GET_BRIGHTNESS:
            ret = mpPQcontrol->GetBrightness();
            break;
        case PQ_GET_CONTRAST:
            ret = mpPQcontrol->GetContrast();
            break;
        case PQ_GET_SATURATION:
            ret = mpPQcontrol->GetSaturation();
            break;
        case PQ_GET_HUE:
            ret = mpPQcontrol->GetHue();
            break;
        case PQ_GET_SHARPNESS:
            ret = mpPQcontrol->GetSharpness();
            break;
        case PQ_GET_NOISE_REDUCTION_MODE:
            ret = mpPQcontrol->GetNoiseReductionMode();
            break;
        case PQ_GET_EYE_PROTECTION_MODE:
            ret = mpPQcontrol->GetEyeProtectionMode((tv_source_input_t)paramData[0]);
            break;
        case PQ_GET_GAMMA:
            ret = mpPQcontrol->GetGammaValue();
            break;
        case PQ_GET_DISPLAY_MODE:
            ret = mpPQcontrol->GetDisplayMode();
            break;
        case PQ_GET_BACKLIGHT:
            ret = mpPQcontrol->GetBacklight();
            break;
        case PQ_GET_DYNAMICBACKLIGHT:
            ret = mpPQcontrol->GetDynamicBacklight();
            break;
        case PQ_GET_LOCALCONTRAST:
            ret = mpPQcontrol->GetLocalContrastMode();
            break;
        case PQ_GET_CM:
            ret = mpPQcontrol->GetColorBaseMode();
            break;
        case PQ_GET_SOURCE_CHANNEL:
            param = mpPQcontrol->GetCurrentSourceInputInfo();
            sprintf(retbuf, "%d.%d.%d", param.source_input, param.sig_fmt, param.trans_fmt);
            break;
        case PQ_GET_COLORGAMUT:
            ret = mpPQcontrol->GetColorGamutMode();
            break;
        case PQ_GET_SOURCE_HDR_TYPE:
            ret = mpPQcontrol->GetSourceHDRType();
            break;
        case PQ_GET_DYNAMICCONTRAST:
            ret = mpPQcontrol->GetDnlpMode();
            break;
        case PQ_GET_MEMCMODE:
            ret = mpPQcontrol->GetMemcMode();
            break;
        case PQ_GET_MEMC_DEBLUR:
            ret = mpPQcontrol->GetMemcDeBlurLevel();
            break;
        case PQ_GET_MEMC_DEJUDDER:
            ret = mpPQcontrol->GetMemcDeJudderLevel();
            break;
        case PQ_GET_DECONTOUR:
            ret = mpPQcontrol->GetSmoothPlusMode();
            break;
        case PQ_GET_DEBLOCK:
            ret = mpPQcontrol->GetDeBlockMode();
            break;
        case PQ_GET_DEMOSQUITO:
            ret = mpPQcontrol->GetDemoSquitoMode();
            break;
        case PQ_GET_BLACKSTRETCH:
            ret = mpPQcontrol->GetBlackStretch();
            break;
        case PQ_GET_WHITESTRETCH:
            ret = mpPQcontrol->GetWhiteStretch();
            break;
        case PQ_GET_BLUESTRETCH:
            ret = mpPQcontrol->GetBlueStretch();
            break;
        case PQ_GET_AIPQ:
            ret = mpPQcontrol->GetAipqEnable();
            break;
        case PQ_GET_AISR:
            ret = mpPQcontrol->GetAiSrMode();
            break;
        case PQ_GET_AISR_MODE_RANGE:
            ret = mpPQcontrol->GetAiSrModeRange();
            break;
        case PQ_GET_LDIM:
            ret = mpPQcontrol->GetLocalDimming();
            break;
        case PQ_GET_MPEGNR:
            ret = mpPQcontrol->GetMpegNr();
            break;
        case PQ_GET_COLORTEMP_USER_PARAM:
            mode = mpPQcontrol->GetColorTemperature();
            rgbogo = mpPQcontrol->GetColorTempParams(mode);
            sprintf(retbuf, "%d.%d.%d.%d.%d.%d.%d.%d.%d.%d", rgbogo.en, rgbogo.r_pre_offset, rgbogo.g_pre_offset, rgbogo.b_pre_offset,
                    rgbogo.r_gain, rgbogo.g_gain, rgbogo.b_gain, rgbogo.r_post_offset, rgbogo.g_post_offset, rgbogo.b_post_offset);
            break;
        case PQ_GET_COLOR_CUSTOMIZE:
            cms_cm = mpPQcontrol->GetColorCustomize((vpp_cms_color_t)paramData[0]);
            sprintf(retbuf, "%d.%d.%d", cms_cm.sat, cms_cm.hue, cms_cm.luma);
            break;
        case PQ_GET_COLOR_CUSTOMIZE_3DLUT:
            cms_3dlut = mpPQcontrol->GetColorCustomizeBy3DLut((vpp_cms_6color_t)paramData[0]);
            sprintf(retbuf, "%d.%d.%d", cms_3dlut.red, cms_3dlut.green, cms_3dlut.blue);
            break;
        case PQ_GET_WB_GAMMA_DATA:
            ret = mpPQcontrol->GetWhitebalanceGamma(paramData[0], paramData[1]);
            break;
        case PQ_GET_SUPERRESOLUTION:
            ret = mpPQcontrol->GetSuperResolution();
            break;
        case PQ_GET_COLOR_CUSTOMIZE_ENABLE:
            ret = mpPQcontrol->GetColorCustomizeEnable();
            break;
        case PQ_GET_DB_VERSION_INFO:
            ver_info = mpPQcontrol->GetDbVersionInfo((db_name_t)paramData[0], (db_version_type_t)paramData[1]);
            sprintf(retbuf, "%s", ver_info.version);
            break;
        case PQ_GET_WB_GAMMA_ENABLE:
            ret = mpPQcontrol->GetWbGammaEnable();
            break;
        case PQ_GET_WB_GAMMA_MODE:
            ret = mpPQcontrol->GetWbGammaMode();
            break;
        case PQ_GET_HDR_TONE_MAPPING_MODE:
            ret = mpPQcontrol->GetHdrToneMappingMode();
            break;
        case PQ_GET_FILM_MAKER_MODE:
            ret = mpPQcontrol->GetFilmMakerMode();
            break;
        case PQ_GET_PQ_CASE_FUNC:
            ret = mpPQcontrol->HasPqCaseFunc((pq_case_func_e)paramData[0]);
            break;
        case PQ_GET_DEMO_STATE:
            ret = mpPQcontrol->GetPQModuleDemoState(paramData[0]);
            break;
        case PQ_GET_AISR_DEMO_WIN:
            ret = mpPQcontrol->GetPQModuleDemoAisrWin();
            break;
        case PQ_GET_AISR_DEMO_AXIS:
            axis = mpPQcontrol->GetPQModuleDemoAisrAxis();
            sprintf(retbuf, "%d.%d.%d.%d", axis.xstart, axis.ystart, axis.xend, axis.yend);
            break;
        case PQ_GET_VDIN_SIG_INFO:
            vdin_sig_info = mpPQcontrol->GetVdinSigInfo();
            sprintf(retbuf, "%d.%d.%d.%d.%d", vdin_sig_info.fps,
                vdin_sig_info.allm_mode, vdin_sig_info.it_content,
                vdin_sig_info.cn_type, vdin_sig_info.vrr_mode);
            break;

        //Factory cmd
        case PQ_FACTORY_GET_COLOR_TEMPERATURE_MODE:
            ret = mpPQcontrol->GetColorTemperature();
            break;
        case PQ_FACTORY_GET_BRIGHTNESS:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactoryGetPQMode_Brightness(param, paramData[3]);
            break;
        case PQ_FACTORY_GET_CONTRAST:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactoryGetPQMode_Contrast(param, paramData[3]);
            break;

        case PQ_FACTORY_GET_SATURATION:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactoryGetPQMode_Saturation(param, paramData[3]);
            break;
        case PQ_FACTORY_GET_HUE:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactoryGetPQMode_Hue(param, paramData[3]);
            break;
        case PQ_FACTORY_GET_SHARPNESS:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactoryGetPQMode_Sharpness(param, paramData[3]);
            break;
        case PQ_FACTORY_GET_OVERSCAN:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            overscan = mpPQcontrol->FactoryGetOverscanParams(param, (vpp_display_mode_t)paramData[3]);
            sprintf(retbuf, "%d.%d.%d.%d", overscan.hs, overscan.he, overscan.vs, overscan.ve);
            break;
        case PQ_FACTORY_GET_WB_RED_GAIN:
            ret = mpPQcontrol->FactoryGetWhiteBalanceRedGain(paramData[0], paramData[1]);
            break;
        case PQ_FACTORY_GET_WB_GREEN_GAIN:
            ret = mpPQcontrol->FactoryGetWhiteBalanceGreenGain(paramData[0], paramData[1]);
            break;
        case PQ_FACTORY_GET_WB_BLUE_GAIN:
            ret = mpPQcontrol->FactoryGetWhiteBalanceBlueGain(paramData[0], paramData[1]);
            break;
        case PQ_FACTORY_GET_WB_RED_OFFSET:
            ret = mpPQcontrol->FactoryGetWhiteBalanceRedPostOffset(paramData[0], paramData[1]);
            break;
        case PQ_FACTORY_GET_WB_GREEN_OFFSET:
            ret = mpPQcontrol->FactoryGetWhiteBalanceGreenPostOffset(paramData[0], paramData[1]);
            break;
        case PQ_FACTORY_GET_WB_BLUE_OFFSET:
            ret = mpPQcontrol->FactoryGetWhiteBalanceBluePostOffset(paramData[0], paramData[1]);
            break;
        case PQ_FACTORY_GET_RGB_PATTERN:
            ret = mpPQcontrol->FactoryGetRGBPattern();
            break;
        case PQ_FACTORY_GET_GRAY_PATTERN:
            ret = mpPQcontrol->FactoryGetGrayPattern();
            break;
        case PQ_FACTORY_GET_NOLINE_PARAMS: {
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            int type = (enum tvin_trans_fmt)paramData[3];
            noline_params_t noline_params = mpPQcontrol->FactoryGetNolineParams(param, type);
            sprintf(retbuf, "%d.%d.%d.%d.%d",
                    noline_params.osd0,
                    noline_params.osd25,
                    noline_params.osd50,
                    noline_params.osd75,
                    noline_params.osd100);
            return;
        }
        case PQ_FACTORY_GET_COLOR_PARAMS:
            ret = mpPQcontrol->FactoryGetRGBGainOffset((vpp_color_temperature_mode_t)paramData[0], &tcon_rgbogo);

            sprintf(retbuf, "%d.%d.%d.%d.%d.%d.%d.%d.%d.%d", ret, tcon_rgbogo.r_pre_offset, tcon_rgbogo.g_pre_offset,
                tcon_rgbogo.b_pre_offset, tcon_rgbogo.r_gain, tcon_rgbogo.g_gain, tcon_rgbogo.b_gain, tcon_rgbogo.r_post_offset,
                tcon_rgbogo.g_post_offset, tcon_rgbogo.b_post_offset);
            return;
        case PQ_FACTORY_GET_DEC_LUMA_PARAMS:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactoryGetDecodeLumaParams(param, paramData[3]);
            break;
        case PQ_FACTORY_GET_Sharpness_Params:
            param.source_input = (tv_source_input_t)paramData[0];
            param.sig_fmt      = (enum tvin_sig_fmt_e)paramData[1];
            param.trans_fmt    = (enum tvin_trans_fmt)paramData[2];
            ret = mpPQcontrol->FactoryGetSharpnessParams(param,(sharpness_timing_t)paramData[3],paramData[4]);
            break;
        case PQ_FACTORY_GET_PQ_ENABLE:
            ret = mpPQcontrol->FactoryGetPQEn(paramData[0]);
            break;

        case PQ_FACTORY_GET_WB_GAMMA_DATA:
            ret = mpPQcontrol->FactoryGetWhitebalanceGamma(paramData[0], paramData[1], paramData[2]);
            break;

        case PQ_FACTORY_GET_PICTURE_MODE:
            ret = mpPQcontrol->FactoryGetPictureMode(paramData[0], paramData[1]);
            break;

        default:
            break;
        }
    } else {
        LOGE("%s: invalid PQ cmd: %d!\n", __FUNCTION__, moduleId);
        ret = -1;
    }

    if ((moduleId != PQ_GET_SOURCE_CHANNEL)
        && (moduleId != PQ_FACTORY_GET_OVERSCAN)
        && (moduleId != PQ_GET_COLORTEMP_USER_PARAM)
        && (moduleId != PQ_GET_COLOR_CUSTOMIZE)
        && (moduleId != PQ_GET_COLOR_CUSTOMIZE_3DLUT)
        && (moduleId != PQ_GET_DB_VERSION_INFO)
        && (moduleId != PQ_GET_VDIN_SIG_INFO)) {
        sprintf(retbuf, "%d", ret);
    }

    return;
}

void PqService::ParserPqCommand(const char *commandData, char *retbuf)
{
    LOGD("%s: cmd data is %s\n", __FUNCTION__, commandData);

    int  cmd_size = 0;
    int  ret      = 0;
    int  i        = 0;

    //split command
    std::vector<std::string> result;
    cmd_size = SplitCommand(commandData, result);

    //parse command
    pq_module_param_t pqParam;
    memset(&pqParam, 0, sizeof(pq_module_param_t));
    pqParam.moduleId = atoi(result.at(2).c_str());
    pqParam.paramLength = cmd_size - 3;

    for (i = 0; i < pqParam.paramLength; i++)
    {
        pqParam.paramBuf[i] = atoi(result.at(i + 3).c_str());
    }

    if ((strcmp(result.at(0).c_str(), "pq") == 0) || (strcmp(result.at(0).c_str(), "pqFactory") == 0)) {
        if (strcmp(result.at(1).c_str(), "set") == 0) {
            ret = SetCmd(pqParam);
            sprintf(retbuf, "%d", ret);
        } else if (strcmp(result.at(1).c_str(), "get") == 0) {
            GetCmd(pqParam, retbuf);
        } else {
            LOGD("%s: invalid cmd\n", __FUNCTION__);
            ret = 0;
            sprintf(retbuf, "%d", ret);
        }
    } else {
        LOGD("%s: invalie cmdType\n", __FUNCTION__);
    }

    //LOGD("%s: retbuf %s\n", __FUNCTION__, retbuf);
}

status_t PqService::onTransact(uint32_t code,
                                const Parcel& data, Parcel* reply,
                                uint32_t flags) {
    //LOGD("%s: code is %u\n", __FUNCTION__, code);

    switch (code) {
        case CMD_PQ_ACTION: {
            const char* command = data.readCString();
            char retbuf[128] = {0};
            ParserPqCommand(command, retbuf);
            reply->writeCString(retbuf);
            break;
        }
        case CMD_PQ_SET_DDR_SSC: {
            int step = data.readInt32();
            reply->writeInt32(mpPQcontrol->FactorySetDDRSSC(step));
            break;
        }
        case CMD_PQ_GET_DDR_SSC: {
            reply->writeInt32(mpPQcontrol->FactoryGetDDRSSC());
            break;
        }
        case CMD_PQ_SET_LVDS_SSC_LEVEL: {
            int level = data.readInt32();
            reply->writeInt32(mpPQcontrol->FactorySetLVDSSSCLevel(level));
            break;
        }
        case CMD_PQ_GET_LVDS_SSC_LEVEL: {
            reply->writeInt32(mpPQcontrol->FactoryGetLVDSSSCLevel());
            break;
        }
        case CMD_PQ_SET_LVDS_SSC_FREP: {
            int step = data.readInt32();
            reply->writeInt32(mpPQcontrol->FactorySetLVDSSSCFrep(step));
            break;
        }
        case CMD_PQ_GET_LVDS_SSC_FREP: {
            reply->writeInt32(mpPQcontrol->FactoryGetLVDSSSCFrep());
            break;
        }
        case CMD_PQ_SET_LVDS_SSC_MODE: {
            int mode = data.readInt32();
            reply->writeInt32(mpPQcontrol->FactorySetLVDSSSCMode(mode));
            break;
        }
        case CMD_PQ_GET_LVDS_SSC_MODE: {
            reply->writeInt32(mpPQcontrol->FactoryGetLVDSSSCMode());
            break;
        }
        case CMD_SET_PQ_CB: {
            int pqServiceCallBackID = SetClientProxyToServer(data.readStrongBinder());
            reply->writeInt32(pqServiceCallBackID);
            LOGD("%s %s pqServiceCallBackID %d\n", __FUNCTION__, "CMD_SET_PQ_CB", pqServiceCallBackID);
            break;
        }
        case CMD_CLR_PQ_CB: {
            RemovePqServiceCallBack(data.readInt32());
            LOGD("%s %s pqServiceCallBackID %d\n", __FUNCTION__, "CMD_CLR_PQ_CB", data.readInt32());
            break;
        }
        case CMD_PQ_SET_COLORTEMPERATURE_USER_PARAM: {
            int ret = -1;
            tcon_rgb_ogo_t Params;
            memset(&Params, 0, sizeof(tcon_rgb_ogo_t));

            Params.en = data.readInt32();

            Params.r_gain = data.readInt32();
            Params.g_gain = data.readInt32();
            Params.b_gain = data.readInt32();

            Params.r_post_offset = data.readInt32();
            Params.g_post_offset = data.readInt32();
            Params.b_post_offset = data.readInt32();

            Params.r_pre_offset = data.readInt32();
            Params.g_pre_offset = data.readInt32();
            Params.b_pre_offset = data.readInt32();

            ret = mpPQcontrol->SetColorTempParams(mpPQcontrol->GetColorTemperature(),&Params);
            reply->writeInt32(ret);
            break;
        }
        case CMD_PQ_GET_COLORTEMPERATURE_USER_PARAM: {
            tvpq_rgb_ogo_t pData;
            memset(&pData, 0, sizeof(tvpq_rgb_ogo_t));
            pData = mpPQcontrol->GetColorTemperatureUserParam(mpPQcontrol->GetColorTemperature());

            reply->writeInt32(pData.en);

            reply->writeInt32(pData.r_gain);
            reply->writeInt32(pData.g_gain);
            reply->writeInt32(pData.b_gain);

            reply->writeInt32(pData.r_post_offset);
            reply->writeInt32(pData.g_post_offset);
            reply->writeInt32(pData.b_post_offset);

            reply->writeInt32(pData.r_pre_offset);
            reply->writeInt32(pData.g_post_offset);
            reply->writeInt32(pData.b_post_offset);
            break;
        }
        case CMD_PQ_RESET_PICTURE_MODE: {
            int ret = -1;
            ret = mpPQcontrol->FactoryResetPictureModeData();
            reply->writeInt32(ret);
            break;
        }
        case CMD_PQ_RESET_ALL_PICTURE_MODE: {
            int ret = -1;
            ret = mpPQcontrol->FactoryResetAllPictureModeData();
            reply->writeInt32(ret);
            break;
        }
        case CMD_PQ_GET_PICTURE_MODE_PARAM: {
            int ret = -1;
            int mode = data.readInt32();
            pq_mode_parameters pData;
            memset(&pData, 0, sizeof(pq_mode_parameters));
            ret = mpPQcontrol->FactoryGetPictureModeData(mode, &pData);
            reply->writeInt32(pData.backlight);
            reply->writeInt32(pData.brightness);
            reply->writeInt32(pData.contrast);
            reply->writeInt32(pData.saturation);
            reply->writeInt32(pData.sharpness);
            reply->writeInt32(pData.gamma);
            reply->writeInt32(pData.dynamic_backlight);
            reply->writeInt32(pData.local_contrast);
            reply->writeInt32(pData.dynamic_contrast);
            reply->writeInt32(pData.super_resolution);
            reply->writeInt32(pData.color_temperature);
            reply->writeInt32(pData.hue);
            reply->writeInt32(pData.eye_protection);
            reply->writeInt32(pData.hdr_tone_mapping);
            reply->writeInt32(pData.color_gamut);
            reply->writeInt32(pData.display_mode);
            reply->writeInt32(pData.noise_reduction);
            reply->writeInt32(pData.MPEG_noise_reduction);
            reply->writeInt32(pData.smooth_plus);

            reply->writeInt32(ret);
            break;
        }
        case CMD_PQ_GET_DEFAULT_PICTURE_MODE_PARAM: {
            int ret = -1;
            int mode = data.readInt32();
            pq_mode_parameters pData;
            memset(&pData, 0, sizeof(pq_mode_parameters));
            ret = mpPQcontrol->FactoryGetDefaultPictureModeData(mode, &pData);
            reply->writeInt32(pData.backlight);
            reply->writeInt32(pData.brightness);
            reply->writeInt32(pData.contrast);
            reply->writeInt32(pData.saturation);
            reply->writeInt32(pData.sharpness);
            reply->writeInt32(pData.gamma);
            reply->writeInt32(pData.dynamic_backlight);
            reply->writeInt32(pData.local_contrast);
            reply->writeInt32(pData.dynamic_contrast);
            reply->writeInt32(pData.super_resolution);
            reply->writeInt32(pData.color_temperature);
            reply->writeInt32(pData.hue);
            reply->writeInt32(pData.eye_protection);
            reply->writeInt32(pData.hdr_tone_mapping);
            reply->writeInt32(pData.color_gamut);
            reply->writeInt32(pData.display_mode);
            reply->writeInt32(pData.noise_reduction);
            reply->writeInt32(pData.MPEG_noise_reduction);
            reply->writeInt32(pData.smooth_plus);

            reply->writeInt32(ret);
            break;
        }
        case CMD_PQ_GET_DEFAULT_ALL_PQ_PARAM: {
            int ret = -1;
            all_pq_parameters pData;
            memset(&pData, 0, sizeof(all_pq_parameters));
            ret = mpPQcontrol->FactoryGetDefaultAllPQData(&pData);
            reply->writeInt32(pData.PictureModeData.backlight);
            reply->writeInt32(pData.PictureModeData.brightness);
            reply->writeInt32(pData.PictureModeData.contrast);
            reply->writeInt32(pData.PictureModeData.saturation);
            reply->writeInt32(pData.PictureModeData.sharpness);
            reply->writeInt32(pData.PictureModeData.gamma);
            reply->writeInt32(pData.PictureModeData.dynamic_backlight);
            reply->writeInt32(pData.PictureModeData.local_contrast);
            reply->writeInt32(pData.PictureModeData.dynamic_contrast);
            reply->writeInt32(pData.PictureModeData.super_resolution);
            reply->writeInt32(pData.PictureModeData.color_temperature);
            reply->writeInt32(pData.PictureModeData.hue);
            reply->writeInt32(pData.PictureModeData.eye_protection);
            reply->writeInt32(pData.PictureModeData.hdr_tone_mapping);
            reply->writeInt32(pData.PictureModeData.color_gamut);
            reply->writeInt32(pData.PictureModeData.display_mode);
            reply->writeInt32(pData.PictureModeData.noise_reduction);
            reply->writeInt32(pData.PictureModeData.MPEG_noise_reduction);
            reply->writeInt32(pData.PictureModeData.smooth_plus);

            for (int i = 0; i < MAX_WB_GAMMA_POINT; i++) {
                reply->writeInt32(pData.WBGammaData.R_OFFSET[i]);
                reply->writeInt32(pData.WBGammaData.G_OFFSET[i]);
                reply->writeInt32(pData.WBGammaData.B_OFFSET[i]);
            }

            for (int j = 0; j < VPP_COLOR_9_MAX; j++) {
                reply->writeInt32(pData.color_tune.data[j].sat);
                reply->writeInt32(pData.color_tune.data[j].hue);
                reply->writeInt32(pData.color_tune.data[j].luma);
            }

            reply->writeInt32(ret);
            break;
        }
        case CMD_PQ_COPY_VALUES_FROM_PICTURE_MODE: {
            int ret = -1;
            int PictureMode = data.readInt32();
            ret = mpPQcontrol->FactoryCopyPictureModeDataFromPQMode(PictureMode);
            reply->writeInt32(ret);
            break;
        }
        case CMD_PQ_COPY_PICTURE_MODE_PARAM_TO_ALL_SOURCE: {
            int ret = -1;
            ret = mpPQcontrol->FactoryCopyPictureModeDataToAllSource();
            reply->writeInt32(ret);
            break;
        }

        case CMD_PQ_SET_GAMMA_TABLE: {
            int ret = -1;
            int level = data.readInt32();
            int type  = data.readInt32();
            int len   = data.readInt32();
            unsigned int gamma[257];
            for (int i = 0; i < len; i++) {
                gamma[i] = data.readInt32();
            }
            ret = mpPQcontrol->FactorySetGammaTable(gamma, type, level, len);
            reply->writeInt32(ret);
            break;
        }

        case CMD_PQ_GET_GAMMA_TABLE: {
            int ret = -1;
            int level = data.readInt32();
            int type  = data.readInt32();
            int len   = data.readInt32();
            unsigned int gamma[257];
            ret = mpPQcontrol->FactoryGetGammaTable(gamma, type, level, len);
            reply->writeInt32(ret);
            if (ret == 0) {
                for (int i = 0; i < len; i++) {
                    reply->writeInt32(gamma[i]);
                }
            }

            break;
        }

        case CMD_PQ_CLEAR_GAMMA_TABLE: {
            int ret = -1;
            ret = mpPQcontrol->FactoryClearGammaTable();
            reply->writeInt32(ret);
            break;
        }

        case PQ_SET_PQ_BYPASS_LEVEL: {
            int ret = -1;
            int level = data.readInt32();
            ret = mpPQcontrol->SetPQByPassLevel(level);
            reply->writeInt32(ret);
            break;
        }

        case PQ_SET_GAMMA_PATTERN: {
            int ret = -1;
            int enable = data.readInt32();
            int R      = data.readInt32();
            int G      = data.readInt32();
            int B      = data.readInt32();
            ret = mpPQcontrol->SetGammaPattern(enable, R, G, B);
            reply->writeInt32(ret);
            break;
        }

        default:
            return BBinder::onTransact(code, data, reply, flags);
    }

    return (0);
}

//for callback to upper client
int PqService::SetClientProxyToServer(sp<IBinder> callBack)
{
    LOGD("%s the main process pid %d\n", __FUNCTION__, getpid());
    int ret = -1;

    if (callBack != nullptr) {
        LOGD("%s callBack is %p\n", __FUNCTION__, callBack);
        int cookie = -1;
        int clientSize = mPqServiceCallBack.size();
        LOGD("%s clientSize is %d\n", __FUNCTION__, clientSize);

        for (int i = 0; i < clientSize; i++) {
            if (mPqServiceCallBack[i] == NULL) {
                cookie = i;
                mPqServiceCallBack[i] = callBack;
                LOGD("%s mPqServiceCallBack[%d] %p\n", __FUNCTION__, i, mPqServiceCallBack[i]);
                break;
            } else {
                LOGD("%s mPqServiceCallBack[%d] has been register\n", __FUNCTION__, i);
            }
        }

        if (cookie < 0) {
            cookie = clientSize;
            mPqServiceCallBack[clientSize] = callBack;
            LOGD("%s mPqServiceCallBack[clientSize] %p\n", __FUNCTION__, mPqServiceCallBack[clientSize]);
        }
        ret = cookie;
    } else {
        LOGE("%s callBack is NULL\n", __FUNCTION__);
    }

    return ret;
}

int PqService::RemovePqServiceCallBack(int callBackId)
{
    LOGD("%s\n", __FUNCTION__);

    int clientSize = mPqServiceCallBack.size();
    if (callBackId < 0) {
        LOGE("%s: invalid callBackId.\n", __FUNCTION__);
    } else {
        mPqServiceCallBack.erase(callBackId);
    }

    clientSize = mPqServiceCallBack.size();
    LOGD("%s: now has %d pqclient after remove.\n", __FUNCTION__, clientSize);

    return 0;
}

void PqService::GetCbDataFromLibpq(CPQControlCb &cb_data)
{
    int cbType = cb_data.getCbType();
    LOGD("%s: cbType: %d\n", __FUNCTION__, cbType);

    switch (cbType) {
        case CPQControlCb::PQ_CB_TYPE_HDRTYPE:
            SetHdrType(cb_data);
            break;
        case CPQControlCb::PQ_CB_TYPE_ALLM_GAME_MODE:
            SetAllmGameMode(cb_data);
            break;
        case CPQControlCb::PQ_CB_TYPE_FILM_MAKER_MODE:
            SetFilmMakerMode(cb_data);
            break;
        case CPQControlCb::PQ_CB_TYPE_REFRESH_RATE:
            SetRefreshRate(cb_data);
            break;
        case CPQControlCb::PQ_CB_TYPE_PQ_MODE_AUTO_CHANGED:
            SetPqModeAutoChanged(cb_data);
            break;
        case CPQControlCb::PQ_CB_TYPE_PQ_MODE_MANUAL_CHANGED:
            SetPqModeManualChanged(cb_data);
            break;
        default :
            LOGE("%s invalie callback type\n", __FUNCTION__);
            break;
    }

    return;
}

void PqService::SetHdrType(CPQControlCb &cb_data)
{
    LOGD("%s the main process's pid %d\n", __FUNCTION__, getpid());
    Parcel send, reply;

    PQControlCb::HdrTypeCb *hdrTypeCb = (PQControlCb::HdrTypeCb *)(&cb_data);
    int clientSize = mPqServiceCallBack.size();
    LOGD("%s now has %d pqclient\n", __FUNCTION__, clientSize);

    for (int i = 0; i < clientSize; i++) {
        if (mPqServiceCallBack[i] != NULL) {
            LOGD("%s send callback data from server to client by binder i %d\n", __FUNCTION__, i);
            send.writeInt32(hdrTypeCb->mHdrType);
            mPqServiceCallBack[i]->transact(CMD_HDR_DT_CB, send, &reply);
        } else {
            LOGE("%s mPqServiceCallBack is NULL\n", __FUNCTION__);
        }
    }

    return;
}

void PqService::SetAllmGameMode(CPQControlCb &cb_data)
{
    LOGD("%s the main process's pid %d\n", __FUNCTION__, getpid());
    Parcel send, reply;

    PQControlCb::AllmGameModeCb *allmGameCb = (PQControlCb::AllmGameModeCb *)(&cb_data);
    int clientSize = mPqServiceCallBack.size();
    LOGD("%s now has %d pqclient\n", __FUNCTION__, clientSize);

    for (int i = 0; i < clientSize; i++) {
        if (mPqServiceCallBack[i] != NULL) {
            LOGD("%s send callback data from server to client by binder i %d\n", __FUNCTION__, i);
            send.writeInt32(allmGameCb->mAllmGameMode);
            mPqServiceCallBack[i]->transact(CMD_ALLM_GAME_CB, send, &reply);
        } else {
            LOGE("%s mPqServiceCallBack is NULL\n", __FUNCTION__);
        }
    }

    return;
}

void PqService::SetFilmMakerMode(CPQControlCb &cb_data)
{
    LOGD("%s the main process's pid %d\n", __FUNCTION__, getpid());
    Parcel send, reply;

    PQControlCb::FilmMakerModeCb *filmMakerCb = (PQControlCb::FilmMakerModeCb *)(&cb_data);
    int clientSize = mPqServiceCallBack.size();
    LOGD("%s now has %d pqclient\n", __FUNCTION__, clientSize);

    for (int i = 0; i < clientSize; i++) {
        if (mPqServiceCallBack[i] != NULL) {
            LOGD("%s send callback data from server to client by binder i %d\n", __FUNCTION__, i);
            send.writeInt32(filmMakerCb->mFilmMakerMode);
            mPqServiceCallBack[i]->transact(CMD_FMM_PQ_CB, send, &reply);
        } else {
            LOGE("%s mPqServiceCallBack is NULL\n", __FUNCTION__);
        }
    }

    return;
}

void PqService::SetRefreshRate(CPQControlCb &cb_data)
{
    LOGD("%s the main process's pid %d\n", __FUNCTION__, getpid());
    Parcel send, reply;

    PQControlCb::RefreshRateCb *refreshRateCb = (PQControlCb::RefreshRateCb *)(&cb_data);
    int clientSize = mPqServiceCallBack.size();
    LOGD("%s now has %d pqclient\n", __FUNCTION__, clientSize);

    for (int i = 0; i < clientSize; i++) {
        if (mPqServiceCallBack[i] != NULL) {
            LOGD("%s send callback data from server to client by binder i %d\n", __FUNCTION__, i);
            send.writeInt32(refreshRateCb->mRefreshRate);
            mPqServiceCallBack[i]->transact(CMD_REFRESH_RATE_CB, send, &reply);
        } else {
            LOGE("%s mPqServiceCallBack is NULL\n", __FUNCTION__);
        }
    }

    return;
}

void PqService::SetPqModeAutoChanged(CPQControlCb &cb_data)
{
    LOGD("%s the main process's pid %p\n", __FUNCTION__, getpid());
    Parcel send, reply;

    PQControlCb::PqModeChangedCb *pqModeChangedCb = (PQControlCb::PqModeChangedCb *)(&cb_data);
    int clientSize = mPqServiceCallBack.size();
    LOGD("%s now has %d pqclient\n", __FUNCTION__, clientSize);

    for (int i = 0; i < clientSize; i++) {
        if (mPqServiceCallBack[i] != NULL) {
            LOGD("%s send callback data from server to client by binder i %d\n", __FUNCTION__, i);
            send.writeInt32(pqModeChangedCb->pq_mode_info.pq_mode);
            send.writeInt32(pqModeChangedCb->pq_mode_info.hdr_type);
            send.writeInt32(pqModeChangedCb->pq_mode_info.input_src);
            send.writeInt32(pqModeChangedCb->pq_mode_info.low_latency);
            mPqServiceCallBack[i]->transact(CMD_PQMODE_AUTO_CHANGED_CB, send, &reply);
        } else {
            LOGE("%s mPqServiceCallBack is NULL\n");
        }
    }

    return;
}

void PqService::SetPqModeManualChanged(CPQControlCb &cb_data)
{
    LOGD("%s the main process's pid %d\n", __FUNCTION__, getpid());
    Parcel send, reply;

    PQControlCb::PictureModeCb *pictureModeCb = (PQControlCb::PictureModeCb *)(&cb_data);
    int clientSize = mPqServiceCallBack.size();
    LOGD("%s now has %d pqclient\n", __FUNCTION__, clientSize);

    for (int i = 0; i < clientSize; i++) {
        if (mPqServiceCallBack[i] != NULL) {
            LOGD("%s send callback data from server to client by binder i %d\n", __FUNCTION__, i);
            send.writeInt32(pictureModeCb->mPictureMode);
            mPqServiceCallBack[i]->transact(CMD_PQMODE_MANUAL_CHANGED_CB, send, &reply);
        } else {
            LOGE("%s mPqServiceCallBack is NULL\n", __FUNCTION__);
        }
    }

    return;
}

#ifdef __cplusplus
}
#endif