1274 lines
50 KiB
C++
1274 lines
50 KiB
C++
/*
|
|
* 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(¶m, 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(¶m, 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
|