UTS6710/drivers/pq/6710/pq_hw.c

#include "osdef.h" //joshua check
#include <linux/delay.h>
#include <linux/types.h>
#include "pq_hw.h"
#include "../../vip/6710/reg_vip_def.h"
#include "pq.h"
#include <drv_cvd2_internal.h>
#include <drv_gpio.h>
#include "drv_vip_internal.h"
#include <drv_pq_internal.h>
#include "drv_slr.h"
#include <linux/vmalloc.h>
#include <project.h>
#include "tv_base.h"
#include "drv_adi.h"
#include "drv_vdi.h"
#include "drv_gfx.h"
#include "drv_picx.h"

#define VIP_DBL_INVALID_WHITE_LEVEL	0xffffffff
UINT32 ucVDI_MotionFlag = 0;
UINT32 ucTempM=0;
UINT32 ucVDI_Static_Cnt = 0;
UINT32 ucVDI_Static_Cnt_2 = 0;
UINT32 ucVDI_Static_Cnt_3 = 0;

PQHW_CONTEXT	PQHwContext;

struct work_struct WQ_NRAdjust, WQ_SWDC, WQ_ColorBarDetect;
struct workqueue_struct *WQ_Struct_NRAdjust=NULL, *WQ_Struct_SWDC=NULL, *WQ_Struct_ColorBarDetect=NULL;

extern VIP_Mute_Flag_st gfTVFEMuteFlg;

#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,8)
DEFINE_SEMAPHORE(LutTableLock);
#else
DECLARE_MUTEX (LutTableLock);
#endif

UINT8 utempSharpnesscValue;
UINT8 utempCheckColorbarDTFunctionEN;
UINT8 ucTempds_disable_func_en;
UINT8 ucTempDCCSceneID;


#define DYNAMICBL_ADJUST 1

#ifdef DYNAMICBL_ADJUST
UINT8 DynamicBL_OSD_MAX = 90;
UINT8 DynamicBL_OSD_Min = 70;

UINT8 DynamicBL_normal = 86;

INT8 DynamicBL_OSD_MAX_FineTune = 0;
INT8 DynamicBL_OSD_Min_FineTune = 0;
INT8 DynamicBL_OSD_Normal_FineTune = 0;


#endif


//#ifdef  VIP_SW_DC
#if 1
UINT8  DLC_Source=0;
//==================DLC TABLE  START==========================

//extern ST_SWDC_Slope PQ_SWDC_HistSlop[];
//extern ST_SWDC_Chroma PQ_SWDC_HistChroma[];
//extern ST_SWDC_Param PQ_SWDC_Param[];
//extern ST_SWDC_Param SWDC_Param[];
//extern ST_SWDC_Slope SWDC_HistSlop[];
//extern ST_SWDC_Chroma SWDC_HistChroma[];

extern ST_SWDC_Slope SWDC_HistSlop[];
extern ST_SWDC_Chroma SWDC_HistChroma[];
extern ST_SWDC_Param SWDC_Param[];
extern RGB_GAIN RGBGain_Param[];


//===================DLC TABLE  END===========================
#endif


#ifdef DYNAMIC_BACKLIGHT

#define VIP_DBL_LEVEL_DEGREE		256
#define VIP_DBL_FRAME_INTERVAL	16
#define VIP_DBL_FRAME_INTERVAL_MASK	0xf
#define VIP_DBL_STATUS_NONE		0
#define VIP_DBL_STATUS_DETECTING	1
#define VIP_DBL_STATUS_ENTERING	2
#define VIP_DBL_STATUS_KEEPING	3
#define VIP_DBL_STATUS_LEAVING	4
#define VIP_DBL_STATUS_DETECTING_WHITE_ENTERING	5
#define VIP_DBL_INVALID_WHITE_LEVEL	0xffffffff

#define VIP_DBL_WHITE_PATTERN_BRIGHTING

DYNAMIC_BACKLIGHT_PARAM g_DynamicBackLight;//= {0, 0, 0, 0, 0, 0, 0, 25, 51, 192, 217, 144, FALSE, {0}};

extern UINT32 LCDBackLightMap[15];
extern const UINT16 LUT17x17DefAngle[17][17];
extern const UINT16 LUT17x17DefSat[17][17];

#endif //#ifdef DYNAMIC_BACKLIGHT

extern BOOL VIP_IsJPEGSource(void);
extern INT32 GetCustomerData(INT8 *pcTableName, INT8 **tablestart, UINT32 *tablesize);

#ifdef CONFIG_COLORLUT_14_COLOR
#define COLORLUT_RGN_NUM 14
#elif defined(CONFIG_COLORLUT_10_COLOR)
#define COLORLUT_RGN_NUM 10
#else
#define COLORLUT_RGN_NUM 7
#endif

#define LUT_HEAD_ID		0x54554c //T=0x54 U=0x55 L=0x4c
#define m_Global_S_offset 8

static UINT8 lut_rgn_hue_min[COLORLUT_RGN_NUM] = {0};
static UINT8 lut_rgn_hue_max[COLORLUT_RGN_NUM] = {0};
static UINT8 lut_rgn_sat_min[COLORLUT_RGN_NUM] = {0};
static UINT8 lut_rgn_sat_max[COLORLUT_RGN_NUM] = {0};
static UINT8 lut_rgn_y_min[COLORLUT_RGN_NUM] = {0};
static UINT8 lut_rgn_y_max[COLORLUT_RGN_NUM] = {0};

static UINT8 lut_rgn_en[COLORLUT_RGN_NUM] = {0};
static INT8 lut_rgn_hue_gain[COLORLUT_RGN_NUM] = {0};
static INT8 lut_rgn_sat_gain[COLORLUT_RGN_NUM] = {0};
static INT8 lut_rgn_y_gain[COLORLUT_RGN_NUM] = {0};

static UINT8 lut_smooth_level = 0;//0~100
static UINT8 lut_make[COLORLUT_RGN_NUM] = {0};


UINT8 check_usr_curve_setup_ok(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    if((pHwContext->UserCurveSetup==0)&&(pHwContext->UserCurveInit==0))
    	return (1);
    else 	return (0);
}

void PQ_HWDestroyWorkqueue(void)
{
    cancel_work_sync(&WQ_NRAdjust);
    cancel_work_sync(&WQ_SWDC);        
    cancel_work_sync(&WQ_ColorBarDetect);

}

UINT8 PQ_CheckSpecialRegister(UINT32 ulReg)
{
	UINT8 Check;
	if((ulReg>>28) == 0 )//vip register
	{
		if( (ulReg&0xffff) == 0xc084 ||			//gamma
			(ulReg&0xffff) == 0xc184 ||			//lut
			(ulReg&0xffff) == 0xd062 ||			//vip coefficient table
			(ulReg&0xffff) == 0xd064 ||
			(ulReg&0xffff) == 0xd068 ||
			(ulReg&0xffff) == 0xd06c ||
			(ulReg&0xf000ffff) == 0xd060 ||			//vip coefficient table
			(ulReg&0xf000ffff) == 0xd064 ||
			(ulReg&0xf000ffff) == 0xd068 ||
			(ulReg&0xf000ffff) == 0xd06c

		)
			Check = TRUE;
		else
			Check =  FALSE;
	}
	else
		Check =  FALSE;

	return Check;
}


UINT32 PQ_GetRegisterType(UINT32 ulRegisterType)
{
	switch(ulRegisterType)
	{
		case 0:
				return 0xBE1C0000;
		case 0x10000000:
				return 0xBE000000;
		case 0x20000000:
				return 0xBE2c0000;
		case 0x30000000:
				return 0xBE2d0000;
		default:
				return 0xBE1C0000;

	}
}


void PQ_DelayMS(UINT32 ulDelayMS )
{
	if( irq_count() || in_atomic() )
	{	//for TY request
		mdelay(ulDelayMS);
	}
	else
	{
		msleep(ulDelayMS);
	}
}

void PQ_DelayUS(UINT32 ulDelayUS )
{
	udelay(ulDelayUS);
}


//****************************************************************************
//
// Function   : PQ_RegisterWrite
// Params    : ulRegisterName -address of the index register
//                  ulValue - value to program to the given bits of the register
// Description: Sets the given bits of the given index register to the given value
// ulRegisterName data format:  TTTT WWWW WWSS SSSS AAAA AAAA AAAA AAAA
//		                                   0:reserved
//							T:register type  0000=VIP_register (offset 0xBE1C)
//							W:register used width
//							S:register start bit
//							A:register address
// Returns    : void
//****************************************************************************
void PQ_RegisterWrite(UINT32 ulRegisterName, UINT32 ulValue)
{
	UINT32 ulData, ulBitMask, ulRegisterType;
	//if((ulRegisterName&0xffff)==0x0044 || (ulRegisterName&0xffff)==0x0045 || (ulRegisterName&0xffff)==0x0048)
	//	PQDebugPrint("*****reg = 0x%lx, value = 0x%lx", ulRegisterName, ulValue);
	if(PQ_CheckSpecialRegister(ulRegisterName))
	{
			//sepcial register (ex lut, gamma table, coefficient table )
			ulRegisterType = PQ_GetRegisterType(ulRegisterName & REGISTER_TYPE_MASK);
			ulRegisterName &= REGISTER_ADDRESS_MASK;
			ulRegisterName |= ulRegisterType;		//offset address
			*((volatile UINT32 *)(ulRegisterName)) = ulValue;
			//PQ_ADVANCE_HWPrint("reg(0x%lx) = 0x%lx", ulRegisterName, ulValue);
	}
	else if ( PQ_GetStartAndEndBits(ulRegisterName) <= WIDTH_BIT_8 )
	{
		ulBitMask = GET_VALUE_BITS(ulRegisterName, 0xFFFFFFFF);
		ulBitMask <<= PQ_GetRegisterStartBit(ulRegisterName);
		ulValue <<= PQ_GetRegisterStartBit(ulRegisterName);
		ulRegisterType = PQ_GetRegisterType(ulRegisterName & REGISTER_TYPE_MASK);
		ulRegisterName &= REGISTER_ADDRESS_MASK;
		ulRegisterName |= ulRegisterType;		//offset address

		if(ulRegisterName%4)
			ulData = *((volatile UINT8*)(ulRegisterName));
		else
			ulData = *((volatile UINT32*)(ulRegisterName));

		ulData &= ~ulBitMask;
		ulData |= (ulValue & ulBitMask);

		if(ulRegisterName%4)
			*((volatile UINT8*)(ulRegisterName)) = ulData;
		else
			*((volatile UINT32*)(ulRegisterName)) = ulData;

	}
	else
	{

			ulBitMask = GET_VALUE_BITS(ulRegisterName, 0xFFFFFFFF);
			ulBitMask <<= PQ_GetRegisterStartBit(ulRegisterName);
			ulValue  <<= PQ_GetRegisterStartBit(ulRegisterName);
			ulRegisterType = PQ_GetRegisterType(ulRegisterName & REGISTER_TYPE_MASK);

			ulRegisterName &= REGISTER_ADDRESS_MASK;
			ulRegisterName |= ulRegisterType;		//offset address
			ulData = *((volatile UINT32*)(ulRegisterName));
			ulData &= ~ulBitMask;
			ulData |= (ulValue & ulBitMask);
 			*((volatile UINT32 *)(ulRegisterName)) = ulData;
	}

	return;
}


//****************************************************************************
//
// Function   : PQ_RegisterRead
// Params    : ulRegisterName -address of the index register
// Description: read the given bits of the given index register to the value
// ulRegisterName data format:  TTTT WWWW WWSS SSSS AAAA AAAA AAAA AAAA
//		                                   0:reserved
//							T:register type  0000=VIP_register (offset 0xBE1C)
//							W:register used width
//							S:register start bit
//							A:register address
// Returns    : register data
//****************************************************************************
UINT32 PQ_RegisterRead(UINT32 ulRegisterName )
{
	UINT32 ulData, ulBitMask, ulRegisterType, ulRegisterNameTmp;

	ulRegisterNameTmp=ulRegisterName;
	ulRegisterType = PQ_GetRegisterType(ulRegisterName & REGISTER_TYPE_MASK);
	ulRegisterNameTmp &= REGISTER_ADDRESS_MASK;
	ulRegisterNameTmp |= ulRegisterType;		//offset address

	ulData = *((UINT32 *)(ulRegisterNameTmp));

	if ( PQ_GetStartAndEndBits(ulRegisterName) != ALL_BITS ){
		ulBitMask = GET_VALUE_BITS(ulRegisterName, 0xFFFFFFFF);
		ulBitMask <<= PQ_GetRegisterStartBit(ulRegisterName);
		ulData &= ulBitMask;
		ulData >>=  (PQ_GetRegisterStartBit(ulRegisterName));
	}

	return ulData;
}


void PQ_GammaCorrect(UINT8 ucGrayLevel)
{
	PQDebugPrint( "%s: ucGrayLevel= %d", __FUNCTION__, ucGrayLevel);

	PQ_RegisterWrite(VIP_reg_dpy_matrix_fix_in_en, ENABLE);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_bypass, ENABLE);
	PQ_RegisterWrite(VIP_reg_dpy_dpy_dtype, 0);
//	PQ_RegisterWrite(VIP_reg_dpy_444, 0);
	PQ_RegisterWrite(VIP_reg_pnl_ovsc_yc, ucGrayLevel);
	PQ_RegisterWrite(VIP_reg_pnl_ovsc_cb, ucGrayLevel);
	PQ_RegisterWrite(VIP_reg_pnl_ovsc_cr, ucGrayLevel);
	PQ_RegisterWrite(VIP_reg_pnl_ovsc_yc_lsb2, 0);
	PQ_RegisterWrite(VIP_reg_pnl_ovsc_cb_lsb2, 0);
	PQ_RegisterWrite(VIP_reg_pnl_ovsc_cr_lsb2, 0);
}


//****************************************************************************
//
//   Function   : PQ_ColorMatrixComp
//   Params    :
//   Description: Calc ColorMatrix compensetion for brightness, bias, dpy_yppn and matrix_self_offset.
//   Note        : C1, C2, C3 register range adjust to 16bit in 531 (330 is 12bit)
//   Returns    : void
//****************************************************************************
void PQ_ColorMatrixComp(UINT8 bReset)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    COLOR_MATRIX_COMP_INT *pColorMatrixC = (COLOR_MATRIX_COMP_INT *)&pHwContext->iColorMatrixC1;
    INT32 iBias[3];
    INT32 iYPPComp[3];
    INT32 *piCTBias = &pHwContext->iRBias;
    INT32 i, iIsYPPEn;
    UINT8 ucUserSource, ucSubSource;
    LONG LONG INT32 litemp; // due to the calc may be overfloe 32bits
    static UINT8 bStart = FALSE;

    if(!PQ_IsFadeEn())
    {
    	if(bReset)
    	{
    		bStart = TRUE;
    		return;
    	}
    }
    
	if(bStart || PQ_IsFadeEn())
    {
        bStart = FALSE;
        VIP_GetSource(&ucUserSource, &ucSubSource);
        iIsYPPEn = PQ_RegisterRead(VIP_reg_dpy_ypp) && (ucUserSource != SOURCE_JPEG);
        for (i = 0; i < 3; i++)
        {
            litemp = (LONG LONG INT32)pHwContext->CurColorMatrix->CSC_Value[i*3]*(pColorMatrixC[i].iValue-iIsYPPEn*COLOR_MATRIX_YPP_COMP_OFFSET);
            litemp = litemp>>(COLOR_MATRIX_GAIN_BIT_SYSTEM);
            iYPPComp[i] = litemp;
            iBias[i] = piCTBias[i]+(pHwContext->iBrightness)+iYPPComp[i];
            iBias[i] = max(-2048, min(2047, iBias[i]));

            if(VIP_Jpeg_GetDisplayMode() && VIP_IsJPEGSource()) 
			{
                iBias[i] = 0x10; //reset RGB offset in thumbnail mode
            }
        }

        PQ_RegisterWrite(VIP_reg_dpy_matrix_c1, pHwContext->bEnableColorProcess?iBias[0]:pColorMatrixC[0].iValue);
        PQ_RegisterWrite(VIP_reg_dpy_matrix_c2, pHwContext->bEnableColorProcess?iBias[1]:pColorMatrixC[1].iValue);
        PQ_RegisterWrite(VIP_reg_dpy_matrix_c3, pHwContext->bEnableColorProcess?iBias[2]:pColorMatrixC[2].iValue);

    }
}


void PQ_SetColorMatrix(UINT8 ucEnable)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	pHwContext->ucMatrixbypassCtl = ucEnable;
	PQ_RegisterWrite(VIP_reg_dpy_matrix_bypass,ucEnable);
}


//****************************************************************************
//
//   Function   : PQ_ColorTempBias
//   Params    :
//   Description: Powers up/down  the panel as per the given power sequence timings
//   Returns    : void
//****************************************************************************
void PQ_ColorTempBias(PQ_COLOR_TEMP_BIAS ucType, INT32 iValue)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT8 ucIndex = 0; // detect the index => R = 0, G = 1, B = 2;

	if( pHwContext->bEnableColorProcess==FALSE )
		iValue= 0;

	//PQDebugPrint("%s: ucType=%d, iValue=%d", __FUNCTION__, ucType, iValue);

	switch(ucType){
		case PQ_CT_BIAS_R:
			ucIndex = 0;
			break;
		case PQ_CT_BIAS_G:
			ucIndex = 1;
			break;
		case PQ_CT_BIAS_B:
			ucIndex = 2;
			break;
	}

	*((&pHwContext->iRBias)+ucIndex) = iValue;
	PQ_ColorMatrixComp(TRUE);

}




//================================================================================
//	function name		: PQ_SetupColorSpaceConversionTable
//	input parameter	: cPath,cType
//	output parameter	: none
//	purpose			: setup color space conversion matrix
//   return			: none

void PQ_SetupColorSpaceConversionTable(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    UINT32 * pColorSpaceTable = 0, * p601ColorSpaceTable = 0, * p709ColorSpaceTable = 0,  * pRGB2YCbCrTable = 0, * p601RGB2YCbCrTable = 0, * p709RGB2YCbCrTable = 0;
    BOOL bEnableEnhancedColor;
    UINT32 tmp = 0;
    INT32 i;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    
    COLOR_MATRIX_DATA *pCOLOR_MATRIX_DATA;

    i = 0;
    ucTableIndex = pVtab->mColorMatrix.mGroupedIndex[ucCurrSrcIndex];
    pCOLOR_MATRIX_DATA = &pVtab->mColorMatrix.mSrcColorMatrix[ucTableIndex];
    p601RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full601;
    p709RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full709;
    p601ColorSpaceTable = ColorSpaceTableYCC_Full601;
    p709ColorSpaceTable = ColorSpaceTableYCC_Full709;

    PQ_ADVANCE_HWPrint("%s: nColorSpaceMode=%d bColorProcess=%d cInputColorStandard=%d", __FUNCTION__, pHwContext->nColorSpaceMode, pHwContext->bEnableColorProcess, VIP_GetInputColorStandard());
    PQDebugPrint("%s: pHwContext->cInputDataFormat = %d",__FUNCTION__, VIP_GetInputDataFormat());

    if(VIP_GetInputDataFormat() == RGB)
    {
        if( VIP_GetRGB2YCbCrRange() == eGFX_YCBCR_235 )
        {
            p601RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Limit601;
            p709RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Limit709;
        }
        else if( VIP_GetRGB2YCbCrRange() == eGFX_YCBCR_255 ) 
        {
            p601RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full601;
            p709RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full709;
        }
        else //eGFX_YCBCR_NONE
        {
            p601RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Limit601;
            p709RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Limit709;
        }
    }
    else if(pCOLOR_MATRIX_DATA->mSrcColorMatrix[1].CSC_Value[0]==(INT32)0xffffffff)
    {
        //vip table not set color matrix by source(for vtab 20)
        p601ColorSpaceTable = (UINT32*) &pVtab->mColorSpaceConversionTable[CSC_601];
        p709ColorSpaceTable = (UINT32*) &pVtab->mColorSpaceConversionTable[CSC_709];
    }
    else
    {
        p601ColorSpaceTable = (UINT32*) &pCOLOR_MATRIX_DATA->mSrcColorMatrix[CSC_601-1];
        p709ColorSpaceTable = (UINT32*) &pCOLOR_MATRIX_DATA->mSrcColorMatrix[CSC_709-1];
        if(pCOLOR_MATRIX_DATA->mSrcColorMatrix[0].CSC_Value[0] == 1024)
        {
            p601RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Limit601;
        }
        else
        {
            p601RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full601;
        }

        if(pCOLOR_MATRIX_DATA->mSrcColorMatrix[1].CSC_Value[0] == 1024)
        {
            p709RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Limit709;
        }
        else
        {
            p709RGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full709;
        }   
    }

    // initial the pRGB2YCbCrTable to 601 matrix, for sync previous chip design
    pRGB2YCbCrTable = p601RGB2YCbCrTable;
    
    if( pHwContext->nColorSpaceMode==PQ_COLOR_SPACE_NORMAL )
    {
        if(VIP_IsPCSource()==TRUE)	//yukuo VGA input range 10~245
        {
            pColorSpaceTable=(UINT32*) &pVtab->mColorSpaceConversionTable[CSC_RGB];
        }
        else
        {
            pColorSpaceTable=p601ColorSpaceTable;
        }
    }
    else if( pHwContext->nColorSpaceMode==PQ_COLOR_SPACE_WIDE )
    {
        pColorSpaceTable= (UINT32*) &pVtab->mColorSpaceConversionTable[CSC_709];
        pRGB2YCbCrTable = p709RGB2YCbCrTable;
    }
    else //PQ_COLOR_SPACE_AUTO
    {
        if(VIP_GetInputDataFormat() == RGB)//when input is rgb, vip set posterior matrix depend on prior transform matrix
        {
            if(VIP_IsPCSource()==TRUE)	//yukuo VGA input range 10~245
            {
                pColorSpaceTable=(UINT32*)&pVtab->mColorSpaceConversionTable[CSC_RGB];
            }
            else
            {
                if(PQ_GetDefinitionIndex() == PQ_HIGH_DEFINITION)
                {
                    pColorSpaceTable = p709ColorSpaceTable;
                    pRGB2YCbCrTable = p709RGB2YCbCrTable;
                }
                else
                {
                    pColorSpaceTable = p601ColorSpaceTable;
                    pRGB2YCbCrTable = p601RGB2YCbCrTable;
                }
            }
        }
        else	//ypp format
        {
            switch(VIP_GetInputColorStandard())
            {
                case YCC_709:
                    pColorSpaceTable=p709ColorSpaceTable;
                    pRGB2YCbCrTable = p709RGB2YCbCrTable;
                    break;
                case YUV_FCC:
                    pColorSpaceTable=ColorSpaceTableFCC;
                    break;
                case YUV_624:
                case YUV_170M:	//ex: ntsc
                    pColorSpaceTable=ColorSpaceTable624;
                    break;
                case YUV_240M: //ex
                    pColorSpaceTable=ColorSpaceTable240M;
                    break;
                case RGB: //rgb format is forcely transformed to ycc before dpy
                case YCC_601:
                    pColorSpaceTable=p601ColorSpaceTable;
                    break;
                default:
                    if(VIP_GetInputVSize() > 700) 	//HD
                    {
                        pColorSpaceTable=p709ColorSpaceTable;
                        pRGB2YCbCrTable = p709RGB2YCbCrTable;
                    }
                    else
                    {
                        pColorSpaceTable=p601ColorSpaceTable;
                    }
                    break;
            }
        }
    }

    if(VIP_IsJPEGSource())
    {
        if(VIP_GetInputDataFormat() == RGB)
        {
            pColorSpaceTable =ColorSpaceTableYCC_Full601;
            pRGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full601;
            PQ_RegisterWrite(VIP_reg_dpy_ypp, 0);
        }
        else
        {
            pColorSpaceTable =ColorSpaceJPEG;
            pRGB2YCbCrTable = ColorSpaceTableRGB2YCC_Full601;
            PQ_RegisterWrite(VIP_reg_dpy_ypp, 1);
        }	 
    }
    else if(VIP_GetInputDataFormat() != RGB)
    {
        PQ_RegisterWrite(VIP_reg_dpy_ypp, 1);
    }
    else
    {
        #ifdef CONFIG_HDMI_RGB_RANGE_FORCE_AUTOMODE_TO_FULLRANGE
        if(VIP_GetUserSource() == SOURCE_HDMI && VIP_GetRGBRange() == RGBRange_LimitedRange)
        {
            PQ_RegisterWrite(VIP_reg_dpy_ypp, 1);
        }
        else
        #endif
        { 
            PQ_RegisterWrite(VIP_reg_dpy_ypp, 0);
        }
    }

    pHwContext->CurColorMatrix = (CSC_SETTING*)pColorSpaceTable;
    pHwContext->RGB2YUVMatrix = (CSC_SETTING*)pRGB2YCbCrTable;

    //set rgb to ycbcr in JPEG RGB color space(to fix color error in RBG Space)
    PQ_RegisterWrite(VIP_reg_picx_clip_high, 0x3ac);
    PQ_RegisterWrite(VIP_reg_picx_clip_low, 0x40);
	
    if( VIP_IsJPEGSource() && VIP_GetInputDataFormat() == RGB )
    {
        PQ_RegisterWrite(VIP_reg_picx_yuv_bypass, 0);
        DRV_PICX_SetMatrix(pHwContext->RGB2YUVMatrix);
        if(VIP_IsInputDataFormatBGR())
        {
            PQ_RegisterWrite(VIP_reg_picx_rgbin_order,0);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_picx_rgbin_order,1);
        }
        //add picx rbg2ycc clip setting
        PQ_RegisterWrite(VIP_reg_picx_clip_high, 0x3ff); //M#1912
        PQ_RegisterWrite(VIP_reg_picx_clip_low, 0);//M#1912
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_picx_yuv_bypass, 1);
        PQ_RegisterWrite(VIP_reg_picx_rgbin_order,0);
        PQ_RegisterWrite(VIP_reg_picx_clip_high, 0x940);
        PQ_RegisterWrite(VIP_reg_picx_clip_low, 64);
    }
    PQ_RegisterWrite(VIP_reg_dpy_444, ENABLE);
    PQ_RegisterWrite(VIP_REG_DPY_MTX_PRE_BOUND, 0);
    PQ_RegisterWrite(VIP_REG_DPY_MTX_MIN_Y, 0);
    PQ_RegisterWrite(VIP_REG_DPY_MTX_MIN_U, 	0);
    PQ_RegisterWrite(VIP_REG_DPY_MTX_MIN_V, 	0);
    PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_Y,	 0x3f7);
    PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_U, 0x3f7);
    PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_V, 0x3f7);

    if(VIP_GetScreenOnSt() )
        PQ_SetColorMatrix(DISABLE);

    for(i=0;i<9;i++)
        PQ_ColorMatrixSetup(TRUE, i);

    DRV_GFX_SetMatrix(pHwContext->RGB2YUVMatrix);

    //unsigned convert to signed number
    tmp = pColorSpaceTable[9] & 0x3fff;
    if(tmp > 0x2000)
        pHwContext->iColorMatrixC1 = -(0x4000 - tmp);
    else if(tmp < 0x2000)
        pHwContext->iColorMatrixC1 = tmp;
    else
        pHwContext->iColorMatrixC1 = 0;

    tmp = pColorSpaceTable[10] & 0x3fff;
    if(tmp > 0x2000)
        pHwContext->iColorMatrixC2 = -(0x4000 - tmp);
    else if(tmp < 0x2000)
        pHwContext->iColorMatrixC2 = tmp;
    else
        pHwContext->iColorMatrixC2 = 0;

    tmp = pColorSpaceTable[11] & 0x3fff;
    if(tmp > 0x2000)
        pHwContext->iColorMatrixC3 = -(0x4000 - tmp);
    else if(tmp < 0x2000)
        pHwContext->iColorMatrixC3 = tmp;
    else
        pHwContext->iColorMatrixC3 = 0;

    PQ_ColorTempBias(PQ_CT_BIAS_R, pMenuValue->iColorBias[0]);
    PQ_ColorTempBias(PQ_CT_BIAS_G, pMenuValue->iColorBias[1]);
    PQ_ColorTempBias(PQ_CT_BIAS_B, pMenuValue->iColorBias[2]);

    PQ_RegisterWrite(VIP_reg_dpy_u_reset,DISABLE);

    bEnableEnhancedColor= pHwContext->bEnableColorProcess;

    if( bEnableEnhancedColor )
    {
        //for color region
        PQ_RegisterWrite(VIP_reg_dpy_hsy_bypass, DISABLE);
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_dpy_hsy_bypass, ENABLE);
    }
}

BOOL BluePatternFlag=0;

void PQ_PureColorControl(INT16 ucPure, INT8 ucPicture)
{
	INT8 ucYUVOffset;

	PQ_RegisterWrite(VIP_reg_dpy_mtx_out_range, 1);	
	if(BluePatternFlag)
	{
		if(ucPure < 0) 
		{
			if(ucPure==-1 && ucPicture==1) ucYUVOffset=6;
			else if(ucPure==-2 && ucPicture==1) ucYUVOffset=8;
			else if(ucPicture==2) ucYUVOffset=8;
			else if(ucPicture==3) ucYUVOffset=12;
			else ucYUVOffset=0;

			if(VIP_IsATVSource() && (VIP_GetStdColorSystem() <= CVD2_STD_NTSC_443) && ucPicture<=2) ucYUVOffset=10;
			
			PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_Y, 	1023-ucYUVOffset);
                   PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_U, 1023-ucYUVOffset);
                   PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_V, 1023-ucYUVOffset);            
                
		}
		else
		{
			if(ucPure<=6 && ucPicture==1) ucYUVOffset=6;
			else if(ucPure<=8 && ucPicture==2) ucYUVOffset=8;
			else if(ucPicture==3) ucYUVOffset=ucPure; 
			else ucYUVOffset=ucPure;

			if(VIP_IsATVSource() && (VIP_GetStdColorSystem() <= CVD2_STD_NTSC_443) && ucPicture<=2) ucYUVOffset=10+ucPure;

			PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_Y, 	1023-ucYUVOffset+ucPure);
                   PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_U, 1023-ucYUVOffset+ucPure);
                   PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_V, 1023-ucYUVOffset+ucPure); 
		}
		PQDebugPrint("%s: ucYUVOffset=%d\n", __FUNCTION__, ucYUVOffset);
		PQDebugPrint("%s: ucPure=%d     ucPicture=%d\n", __FUNCTION__, ucPure,ucPicture);
	}
       else if( VIP_GetUserSource() == SOURCE_PATTERN )
      	{
		PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_Y,1023);
		PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_U,1023);
		PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_V,1023);		
      	}
	else
	{
		ucYUVOffset=8;
 
		PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_Y, 1023-ucYUVOffset);
             PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_U, 1023-ucYUVOffset);
             PQ_RegisterWrite(VIP_REG_DPY_MTX_MAX_V, 1023-ucYUVOffset);   
	}
}


void PQ_ColorSpaceMode(UINT8 ucMode, UINT8 ucInputSource)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

    PQDebugPrint("%s: ucMode=%d ucOld=%d", __FUNCTION__, ucMode, pHwContext->nColorSpaceMode);
    if( ucMode!=pHwContext->nColorSpaceMode || ucMode==PQ_COLOR_SPACE_AUTO )
    {
        pHwContext->nColorSpaceMode= ucMode;
        PQ_SetupColorSpaceConversionTable();
    }
}

void PQ_GetVtabHwRange(UINT8 ucFunID, INT32* pMin, INT32* pMax, INT32* pMiddle)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    RANGE_DATA *pRANGE_DATA;

    ucTableIndex = pVtab->mRange.mGroupedIndex[ucCurrSrcIndex];
    pRANGE_DATA = &pVtab->mRange.mRange_Data[ucTableIndex];
	if( ucFunID==PQ_BRIGHTNESS )
	{
		*pMin= pRANGE_DATA->BrightnessRange.min;
		*pMax= pRANGE_DATA->BrightnessRange.max;
		*pMiddle= pRANGE_DATA->BrightnessRange.middle;
	}

	else if( ucFunID==PQ_CONTRAST )
	{
		*pMin= pRANGE_DATA->ContrastRange.min;
		*pMax= pRANGE_DATA->ContrastRange.max;
		*pMiddle= pRANGE_DATA->ContrastRange.middle;
	}

	else if( ucFunID==PQ_SATURATION )
	{
		*pMin= pRANGE_DATA->SaturationRange.min;
		*pMax= pRANGE_DATA->SaturationRange.max;
		*pMiddle= pRANGE_DATA->SaturationRange.middle;
	}

#if 0
	else if( ucFunID==VIP_HUE )
	{
		if( pVtab->HueRange.min>=0 && pVtab->HueRange.min<=32 )
			*pMin= pVtab->HueRange.min;
		if( pVtab->HueRange.max>=0 && pVtab->HueRange.max<=32 )
			*pMax= pVtab->HueRange.max;
		if( pVtab->HueRange.middle>=0 && pVtab->HueRange.middle<=32 )
			*pMiddle= pVtab->HueRange.middle;
	}


#else
	else if( ucFunID==PQ_HUE )
	{
		if( pRANGE_DATA->HueRange.min>=0 && pRANGE_DATA->HueRange.min<=100 )
			*pMin= pRANGE_DATA->HueRange.min;
		if( pRANGE_DATA->HueRange.max>=0 && pRANGE_DATA->HueRange.max<=100 )
			*pMax= pRANGE_DATA->HueRange.max;
		if( pRANGE_DATA->HueRange.middle>=0 && pRANGE_DATA->HueRange.middle<=100 )
			*pMiddle= pRANGE_DATA->HueRange.middle;
	}
#endif

	else if( ucFunID>=PQ_CT_R_GAIN &&  ucFunID<=PQ_CT_B_GAIN )
	{
		if(((pRANGE_DATA->ColorTempGainRange.min & 0xff000000) >>24) == 1)
		{
			switch(ucFunID)
			{
				case PQ_CT_R_GAIN:
					*pMin= pRANGE_DATA->ColorTempGainRange.min & 0xff;
					*pMax= pRANGE_DATA->ColorTempGainRange.max & 0xff;
					*pMiddle= pRANGE_DATA->ColorTempGainRange.middle & 0xff;
					break;
				case PQ_CT_G_GAIN:
					*pMin= (pRANGE_DATA->ColorTempGainRange.min & 0xff00) >> 8;
					*pMax= (pRANGE_DATA->ColorTempGainRange.max & 0xff00) >> 8;
					*pMiddle= (pRANGE_DATA->ColorTempGainRange.middle & 0xff00) >> 8;
					break;
				case PQ_CT_B_GAIN:
					*pMin= (pRANGE_DATA->ColorTempGainRange.min & 0xff0000) >> 16;
					*pMax= (pRANGE_DATA->ColorTempGainRange.max & 0xff0000) >> 16;
					*pMiddle= (pRANGE_DATA->ColorTempGainRange.middle & 0xff0000) >> 16;
					break;
			}
		}
		else
		{
			*pMin= pRANGE_DATA->ColorTempGainRange.min;
			*pMax= pRANGE_DATA->ColorTempGainRange.max;
			*pMiddle= pRANGE_DATA->ColorTempGainRange.middle;
		}
	}

	else if( ucFunID>=PQ_CT_R_BIAS && ucFunID<=PQ_CT_B_BIAS )
	{
		if(((pRANGE_DATA->ColorTempOffsetRange.min & 0xff000000) >> 24) == 1)
		{
			switch(ucFunID)
			{
				case PQ_CT_R_BIAS:
					*pMin= (INT8)(pRANGE_DATA->ColorTempOffsetRange.min & 0xff);
					*pMax= (INT8)(pRANGE_DATA->ColorTempOffsetRange.max & 0xff);
					*pMiddle= (INT8)(pRANGE_DATA->ColorTempOffsetRange.middle & 0xff);
					break;
				case PQ_CT_G_BIAS:
					*pMin= (INT8)((pRANGE_DATA->ColorTempOffsetRange.min & 0xff00) >> 8);
					*pMax= (INT8)((pRANGE_DATA->ColorTempOffsetRange.max & 0xff00) >> 8);
					*pMiddle= (INT8)((pRANGE_DATA->ColorTempOffsetRange.middle & 0xff00) >> 8);
					break;
				case PQ_CT_B_BIAS:
					*pMin= (INT8)((pRANGE_DATA->ColorTempOffsetRange.min & 0xff0000) >> 16);
					*pMax= (INT8)((pRANGE_DATA->ColorTempOffsetRange.max & 0xff0000) >> 16);
					*pMiddle= (INT8)((pRANGE_DATA->ColorTempOffsetRange.middle & 0xff0000) >> 16);
					break;
			}
		}
		else
		{
			*pMin= pRANGE_DATA->ColorTempOffsetRange.min;
			*pMax= pRANGE_DATA->ColorTempOffsetRange.max;
			*pMiddle= pRANGE_DATA->ColorTempOffsetRange.middle;
		}
	}

}

void PQ_GetVtabHwRangeExt(UINT8 ucFunID, INT32* pMidLeft, INT32* pMidRight)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    RANGE_DATA *pRANGE_DATA;

    ucTableIndex = pVtab->mRange.mGroupedIndex[ucCurrSrcIndex];
    pRANGE_DATA = &pVtab->mRange.mRange_Data[ucTableIndex];

	if( ucFunID==PQ_BRIGHTNESS )
	{
		*pMidLeft= pRANGE_DATA->BrightnessRangeExt.midleft;
		*pMidRight= pRANGE_DATA->BrightnessRangeExt.midright;
	}
	else if( ucFunID==PQ_CONTRAST )
	{
		*pMidLeft= pRANGE_DATA->ContrastRangeExt.midleft;
		*pMidRight= pRANGE_DATA->ContrastRangeExt.midright;
	}
	else if( ucFunID==PQ_SATURATION )
	{
		*pMidLeft= pRANGE_DATA->SaturationRangeExt.midleft;
		*pMidRight= pRANGE_DATA->SaturationRangeExt.midright;
	}
}

void PQ_YUV_Datat_Formal(UINT8 ucType)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	pHwContext->ucYuvDataFormat = ucType;
}

UINT8 PQ_GET_YUV_Datat_Formal(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	return pHwContext->ucYuvDataFormat;
}

void PQ_FleshTone_Init(void)
{
	PQ_RegisterWrite(VIP_reg_dpy_flcom0_magmax, 0x37);

	PQ_RegisterWrite(VIP_reg_dpy_fil0_rgn_en, 0);
	PQ_RegisterWrite(VIP_reg_dpy_fil1_rgn_en, 0);
	PQ_RegisterWrite(VIP_reg_dpy_flcom0_rgn_en, 1);
	PQ_RegisterWrite(VIP_reg_dpy_flcom1_rgn_en, 0);
	PQ_RegisterWrite(VIP_reg_dpy_flcom2_rgn_en, 0);

	PQ_RegisterWrite(VIP_reg_dpy_fl_detail_minus, 0);
	PQ_RegisterWrite(VIP_reg_dpy_fl_detail_factor, 0);

	PQ_RegisterWrite(VIP_reg_dpy_fl_det_minus, 0);

}

//****************************************************************************
//   Function   : PQ_NR_Init
//   Params    : void
//   Description: (1)Disable 331 NR function related register(6994 ~ 6998) in 531
//                    (2) Initial NR related register setting
//   Returns    : void
//****************************************************************************

void PQ_NR_TnrzEnable(BOOL bEnable)
{
	//add this function because color bar display abnormal when change source from pc to atv like mantis 42375.
    if(VIP_IsPCSource() || VIP_RunDVIMode())
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_en,	0);//For 305 bandwidth issue.//307/506 should be ok.
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_en, bEnable);	
    }

}

void PQ_NR_Init(void)
{
    //685e 0xbb
    PQ_NR_TnrzEnable(ENABLE);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th_dyn_adj,   1);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_dyn_adj,    0);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_dith_en,    1);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_mbw_en, 1);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_en, 1);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_sel,    0);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_bmax_sel,   1);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_alpha_inc,  0x8);


    //6860 0x42 , Grid Mobile Noise//6860 0xf8 640X480 YCBCR444 ColorBar shake
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_chroma_tap_sel0,  0);     //0x00406860
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_chroma_tap_sel1,  0);     //0x00416860
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_debug_en,     0);     //0x00426860
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_blk_diff_sel,  1);     //0x00436860
    PQ_RegisterWrite(VIP_reg_vdi_tnr_blk_diff_sel,      1);     //0x00446860
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_blk_diff_sel,    0);     //0x00456860
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_blk_diff_sel,     1);     //0x00466860
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_blk_diff_sel,   1);     //0x00476860
    PQ_RegisterWrite(VIP_reg_vdi_mnr_gain_inc, 0);
    PQ_RegisterWrite(VIP_reg_vdi_snr_gain_th, 0);

	//sigmaNR request by kent 
	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_BLK_MODE_W, 1);
	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_BLK_MODE_N, 1);
	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_BLK_MODE_S, 1);
		
}


void PQ_SetupStrength(PQ_ITEM ucItemID, UINT8 ucDegree)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    const LUMA_TNR_STRENGTH* pLTNRStrength;
    const CHROMA_TNR_STRENGTH* pCTNRStrength;
    const LUMA_SNR1_STRENGTH* pLSNR1Strength;
    const BLOCK_NR_CORING* pBlockNrCoring;
    const BLOCK_NR_STRENGTH* pBlockNrStrength;
    const MOSQUITO_NR_CORING* pMosquitoNrCoring;
    const MOSQUITO_NR_STRENGTH* pMosquitoNrStrength;

    pHwContext->CVD2_store_nr_setting=0;
    pHwContext->Degree=ucDegree;

    ucDegree = min(15, max(0, (INT32)ucDegree));

    if( ucItemID<PQ_ITEM_BLOCK_NR_CORING || (ucItemID >= PQ_ITEM_TNR_ULTRA_LOW &&  ucItemID <= PQ_ITEM_SNR2_ULTRA_LOW))
    {
        if( ucItemID==PQ_ITEM_LUMA_SNR1_CORING || ucItemID==PQ_ITEM_LUMA_SNR2_CORING )
            ucDegree = min(ucDegree,(UINT8)PQ_MAX_LSNR_DEGREE);
        else if(ucItemID == PQ_ITEM_SNR1_ULTRA_LOW || ucItemID == PQ_ITEM_SNR2_ULTRA_LOW)
            ucDegree = min(ucDegree,(UINT8)PQ_MAX_SNR_ULOW_DEGREE);
        else
            ucDegree = min(ucDegree,(UINT8)PQ_MAX_ITEM_DEGREE);
    }
    else
    {
        //digital NR
        ucDegree=min(ucDegree ,(UINT8)PQ_MAX_MPEGNR_DEGREE );
    }
    
    switch(ucItemID)
    {
        case PQ_ITEM_LUMA_TNR_CORING:
            PQ_RegisterWrite(VIP_reg_vdi_tnr_th1_adj_min,0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_th1,0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_th1_adj_max, 34);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_th1_adj_fact, 40);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_mbw1_alpha_adj, (VIP_GetInputVSize()<720)?8:0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_mbw2_alpha_adj, (VIP_GetInputVSize()<720)?12:8);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_mbw3_alpha_adj, 16);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_mbwm_alpha_adj, 24);
            break;
        case PQ_ITEM_LUMA_TNR_STRENGTH:
            if(VIP_IsATVSource())
                pLTNRStrength= &ATVLTNRStrength[ucDegree];
            else if(VIP_IsAVSource())
                pLTNRStrength= &AVLTNRStrength[ucDegree];
            else if(VIP_IsPCSource())
            {
                if(VIP_GetInputVSize()<720)
                    pLTNRStrength= &PCSDLTNRStrength[ucDegree];
                else
                    pLTNRStrength = &PCHDLTNRStrength[ucDegree];
            }
            else
            {
                if(VIP_GetInputVSize()<720)
                    pLTNRStrength= &SDLTNRStrength[ucDegree];
                else
                    pLTNRStrength = &HDLTNRStrength[ucDegree];
            }

            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_adj_min, pLTNRStrength->vdi_tnr_alpha_adj_min);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_init, pLTNRStrength->vdi_tnr_alpha_init);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_adj_min_dith, pLTNRStrength->vdi_tnr_alpha_adj_min_dith);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_alpha, pLTNRStrength->vdi_tnr_alpha);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_inc_fact,4);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dec_fact,2);
            break;
        case PQ_ITEM_CHROMA_TNR_CORING:
            if(VIP_GetUserSource() == SOURCE_MPEG && (VIP_GetInputVSize() == 1080))
                PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_chroma, 0x38);   //#47690
            else
                PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_chroma, 16);
            break;
        case PQ_ITEM_CHROMA_TNR_STRENGTH:
            pCTNRStrength = &CTNRStrength[ucDegree];
            if(VIP_GetUserSource() == SOURCE_CVD2)
                pCTNRStrength = &CVD2CTNRStrength[ucDegree];

            PQ_RegisterWrite(VIP_reg_vdi_tnr_th1_chroma, pCTNRStrength->vdi_tnr_alpha_chroma);
            break;
        case PQ_ITEM_TNR_ULTRA_LOW:
            PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th3, 0x800);
            break;
        case PQ_ITEM_LUMA_SNR1_CORING:
            if(VIP_IsATVSource() )
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring, 0x10);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_limit, 0xff);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th1, 0x10);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th2, 8);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th3, 0);
            }
            else if(VIP_IsAVSource() )
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring, 0);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_limit, 0x20);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th1, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th2, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th3, 0x16);
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring, 0xc);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_limit, 0x2c);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th1, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th2, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_coring_th3, 0x11);
            }
            break;
        case PQ_ITEM_LUMA_SNR1_STRENGTH:
            if(VIP_IsATVSource())
                pLSNR1Strength = &ATVLSNR1Strength[ucDegree];
            else if(VIP_IsAVSource())
                pLSNR1Strength = &AVLSNR1Strength[ucDegree];
            else if(VIP_IsPCSource())
            {
                if(VIP_GetlInputCaptureVSize()<720)
                    pLSNR1Strength = &PCSDSNR1Strength[ucDegree];
                else
                    pLSNR1Strength = &PCHDSNR1Strength[ucDegree];
            }
            else
            {
                if(VIP_GetlInputCaptureVSize()<720)
                    pLSNR1Strength = &SDSNR1Strength[ucDegree];
                else
                    pLSNR1Strength = &HDSNR1Strength[ucDegree];
            }

            PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, pLSNR1Strength->vdi_snr_ulow_gain_inc);

            if(VIP_IsATVSource())
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_smooth,  0x10);
            else if(VIP_IsAVSource())
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_smooth, 0x28);
            else
                PQ_RegisterWrite(VIP_reg_vdi_snr_hl_smooth, 0x22);
            break;
        case PQ_ITEM_LUMA_SNR2_CORING:
            if(VIP_IsATVSource() )
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring, 0x10);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_limit, 0xff);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th1, 16);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th2,8);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th3, 0);
            }
            else if(VIP_IsAVSource() )
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_limit, 0x24);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th1, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th2, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th3, 0x15);
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring, 0x14);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_limit, 0x34);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th1, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th2, 4);
                PQ_RegisterWrite(VIP_reg_vdi_snr_vl_coring_th3, 0xf);
            }
            break;
        case PQ_ITEM_LUMA_SNR2_STRENGTH:
            break;
        case PQ_ITEM_CHROMA_SNR_CORING:
            if(VIP_IsATVSource() )
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring_limit, 0x30);
            }
            else if(VIP_IsAVSource() )
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring_limit, 0x28);
            }
            else if(VIP_GetInputVSize() <720)
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring_limit, 0x2C);
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring_limit, 0x60);
            }
            break;
        case PQ_ITEM_CHROMA_SNR_STRENGTH:
            PQ_RegisterWrite(VIP_reg_vdi_snr_hc_smooth, CSNRStrength[ucDegree].vdi_snr_hc_smooth);
            break;
        case PQ_ITEM_SNR1_ULTRA_LOW:
            break;
        case PQ_ITEM_SNR2_ULTRA_LOW:
            break;
        case PQ_ITEM_BLOCK_NR_CORING:
            pBlockNrCoring= &BlockNrCoring[ucDegree];
            PQ_RegisterWrite(VIP_reg_vdi_dbk_vdiff_th2, pBlockNrCoring->vdi_dbk_hdiff_th2);
            PQ_RegisterWrite(VIP_reg_vdi_dbk_vdiff_hmot_th2, pBlockNrCoring->vdi_dbk_hdiff_th2 +2);
            PQ_RegisterWrite(VIP_reg_vdi_dbk_vdiff_lmot_th2, pBlockNrCoring->vdi_dbk_hdiff_th2 -2);
            PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_hmot_th2, min(pBlockNrCoring->vdi_dbk_hdiff_th2 + 2, 42));
            PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_lmot_th2, max(pBlockNrCoring->vdi_dbk_hdiff_th2 - 2, 0));
            PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_th2, pBlockNrCoring->vdi_dbk_hdiff_th2);
            break;
	case PQ_ITEM_BLOCK_NR_STRENGTH:
            pBlockNrStrength= &BlockNrStrength[ucDegree];
            //yuling:must less than 42
            PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_hmot_th1, min(pBlockNrStrength->vdi_dbk_hdiff_th1 + 2, 42));
            PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_lmot_th1, max(pBlockNrStrength->vdi_dbk_hdiff_th1 - 2, 0));
            PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_th1, pBlockNrStrength->vdi_dbk_hdiff_th1);
            PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_slope1, pBlockNrStrength->vdi_dbk_hdiff_slope1);
            PQ_RegisterWrite(VIP_reg_vdi_dbk_vdiff_th1,pBlockNrStrength->vdi_dbk_hdiff_th1);
            PQ_RegisterWrite(VIP_reg_vdi_dbk_vfil_slope, pBlockNrStrength->vdi_dbk_hdiff_slope1);
            PQ_RegisterWrite(VIP_reg_vdi_dbk_vdiff_hmot_th1,pBlockNrStrength->vdi_dbk_hdiff_th1+2);
            PQ_RegisterWrite(VIP_reg_vdi_dbk_vdiff_lmot_th1,pBlockNrStrength->vdi_dbk_hdiff_th1-2);
            break;
        case PQ_ITEM_MOSQUITO_NR_CORING:
            pMosquitoNrCoring= &MosquitoNrCoring[ucDegree];
            PQ_RegisterWrite(VIP_reg_vdi_mnr_h_coring_inc, pMosquitoNrCoring->vdi_mnr_h_coring_inc);
            PQ_RegisterWrite(VIP_reg_vdi_mnr_v_coring_inc, pMosquitoNrCoring->vdi_mnr_v_coring_inc);
            break;
        case PQ_ITEM_MOSQUITO_NR_STRENGTH:
            pMosquitoNrStrength= &MosquitoNrStrength[ucDegree];
            PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, pMosquitoNrStrength->vdi_mnr_gain_inc);
            break;
	}

}


void PQ_Set_NR_BlockAlpha(UINT8 NRBlockAlphaType)
{

    PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucLevel;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    NR_Setting_BY_Group_Idx *pNR_Setting_BY_Group_Idx;
    //UINT8 j;	

    if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
	
    if(pVtab == NULL)
    {
    	return ;
    }

    if (pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex] >= 8)	
    {
    	return;
    }


	if((*((UINT8*)(0xbe1cd688))) == 0x6)
		printk("<0>%s %d, ucCurrSrcIndex = %d\n",__FUNCTION__, __LINE__, ucCurrSrcIndex);
    ucTableIndex = pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex];
	if((*((UINT8*)(0xbe1cd688))) == 0x6)
		printk("<0>%s %d, ucTableIndex = %d\n",__FUNCTION__, __LINE__, ucTableIndex);	
    pNR_Setting_BY_Group_Idx = &pVtab->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex];

    if(pNR_Setting_BY_Group_Idx == NULL)
    {
    	return ;
    }
		
    ucLevel = pHwContext->nNRLevel-1;
	if((*((UINT8*)(0xbe1cd688))) == 0x6)
		printk("<0>%s, NRBlockAlphaType = %d, nNRLevel = %d\n",__FUNCTION__,NRBlockAlphaType, pHwContext->nNRLevel);


			
	if(pHwContext->nNRLevel == OFF && 
		(VIP_GetUserSource() == SOURCE_CVD2 ||
		(VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource()))
	  )
	{
		ucLevel = 0;
	}

    if(pHwContext->nNRLevel == OFF && 
		(VIP_GetUserSource() == SOURCE_JPEG ||
		VIP_GetUserSource() == SOURCE_HDMI ||
		VIP_GetUserSource() == SOURCE_MPEG ||
		VIP_IsPCSource())
	  )
	{
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr4, 0);
		
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac0, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac1, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac2, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, 255);

		
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5, 0);

		
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr4, 0);
		
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac0, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac1, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac2, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac3, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac4, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac5, 255);

		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp4, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp5, 0);

		
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr4, 0);
		
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac0, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac1, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac2, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac3, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac4, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac5, 255);
		
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp4, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp5, 0);

		
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr4, 0);

		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac0, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac1, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac2, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac3, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac4, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac5, 255);
		
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp4, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp5, 0);
		
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr4, 0);
		
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac0, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac1, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac2, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac3, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac4, 255);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac5, 255);

		
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp2, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp3, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp4, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp5, 0);
	}
	else
	{

        switch(NRBlockAlphaType){
        case NR_BLOCK_ALPHA_TNR:

            // TNR enable
            if(pVtab->MagicNumber9 == NewTNRVer)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mmap_en >> (ucTableIndex*4));
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mmap_en);
            }


            // thr 0 ~ 4
		    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mthr[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mthr[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mthr[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mthr[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mthr[4].Degree[ucLevel]);


            // slp 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mslp[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mslp[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mslp[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mslp[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mslp[4].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mslp[5].Degree[ucLevel]);


            // fac 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mfac[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mfac[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mfac[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mfac[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mfac[4].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mfac[5].Degree[ucLevel]);

            //for VIP_reg_vdi_tnr_map_en disable
            PQ_RegisterWrite(VIP_reg_vdi_tnr_blk_diff_lp_en, 1);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_7tap, 0);

		//
		/*for(j = 0; j < 5; j++)
			VIPDebugPrint("%s, mthr[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mthr[j].Degree[ucLevel]);

		for(j = 0; j < 6; j++)	
  	    {
	  		VIPDebugPrint("%s,  mslp[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mslp[j].Degree[ucLevel]);
	  		VIPDebugPrint("%s, mfac[%d].Degree[%d] = %d",__FUNCTION__, j,ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR].mfac[j].Degree[ucLevel]);
	  	}*/
            break;
        case NR_BLOCK_ALPHA_TNR_SNR:

            // TNR_SNR enable
             if(pVtab->MagicNumber9 == NewTNRVer)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mmap_en >> (ucTableIndex*4));
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mmap_en);
            }


                // thr 0 ~ 4
		        PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mthr[0].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mthr[1].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mthr[2].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mthr[3].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_thr4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mthr[4].Degree[ucLevel]);


                // slp 0 ~ 5
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mslp[0].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mslp[1].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mslp[2].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mslp[3].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mslp[4].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_slp5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mslp[5].Degree[ucLevel]);


                // fac 0 ~ 5
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mfac[0].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mfac[1].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mfac[2].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mfac[3].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mfac[4].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_fac5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mfac[5].Degree[ucLevel]);

                //for VIP_reg_vdi_tnr_snr_map_en  disable
                PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_slope, 0x1f);//need default
		//
		/*for(j = 0; j < 5; j++)
			VIPDebugPrint("%s, mthr[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mthr[j].Degree[ucLevel]);

		for(j = 0; j < 6; j++)	
  	    	{
	  		VIPDebugPrint("%s,  mslp[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mslp[j].Degree[ucLevel]);
	  		VIPDebugPrint("%s, mfac[%d].Degree[%d] = %d",__FUNCTION__, j,ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_SNR].mfac[j].Degree[ucLevel]);
	  	}*/
            break;
        case NR_BLOCK_ALPHA_TNR_C:

            // TNR_C enable
            if(pVtab->MagicNumber9 == NewTNRVer)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mmap_en >> (ucTableIndex*4));
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mmap_en);
            }



                // thr 0 ~ 4
		        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mthr[0].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mthr[1].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mthr[2].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mthr[3].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mthr[4].Degree[ucLevel]);


                // slp 0 ~ 5
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mslp[0].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mslp[1].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mslp[2].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mslp[3].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mslp[4].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mslp[5].Degree[ucLevel]);


                // fac 0 ~ 5
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mfac[0].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mfac[1].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mfac[2].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mfac[3].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mfac[4].Degree[ucLevel]);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mfac[5].Degree[ucLevel]);
//
		/*for(j = 0; j < 5; j++)
			VIPDebugPrint("%s, mthr[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mthr[j].Degree[ucLevel]);

		for(j = 0; j < 6; j++)	
  	    	{
	  		VIPDebugPrint("%s,  mslp[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mslp[j].Degree[ucLevel]);
	  		VIPDebugPrint("%s, mfac[%d].Degree[%d] = %d",__FUNCTION__, j,ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNR_C].mfac[j].Degree[ucLevel]);
	  	}*/
            break;
        case NR_BLOCK_ALPHA_TNRZ:

            // TNRZ enable
           if(pVtab->MagicNumber9 == NewTNRVer)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mmap_en >> (ucTableIndex*4));
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mmap_en);
            }


            // thr 0 ~ 4
		    PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mthr[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mthr[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mthr[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mthr[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_thr4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mthr[4].Degree[ucLevel]);


            // slp 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mslp[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mslp[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mslp[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mslp[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mslp[4].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_slp5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mslp[5].Degree[ucLevel]);


            // fac 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mfac[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mfac[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mfac[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mfac[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mfac[4].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_fac5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mfac[5].Degree[ucLevel]);

            //for VIP_reg_vdi_tnrz_map_en disable
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope, 31);
//
		/*for(j = 0; j < 5; j++)
			VIPDebugPrint("%s, mthr[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mthr[j].Degree[ucLevel]);

		for(j = 0; j < 6; j++)	
  	    	{
	  		VIPDebugPrint("%s,  mslp[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mslp[j].Degree[ucLevel]);
	  		VIPDebugPrint("%s, mfac[%d].Degree[%d] = %d",__FUNCTION__, j,ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ].mfac[j].Degree[ucLevel]);
		}*/
            break;
        case NR_BLOCK_ALPHA_TNRZ_C:

            // TNRZ_C enable
            if(pVtab->MagicNumber9 == NewTNRVer)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mmap_en >> (ucTableIndex*4));
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_en, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mmap_en);
            }


            // thr 0 ~ 4
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mthr[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mthr[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mthr[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mthr[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mthr[4].Degree[ucLevel]);


            // slp 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mslp[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mslp[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mslp[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mslp[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mslp[4].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mslp[5].Degree[ucLevel]);


            // fac 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac0, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mfac[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac1, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mfac[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac2, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mfac[2].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac3, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mfac[3].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac4, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mfac[4].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac5, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mfac[5].Degree[ucLevel]);

            // for VIP_reg_vdi_tnrz_c_map_en disable
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_chroma, 20);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_chroma, 25);

		//
		/*for(j = 0; j < 5; j++)
			VIPDebugPrint("%s, mthr[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mthr[j].Degree[ucLevel]);

		for(j = 0; j < 6; j++)	
  	    	{
	  		VIPDebugPrint("%s,  mslp[%d].Degree[%d] = %d",__FUNCTION__, j, ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mslp[j].Degree[ucLevel]);
	  		VIPDebugPrint("%s, mfac[%d].Degree[%d] = %d",__FUNCTION__, j,ucLevel, pNR_Setting_BY_Group_Idx->NRBlockAlpha[NR_BLOCK_ALPHA_TNRZ_C].mfac[j].Degree[ucLevel]);
		}*/
            break;
        case NR_BLOCK_ALPHA_AV_SECAM_PATCH:
            //TNR C
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_en  ,1);
            // thr 0 ~ 4
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr0, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr2, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr3, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr4, 0);		 
            // slp 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp0, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp2, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp3, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp4, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp5, 0);
            // fac 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac0, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac2, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac3, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac4, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac5, 0);

            //TNRZ C
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_en	,1);
            // thr 0 ~ 4
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr0, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr2, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr3, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr4, 0);
            // slp 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp0, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp2, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp3, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp4, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp5, 0);
            // fac 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac0, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac2, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac3, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac4, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac5, 0); 
            break;
        }
    }
}




void PQ_Set_NR_SLR_SNR(UINT8 ucSLR_SNR_TYPE)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucLevel;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    SNR_Setting *pNR_SLR_SNR1;
    SNR_Setting *pNR_SLR_SNR2;

    if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
    if (pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex] >= 8) return;

    ucTableIndex = pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex];
    pNR_SLR_SNR1 = &pVtab->mSNR1Setting[ucTableIndex];
    pNR_SLR_SNR2 = &pVtab->mSNR2Setting[ucTableIndex];

    ucLevel = (pHwContext->nNRLevel==OFF) ? 0 : (pHwContext->nNRLevel-1) ;    

    switch(ucSLR_SNR_TYPE){
        case NR_SNR_BEFORE_SCALER:
            //SNR1
            PQ_RegisterWrite(VIP_reg_slr_snr_bypass, (pHwContext->nNRLevel==OFF) ? 1 : pNR_SLR_SNR1->SNR_MapByPass);
            //LUMA
            PQ_RegisterWrite(VIP_reg_slr_snr_sel, pNR_SLR_SNR1->SNR_Luma.SNR_Sel.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_chk_middle_pxl, pNR_SLR_SNR1->SNR_Luma.SNR_Chk_Middle_Pxl.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_th1, pNR_SLR_SNR1->SNR_Luma.SNR_th.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_gain1, pNR_SLR_SNR1->SNR_Luma.SNR_Gain[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_gain2, pNR_SLR_SNR1->SNR_Luma.SNR_Gain[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_slope, pNR_SLR_SNR1->SNR_Luma.SNR_Slope.Degree[ucLevel]);
            //CHROMA
            PQ_RegisterWrite(VIP_reg_slr_snr_sel_c, pNR_SLR_SNR1->SNR_Chroma.SNR_Sel.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_chk_middle_pxl_c, pNR_SLR_SNR1->SNR_Chroma.SNR_Chk_Middle_Pxl.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_th1_c, pNR_SLR_SNR1->SNR_Chroma.SNR_th.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_gain1_c, pNR_SLR_SNR1->SNR_Chroma.SNR_Gain[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_gain2_c, pNR_SLR_SNR1->SNR_Chroma.SNR_Gain[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_snr_slope_c, pNR_SLR_SNR1->SNR_Chroma.SNR_Slope.Degree[ucLevel]);
            break;
        case NR_SNR_AFTER_SCALER:
             //SNR2
            PQ_RegisterWrite(VIP_reg_slr_s_snr_bypass, (pHwContext->nNRLevel==OFF) ? 1 : pNR_SLR_SNR2->SNR_MapByPass);
            //LUMA
            PQ_RegisterWrite(VIP_reg_slr_s_snr_sel, pNR_SLR_SNR2->SNR_Luma.SNR_Sel.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_chk_middle_pxl, pNR_SLR_SNR2->SNR_Luma.SNR_Chk_Middle_Pxl.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_th1, pNR_SLR_SNR2->SNR_Luma.SNR_th.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_gain1, pNR_SLR_SNR2->SNR_Luma.SNR_Gain[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_gain2, pNR_SLR_SNR2->SNR_Luma.SNR_Gain[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_slope, pNR_SLR_SNR2->SNR_Luma.SNR_Slope.Degree[ucLevel]);
            //CHROMA
            PQ_RegisterWrite(VIP_reg_slr_s_snr_sel_c, pNR_SLR_SNR2->SNR_Chroma.SNR_Sel.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_chk_middle_pxl_c, pNR_SLR_SNR2->SNR_Chroma.SNR_Chk_Middle_Pxl.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_th1_c, pNR_SLR_SNR2->SNR_Chroma.SNR_th.Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_gain1_c, pNR_SLR_SNR2->SNR_Chroma.SNR_Gain[0].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_gain2_c, pNR_SLR_SNR2->SNR_Chroma.SNR_Gain[1].Degree[ucLevel]);
            PQ_RegisterWrite(VIP_reg_slr_s_snr_slope_c, pNR_SLR_SNR2->SNR_Chroma.SNR_Slope.Degree[ucLevel]);
            break;
	case NR_SNR_CASE1:
		PQ_RegisterWrite(VIP_reg_slr_snr_sel_c, 3); //db3c
            	PQ_RegisterWrite(VIP_reg_slr_snr_chk_middle_pxl_c, 1);//db3d
            	PQ_RegisterWrite(VIP_reg_slr_snr_th1_c, 154); //db40
            	PQ_RegisterWrite(VIP_reg_slr_snr_gain1_c, 255); //db41
            	PQ_RegisterWrite(VIP_reg_slr_snr_gain2_c, 1); //db42
            	PQ_RegisterWrite(VIP_reg_slr_snr_slope_c, 451); // db44
		break;	
    }
}

UINT32 PQ_ChromaBinPercentage(UINT8 ucBin)
{
	UINT32 dwChromaHistTotal=1;
	INT32 ulChromaHistBin[14];
	UINT8 i=0;
	UINT32 cbin=0;
	
	for ( i=0 ; i<14 ; i++ )
	{
		dwChromaHistTotal += PQ_RegisterRead(VIP_reg_dpy_chroma_bin0+4*i);
		ulChromaHistBin[i]= PQ_RegisterRead(VIP_reg_dpy_chroma_bin0+4*i);
	}

	if(dwChromaHistTotal == 0) 
	{
		dwChromaHistTotal = 1;
	}
	if (VIP_IsATVSource() || VIP_IsAVSource())
		cbin = 	((ulChromaHistBin[ucBin]+1) * 999) / dwChromaHistTotal;
	else
		cbin = 	(ulChromaHistBin[ucBin] * 1000) / dwChromaHistTotal;

	return (cbin);	
}

UINT8 PQ_IsColorBar(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    
    return pHwContext->bIsColorBar;
}


UINT8 PQ_IsDigitalScanADC2(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    
    return pHwContext->bIsPattern_DIG_ADC2;
}


/**
 * @brief For detect specific pattern : FLUKE 54200, PAT#DIGITAL SCAN(DIG_ADC2)
 *
 * This function detec tthe Chroma bin distribution for check specific pattern
 *
 * @param n/a
 * @return 1 : is DIGITAL SCAN(DIG_ADC2), 0 : not DIGITAL SCAN(DIG_ADC2)
 * note : the Hue distribution only in ChromaHist[0, 4, 9, 13] and the reset chroma hist should be 0
*/
void PQ_DigitalScanADC2Detect(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    UINT8 SpecificHueTotal = 0, SpecificHueAverage = 0, ChromaHistDiffTH = 1;
    BOOL bPAL_DIG_ADC2 = FALSE, ucStaticFlag = PQ_GetMotionStatusByMethod3();
    
    pHwContext->bIsPattern_DIG_ADC2 = FALSE;

    if((VIP_GetUserSource() == SOURCE_CVD2) && ((VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK) && (VIP_GetStdColorSystem() <= CVD2_STD_PAL_60))&& ucStaticFlag == STATIC_FRAME)   
    {
        SpecificHueTotal = pHwContext->ChromaHist.ulChromaHistAvg[0] + pHwContext->ChromaHist.ulChromaHistAvg[4]+ pHwContext->ChromaHist.ulChromaHistAvg[9] + pHwContext->ChromaHist.ulChromaHistAvg[13];
        SpecificHueAverage = SpecificHueTotal/4;

        if(pHwContext->ChromaHist.ulChromaHistAvg[0] != 0 && pHwContext->ChromaHist.ulChromaHistAvg[4] != 0 && pHwContext->ChromaHist.ulChromaHistAvg[9] != 0 && pHwContext->ChromaHist.ulChromaHistAvg[13] != 0)
        {
            if((*((UINT8*)(0xbe1cd688))) == 0x12) myprintk("SpecificHueTotal = %d, totoal = %d, percent = %d", SpecificHueTotal, pHwContext->ChromaHist.dwTotalChromaHistAvg, (SpecificHueTotal * 100 / pHwContext->ChromaHist.dwTotalChromaHistAvg));
            if(pHwContext->ChromaHist.dwTotalChromaHistAvg != 0)
            {
                if((SpecificHueTotal * 100 / pHwContext->ChromaHist.dwTotalChromaHistAvg) >= 99) //only ChromaHist[0, 4, 9, 13] with value
                {
                    bPAL_DIG_ADC2 = TRUE;
                }
            }
        }

        //avoid ChromaHist[0, 4, 9, 13] do not average distribute
        if(abs(pHwContext->ChromaHist.ulChromaHistAvg[0] -SpecificHueAverage) > ChromaHistDiffTH || abs(pHwContext->ChromaHist.ulChromaHistAvg[4] -SpecificHueAverage) > ChromaHistDiffTH 
             || abs(pHwContext->ChromaHist.ulChromaHistAvg[9] -SpecificHueAverage) > ChromaHistDiffTH || abs(pHwContext->ChromaHist.ulChromaHistAvg[13] -SpecificHueAverage) > ChromaHistDiffTH)
        {
            bPAL_DIG_ADC2 = FALSE;
        }

        if(bPAL_DIG_ADC2)
        {
            pHwContext->bIsPattern_DIG_ADC2 = TRUE;
            if((*((UINT8*)(0xbe1cd688))) == 0x12) myrprintk("DigitalScanADC2 = %d", pHwContext->bIsPattern_DIG_ADC2);
        }
        else
        {
            pHwContext->bIsPattern_DIG_ADC2 = FALSE;
            if((*((UINT8*)(0xbe1cd688))) == 0x12) myrprintk("DigitalScanADC2 = %d", pHwContext->bIsPattern_DIG_ADC2);
        }
        
    }
    
}


void _ChromaHistDetect(void)
{
    PQHW_CONTEXT* pHwContext = &PQHwContext;
    UINT8 i = 0;
    UINT32 CaptureWindowSize = 0;
    
    memset(&pHwContext->ChromaHist, 0, sizeof(CHROMA_HISTOGRAM));
    CaptureWindowSize = (PQ_RegisterRead(VIP_reg_adix_che) - PQ_RegisterRead(VIP_reg_adix_chs))*(PQ_RegisterRead(VIP_reg_adix_cve) - PQ_RegisterRead(VIP_reg_adix_cvs)); 
    
    for(i = 0; i <18; i++)
    {
        pHwContext->ChromaHist.ulChromaHist[i] = PQ_RegisterRead(VIP_c_bin00_pre+i*4);
        pHwContext->ChromaHist.dwTotalChromaHistPixel += pHwContext->ChromaHist.ulChromaHist[i];
        if(CaptureWindowSize > 0)
        {
            pHwContext->ChromaHist.ulChromaHistAvg[i] = pHwContext->ChromaHist.ulChromaHist[i] * 100 /  CaptureWindowSize;
        }
        pHwContext->ChromaHist.dwTotalChromaHistAvg += pHwContext->ChromaHist.ulChromaHistAvg[i];

        if((*((UINT8*)(0xbe1cd688))) == 0x11) myprintk("HistAvg[%d] = %d, Hist[%d] = %d, totalAVG = %d,  totalPixel = %d", i, pHwContext->ChromaHist.ulChromaHistAvg[i], i, pHwContext->ChromaHist.ulChromaHist[i], pHwContext->ChromaHist.dwTotalChromaHistAvg, pHwContext->ChromaHist.dwTotalChromaHistPixel);
        
    }

}

/**
 * @brief color bar SW detect function
 *
 * This function collect the hue bin distribution to check if current pattern color bar or not
 *
 * @param n/a
 * @return 1 : color bar, 0 : not color bar
 * note : secam case 1, for TG-39, Pattern Round 1 with Cross and circle mixed signal, the Hue distribution as follow
 *          huebin[2, 5, 8, 11, 14, 17] is almost equal and with value, the reset huebin should be 0
*/
BOOL PQ_SWDTColorBar(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    UINT8 i=0,dis_th=0, act_th=2;
    UINT8 c_bin_cnt=0, c_bin_cnt_th, SecamHueBinDiffTH = 1;
    UINT8 StableCntTH, StableCntMax;
    static UINT8 StableCnt = 0;
    UINT8 ucNoiseStatus = 0;
    BOOL ucStaticFlag = PQ_GetMotionStatusByMethod3();
    UINT8 SpecificHueTotal = 0, SecamColorBarFlag = 0, SpecificHueAverage = 0;

    if((*((UINT8*)(0xbe1cd688))) == 0x4) 
    {
        pHwContext->bIsColorBar = 0;
        return 0;
    }

    _ChromaHistDetect();
#ifdef DRV_ENABLE_CVD2
    if(VIP_GetUserSource() == SOURCE_CVD2)
    {
    	if(VIP_IsATVSource())
    	{
	        if(DRV_CVD2_GetColbarCnt() >= 0x60)
	        {
	            pHwContext->bIsColorBar = 1;
	            return 1;
	        }
    	}
		else if(VIP_IsAVSource())
		{
	        if(DRV_CVD2_GetColbarCnt() >= 0x90)
	        {
	            pHwContext->bIsColorBar = 1;
	            return 1;
	        }
    	}
    }
#endif
    //non-standard pattern
    if(((pHwContext->ChromaHist.ulChromaHistAvg[8] > act_th) && (pHwContext->ChromaHist.ulChromaHistAvg[9] > act_th) && (pHwContext->ChromaHist.ulChromaHistAvg[10] > act_th)) || (pHwContext->ChromaHist.ulChromaHistAvg[1] > act_th))
    {
        pHwContext->bIsColorBar = 0;
        if((*((UINT8*)(0xbe1cd688))) == 0x11)  myrprintk("bIsColorBar = %d, non standard pattern", pHwContext->bIsColorBar);
        return 0;
    }

    //secam case 1
    if((VIP_GetUserSource() == SOURCE_CVD2) && (VIP_GetStdColorSystem() == CVD2_STD_SECAM) && ucStaticFlag == STATIC_FRAME)   
    {
        SpecificHueTotal = pHwContext->ChromaHist.ulChromaHistAvg[2] + pHwContext->ChromaHist.ulChromaHistAvg[5]+ pHwContext->ChromaHist.ulChromaHistAvg[8] + pHwContext->ChromaHist.ulChromaHistAvg[11] 
            + pHwContext->ChromaHist.ulChromaHistAvg[14] + pHwContext->ChromaHist.ulChromaHistAvg[17];
        SpecificHueAverage = SpecificHueTotal/6;

        if(pHwContext->ChromaHist.ulChromaHistAvg[2] != 0 && pHwContext->ChromaHist.ulChromaHistAvg[5] != 0 && pHwContext->ChromaHist.ulChromaHistAvg[8] != 0 
            && pHwContext->ChromaHist.ulChromaHistAvg[11] != 0 && pHwContext->ChromaHist.ulChromaHistAvg[14] != 0 && pHwContext->ChromaHist.ulChromaHistAvg[17] != 0)
        {
            if(pHwContext->ChromaHist.dwTotalChromaHistPixel > 0)
            {
                if((SpecificHueTotal * 100 / pHwContext->ChromaHist.dwTotalChromaHistAvg) >= 99) //only huebin[2, 5, 8, 11, 14, 17] with value
                {
                    SecamColorBarFlag = 1;
                }
            }
        }

        //avoid huebin[2, 5, 8, 11, 14, 17] do not average distribute
        if(abs(pHwContext->ChromaHist.ulChromaHistAvg[2] -SpecificHueAverage) > SecamHueBinDiffTH || abs(pHwContext->ChromaHist.ulChromaHistAvg[5] -SpecificHueAverage) > SecamHueBinDiffTH || abs(pHwContext->ChromaHist.ulChromaHistAvg[8] -SpecificHueAverage) > SecamHueBinDiffTH
             || abs(pHwContext->ChromaHist.ulChromaHistAvg[11] -SpecificHueAverage) > SecamHueBinDiffTH || abs(pHwContext->ChromaHist.ulChromaHistAvg[14] -SpecificHueAverage) > SecamHueBinDiffTH || abs(pHwContext->ChromaHist.ulChromaHistAvg[17] -SpecificHueAverage) > SecamHueBinDiffTH)
        {
            SecamColorBarFlag = 0;
        }

        if(SecamColorBarFlag)
        {
            pHwContext->bIsColorBar = 1;
            if((*((UINT8*)(0xbe1cd688))) == 0x11) myrprintk("bIsColorBar = %d", pHwContext->bIsColorBar);
            return 1;
        }
        
    }
	
    c_bin_cnt=0;
    if (VIP_IsAVSource() || (VIP_IsATVSource() && (VIP_GetStdColorSystem() > CVD2_STD_NTSC_443) && (VIP_GetStdColorSystem() < CVD2_STD_SECAM))) act_th=3;   // #48695 

    for(i=0;i<18;i++)
    {
        if ((i==0)&&((pHwContext->ChromaHist.ulChromaHistAvg[0]>act_th)&&
            (((pHwContext->ChromaHist.ulChromaHistAvg[17]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[1]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[2]<=dis_th)))||
            ((pHwContext->ChromaHist.ulChromaHistAvg[1]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[17]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[16]<=dis_th))))))    
                c_bin_cnt = c_bin_cnt + 1;	
        else if ((i==1)&&((pHwContext->ChromaHist.ulChromaHistAvg[1]>act_th)&&
            (((pHwContext->ChromaHist.ulChromaHistAvg[0]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[2]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[3]<=dis_th)))||
            ((pHwContext->ChromaHist.ulChromaHistAvg[2]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[0]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[17]<=dis_th))))))    
                c_bin_cnt = c_bin_cnt + 1;	
        else if ((i==2)&&((pHwContext->ChromaHist.ulChromaHistAvg[2]>act_th)&&
            (((pHwContext->ChromaHist.ulChromaHistAvg[1]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[3]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[4]<=dis_th)))||
            ((pHwContext->ChromaHist.ulChromaHistAvg[3]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[1]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[0]<=dis_th))))))    
                c_bin_cnt = c_bin_cnt + 1;			
        else if ((i>2)&&(pHwContext->ChromaHist.ulChromaHistAvg[i]>act_th)&&
            (((pHwContext->ChromaHist.ulChromaHistAvg[(i-1)%18]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[(i+1)%18]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[(i+2)%18]<=dis_th)))||
            ((pHwContext->ChromaHist.ulChromaHistAvg[(i+1)%18]<=dis_th)&&((pHwContext->ChromaHist.ulChromaHistAvg[(i-1)%18]<=dis_th)||(pHwContext->ChromaHist.ulChromaHistAvg[(i-2)%18]<=dis_th)))))    
                c_bin_cnt = c_bin_cnt + 1;	
    }

    if((VIP_GetInputDataFormat() == 0 && VIP_GetRGB2YCbCrRange() == 0) || (VIP_GetUserSource() == SOURCE_HDMI))
    {
        c_bin_cnt_th = 5;
    }
    else if(VIP_IsATVSource())
    {
        if(VIP_GetStdColorSystem() == CVD2_STD_SECAM)
        {
            c_bin_cnt_th = 4;
        }
        else if((VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK) && (VIP_GetStdColorSystem() <= CVD2_STD_PAL_60))
        {
            c_bin_cnt_th = 6;
        }
        else
        {
            c_bin_cnt_th = 5;  
        }
    }
    else if(VIP_IsAVSource())
    {
        if(VIP_GetStdColorSystem() == CVD2_STD_SECAM)
        {
            c_bin_cnt_th = 4;
        }
        else if(VIP_GetStdColorSystem() == CVD2_STD_PAL_M)
        {
            c_bin_cnt_th = 5;
        }
        else
        {
            c_bin_cnt_th = 6;
        }
    }
    else
    {
        c_bin_cnt_th = 6;
    }
#ifdef DRV_ENABLE_CVD2
    CVD2_GetNoiseStatus(&ucNoiseStatus);
#endif
    if(ucTempM <= 2)
    {
        StableCntMax =  5;
        StableCntTH = 2;
    }   
    else if(ucTempM > 2 && ucTempM <= 8)
    {
        StableCntMax =  30;
        StableCntTH = 10;
    }
    else if(ucTempM > 8 && ucTempM <= 18)
    {
        StableCntMax =  40;
        StableCntTH = 10;
    }
    else if(ucTempM > 18 && ucTempM <= 22)
    {
        StableCntMax =  60;
        StableCntTH = 20;
    }
    else if(ucTempM > 22 && ucTempM <= 25)
    {
        StableCntMax =  60;
        StableCntTH = 25;
    }
    else
    {
        StableCntMax =  1;
        StableCntTH = 10;
    }
    
    if ((c_bin_cnt >= c_bin_cnt_th))
    {
        if(StableCnt < StableCntMax)
        {
            StableCnt++;
        }
    }
    else 
    {
        if(StableCnt > 0)
        {
            StableCnt--;
        }
    }

    if(StableCnt > StableCntTH)
    {
        pHwContext->bIsColorBar = 1;
        if((*((UINT8*)(0xbe1cd688))) == 0x11) myprintk("bIsColorBar : %d, 23e = %d, ucTempM = %d,  chromacount = %d, cnt > TH : %d > %d, sat_all = %d", pHwContext->bIsColorBar, ucNoiseStatus, ucTempM, c_bin_cnt, StableCnt, StableCntTH, PQ_RegisterRead(VIP_deg_dpy_sat_all));
        return 1;
    }
    else
    {
        pHwContext->bIsColorBar = 0;
        if((*((UINT8*)(0xbe1cd688))) == 0x11) myprintk("bIsColorBar : %d, 23e = %d, ucTempM = %d,  chromacount = %d, cnt < TH : %d < %d, sat_all = %d", pHwContext->bIsColorBar, ucNoiseStatus, ucTempM, c_bin_cnt, StableCnt, StableCntTH, PQ_RegisterRead(VIP_deg_dpy_sat_all));
        return 0;
    }
	
}

void PQ_EnColorBarDetectWorkQue_ISR(void)
{     
    queue_work(WQ_Struct_ColorBarDetect,&WQ_ColorBarDetect);
}

void PQ_SetColorBarFnFlag(UINT8 ucenable)
{
    utempCheckColorbarDTFunctionEN = ucenable;
}

void PQ_PCColorBar_SharpnessPatch(void)
{
    UINT8 pccolor;

    pccolor = PQ_IsColorBar();

	if (pccolor != 0 && utempCheckColorbarDTFunctionEN == 0)
	{
        PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre, 0x03);        
	    PQ_RegisterWrite(VIP_reg_slr_dcti_c1_pre, 0xd0);
		PQ_RegisterWrite(VIP_reg_slr_dcti_c2_pre, 0xe6f);
		PQ_RegisterWrite(VIP_reg_slr_dcti_c3_pre, 0xf84);			
		PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_post, 0x0);

		PQ_RegisterWrite(VIP_reg_slr_dcti_c1_post, 0x173);	//49315,48665
		PQ_RegisterWrite(VIP_reg_slr_dcti_c2_post, 0x53);
		PQ_RegisterWrite(VIP_reg_slr_dcti_c3_post, 0xf5b);
		PQ_RegisterWrite(VIP_reg_slr_dcti_c4_post, 0xf0a);
		PQ_RegisterWrite(VIP_reg_slr_dcti_c5_post, 0xf43);
		PQ_RegisterWrite(VIP_reg_slr_dcti_c6_post, 0xf98); 
        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_0_post, 0x10);		
		PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,	0x3);	 
		PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x5);

		if (VIP_GetInputVSize() <= 450)	//#49219
		{
			PQ_RegisterWrite(VIP_reg_slr_2d_l_sel, 0x2);		
		}
		else
		{
			PQ_Sharpness_POST_2D(TRUE, utempSharpnesscValue);	
		}

		PQ_SetColorBarFnFlag(ENABLE);
	}
	else if (pccolor == 0 && utempCheckColorbarDTFunctionEN  == 1)
	{
		PQ_SetColorBarFnFlag(DISABLE);
		PQ_Sharpness_PREDCTI(TRUE, utempSharpnesscValue);
             PQ_Sharpness_POSTDCTI(TRUE,utempSharpnesscValue);
		PQ_Sharpness_POST_2D(TRUE, utempSharpnesscValue);
	}
}


UINT32 PQ_PureColorPatternDetect(INT8 ucHBin)  //eric
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    int scond1 = 0; 
    static int scounter = 0;
    UINT32 ulTotalHueBin=0;
    UINT32 ulGrayBin;
    UINT8 i=0, j=0;
    UINT8 bCVD2_NTSC_to_PAL_Patch = FALSE;
    UINT32 ulHsize=0, ulVsize=0;
    UINT32 dwTotalPixel =0, dwChromaHistTotal = 0;
	BOOL ulChromaBin0 = 0, ulChromaBin1 = 0;

    ulGrayBin=PQ_RegisterRead(VIP_c_gray_bin_pre);	

    ulTotalHueBin = pHwContext->ChromaHist.dwTotalChromaHistPixel;
    
    if(ulTotalHueBin==0) ulTotalHueBin=1;

	//==Total Pixel=========
	ulHsize = PQ_RegisterRead(VIP_reg_slr_out_width);
	ulVsize = PQ_Get_VDI_VSize();
	dwTotalPixel = ulHsize*ulVsize ;

	if(dwTotalPixel==0) return 0;

    //==Chroma================== #52938
    for ( i=0 ; i<14 ; i++ )
    {
        dwChromaHistTotal += PQ_RegisterRead(VIP_reg_dpy_chroma_bin0+4*i);
    }
	
    ulChromaBin0 = ( (((PQ_RegisterRead(VIP_reg_dpy_chroma_bin0)) *100) / (dwChromaHistTotal+1))> 91 )? 1:0;
    ulChromaBin1 = ( (((PQ_RegisterRead(VIP_reg_dpy_chroma_bin1)) *100) / (dwChromaHistTotal+1))< 8 )? 1:0;

    j = ucHBin;

    //==Gray Pattern========
	if((*((UINT8*)(0xbe1cd688))) == 0x25) myrprintk("ulGrayBin = %d, ulTotalHueBin = %d, j = %d", ulGrayBin, dwTotalPixel, j);    
    if((j == 21) && ( ((ulGrayBin*100)/dwTotalPixel) >= 99 ) && ulChromaBin0 && ulChromaBin1)
   	{
		return 2;
   	}
	else if ( j == 21 )  return 0;

    if(ulGrayBin > ulTotalHueBin)
    {
        pHwContext->bIsPureColorPattern = FALSE;
        return 0;
    }

    j = ucHBin;

    if ( j == 20 )
    {
        for(i=0;i<18;i++)
        {
            if ( (pHwContext->ChromaHist.ulChromaHist[i] * 100 / ulTotalHueBin) > 98 ) //eric
            {
                scond1=1;
                break;
            }
        }
    }

    if(scond1 == 1)
    {
        if(scounter < 3)
        {
            scounter++;
        }
    }
    else
    {
        if(scounter > 0)
        {
            scounter--;
        }
    }
    
    if(scounter > 0 && scond1 != 1) // 3 buffer for 99% pure color pattern
    {
        scond1=1;
    }

    if(VIP_GetUserSource() == SOURCE_CVD2 && VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK)
    {
        if ((pHwContext->ulHistCaseCur == 23 || pHwContext->ulHistCaseCur == 31) &&  (( (pHwContext->ChromaHist.ulChromaHist[17] * 100 / ulTotalHueBin) >= 98) || ((pHwContext->ChromaHist.ulChromaHist[17]+ pHwContext->ChromaHist.ulChromaHist[6])* 100 / ulTotalHueBin >= 98)))
        {
            bCVD2_NTSC_to_PAL_Patch = 1;
        }

        if((pHwContext->ulHistCaseCur == 5 || pHwContext->ulHistCaseCur == 4) && ((pHwContext->ChromaHist.ulChromaHist[16]+ pHwContext->ChromaHist.ulChromaHist[17])* 100 / ulTotalHueBin) >= 99) //#51954
        {
            bCVD2_NTSC_to_PAL_Patch = 1;
        }
    }

    pHwContext->bCVD2_NTSC_to_PAL_Patch = bCVD2_NTSC_to_PAL_Patch;
    
    if ( scond1==1 )
    {
        pHwContext->bIsPureColorPattern = TRUE;
        return 1;
    }
    else
    {
        pHwContext->bIsPureColorPattern = FALSE;
        return 0;
    }
}


BOOL PQ_GetPureColorPattern(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

    return pHwContext->bIsPureColorPattern;
}


void PQ_ColorBarDetect(void) //sharlene
{
    UINT8 ucSD, cnt_th=5, colorbar;
    UINT32 vdi_vsize;
    UINT8 ucUserSource;
    UINT8 ucSubSource;
    static UINT8  stable_cnt = 0;
    UINT8 TNRZ_C_patch_flag = FALSE;
#ifdef	CONFIG_SUPPORT_SATURATION_PROTECT
    UINT8  satprot=0;
    UINT32 sat_under;
    static UINT8  sat_flag = 0;
#endif
    BOOL ucCVD2_NSTD_Flag=PQ_CheckCvd2NonSTDStatus();

    // if(VIP_IsSourceDTV()|| VIP_RunDVIMode() || VIP_IsPCSource()|| VIP_GetVDIPause())
    if(VIP_IsSourceDTV()|| VIP_RunDVIMode() || VIP_GetVDIPause())		
    {
        return ;
    }
    else if (VIP_IsPCSource())
    {
        PQ_PCColorBar_SharpnessPatch();
        return;
    }	

     if((*((UINT8*)(0xbe1cd688))) == 0x5) return;

    if(PQ_GetColorProcessor() == FALSE)
    {
        PQ_SetColorBarFnFlag(DISABLE);
        PQ_Sharpness_PREDCTI(TRUE, utempSharpnesscValue);
        PQ_Sharpness_POSTDCTI(TRUE,utempSharpnesscValue);
        PQ_Sharpness_POST_2D(TRUE, utempSharpnesscValue);
        PQ_Sharpness_Peaking_DLTI(TRUE, utempSharpnesscValue);
        PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0x200);
        
        return;
    }
        
    vdi_vsize= PQ_Get_VDI_VSize();

    // #47928 
    if(VIP_GetInterlaceMode())
        ucSD = (vdi_vsize<=288)?1:0;   
    else if(VIP_GetInputHSize()<=800)
        ucSD = (vdi_vsize<=576)?1:0;    
    else ucSD = 0;


    VIP_GetSource(&ucUserSource, &ucSubSource);

    colorbar = PQ_IsColorBar();
  
    if(colorbar==0 && stable_cnt != 0)
    {
        stable_cnt = stable_cnt - 1;   
    }  
    else if(colorbar!=0 && stable_cnt != cnt_th)
    {
        stable_cnt = stable_cnt + 1;   
    }  

    #ifdef	CONFIG_SUPPORT_SATURATION_PROTECT
    if( VIP_IsATVSource() || (VIP_IsAVSource() && VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) )
    {
        satprot = PQ_GetPureColorPattern();  // check pure color noise issue #51828 & #51962 & #51940
        if (satprot==1 && sat_flag==0)
        {
            PQ_RegisterWrite(VIP_reg_dpy_mtx_sat_limit_fac0,(((PQ_RegisterRead(VIP_reg_dpy_mtx_sat_limit_fac0))&0xffff00ff)|(0xfc<<8)));
            sat_flag = 1;
        }
        else if (satprot==0 && sat_flag==1)
        {
            PQ_RegisterWrite(VIP_reg_dpy_mtx_sat_limit_fac0,(((PQ_RegisterRead(VIP_reg_dpy_mtx_sat_limit_fac0))&0xffff00ff)|(0xd8<<8)));
            sat_flag = 0;
        }
        else if (satprot==1 && sat_flag==1)
        {
            sat_under = PQ_RegisterRead(VIP_reg_dpy_mtx_sat_limit_fac0);
            sat_under = sat_under & 0x0000ff00;
            if (sat_under == 0xd8) sat_flag = 0;
        }
    }
    #endif

    if (colorbar==0 && utempCheckColorbarDTFunctionEN  == 0)
    {   
        if((*((UINT8*)(0xbe1cd688))) == 0x1) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: Colorbar Return \n\033[0m\n ",__LINE__,__FUNCTION__);
        return;
    }
    else if ((colorbar!=0 && utempCheckColorbarDTFunctionEN == 0 && stable_cnt == cnt_th) || ucCVD2_NSTD_Flag)    
    {
        if((*((UINT8*)(0xbe1cd688))) == 0x1) printk(KERN_EMERG"\033[1m\033[40;35m [%s][%d]Colorbor Enable\033[0m\n ",__FUNCTION__,__LINE__); 
        if(ucSD) //SD
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre,    2);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_pre, 2);
            PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_pre,0);
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,    0x2);

            if(ucUserSource == SOURCE_CVD2){
                if(VIP_IsATVSource())
                {
                    if(VIP_GetStdColorSystem() > CVD2_STD_NTSC_443 && VIP_GetStdColorSystem() < CVD2_STD_SECAM)
                    {
                        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x5);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x3);
                    }
                    else if(VIP_GetStdColorSystem() == CVD2_STD_SECAM)   //for ATV SECAM yellow_cyan noise : #51678
                    {
                        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x5);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x0);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_c1_post, 0x13f);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_c2_post, 0xf75);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_c3_post, 0xeb4);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_c4_post, 0xf44);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_c5_post, 0x4);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_c6_post, 0xf33); 
                    }
                    else
                    {
                        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x2);
                        PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x0);
                    }
                }
                else
                {
                    PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x5);

                    if(VIP_GetStdColorSystem() == CVD2_STD_PAL_M || VIP_GetStdColorSystem() == CVD2_STD_PAL_CN)
                    {
                        PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x3);	
                    }
                    else
                    {
                        PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x5);  
                    }
                } 

                if(ucCVD2_NSTD_Flag)
                {
                    if(VIP_GetStdColorSystem() < CVD2_STD_SECAM)
                    {
                        PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0);
                        stable_cnt = 0;
                    }
                }
                else
                {
                    if(VIP_GetStdColorSystem() != CVD2_STD_NTSC_443)
                    {
                        if (VIP_GetStdColorSystem() == CVD2_STD_SECAM)
                        {
                            PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0); //#33736
                        }
                        else
                        {
                             PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0x80);
                        }
                    }
                    else
                    {
                        PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0x200);
                    }
                }
                if( ucSubSource==S1_INPUT_CHANNEL || ucSubSource==S2_INPUT_CHANNEL || ucSubSource==S3_INPUT_CHANNEL ){  //#40329
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c1_post, 0x173);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c2_post, 0x53);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c3_post, 0xf5b);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c4_post, 0xf0a);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c5_post, 0xf43);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c6_post, 0xf98); 
                    PQ_RegisterWrite(VIP_reg_slr_dlti_scale_post, 0x0); 
                    PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x2);   }

                if( VIP_GetStdColorSystem() == CVD2_STD_NTSC_M )
                {
                    TNRZ_C_patch_flag = TRUE;
                }

                //for AV & ATV colorbar noise
                PQ_RegisterWrite(VIP_reg_dpy_mtx_sat_limit_fac0,(((PQ_RegisterRead(VIP_reg_dpy_mtx_sat_limit_fac0))&0xffff00ff)|(0xfc<<8)));

                //for ATV NTSC noise : #48347
                if( VIP_IsATVSource() && VIP_GetStdColorSystem() == CVD2_STD_NTSC_M )
                {
                    PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_SEL_S, 0x8);			 
                    PQ_RegisterWrite(VIP_REG_VDI_SIGMA_FIL_GAIN_S, 0x6);
                    PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_GAIN_S, 0x6);				
                }			   

                //for ATV PAL/SECAM yellow_cyan noise : #51823 & #51678
                if( VIP_IsATVSource() && ((VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) || (VIP_GetStdColorSystem() == CVD2_STD_SECAM)) )
                {
                    if( VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_alpha_div0, 0x1);
                    }
                    else
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_alpha_div1, 0x1);			
                    }
                }				
            }			
            else if (ucUserSource == SOURCE_HDMI) 
            {
                PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,       0x3);
                PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post,    0x5);
                PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,   0x3);   
                PQ_RegisterWrite(VIP_REG_SLR_2D_SEL_SP, 0x0);   //49268
                // #49399
                PQ_RegisterWrite(VIP_reg_slr_dcti_c1_post, 0x173);
                PQ_RegisterWrite(VIP_reg_slr_dcti_c2_post, 0x53);
                PQ_RegisterWrite(VIP_reg_slr_dcti_c3_post, 0xf5b);
                PQ_RegisterWrite(VIP_reg_slr_dcti_c4_post, 0xf0a);
                PQ_RegisterWrite(VIP_reg_slr_dcti_c5_post, 0xf43);
                PQ_RegisterWrite(VIP_reg_slr_dcti_c6_post, 0xf98); 
            }   //#42800
            else
            { 
                PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre,    1);	//#40391

                if (!VIP_IsPCSource() && VIP_GetUserSource() == SOURCE_EXTS) 
                {
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c1_pre, 0x043);	 //#42567
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c2_pre, 0xe86);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c3_pre, 0xfa8);
                }
                else
                {						 
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c1_pre, 0x1c0);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c2_pre, 0xfdc);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_c3_pre, 0xf19);
                }
                PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,       0x3);
                PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post,    0x5);
                PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,   0x5);   
            }
                
            if (VIP_IsATVSource() && (VIP_GetStdColorSystem() > CVD2_STD_NTSC_443 && VIP_GetStdColorSystem() <= CVD2_STD_SECAM))
            {
                PQ_RegisterWrite(VIP_reg_slr_2d_c_scale, 1);
                if(VIP_GetStdColorSystem() == CVD2_STD_SECAM)
                    PQ_RegisterWrite(VIP_reg_slr_2d_c_scale, 0);	
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_slr_2d_c_scale, 0x3);
            }
        }
        else //HD
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre,    0x3);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_pre, 0x3);
            PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_pre,0x0);

            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,   0x3);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post,0x5);
            
            if (ucUserSource == SOURCE_HDMI || ucUserSource == SOURCE_EXTS) 
                PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x2);          
            else
                PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x0);
            
            if (ucUserSource == SOURCE_HDMI)
                PQ_RegisterWrite(VIP_REG_SLR_2D_SEL_SP, 0x0);	//49268
            // #47928
            PQ_RegisterWrite(VIP_reg_slr_dcti_c1_post, 0x173);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c2_post, 0x53);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c3_post, 0xf5b);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c4_post, 0xf0a);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c5_post, 0xf43);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c6_post, 0xf98); 
        }
        
        PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_pre,    0x1);
        PQ_RegisterWrite(VIP_reg_slr_pre_icp_alpha_pre, 0x3);
        //PQ_RegisterWrite(VIP_reg_slr_post_icp_en_pre,   0x1); //#34032
        
        PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_post,   0x1);
        PQ_RegisterWrite(VIP_reg_slr_pre_icp_alpha_post,0x3);
        PQ_RegisterWrite(VIP_reg_slr_post_icp_en_post,  0x1);

        if(ucUserSource == SOURCE_CVD2)
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_0_post,  0x7f);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_1_post,  0x7f);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_2_post,  0x7f);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_0_post,  0xff);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_1_post,  0xff);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_2_post,  0xff);
        }   

        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_th0_post,0x0);
        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_th1_post,0x0);
        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_slope0_post,0x0);
        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_slope1_post,0x0);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_sel, 0x1);
        PQ_SetColorBarFnFlag(ENABLE);

        //pre-DLTI
        if(VIP_IsATVSource() && (VIP_GetStdColorSystem() >= CVD2_STD_NTSC_M && VIP_GetStdColorSystem() < CVD2_STD_SECAM))
        {
            PQ_RegisterWrite(VIP_reg_slr_dlti_en_pre, 1);
            PQ_RegisterWrite(VIP_reg_slr_dlti_scale_pre, 2);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_tap_pre, 2);
            PQ_RegisterWrite(VIP_reg_slr_dlti_shoot_tap_pre, 0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c1_pre, 0xfa3);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c2_pre, 0xed1);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c3_pre, 0xfa3);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_0_pre, 0x9b);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_1_pre, 0x9b);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_2_pre, 0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_th0_pre, 0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_th1_pre, 0x2c);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_slope0_pre, 0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_slope1_pre, 0x140);
        }
        
        if(TNRZ_C_patch_flag)
        {
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_8bit1, 1);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_8bit1, 0);
        }
        
    }
    else if(colorbar==0 && utempCheckColorbarDTFunctionEN ==1)
    {
        PQ_SetColorBarFnFlag(DISABLE);
        PQ_Sharpness_PREDCTI(TRUE, utempSharpnesscValue);
        PQ_Sharpness_POSTDCTI(TRUE,utempSharpnesscValue);
        PQ_Sharpness_POST_2D(TRUE, utempSharpnesscValue);
        PQ_Sharpness_PREDLTI(TRUE, utempSharpnesscValue);	
        PQ_Sharpness_Peaking_DLTI(TRUE, utempSharpnesscValue);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_8bit1, 0);
        PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0x200);
        if(VIP_IsAVSource()||VIP_IsATVSource())
        {
            PQ_RegisterWrite(VIP_reg_dpy_mtx_sat_limit_fac0,(((PQ_RegisterRead(VIP_reg_dpy_mtx_sat_limit_fac0))&0xffff00ff)|(0xd8<<8)));

            //for ATV PAL/SECAM yellow_cyan  noise : #51823 & #51678
            if( VIP_IsATVSource() && ((VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) || (VIP_GetStdColorSystem() == CVD2_STD_SECAM)) )
            {
                if( VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK)
                {
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_alpha_div0, 0x0);
                }
                else
                {
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_alpha_div1, 0x0);
                }
            }			
        }
        if((*((UINT8*)(0xbe1cd688))) == 0x1) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ColorBarDisable \n\033[0m\n ",__LINE__,__FUNCTION__);
        PQDebugPrint("\033[1m\033[40;35m    [%s][%d]ColorBarDisable    \033[0m\n ",__FUNCTION__,__LINE__);
    }
    else
    {
        return;
    }
}


void PQ_SetFuzzyEliminate(UINT8 ucEnable) 
{
	if(ucEnable)
	{
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_lb_1, 0xa5);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_rb_1, 0x104);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_min_1, 0x10);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_max_1, 0x3ff);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_y_lb_1, 0x30);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_y_rb_1, 0xff);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_sel, 0x0f);
	   	PQ_RegisterWrite(VIP_reg_vdi_alpha1_tnulow_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_debug_fix_val0, 0xff);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_inc, 0x39);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_min_2, 0x19);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_max_2, 0x79);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_inc, 0x39);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_tnulow_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tulow_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tnulow_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_lb_2, 0x64);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_rb_2, 0x96);
		PQ_RegisterWrite(VIP_reg_vdi_alpha_sel, 0x03);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha1_inc, 0x39);

	}
	else
	{
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_lb_1, 0x12c);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_rb_1, 0x15e);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_min_1, 0x1900);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_max_1, 0x19000);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_y_lb_1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_y_rb_1, 0x40);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_sel, 0x01);
		PQ_RegisterWrite(VIP_reg_vdi_alpha1_tnulow_en, 0);
		PQ_RegisterWrite(VIP_reg_vdi_debug_fix_val0, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_inc, 0x23);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_lb_2, 175);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_rb_2, 270);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_min_2, 400);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_max_2, 0xfffff);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_inc, 0x0A);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_tnulow_en, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tulow_en, 0);
		 PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tnulow_en, 0);
		 PQ_RegisterWrite(VIP_reg_vdi_alpha_sel, 0x01);
		 PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha1_inc, 0x23);
	}
}


void _TnrClampPatch(void)
{
    PQHW_CONTEXT* pHwContext = &PQHwContext;
    UINT8 ucSigmaNgGain = 0; 

    if(pHwContext->PqPatch.TnrClampPatch == TNR_CLAMP_DEFAULT_ATV_GRAYSCALE_PATCH)
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_typ3, 0x1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_fac1, 0x20);
        
        PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add1, 0x01);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add2, 0x80);

        PQ_RegisterWrite(VIP_reg_slr_y_data_type, 3);

    }
    else
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_typ3, 0x0);        
        PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_fac1, 0x02);
        
        PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add1, 0x00);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add2, 0x00);

        PQ_RegisterWrite(VIP_reg_slr_y_data_type, 0);
    }

    if(pHwContext->PqPatch.TnrClampPatch == TNR_CLAMP_DEFAULT_AV_GRAYSCALE_PATCH)
    {
        ucSigmaNgGain = 1;
    }

    PQ_RegisterWrite(VIP_reg_slr_dither, 0);
    
    PQ_RegisterWrite(VIP_REG_VDI_SIGMA_NG_GAIN, ucSigmaNgGain);
}


void PQ_AdjustNr(void)
{
#ifdef ADJUST_NR_By_Yavg
    PQHW_CONTEXT* pHwContext = &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    static UINT32 ucLastSwapNRLevel =0;
    static UINT8 ucLastNRLevel = 0;
    UINT32 ucSwapTNRLevel =0;
    UINT32 ulHsize=0, ulVsize=0;
    UINT32 dwTotalPixel =0;
    UINT8 ucNRLevel = 0;
    BOOL DPYGrayFlag=0;
    UINT32 dwTotalWPixel;
    UINT32 ulHistBin[16];
    UINT32 NRGain[5] = {SDNR_Gain_normal,SDNR_Gain_Low,SDNR_Gain_Mid,SDNR_Gain_High,600};
    UINT32 dwChromaHistTotal = 0;
    BOOL ulChromaBin98 = 0;
    UINT8 i=0;
    UINT32 ucfield_diff_cnt = PQ_RegisterRead(VIP_field_diff_cnt);
    UINT32 ucvdi_mot_cnt = PQ_RegisterRead(VIP_vdi_mot_cnt);
    UINT32 ucvdi_vdbk_sts = PQ_RegisterRead(VIP_vdi_vdbk_sts);
#ifdef DRV_ENABLE_CVD2
    UINT8 CVD2NoiseLevel, ucNoiseStatus = 0;
    BOOL ucCVD2_NSTD_Flag=PQ_CheckCvd2NonSTDStatus();
	BOOL ucStaticFlag = PQ_GetMotionStatusByMethod3();
	BOOL AdjustTNRZCEnFlag = FALSE;
    BOOL AdjustTNRZCAVSecamFlag = FALSE;
    BOOL AdjustTNRZAlphaChromaFlag = FALSE;
    UINT8 AdjustTNRZEn = REFERENCE_VIPTABLE;
    UINT8 AdjustChromaTnrCoring = FALSE;
#endif
    BOOL ucVDI_static_flag = PQ_GetMotionStatusByMethod2(), SpecialFlag=0;
    UINT32 ucCTNRLevel = NRGain[4];
    
    UINT8 ucUserSource;
    UINT8 ucSubSource;
    #ifdef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
    UINT8 ucLowValue_tnrLstr = 0,ucMidValue_tnrLstr = 0,ucHighValue_tnrLstr = 0;
    UINT8 ucLowValue_tnrCstr = 0,ucMidValue_tnrCstr = 0,ucHighValue_tnrCstr = 0;
    #endif

	#ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION	
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
	#endif

    UINT8 ucSNR1Case = NR_SNR_BEFORE_SCALER;
#ifdef DRV_ENABLE_CVD2
    static UINT8 ucNoiseStatusStaticCount = 0;
    static UINT8 ucPreNoiseStatus = 0, TNR_REST_COUNT = 0;
#endif
    BOOL bTNR_C_EN_FLAG = ENABLE, bTNRZ_C_EN_FLAG = ENABLE;
    UINT8 SatGainPatch = SAT_GAIN_NORMAL;
    BOOL bTNRZ_EN_FLAG = ENABLE;

    NR_Setting_BY_Group_Idx *pNR_Setting_BY_Group_Idx;
    if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;

    if((*((UINT8*)(0xbe1cd688))) == 0x2) return;

    if(PQ_GetColorProcessor() == FALSE|| VIP_GetVDIPause())
        return;

    VIP_GetSource(&ucUserSource, &ucSubSource);
	 
    if (pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex] >= 8) return;
    ucTableIndex = pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex];
    pNR_Setting_BY_Group_Idx = &pVtab->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex];
    pHwContext->PqPatch.TnrClampPatch = TNR_CLAMP_DEFAULT;

	//==Total Pixel=========
	ulHsize = PQ_RegisterRead(VIP_reg_slr_out_width);
	ulVsize = PQ_Get_VDI_VSize();
	dwTotalPixel = ulHsize*ulVsize ;
	
	if(dwTotalPixel==0)
	{
		ucLastNRLevel = 0;
		return;
	}

	//==MotionCut============
	
	ucVDI_MotionFlag = PQ_GetMotionStatus(); //#40034
	
    //==Chroma==================
    for ( i=0 ; i<14 ; i++ )
    {
        dwChromaHistTotal += PQ_RegisterRead(VIP_reg_dpy_chroma_bin0+4*i);
    }
	
    ulChromaBin98 = ( (((PQ_RegisterRead(VIP_reg_dpy_chroma_bin0)) *100) / (dwChromaHistTotal+1))> 98 )? 1:0;

    //==Gray Pattern========
    if(( ((PQ_RegisterRead(VIP_c_gray_bin_pre)*100)/dwTotalPixel) >= 98 ) && ulChromaBin98)
    {
        DPYGrayFlag = 1;
    }
    else
    {
        DPYGrayFlag = 0;
    }

    dwTotalWPixel = 0;
    for(i = 0; i <16; i++)
    {
        ulHistBin[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
        dwTotalWPixel += ulHistBin[i];
    }    
    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s:DPYGrayFlag = %d, 63a4=%d,624c=%d,6238=%d \n\033[0m\n ",__LINE__,__FUNCTION__,DPYGrayFlag, ucfield_diff_cnt,ucvdi_mot_cnt,ucvdi_vdbk_sts);

#ifdef DRV_ENABLE_CVD2
//==CVD2NoiseLV==================
	CVD2_GetNoiseStatus(&ucNoiseStatus);
	if( (ucNoiseStatus > (ucTempM+2)) || (ucNoiseStatus < (ucTempM-2)))
	{
		ucTempM = ucNoiseStatus;

		// == Low noise detailless issue ==============
		if( VIP_IsATVSource() && ucTempM >= 12 ) PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 1);
		else if( VIP_IsATVSource() && ucTempM < 12 ) PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 0);
	}
	// == Low noise detailless issue ==============
	else if( VIP_IsATVSource() && (((ucNoiseStatus > (ucTempM+1)) && ucNoiseStatus > 12 ) || ucNoiseStatus == 12 ))
	{
		ucTempM = ucNoiseStatus;
		PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 1);
	}

    if(ucPreNoiseStatus == ucNoiseStatus)
    {
        ucNoiseStatusStaticCount++;
    }
    else
    {
        if(ucNoiseStatusStaticCount)
        {
            ucNoiseStatusStaticCount--;
        }
    }

    if(ucNoiseStatusStaticCount == 50)
    {
        if(ucTempM != ucNoiseStatus)
        {
            ucTempM = ucNoiseStatus;
        }
        ucNoiseStatusStaticCount = 0;
    }
    ucPreNoiseStatus = ucNoiseStatus;

	if ( ucTempM <= 5 )
		CVD2NoiseLevel = 0;
	else if ( ucTempM <= 8 )
		CVD2NoiseLevel = 1; 
	else if ( ucTempM <= 20 )
		CVD2NoiseLevel = 2;
	else CVD2NoiseLevel = 3;

	if((*((UINT8*)(0xbe1cd688))) == 0x8) myrprintk("23e = %d, ucTempM = %d, CVD2NoiseLevel = %d, menu NR = %d", ucNoiseStatus, ucTempM, CVD2NoiseLevel, pHwContext->nNRLevel);

	if( VIP_IsATVSource() && (VIP_GetStdColorSystem() < CVD2_STD_SECAM))
	{
		if((VIP_GetStdColorSystem() <  CVD2_STD_SECAM) && (VIP_GetStdColorSystem() > CVD2_STD_NONE) && PQ_GetColorBarStatus())
		{
			if(ucCVD2_NSTD_Flag)
			{
				ucSNR1Case = NR_SNR_CASE1;
				bTNR_C_EN_FLAG = DISABLE;
			}
		}
		PQ_Set_NR_SLR_SNR(ucSNR1Case);
		
		if(ucvdi_mot_cnt > 300) //if need change setting please sync with PQ_Set_NR_SLR_SNR()
		{
			PQ_RegisterWrite(VIP_reg_slr_snr_sel, 3);
		}
		else
		{
			PQ_RegisterWrite(VIP_reg_slr_snr_sel, 0);
		}
		
	}
	else
#endif
	{
		PQ_Set_NR_SLR_SNR(ucSNR1Case);
	}

    //Chroma TNR always Enable (DTV 1080i Disable), sync this with tool, noisereuction sub1, SetValue()
    if( (VIP_GetUserSource()==MPEG) && (VIP_GetInputVSize()>720) && VIP_GetInterlaceMode())
    {
        bTNR_C_EN_FLAG = DISABLE;
        bTNRZ_C_EN_FLAG = DISABLE;
    }
    else if((VIP_GetUserSource()==SOURCE_EXTS) && (PQ_GET_YUV_Datat_Formal()== eGFX_YUV_444_10bit || PQ_GET_YUV_Datat_Formal()==eGFX_YUV_444_8bit))
    {
        bTNR_C_EN_FLAG=DISABLE;
        bTNRZ_C_EN_FLAG = DISABLE;
    }

	
    //==Color Bar================================================================
#ifdef DRV_ENABLE_CVD2
	if((*((UINT8*)(0xbe1cd688))) == 0x8) myprintk("ColorBarStatus() = %d, StaticFlag = %d, CVD2_NSTD_Flag = %d, ucVDI_static_flag = %d", PQ_GetColorBarStatus(), ucStaticFlag, ucCVD2_NSTD_Flag, ucVDI_static_flag);
    if ( (PQ_GetColorBarStatus() && ucStaticFlag == STATIC_FRAME) || ucCVD2_NSTD_Flag == 1 )
    {
        ucSwapTNRLevel = NRGain[4];
        PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,0);

        PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,2);
        PQ_RegisterWrite(VIP_reg_slr_mbw_en			,1);

        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
        
        if(ucUserSource == SOURCE_CVD2)
        {
            AdjustTNRZCEnFlag = TRUE;
            AdjustChromaTnrCoring= TRUE;
            AdjustTNRZAlphaChromaFlag = TRUE;
            AdjustTNRZEn = DISABLE;

            if((ucTempM <= 10) && ucVDI_static_flag)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_slope_s, 0xff);
                bTNR_C_EN_FLAG = DISABLE;
                bTNRZ_EN_FLAG = DISABLE;
                PQ_RegisterWrite(VIP_REG_VDI_SIGMA_EN, 3);
                
                TNR_REST_COUNT = 2;
            }
            
            if(VIP_IsAVSource() && VIP_GetStdColorSystem() == CVD2_STD_NTSC_M)
            {
                bTNRZ_C_EN_FLAG = DISABLE; //#51586
            }

            if(VIP_IsATVSource())
            {
                if((VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) && (VIP_GetPanelWidth()==1280))
                {
                    SatGainPatch = SAT_GAIN_ATV_PAL_I_1280_PANEL_COLORBAR_PATCH;
                }

                if(VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK)
                {
                    //#52035
                    PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH, 15);
                    PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, 15);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr0, 0xa);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr1, 0x17);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr2, 0x27);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr3, 0x43);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_thr4, 0x60);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp0, 0x23);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp1, 0x18);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp2, 0x0c);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3, 0x6);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4, 0x6);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5, 0x5);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac0, 0x1);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac1, 0xc);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac2, 0x16);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, 0x1c);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, 0x22);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, 0x28);                    
                }
            }
        }
        
        if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ColorBar \n\033[0m\n ",__LINE__,__FUNCTION__);
    }//~Color Bar
    else if(VIP_GetUserSource() == SOURCE_CVD2 && (VIP_IsATVSource() || VIP_GetStdColorSystem() == CVD2_STD_SECAM)) // ATV, and AV SECAM
    {       
        #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION
        if(pHwContext->nNRLevel > WEAK) //20170310 for increase NR effect in OFF mode
        #endif 
        {
            if (CVD2NoiseLevel == 0)
            {
                ucSwapTNRLevel = NRGain[1];
                PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,2);
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,2);
    		
                PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,2);
                PQ_RegisterWrite(VIP_reg_slr_mbw_en			,1);

                if (DPYGrayFlag == 1 && VIP_IsATVSource())
                {
                    if (VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);	
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);	
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_PAL_M)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_hl_smooth,  0x14);
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_PAL_CN)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);	
                        PQ_RegisterWrite(VIP_reg_vdi_snr_hl_smooth,  0x14);	
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_SECAM)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x30);
                        if( PQ_RegisterRead(VIP_c_gray_bin_pre) == dwTotalPixel && (ulHistBin[2] == dwTotalWPixel || ulHistBin[3] == dwTotalWPixel)) PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,1);
                    }
                    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-0GY \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
                }
                else
                {
					if (VIP_GetStdColorSystem() == CVD2_STD_PAL_CN)	PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
					else PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
            		PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Strength.Degree[ucNRLevel] * 100 / 100);					
                }    			
                if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-0 \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
            } // ~CVD2NoiseLevel = 0, in ATV, and AV SECAM
            else if (CVD2NoiseLevel == 1)
            {
                ucSwapTNRLevel = NRGain[2];
                PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,2);
                PQ_RegisterWrite(VIP_reg_slr_mbw_en 		,1);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,0);
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,0);

                if (DPYGrayFlag == 1 && VIP_IsATVSource())
                {
                	if (VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK)
                	{
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);	
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);	
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_PAL_M)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_hl_smooth,  0x14);
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_PAL_CN)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);	
                        PQ_RegisterWrite(VIP_reg_vdi_snr_hl_smooth,  0x14);	
                    }
                    else if (VIP_GetStdColorSystem() == CVD2_STD_SECAM)
                    {
                        PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                        PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x30);
                        if( PQ_RegisterRead(VIP_c_gray_bin_pre) == dwTotalPixel && (ulHistBin[2] == dwTotalWPixel || ulHistBin[3] == dwTotalWPixel)) PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,1);
                    }
                    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-1GY \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
                }
                else
                {
                    if (VIP_GetStdColorSystem() == CVD2_STD_PAL_CN)	PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
                    else PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
            		PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Strength.Degree[ucNRLevel] * 100 / 100);										
                }    
                PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3	,6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4	,6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5	,6);
                if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-1 \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
            }// ~CVD2NoiseLevel = 1, in ATV, and AV SECAM
            else if (CVD2NoiseLevel == 2)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,0);
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,0);
                PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,2);
                PQ_RegisterWrite(VIP_reg_slr_mbw_en 		,1);
                
                #ifndef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
                ucSwapTNRLevel = NRGain[3];
                if (DPYGrayFlag == 1 && VIP_IsATVSource() && (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M))
                {
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                    PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, 0x48);	
                    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-N2GY \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
                }
                else
                {
                    PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
            		PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Strength.Degree[ucNRLevel] * 100 / 100);										
                }    
                
                #ifdef CONFIG_CONTROL_TNRZ_BY_PQ_DRIVER
                AdjustTNRZEn = DISABLE;
                #endif	
				
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+12);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+18);

                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3	,6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4	,6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5	,6);
							
                #else
				
                ucSwapTNRLevel = NRGain[2];
		
                if (DPYGrayFlag == 1 )
                {
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                    AdjustTNRZEn = DISABLE;
                    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-2GY \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
                }
                else
                {
                    PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
                    AdjustTNRZEn = ENABLE;		
                }

                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+10);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+20);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+30);

                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3	,10);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4	,10);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5	,10);
                
                #endif //~ifndef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
    			
                if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-2 \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
            }// ~CVD2NoiseLevel = 2, in ATV, and AV SECAM
            else //CVD2NoiseLevel == 3
            {
                if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-3 \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);

                #ifndef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
                ucSwapTNRLevel = NRGain[4];
                #else
                ucSwapTNRLevel = NRGain[2];
                #endif
                PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,0);
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,0);
                PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,0x1f);	
                PQ_RegisterWrite(VIP_reg_slr_mbw_en			,0);
                PQ_RegisterWrite(VIP_reg_ds_disable_func_en	,1);
    			
                if (DPYGrayFlag == 1 )//&& ulChromaBin98 == 1) //&& ucVDI_MotionFlag == 0)
                {
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                    AdjustTNRZEn = DISABLE;
                    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-3GY \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
                }
                else
                {
                    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel = %d, ATV_NR-3NGY \n\033[0m\n ",__LINE__,__FUNCTION__, pHwContext->nNRLevel);
                    PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
                    #ifndef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
                        #ifdef CONFIG_CONTROL_TNRZ_BY_PQ_DRIVER
                        AdjustTNRZEn = DISABLE;
                        #endif					
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+6);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+12);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+18);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3	,6);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4	,6);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5	,6);
                    #else
                    AdjustTNRZEn = ENABLE;
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+10);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+20);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+30);

                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3	,10);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4	,10);
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5	,10);
                    #endif
                }
            }// ~CVD2NoiseLevel = 3, in ATV, and AV SECAM

            if((*((UINT8*)(0xbe1cd688))) == 0x8) myprintk("ucTempDCCSceneID = %d, ulChromaBin98 = %d, PQ_ChromaBinPercentage(13) = %d, ucVDI_MotionFlag = %d", ucTempDCCSceneID, ulChromaBin98, PQ_ChromaBinPercentage(13), ucVDI_MotionFlag);
            if( ( ((ucTempDCCSceneID == 31 || ucTempDCCSceneID == 32) && ulChromaBin98) || PQ_ChromaBinPercentage(13)>980 ) && !ucVDI_MotionFlag )		
            {
                ucSwapTNRLevel = NRGain[4];
				
                if((DPYGrayFlag) && (CVD2NoiseLevel < 2))
                {							
                    AdjustTNRZEn = ENABLE;
                    PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,0);
                    PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,0);
                    PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,0x2); 
                    PQ_RegisterWrite(VIP_reg_slr_mbw_en 		,1);                    
					
                    if(VIP_IsATVSource())   //#51245
                    {
                        if(VIP_GetStdColorSystem() == CVD2_STD_PAL_M)
                        {
                            SatGainPatch = SAT_GAIN_ATV_PAL_M_GREY_SCALE_NR_PATCH;
                        }
                        else if(VIP_GetStdColorSystem() == CVD2_STD_SECAM)
                        {
                            SatGainPatch = SAT_GAIN_ATV_SECAM_GREY_SCALE_NR_PATCH;
                        }
                        else
                        {
                            SatGainPatch = SAT_GAIN_ATV_GREY_SCALE_PATCH;
                        }
                    }
                }
				
                PQ_SigmaNR(TRUE, 0, 0, 0);
                SpecialFlag = 1;
                
                if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: 31/32 , SpecialFlag = TRUE, DPYGrayFlag = %d, CVD2NoiseLevel = %d \n\033[0m\n ",__LINE__,__FUNCTION__, DPYGrayFlag, CVD2NoiseLevel);
            }
            else
            {
                if(VIP_IsATVSource())
                {
                    #ifdef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION			
                    PQ_SigmaNR(TRUE, 0xff, 0xff, 0xff);
                    #else
                    PQ_SigmaNR(TRUE, pMenuValue->ucNRLevel, 0xff, 0xff);		
                    #endif
                    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: regular pattern , in ATV source \n\033[0m\n ",__LINE__,__FUNCTION__);
                }
            }

        }// pHwContext->nNRLevel > WEAK in  ATV, and AV SECAM
        #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION
        else // NR = OFF in ATV, and AV SECAM
        {
            ucSwapTNRLevel = NRGain[0];
            PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,2);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,2);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,2);
            PQ_RegisterWrite(VIP_reg_slr_mbw_en 		,1);
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
            if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: nNRLevel == OFFATV_NR-0 \n\033[0m\n ",__LINE__,__FUNCTION__);
        }
        #endif

        // ==AV SECAM graycolorbar noise== #46926
        if (VIP_IsAVSource() && (VIP_GetStdColorSystem() == CVD2_STD_SECAM)) 
        {
            if (ucfield_diff_cnt == 0 && ucVDI_Static_Cnt_3 < 10) ucVDI_Static_Cnt_3++;
            else if (ucfield_diff_cnt == 0 && ucVDI_Static_Cnt_3 == 99) ucVDI_Static_Cnt_3 = 1;
            else if (ucfield_diff_cnt > 0 && ucVDI_Static_Cnt_3 > 0)	ucVDI_Static_Cnt_3 = 99;
            else if (ucVDI_Static_Cnt_3 >= 10 && ucVDI_Static_Cnt_3 < 15) ucVDI_Static_Cnt_3 = 10;

            if (ucVDI_Static_Cnt_3 >= 5 && ucVDI_Static_Cnt_3 <= 10)
            {
                AdjustTNRZCAVSecamFlag = TRUE;			
            }
            else if (ucVDI_Static_Cnt_3 == 99)
            {
                ucVDI_Static_Cnt_3 = 0;
            }		
        }	//~AV SECAM only

        if(VIP_IsATVSource() && VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) //#52035
        {
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
        }
    }// ~ATV or AV SECAM only    else if(VIP_GetUserSource() == SOURCE_CVD2 && (VIP_IsATVSource() || VIP_GetStdColorSystem() == CVD2_STD_SECAM)) // ATV, and AV SECAM
    else if( VIP_GetUserSource() == SOURCE_CVD2 && (!VIP_IsATVSource() && VIP_GetStdColorSystem() != CVD2_STD_SECAM)) // AV source, except AV Secam 
    {
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
        
        if( ucNoiseStatus <= 1 )
        {
            ucSwapTNRLevel =  NRGain[0];
            if (DPYGrayFlag == 1 && VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) //#49773
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_typ0, 0x0);
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_typ1, 0x1);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_fac, 0x1f);

                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2));
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+10);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+20);
				
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3	,16);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4	,16);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5	,16);
            }
            else
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_typ0, 0x1);
                PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_typ1, 0x0);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_fac, 0x10);				
            }
        }
        else if(ucNoiseStatus <=0x5)
        {
            if(ucVDI_MotionFlag == 0)
                ucSwapTNRLevel = NRGain[2];
            else
                ucSwapTNRLevel = NRGain[0];
        }
        else
        {
            ucSwapTNRLevel = NRGain[4];
            PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,0);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,0x1f);
            PQ_RegisterWrite(VIP_reg_slr_mbw_en			,0);
			
            if (DPYGrayFlag == 1 && ucVDI_MotionFlag == 0)
            {
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
                #ifdef CONFIG_CONTROL_TNRZ_BY_PQ_DRIVER
                AdjustTNRZEn = DISABLE;			
                #endif
                if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: AV_NR-3_GY \n\033[0m\n ",__LINE__,__FUNCTION__);
            }
            else
            {
                if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: AV_NR-3_NGY \n\033[0m\n ",__LINE__,__FUNCTION__);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac3, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac4, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+12);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_fac5, PQ_RegisterRead(VIP_reg_vdi_tnr_map_fac2)+18);

                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp3	,6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp4	,6);
                PQ_RegisterWrite(VIP_reg_vdi_tnr_map_slp5	,6);
            }
        }
 
    }// ~AV, NTSC & PAL only
    else 
#endif
	{
		if ( VIP_IsSourceDTV() && (VIP_GetInputVSize()<=600))
	    {
	        ucSwapTNRLevel = NRGain[0];
	        PQ_RegisterWrite(VIP_reg_slr_mbw_en 		,0);          //#40037
	    }
	    else if( VIP_GetUserSource() == SOURCE_MPEG && ucVDI_MotionFlag == 0 )
	    {
	        ucSwapTNRLevel = NRGain[0];
	        PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 1);
	    }
	    else
	    {
	        ucSwapTNRLevel = NRGain[0];
	    }
    }

    //NR setting patch, and recover while exit specific condition
#ifdef DRV_ENABLE_CVD2
    if(AdjustTNRZCEnFlag)
    {
        if (VIP_IsAVSource())// AV #50100
        {
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_en  ,0);
        }
            
        if (VIP_IsATVSource())// ATV #50100 
        {
        	if ((VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) && VIP_GetPanelWidth()==1280)
            	PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_en	,1);
			else
	            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_en	,0);
        }    
    }
    else if(AdjustTNRZCAVSecamFlag)
    {
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_AV_SECAM_PATCH);
    }
    else
#endif
    {
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR_C);
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ_C);
    }

#ifdef DRV_ENABLE_CVD2
    if(AdjustTNRZAlphaChromaFlag)
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_chroma, 0x1);
    }
    else
#endif
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_chroma, 0x10);
    }

#ifdef DRV_ENABLE_CVD2
    if(AdjustChromaTnrCoring)
    {
        if (VIP_IsAVSource())// AV #50100
        {
            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_chroma, 0x0);
        }
            
        if (VIP_IsATVSource())// ATV #50100 
        {
			if ((VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK) && VIP_GetPanelWidth()==1280 && VIP_GetPanelHeight()==800)
	            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_chroma, 0x1);
			else
	            PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_chroma, 0x9);
        }
		AdjustChromaTnrCoring= FALSE;
    }
    else
#endif
    {
        PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_CORING, 0);
    }

#ifdef DRV_ENABLE_CVD2
    if(AdjustTNRZEn == DISABLE)
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en, 0);	
    }
    else if(AdjustTNRZEn == ENABLE)
    {
		if (CVD2NoiseLevel <= 1 && DPYGrayFlag == 1 && VIP_IsATVSource() && VIP_GetStdColorSystem() == CVD2_STD_PAL_CN) 
		{
			// #51261
		}
		else 
		{
			PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en, 1);	
		}
    }
    else
#endif
    {
		PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
    }

    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_en, bTNRZ_C_EN_FLAG);

#ifdef DRV_ENABLE_CVD2
    if(TNR_REST_COUNT > 0)
    {
        TNR_REST_COUNT--;
        if(TNR_REST_COUNT == 0)
        {
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_slope_s, 0);
            bTNR_C_EN_FLAG = ENABLE;
            bTNRZ_EN_FLAG = ENABLE;
        }
    }
#endif
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_en, bTNR_C_EN_FLAG); //disable this can save memory bandwidth
    PQ_NR_TnrzEnable(bTNRZ_EN_FLAG);  

	
#ifdef DRV_ENABLE_CVD2
    if((VIP_GetUserSource() == SOURCE_CVD2) && DPYGrayFlag && ((ucTempDCCSceneID == 31 || ucTempDCCSceneID == 32)) && !ucVDI_MotionFlag)
    {
        if(VIP_IsATVSource())
        {
            pHwContext->PqPatch.TnrClampPatch = TNR_CLAMP_DEFAULT_ATV_GRAYSCALE_PATCH;    
        }
        else
        {
            pHwContext->PqPatch.TnrClampPatch = TNR_CLAMP_DEFAULT_AV_GRAYSCALE_PATCH;
        }     
    }
    _TnrClampPatch();
#endif
	if(VIP_GetUserSource() == SOURCE_HDMI && DPYGrayFlag==1)
		PQ_RegisterWrite(VIP_REG_VDI_SIGMA_EN, 0x00);
	else
		PQ_RegisterWrite(VIP_REG_VDI_SIGMA_EN, 0x01);
    //~recover NR setting while exit specific condition

    PQ_SetupSaturationGainCurve(SatGainPatch);
	
    if((ucSwapTNRLevel == ucLastSwapNRLevel && ucLastNRLevel == pHwContext->nNRLevel) && !pHwContext->bNR_Reset_by_changeSrc) 
    {
        return;
    }

    if(VIP_GetUserSource() != SOURCE_CVD2)
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s	,3);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s	,3);
        PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope	,2);
        PQ_RegisterWrite(VIP_reg_ds_disable_func_en, ucTempds_disable_func_en);
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);	
        if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: NO_DNR \n\033[0m\n ",__LINE__,__FUNCTION__);
    }    
	
    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ucSwapTNRLevel=%d \n\033[0m\n ",__LINE__,__FUNCTION__,ucSwapTNRLevel);
	
    if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ucNRLevel=%d \n\033[0m\n ",__LINE__,__FUNCTION__,ucNRLevel);

    if(pHwContext->nNRLevel>=WEAK && pHwContext->nNRLevel<=STRONG )
    {
        ucNRLevel = pHwContext->nNRLevel - 1;
    }
    else
    {
        ucNRLevel = OFF;
    }
#ifdef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
	ucLowValue_tnrLstr= (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[0] * ucSwapTNRLevel / 100;
	ucMidValue_tnrLstr= (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1] * ucSwapTNRLevel / 100;
	ucHighValue_tnrLstr = (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[2] * ucSwapTNRLevel / 100;
	
	ucLowValue_tnrCstr = (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[0] * ucSwapTNRLevel / 100;
	ucMidValue_tnrCstr = (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1] * ucSwapTNRLevel / 100;
	ucHighValue_tnrCstr = (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[2] * ucSwapTNRLevel / 100;

	if(((UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[0] < 13) && ((UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1] < 15 )\
	&& ((UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[0] < 13) && (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1] < 15)//tiaodebudui
	{

		if(ucHighValue_tnrLstr>=15)
		{
			if(ucLowValue_tnrLstr>= 14)
			{
				ucLowValue_tnrLstr= (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[0];

				if(( (PQ_GetColorBarStatus() && ucVDI_MotionFlag == 0) || ucCVD2_NSTD_Flag == 1 ) || (SpecialFlag == 1) )
					ucMidValue_tnrLstr= (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1]) * 3 / 4;
				else
					ucMidValue_tnrLstr= (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1]) / 2;

				if(ucMidValue_tnrLstr>=15)
					ucMidValue_tnrLstr = 14;
					
			}
			else if(ucMidValue_tnrLstr >= 15)
			{		
				if(( (PQ_GetColorBarStatus() && ucVDI_MotionFlag == 0) || ucCVD2_NSTD_Flag == 1 ) || (SpecialFlag == 1) )
					ucMidValue_tnrLstr= (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1]) * 2 / 3;			
				else
					ucMidValue_tnrLstr= (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[1]) / 2;

				if(ucMidValue_tnrLstr >= 15)
				{
					ucMidValue_tnrLstr = 14;

				}
			}
		}


		if(ucHighValue_tnrCstr>=15)
		{
			if(ucLowValue_tnrCstr>= 14)
			{
				ucLowValue_tnrCstr= (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[0];
				if(( (PQ_GetColorBarStatus() && ucVDI_MotionFlag == 0) || ucCVD2_NSTD_Flag == 1 ) || (SpecialFlag == 1) )
					ucMidValue_tnrCstr= (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1]) * 3 / 4;
				else
					ucMidValue_tnrCstr= (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1])  / 2;

				if(ucMidValue_tnrCstr>=15)
					ucMidValue_tnrCstr = 14;
			}
			else if(ucMidValue_tnrCstr >= 15)
			{		
				if(( (PQ_GetColorBarStatus() && ucVDI_MotionFlag == 0) || ucCVD2_NSTD_Flag == 1 ) || (SpecialFlag == 1) )
					ucMidValue_tnrCstr= (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1]) * 2 / 3; 		
				else
					ucMidValue_tnrCstr= (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1] + (16 - (UINT32) pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[1])  / 2;

				if(ucMidValue_tnrCstr >= 15)
				{
					ucMidValue_tnrCstr = 14;
				
				}
			}
		}
	}
#endif
	
  
    if((pHwContext->nNRLevel == OFF) && // JPEG HDMI, MPEG, PC , OSD NR = OFF only
  	(VIP_GetUserSource() == SOURCE_JPEG ||
 	VIP_GetUserSource() == SOURCE_HDMI ||
  	VIP_GetUserSource() == SOURCE_MPEG ||
 	VIP_IsPCSource() 
	))
  	 
    {
	    PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, 0);
   	    PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH, 0);
   	    PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, 0);
   	    PQ_SetupStrength(PQ_ITEM_TNR_ULTRA_LOW, 0);
   	    PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING,  0);
   	    PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH,		0);
   	    PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING,  0);
   	    PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH,		0);
   	    PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, 0);
   	    PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH,   0);
    } // ~ JPEG HDMI, MPEG, PC , OSD NR = OFF only
    else if((pHwContext->nNRLevel == OFF) && ((VIP_GetUserSource() == SOURCE_CVD2) ||(VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource()))) //only CVD2 or YPP  in OSD NR = OFF
    {
    	
        // #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION
        if(VIP_IsATVSource())
        {
            #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION			 
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,0);//ucLowValue_tnrLstr/2);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH,0);//ucLowValue_tnrCstr/2);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, 0);
            PQ_SetupStrength(PQ_ITEM_TNR_ULTRA_LOW, 0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING,  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH,		  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING,  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH,		  0);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, 0);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH,   0);			 
            #else
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, 9);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH, 9);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, 9);
            PQ_SetupStrength(PQ_ITEM_TNR_ULTRA_LOW, 0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING,	4);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH,		 0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING,	4);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH,		 2);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, 4);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH,	1);
            #endif
        }        
        #ifdef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
        else if( (SpecialFlag ) ||( (PQ_GetColorBarStatus() && ucVDI_MotionFlag == 0) || ucCVD2_NSTD_Flag == 1 ))
        #else
        else if( SpecialFlag )
        #endif
        {
            #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION			
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,0);//ucLowValue_tnrLstr/2);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH,0);//ucLowValue_tnrCstr/2);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, 0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING,  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH,		  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING,  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH,		  0);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, 0);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH,	 0);			 
            #else
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,(UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaTnrCoring.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Coring.Degree[ucNRLevel] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Strength.Degree[ucNRLevel] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr2Coring.Degree[ucNRLevel] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr2Strength.Degree[ucNRLevel] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->ChromaSnrCoring.Degree[ucNRLevel] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaSnrStrength.Degree[ucNRLevel] * 100 / 100);
            #endif
        }
        else
        {
            #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION	
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,0);//ucLowValue_tnrLstr/2);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH,0);//ucLowValue_tnrCstr/2);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, 0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING,  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH,		  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING,  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH,		  0);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, 0);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH,	 0);			 
            #else
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaTnrCoring.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Coring.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Strength.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr2Coring.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr2Strength.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->ChromaSnrCoring.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaSnrStrength.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,(UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[0] * 100 / 100);
            #endif		  
        }  
    }// ~only CVD2 or YPP  in OSD NR = OFF
    else
    {
        #ifdef CONFIG_SUPPORT_NR_SETTIGN_BY_TOOL 
        {
            if(ucNRLevel == 0)
            {
                PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,ucLowValue_tnrLstr);
                PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH,ucLowValue_tnrCstr );
            }
            else if(ucNRLevel == 1)
            {
                PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,ucMidValue_tnrLstr);
                PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH,ucMidValue_tnrCstr );
            }
            else if(ucNRLevel == 2)
            {
                PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,ucHighValue_tnrLstr);
                PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH,ucHighValue_tnrCstr );
            }

            if (VIP_GetUserSource() == SOURCE_MPEG && ucVDI_static_flag)
            {
                PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[ucNRLevel] * ucCTNRLevel);
            }
        }
        #else
        {
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,(UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[ucNRLevel] * ucSwapTNRLevel / 100);

            if (VIP_GetUserSource() == SOURCE_MPEG && ucVDI_static_flag)
            {
                PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[ucNRLevel] * ucCTNRLevel);
            }
            else
            {
                PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
            }
        }
        #endif
        PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaTnrCoring.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
        PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Coring.Degree[ucNRLevel] * 100 / 100);
        PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr1Strength.Degree[ucNRLevel] * 100 / 100);
        PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr2Coring.Degree[ucNRLevel] * 100 / 100);
        PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->LumaSnr2Strength.Degree[ucNRLevel] * 100 / 100);
        PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->ChromaSnrCoring.Degree[ucNRLevel] * 100 / 100);
#ifdef DRV_ENABLE_CVD2
        if (CVD2NoiseLevel <= 1 && DPYGrayFlag == 1 && VIP_IsATVSource() && (VIP_GetStdColorSystem() == CVD2_STD_PAL_CN || VIP_GetStdColorSystem() == CVD2_STD_PAL_M)) 
        {
            // #51261
        }
        else
#endif
        {
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaSnrStrength.Degree[ucNRLevel] * 100 / 100);
        }
     }

    ucLastSwapNRLevel = ucSwapTNRLevel;
    ucLastNRLevel = pHwContext->nNRLevel;
    pHwContext->bNR_Reset_by_changeSrc = FALSE;

#endif
}


void PQ_LoadSettingValue(UINT8* pVipTable, UINT8 ucTableIndex)
{
	PQ_TABLE_BOOK* pTableBook= (PQ_TABLE_BOOK*) pVipTable;
	UINT32 ulTableOffset,ulTableCount,ulRegister,ulValue,ulTotal,i;
	volatile UINT32* pAddr;
	PQHW_CONTEXT* pHwContext= &PQHwContext;
   // int j, k, m;
    //int m;
	INT32* pValArray= (INT32*) (&pHwContext->VtabCmnValue);

    if( ucTableIndex>=pTableBook->nTotalTable )
		return;

	ulTotal= sizeof(VTAB_CMN_VALUE_DEFINE)/sizeof(INT32);
	ulTableOffset= pTableBook->TableIndex[ucTableIndex].nOffset + (UINT32)pVipTable;
	ulTableCount= pTableBook->TableIndex[ucTableIndex].nSize >> 3;
	pAddr= (volatile UINT32*) ulTableOffset;

    #if SEPERATE_YPBPR1_YPBPR2
	if( ucTableIndex>=VTAB_EXTS_YPP_VALUE && ucTableIndex<=VTAB_EXTS_YPP2_HD_VALUE)
    #else
    if( ucTableIndex>=VTAB_EXTS_YPP_VALUE && ucTableIndex<=VTAB_HDMI_HD_VALUE)
    #endif
	{
		ulTotal= sizeof(VTAB_SRC_VALUE_DEFINE)/sizeof(INT32);
		pValArray= (INT32*) (&pHwContext->VtabSrcValue[ucTableIndex-VTAB_EXTS_YPP_VALUE]);
	}

	for (i=0; i<ulTableCount; i++)
	{
		ulRegister= *pAddr;

		if( ulRegister & PQ_REG_VALUE_DEFINE )
		{
			ulRegister&= ~PQ_REG_VALUE_DEFINE;
			ulValue= *(pAddr+1);
			
			if(ucTableIndex ==1)
			{
			   // if(ulRegister >= 0x29c0)
				//myprintk("ulRegister=0x%x ulValue=0x%x \n",  ulRegister, ulValue);
			}

			//PQDebugPrint("%s: i=0x%lx ulRegister=0x%8.8lx ulValue=0x%8.8lx", __FUNCTION__, i, ulRegister, ulValue);
			if( ulRegister<ulTotal )
			{
				*(&pValArray[ulRegister])= ulValue;
			}
		}
		pAddr+= 2;
	}

	/*
	myprintk("sizeof(SHARPNESS) = %d, SHARPNESS_DATA = %d, SHARP_INFO = %d", sizeof(SHARPNESS)/sizeof(int), sizeof(SHARPNESS_DATA)/sizeof(int), sizeof(SHARP_INFO)/sizeof(int));
	if(ucTableIndex ==1)
	for( j = 0; j< 8; j++)
	{
		pSharpness_setting = &pHwContext->VtabCmnValue.mSharpenss.mSharpness_Data[j];
	
	}
	*/
}

void PQ_InitVtabSRCValue_DF(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    //VTAB_SRC_VALUE_DEFINE* pVtabSrcValue;
   #if 0
    int i;
    DIN_FILTER df[VTAB_MAX_SOURCE]={
    {0,0,0,0,0,0,0,0,0}, // YPP
    {0,0,0,0,0,0,0,0,0}, // RGB
    {1,0,0,1,0,0,1,0,0}, // ATV
    {0,0,0,0,0,0,0,0,0}, // AV
    {0,0,0,0,0,0,0,0,0}, // SV
    {1,0,0,1,0,0,1,0,0}, // MPEG
    {0,0,0,0,0,0,0,0,0},  // HDMI
    {0,0,0,0,0,0,0,0,0}, // SCART_RGB
    {0,0,0,0,0,0,0,0,0}, // YPP_HD
    {1,0,0,1,0,0,1,0,0}, // MPEG_HD
    {0,0,0,0,0,0,0,0,0},  // HDMI_HD
#if SEPERATE_YPBPR1_YPBPR2
    {0,0,0,0,0,0,0,0,0}, // YPP2_SD
    {0,0,0,0,0,0,0,0,0}, // YPP2_HD
#endif
    };
    i = 0;


    for(i=0; i<VTAB_MAX_SOURCE; i++)
    {
        pVtabSrcValue= &pHwContext->VtabSrcValue[i];
        memcpy(&pVtabSrcValue->DeinterlaceFilter, &df[i], sizeof(DIN_FILTER));
    }
    #endif

    memset(&pVtab->mDeinterlaceFilter.mDeIN_Fil_Data, 0,  sizeof(DEIN_FILTER_DATA));

}


void PQ_InitVtabValue(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtabCmnValue= &pHwContext->VtabCmnValue;
//	VTAB_SRC_VALUE_DEFINE* pVtabSrcValue;

	/*SHARP_INFO sharp_strong[4]= { //hl,hc,vl,vc
		{ 6, -2, 100, 127, {63}, 0, 0}, { 6,  -2, 100, 127, {63}, 0, 0},
		{ 2, -2, 16, 32, {20}, 0, 0}, { 2,  -2, 4, 32, {8}, 0, 0} };
	SHARP_INFO sharp_normal[4]= {
		{ 6, -2, 20, 64, {8}, 0, 0}, { 6,  -2, 20, 64, {8}, 0, 0},
		{ 2,  -2, 8, 24, {16}, 0, 0}, { 2,  -2, 8, 24, {4}, 0, 0} };
	SHARP_INFO sharp_weak[4]= {
		{ 6,  -2, 0, 0, {4}, 0, 0}, { 6,  -2, 0, 0, {4}, 0, 0},
		{ 2,  -2, 2, 6, {12}, 0, 0}, { 2,  -2, 2, 6, {2}, 0, 0} };
		*/
	PEAKING_SETTING pk[3]= {
			{-11, 2, 7, 4}, //SD
			{-6, 12, 2, -2},
			{1, 7, 2, 1}, //HD
		};
	STRENGTH_DEFINE StrengthDefine;
	//DC_STRENGTH_DEFINE DCStrengthDefine;
	UINT8 i,  PCSrcIdx;

	CSC_SETTING ColorMatirx[2] = {{{0xffffffff}},{{0xffffffff}}};
	INT32 SharpRatio[6] = {6,8,8,10,8,8};
	DS_SHARP_INFO DSWeak[2] = {{0,0,0,16,1023,118,0,{0},{0}},{0,0,0,16,1023,118,0,{0},{0}}};
	DS_SHARP_INFO DSNormal[2] = {{24,48,48,16,1023,118,0,{64},{128}},{24,48,48,16,1023,118,0,{0},{0}}};
	DS_SHARP_INFO DSStrong[2] = {{36,72,72,16,1023,118,0,{64},{128}},{36,72,72,16,1023,118,0,{0},{0}}};

	UINT8 ucSatGainDefault[16] = {0x4a,0x4c,0x4c,0x53,0x50,0x4b,0x48,0x44,0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x40};
	UINT32 dwDarkSharpDefault[6] = {0x19000c8, 0x3200258, 0xfa0032, 0x3cf0307, 0x102a1004, 0x4};


#if 0 //( defined(CONFIG_SUPPORT_ATV_PAL) && defined(CONFIG_LOCATION_IS_CN) )
	//ATV
	df[2].sd_slr_mix_ach= df[2].md_slr_mix_ach= df[2].hd_slr_mix_ach= 2;  //2009-06-19 JY,
	df[2].sd_vdi_mad_hlp_en= df[2].md_vdi_mad_hlp_en= df[2].hd_vdi_mad_hlp_en= 0;
#endif

 	//init 601/709 FleshTone and ColorRegion
	pVtabCmnValue->mGmaOpt.pc_no_gamma = 0;
	pVtabCmnValue->ucLoadScartRGBTab = 0;
	memcpy(&pVtabCmnValue->mSharpRatio[0], &SharpRatio,sizeof(DS_SHARP_RATIO) );
	memcpy(&pVtabCmnValue->mSharpRatio[1], &SharpRatio,sizeof(DS_SHARP_RATIO) );
	pVtabCmnValue->iSharpRatio6 = 0;
	pVtabCmnValue->iSharpRatio6_c = 0;
	//init CSC Table
	memcpy(&pVtabCmnValue->mColorSpaceConversionTable[CSC_RGB], ColorSpaceTableRGB, sizeof(CSC_SETTING));
	memcpy(&pVtabCmnValue->mColorSpaceConversionTable[CSC_601], ColorSpaceTableYCC_Full601, sizeof(CSC_SETTING));
	memcpy(&pVtabCmnValue->mColorSpaceConversionTable[CSC_709], ColorSpaceTableYCC_Full709, sizeof(CSC_SETTING));
	memset(pVtabCmnValue->mSatGainCurve.mSatGainCurveSource, 0x0, 20);
	memset(pVtabCmnValue->mSatGainCurve.sat_gb, 0x40, 8*16); // set linier
	memcpy(pVtabCmnValue->mSatGainCurve.sat_gb, ucSatGainDefault, 16); // for compatibility setting before VIPTable v32

	//calc sharpness pivotx,y
	for(i=0; i<4; i++)
	{
		//PQ_CalcPivotxy(&sharp_strong[i]);
		//PQ_CalcPivotxy(&sharp_normal[i]);
		//PQ_CalcPivotxy(&sharp_weak[i]);
	}

    //init nr,mpeg nr strength define
	StrengthDefine.Degree[WEAK-1]= 4;
	StrengthDefine.Degree[MEDIUM-1]= 8;
	StrengthDefine.Degree[STRONG-1]= 12;
    for(i=0; i<VIP_TABLE_GROUPED_NUMBER; i++)
    {
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].LumaTnrCoring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].LumaTnrStrength, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].ChromaTnrCoring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].ChromaTnrStrength, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].LumaSnr1Coring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].LumaSnr1Strength, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].LumaSnr2Coring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].LumaSnr2Strength, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].ChromaSnrCoring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].ChromaSnrStrength, &StrengthDefine, sizeof(STRENGTH_DEFINE));

        //weifeng, need check if still used after 531
		//memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].TnrUltraLowAlpha, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		//memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].Snr1UltraLowCoring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
		//memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].Snr2UltraLowCoring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
    }

	//init nr,mpeg nr strength define
	StrengthDefine.Degree[WEAK-1]= 2;
	StrengthDefine.Degree[MEDIUM-1]= 5;
	StrengthDefine.Degree[STRONG-1]= 8;
    for(i=0; i<VIP_TABLE_GROUPED_NUMBER; i++)
    {
        memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].BlockNrCoring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
    	memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].BlockNrStrength, &StrengthDefine, sizeof(STRENGTH_DEFINE));
    	memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].MosquitoNrCoring, &StrengthDefine, sizeof(STRENGTH_DEFINE));
    	memcpy(&pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].MosquitoNrStrength, &StrengthDefine, sizeof(STRENGTH_DEFINE));
    }

    //ultra low en
    for(i=0; i<VIP_TABLE_GROUPED_NUMBER; i++)
    {
	    pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].TnrUltraLowCtl= 0;
	    pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[i].SnrUltraLowCtl= 0;
    }

    //init peaking setting
    for(i=0; i<VIP_TABLE_GROUPED_NUMBER; i++)
    {
	    memcpy(&pVtabCmnValue->mPeaking.mPeaking_Data[i], pk, 3*sizeof(PEAKING_SETTING));
    }

    PCSrcIdx = pVtabCmnValue->mDS_Sharpenss.mGroupedIndex[SRC_INDEX_PC];

    StrengthDefine.Degree[WEAK-1]= 0x88a886;
    StrengthDefine.Degree[MEDIUM-1]= 0x88a886;
    StrengthDefine.Degree[STRONG-1]= 0x88a886;

    for(i=0; i<VIP_TABLE_GROUPED_NUMBER; i++)
    {
        //ds sharpness
		memcpy(pVtabCmnValue->mDS_Sharpenss.mDS_Sharpness_Data[i].DSSharpWeak, DSWeak, 2*sizeof(DS_SHARP_INFO));
		memcpy(pVtabCmnValue->mDS_Sharpenss.mDS_Sharpness_Data[i].DSSharpNormal, DSNormal, 2*sizeof(DS_SHARP_INFO));
		memcpy(pVtabCmnValue->mDS_Sharpenss.mDS_Sharpness_Data[i].DSSharpStrong, DSStrong, 2*sizeof(DS_SHARP_INFO));

		//horizontal sharpness 20120724
		memcpy(pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpWeak, DSWeak, 2*sizeof(DS_SHARP_INFO));
		memcpy(pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpNormal, DSNormal, 2*sizeof(DS_SHARP_INFO));
		memcpy(pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpStrong, DSStrong, 2*sizeof(DS_SHARP_INFO));
		memset(&pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpWeak[0], 0, 3*sizeof(INT32));
		memset(&pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpWeak[1], 0, 3*sizeof(INT32));
		memset(&pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpNormal[0], 0, 3*sizeof(INT32));
		memset(&pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpNormal[1], 0, 3*sizeof(INT32));
		memset(&pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpStrong[0], 0, 3*sizeof(INT32));
		memset(&pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpStrong[1], 0, 3*sizeof(INT32));

		//sharpness filter

		if(i == PCSrcIdx) // pc source
		{
			pVtabCmnValue->mDS_Sharpenss.mDS_Sharpness_Data[i].DS_Sharp_Angle = 0x00020202;
		}
		else
		{
			pVtabCmnValue->mDS_Sharpenss.mDS_Sharpness_Data[i].DS_Sharp_Angle = 0x00040404;
		}

        memcpy(&pVtabCmnValue->mDS_Sharpenss.mDS_Sharpness_Data[i].SlrSharpRatio, &StrengthDefine, sizeof(STRENGTH_DEFINE));

        memcpy(&pVtabCmnValue->mDS_Sharpenss.mDS_Sharpness_Data[i].DSSharpDark,dwDarkSharpDefault, sizeof(DARK_SHARP_INFO));
        memcpy(&pVtabCmnValue->mHOR_Sharpenss.mHOR_Sharpness_Data[i].HorSharpDark,dwDarkSharpDefault, sizeof(DARK_SHARP_INFO));
    }

	//memcpy(pVtabCmnValue->, MiddleRegion, 4*sizeof(CR_MSETTING) );
	for(i=0; i<VIP_TABLE_GROUPED_NUMBER; i++)
	{

		//init reg range
		pVtabCmnValue->mRange.mRange_Data[i].BrightnessRange.min= -64;
		pVtabCmnValue->mRange.mRange_Data[i].BrightnessRange.max= 64;
		pVtabCmnValue->mRange.mRange_Data[i].BrightnessRange.middle= 0;
		pVtabCmnValue->mRange.mRange_Data[i].ContrastRange.min= 0x20;
		pVtabCmnValue->mRange.mRange_Data[i].ContrastRange.max= 0x60;
		pVtabCmnValue->mRange.mRange_Data[i].ContrastRange.middle= 0x40;
		pVtabCmnValue->mRange.mRange_Data[i].SaturationRange.min= 0;
		pVtabCmnValue->mRange.mRange_Data[i].SaturationRange.max= 127;
		pVtabCmnValue->mRange.mRange_Data[i].SaturationRange.middle= 64;
		pVtabCmnValue->mRange.mRange_Data[i].HueRange.min= 0;
		pVtabCmnValue->mRange.mRange_Data[i].HueRange.max= 32;
		pVtabCmnValue->mRange.mRange_Data[i].HueRange.middle= 16;
		pVtabCmnValue->mRange.mRange_Data[i].ColorTempGainRange.min= 0;
		pVtabCmnValue->mRange.mRange_Data[i].ColorTempGainRange.max= 127;
		pVtabCmnValue->mRange.mRange_Data[i].ColorTempGainRange.middle= 64;
		pVtabCmnValue->mRange.mRange_Data[i].ColorTempOffsetRange.min= -128;
		pVtabCmnValue->mRange.mRange_Data[i].ColorTempOffsetRange.max= 127;
		pVtabCmnValue->mRange.mRange_Data[i].ColorTempOffsetRange.middle= 0;
		//init color region contrl by source
		//for(j = 0; j <4; j++)
			//pVtabSrcValue->ColorRegionSrcCtl[j] = 0x80; //ctl disable
		memcpy(pVtabCmnValue->mColorMatrix.mSrcColorMatrix[i].mSrcColorMatrix, ColorMatirx, 2*sizeof(CSC_SETTING));



		//init dynamic contrast
		/*
		DCStrengthDefine.Degree[WEAK-1]=0x00000119;
		DCStrengthDefine.Degree[MEDIUM-1]=0x00000134;
		DCStrengthDefine.Degree[STRONG-1]=0x0000014c;
		DCStrengthDefine.Degree[WEAK-1]=0x011900e8;
		DCStrengthDefine.Degree[MEDIUM-1]=0x013400d5;
		DCStrengthDefine.Degree[STRONG-1]=0x014c00c4;
		DCStrengthDefine.Degree[WEAK-1]=0x00108080;
		DCStrengthDefine.Degree[MEDIUM-1]=0x00108080;
		DCStrengthDefine.Degree[STRONG-1]=0x00108080;
             */

		memset(&pVtabCmnValue->mRange.mRange_Data[i].BrightnessRangeExt, 0, sizeof(REG_RANGE_EXT)); // 0 -> disable default
		memset(&pVtabCmnValue->mRange.mRange_Data[i].ContrastRangeExt, 0, sizeof(REG_RANGE_EXT)); // 0 -> disable default
		memset(&pVtabCmnValue->mRange.mRange_Data[i].SaturationRangeExt, 0, sizeof(REG_RANGE_EXT)); // 0 -> disable default


	}



        pVtabCmnValue->SlrLowAngleOrMBWDisable = 0x7;

	//initialize to avoid kernal panic before assign the pointer
	pHwContext->CurColorMatrix=&pVtabCmnValue->mColorSpaceConversionTable[CSC_601];
}



//================================================================================
//	function name		: PQ_InitialTable()
//	input parameter	: none
//	output parameter	: none
//	purpose			: setup PQ initial value or fix setting
//   return			:

void PQ_InitialTable(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
		
    pHwContext->LoadPQTable=0;
#ifdef DYNAMIC_BACKLIGHT
    pHwContext->ucLocationMode = STOREMODE;
    pHwContext->ucDynamicBacklightMode=0;
    PQ_InitDynamicBackLight();

#endif //#ifdef DYNAMIC_BACKLIGHT

    pHwContext->CurColorMatrix = NULL;
    pHwContext->pCurVtabSrcValue= &pHwContext->VtabSrcValue[0];
    pMenuValue->bNoGamma = FALSE; // VIP_SetupGammaTable(ENABLE, 0);
    pHwContext->nColorSpaceMode= PQ_COLOR_SPACE_NONE;
    pHwContext->bDynamicSaturation= DISABLE;
    pHwContext->bEnableColorProcess= TRUE;
    pHwContext->bFadeEn = FALSE;
    pHwContext->bPWMOff = FALSE;
    pHwContext->bIsMenuOpen = FALSE;
    pHwContext->bIsPureColorPattern = FALSE;
    pHwContext->PqPatch.PeakLtiPatch = PEAKLTI_NON_PATCH;
    pHwContext->PqPatch.DpyPeakingPatch = DPY_PEAKING_NON_PATCH;
    pHwContext->PqPatch.DsSharpnessPatch = DS_SHARPNESS_NON_PATCH;
    pHwContext->PqPatch.TnrClampPatch = TNR_CLAMP_DEFAULT;
    pHwContext->PqPatch.Post2DPatch = POST_2D_SHARPNESS_DEFAULT;
    pHwContext->PqPatch.PostDLTIPatch = POST_DLTI_DEFAULT;
    pHwContext->PqPatch.DPYSharpnessPatch = DPY_SHARPNESS_DEFAULT;
    pHwContext->bIsPattern_DIG_ADC2 = FALSE;
    pHwContext->bGammaChange=FALSE;
    memset(&pHwContext->mSharp_PREDCTI_Reserve, 0, sizeof(SHARP_PREDCTI_RESERVE));    
    memset(&pHwContext->mSharp_POSTDCTI_Reserve, 0, sizeof(SHARP_POSTDCTI_RESERVE)); 
    memset(&pHwContext->mSharp_PREDLTI_Reserve, 0, sizeof(SHARP_PREDLTI_RESERVE));    	
    memset(&pHwContext->mSharp_POSTDLTI_Reserve, 0, sizeof(SHARP_POSTDLTI_RESERVE));    
    memset(&pHwContext->mSharp_POST2D_Reserve, 0, sizeof(SHARP_POST2D_RESERVE));

    spin_lock_init(&pHwContext->Spin_PresetContrast);

    PQ_InitVtabValue();

    //default menu value����
    pMenuValue->iContrast = pHwContext->iCurrContrastValue = 1024;
    //default menu value����

    PQ_RegisterWrite(VIP_reg_dpy_dither_sel, 0);

    PQ_DS_Init();
    PQ_NR_Init();
    PQ_FleshTone_Init();
    PQ_HW_Initial();
    PQ_DefaultSetting();
	
#ifdef CONFIG_PANEL_LM201WE3_TLF5_1680X1050__S2TEK_IS_DEFAULT
	//OSD & GAMMA swap enable in 531
    PQ_RegisterWrite(VIP_reg_osd_after_gamma,	0);
#else
    PQ_RegisterWrite(VIP_reg_osd_after_gamma,	1);
#endif

    pHwContext->CVD2_store_nr_setting=0;

    //PQ_RegisterWrite(VIP_reg_dpy_round,	0x0);
    //20140624 HD VideoBook Blue pettern
    //HiVi Case15 Blue+Gray pattern, junction with black edges
    PQ_RegisterWrite(VIP_reg_dpy_ye0_idx_sat,	0x9);

	if(WQ_Struct_NRAdjust==NULL)
    {
    	WQ_Struct_NRAdjust = create_singlethread_workqueue("NR_Adjust_Workqueue");
    	INIT_WORK(&WQ_NRAdjust,(work_func_t)PQ_AdjustNr);
	}

	if(WQ_Struct_SWDC==NULL)
    {
	    WQ_Struct_SWDC = create_singlethread_workqueue("SWDC_Workqueue");	
	    INIT_WORK(&WQ_SWDC,(work_func_t)PQ_SW_DynamicContrast_SceneChangeDetect_ISR);    
	}

	if(WQ_Struct_ColorBarDetect==NULL)
    {
	    WQ_Struct_ColorBarDetect = create_singlethread_workqueue("ColorBarDetect_Workqueue");	
	    INIT_WORK(&WQ_ColorBarDetect,(work_func_t)PQ_ColorBarDetect);
	}
}

//****************************************************************************
//
//   Function   : PQ_Brightness
//   Params    : iValue (-128~+127)
//   Description:
//   Returns    : void
//****************************************************************************
void PQ_Brightness(UINT8 bReset, INT32 iValue) //-128~+127 => -64~64
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	static UINT8 bStart = FALSE;

	if(bReset)
	{
		bStart = TRUE;
		return;
	}

	if(bStart)
	{
		bStart = FALSE;

		if( pHwContext->bEnableColorProcess==FALSE )
			iValue= 0;

		//iValue -=512;
		iValue -=BRIGHTNESS_OFFSET;
		PQDebugPrint("%s: iValue=%d\n", __FUNCTION__, iValue);
        pHwContext->iBrightness=iValue;
		PQ_ColorMatrixComp(TRUE);
		PQ_PureColorControl((iValue-1)/21, 1);		
	}
}

void PQ_ColorMatrixSetup(UINT8 bReset, UINT8 ucNum)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	INT32 iCSC_AfterHueSat = 50;
	INT32 iCSC_Value;
	LONG LONG INT32 lliTmpValue;
	COLOR_MATRIX_INT *pCurMatrix = (COLOR_MATRIX_INT *)pHwContext->CurColorMatrix->CSC_Value;
	static UINT16 usNum = 0;
	static UINT8 bStart = FALSE;
      #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
      INT32 *piGain = &pHwContext->iRGain;
      #endif

	if(!pHwContext->CurColorMatrix)
		return;

   
    if(bReset)
    {
    	usNum |= 1<<ucNum;
    	bStart = TRUE;
    	return;
    }


	if(bStart)
	{

		INT32 i;
		bStart = FALSE;

		for(i=0;i<9;i++)
		{
			if(((usNum>>i)&1) == 1)
			{
				ucNum = i;
				if (ucNum%3)
				{
					switch(ucNum%3)
					{
						case 1:
							iCSC_AfterHueSat = pCurMatrix[ucNum].iValue*NewHueSetting[pHwContext->iHue].cosine-
											pCurMatrix[ucNum+1].iValue*NewHueSetting[pHwContext->iHue].sine;
						break;
						case 2:
							iCSC_AfterHueSat = pCurMatrix[ucNum].iValue*NewHueSetting[pHwContext->iHue].cosine+
											pCurMatrix[ucNum-1].iValue*NewHueSetting[pHwContext->iHue].sine;
						break;
					}
					iCSC_AfterHueSat *= pHwContext->iSaturation;
				}
				else
					iCSC_AfterHueSat = pCurMatrix[ucNum].iValue<<(8+COLOR_MATRIX_GAIN_BIT_SYSTEM);

				#ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
                          lliTmpValue = pHwContext->iContrast * (LONG LONG INT32)piGain[ucNum/3];
                          #else
				lliTmpValue = pHwContext->iContrast * 1024;
                          #endif
				lliTmpValue = lliTmpValue * iCSC_AfterHueSat;
				lliTmpValue = lliTmpValue >> (COLOR_MATRIX_GAIN_BIT_SYSTEM+COLOR_MATRIX_GAIN_BIT_SYSTEM+COLOR_MATRIX_GAIN_BIT_SYSTEM+8);
				iCSC_Value = lliTmpValue;
				//PQ_ADVANCE_HWPrint("%s: contrast = %d , gain = %d, matrix = %d ",__FUNCTION__,pHwContext->iContrast , iGain , pHwContext->CurColorMatrix->CSC_Value[ucNum]);
				//PQ_ADVANCE_HWPrint("%s: matrix[%d] = %d",__FUNCTION__, ucNum, iTmpValue);
				iCSC_Value = min(8191, max(iCSC_Value,  -8192));

				PQ_RegisterWrite(VIP_reg_dpy_matrix_a11 + ucNum*4 , pHwContext->bEnableColorProcess?iCSC_Value:pCurMatrix[ucNum].iValue);

				usNum &= ~(1<<i);
			}

		}

	}

}


//****************************************************************************
//
//   Function   : PQ_Contrast
//   Params    :
//   Description:
//   Returns    : void
//****************************************************************************
void PQ_Contrast(UINT8 bReset, INT32 iValue) // 0 ~ 127 => 0x20~0x60
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	INT32 i;
	static UINT8 bStart = FALSE;

    if(!PQ_IsFadeEn())//if fade effect, do contrast
    {
    	if(bReset)
    	{
    		bStart = TRUE;
    		return;
    	}
    }
	if(bStart || PQ_IsFadeEn())
	{
	    bStart = FALSE;
		if( pHwContext->bEnableColorProcess==FALSE)
			iValue=64;

		if(PQ_IsFadeEn()==FALSE)	//backup for fade in/out
			pHwContext->iCurrContrastValue= iValue;


		pHwContext->iContrast=iValue<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);

		for(i=0; i<9 ;i++)
			PQ_ColorMatrixSetup(TRUE, i);

		PQ_ColorMatrixComp(TRUE);
		PQ_PureColorControl((iValue-1024+1)/10, 2);
	}
}


//****************************************************************************
//   Function   : PQ_Sharpness_Control_In_3D
//   Params    : bStatus : 0 = stop sharpness and NR function, 1 = resume sharpness and NR fnction
//   Description: (1)in 3D mode, disable sharpness_2D and bypass NR
//   Returns    : void
//****************************************************************************

void PQ_Sharpness_Control_In_3D(UINT8 bStatus)
{
    if(bStatus == DISABLE)
    {
        PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en, DISABLE);
        PQ_RegisterWrite(VIP_reg_slr_snr_bypass, ENABLE);
        PQ_RegisterWrite(VIP_reg_slr_s_snr_bypass, ENABLE);
    }
    else
    {
        PQHW_CONTEXT* pHwContext= &PQHwContext;
	    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
        SHARP_POST2DSHARPNESS* pPost2DSharpness = &pVtab->mSharpness_Post2DSharpness;
        SHARP_POST2DSHARPNESS_DATA* pPost2DSharpData;
        UINT8 ucCurrSrcIndex, ucTableIndex;
        
        ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
        ucTableIndex = pPost2DSharpness->mGroupedIndex[ucCurrSrcIndex];
        pPost2DSharpData = &pPost2DSharpness->mPost2DSharpData[ucTableIndex];
	if(_VIP_GetPreviewWndowStatus())
	PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en,0);
	else
        PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en, pPost2DSharpData->iPost2DSharpEnable);
        PQ_RegisterWrite(VIP_reg_slr_snr_bypass, DISABLE);
        PQ_RegisterWrite(VIP_reg_slr_s_snr_bypass, DISABLE);
    }
}

void PQ_Sharpness_PREDCTI(BOOL bReset, UINT8 ucValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    SHARP_PREDCTI* pSHARP_PREDCTI = &pVtab->mSharpness_PreDCTI;
    SHARP_PREDCTI_DATA* pSHARP_PREDCTI_DATA;
    SHARP_PREDCTI_RESERVE* pSharp_PRECTI_Reserve;
    UINT8 ucCurrSrcIndex, ucTableIndex;
    SHARP_PREDCTI_EXT *pSharp_PreDCTI_Ext;

    static UINT32 dwPreDCTIFacReg[3] = {VIP_reg_slr_dcti_gain_0_pre,VIP_reg_slr_dcti_gain_1_pre,VIP_reg_slr_dcti_gain_2_pre};
    static UINT32 dwPreDCTITHReg[2] = {VIP_reg_slr_dcti_gain_th0_pre,VIP_reg_slr_dcti_gain_th1_pre};
    static UINT32 dwPreDCTISlopeReg[2] = {VIP_reg_slr_dcti_gain_slope0_pre,VIP_reg_slr_dcti_gain_slope1_pre};
    static UINT8 bStart = FALSE;

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

    if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
    {
        PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
        return;
    }

    ucTableIndex = pSHARP_PREDCTI->mGroupedIndex[ucCurrSrcIndex];
    pSHARP_PREDCTI_DATA = &pSHARP_PREDCTI->mPreDCTIData[ucTableIndex];
    pSharp_PRECTI_Reserve = &pHwContext->mSharp_PREDCTI_Reserve;
    pSharp_PreDCTI_Ext =  &pVtab->mSharp_PreDCTI_Ext[ucTableIndex];
	
    if(bReset)
    {
        bStart = TRUE;
        
        
        if( ucValue>127 )
            ucValue= 127;
        
        PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);

        if( ucValue<64 )
        {
            pSharp_PRECTI_Reserve->iTagetFac0 = pSHARP_PREDCTI_DATA->iGain0[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDCTI_DATA->iGain0[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDCTI_DATA->iGain0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetFac1 = pSHARP_PREDCTI_DATA->iGain1[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDCTI_DATA->iGain1[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDCTI_DATA->iGain1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetFac2 = pSHARP_PREDCTI_DATA->iGain2[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDCTI_DATA->iGain2[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDCTI_DATA->iGain2[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetTh0 = pSHARP_PREDCTI_DATA->iTh0[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDCTI_DATA->iTh0[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDCTI_DATA->iTh0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetTh1 = pSHARP_PREDCTI_DATA->iTh1[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDCTI_DATA->iTh1[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDCTI_DATA->iTh1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetSlp0 = pSHARP_PREDCTI_DATA->iSlope0[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDCTI_DATA->iSlope0[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDCTI_DATA->iSlope0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetSlp1 = pSHARP_PREDCTI_DATA->iSlope1[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDCTI_DATA->iSlope1[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDCTI_DATA->iSlope1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
	     pSharp_PRECTI_Reserve->iTargetGainLpTap = pSharp_PreDCTI_Ext->iGain_Lp[PQ_SHARPNESS_0PERCENT]+ ( pSharp_PreDCTI_Ext->iGain_Lp[PQ_SHARPNESS_50PERCENT] -  pSharp_PreDCTI_Ext->iGain_Lp[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
	     pSharp_PRECTI_Reserve->iTagetSlpLp = pSharp_PreDCTI_Ext->iSlp_Lp[PQ_SHARPNESS_0PERCENT]+ ( pSharp_PreDCTI_Ext->iSlp_Lp[PQ_SHARPNESS_50PERCENT] -  pSharp_PreDCTI_Ext->iSlp_Lp[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;	 
        }
        else
        {
            //from normal to strong
            ucValue-= 64;
            pSharp_PRECTI_Reserve->iTagetFac0 = pSHARP_PREDCTI_DATA->iGain0[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDCTI_DATA->iGain0[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDCTI_DATA->iGain0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetFac1 = pSHARP_PREDCTI_DATA->iGain1[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDCTI_DATA->iGain1[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDCTI_DATA->iGain1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetFac2 = pSHARP_PREDCTI_DATA->iGain2[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDCTI_DATA->iGain2[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDCTI_DATA->iGain2[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetTh0 = pSHARP_PREDCTI_DATA->iTh0[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDCTI_DATA->iTh0[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDCTI_DATA->iTh0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetTh1 = pSHARP_PREDCTI_DATA->iTh1[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDCTI_DATA->iTh1[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDCTI_DATA->iTh1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetSlp0 = pSHARP_PREDCTI_DATA->iSlope0[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDCTI_DATA->iSlope0[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDCTI_DATA->iSlope0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PRECTI_Reserve->iTagetSlp1 = pSHARP_PREDCTI_DATA->iSlope1[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDCTI_DATA->iSlope1[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDCTI_DATA->iSlope1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
	     pSharp_PRECTI_Reserve->iTargetGainLpTap = pSharp_PreDCTI_Ext->iGain_Lp[PQ_SHARPNESS_50PERCENT]+ (pSharp_PreDCTI_Ext->iGain_Lp[PQ_SHARPNESS_100PERCENT] - pSharp_PreDCTI_Ext->iGain_Lp[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
	     pSharp_PRECTI_Reserve->iTagetSlpLp = pSharp_PreDCTI_Ext->iSlp_Lp[PQ_SHARPNESS_50PERCENT]+ (pSharp_PreDCTI_Ext->iSlp_Lp[PQ_SHARPNESS_100PERCENT] - pSharp_PreDCTI_Ext->iSlp_Lp[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;	 
        }
        pSharp_PRECTI_Reserve->iTargetScale = pSHARP_PREDCTI_DATA->iScale[PQ_SHARPNESS_50PERCENT];
        pSharp_PRECTI_Reserve->iTargetGainTap = pSHARP_PREDCTI_DATA->iGainTap[PQ_SHARPNESS_50PERCENT];
        pSharp_PRECTI_Reserve->iTargetShootTap = pSHARP_PREDCTI_DATA->iShootTap[PQ_SHARPNESS_50PERCENT];
        
        return;
    }

    if(bStart)
    {
        bStart = FALSE;
        
        if( pHwContext->bEnableColorProcess==FALSE )
        {
            PQ_RegisterWrite(dwPreDCTIFacReg[0], 0);
            PQ_RegisterWrite(dwPreDCTIFacReg[1], 0);
            PQ_RegisterWrite(dwPreDCTIFacReg[2], 0);

            return;
        }

	#ifdef CONFIG_APPLY_DIFFERENT_SHARPNESS_SETTING_IN_PANEL_INVERT
	 if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
	 {
		 /* Modify sharpness setting in invert panel here */	
	 }
	 else
	 {
	 	/* Modify another sharpness setting in regular panel here */	
	 }
	#else
	    /* Check different setting status and remove same setting item to here */
	#endif
	
        if(VIP_IsSourceDTV() || !PQ_IsColorBar() || VIP_RunDVIMode() || VIP_IsPCSource())
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_en_pre, pSHARP_PREDCTI_DATA->iPreDCTIEnable);
            PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_pre, pSHARP_PREDCTI_DATA->iPreChromaFilterEnable);            
            PQ_RegisterWrite(VIP_reg_slr_pre_icp_alpha_pre, pSHARP_PREDCTI_DATA->iPreChromaFilterLevel);
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre, pSharp_PRECTI_Reserve->iTargetScale);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_pre, pSharp_PRECTI_Reserve->iTargetGainTap);
            PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_pre, pSharp_PRECTI_Reserve->iTargetShootTap);
        }
		
        PQ_RegisterWrite(VIP_reg_slr_dcti_c1_pre, pSHARP_PREDCTI_DATA->icoef[0]);
        PQ_RegisterWrite(VIP_reg_slr_dcti_c2_pre, pSHARP_PREDCTI_DATA->icoef[1]);
        PQ_RegisterWrite(VIP_reg_slr_dcti_c3_pre, pSHARP_PREDCTI_DATA->icoef[2]);

        if (VIP_IsPCSource() && VIP_GetInputVSize() <= 550)    //#42350 & #42784 & #51240
	 	{
	    	PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_pre, 0x00);
	    	PQ_RegisterWrite(VIP_reg_slr_post_icp_en_pre, 0x01);			
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre, 0x01);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_pre, 0x02);
            PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_pre, 0x02);
	    	PQ_RegisterWrite(VIP_reg_slr_dcti_c1_pre, 0xfa3);
			PQ_RegisterWrite(VIP_reg_slr_dcti_c2_pre, 0xed1);
			PQ_RegisterWrite(VIP_reg_slr_dcti_c3_pre, 0xfa3);
	  	}
		else if(VIP_IsPCSource() && VIP_GetInputVSize()>700 && VIP_GetInputVSize()<800)     //#51253
		{
			PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_pre, 0x01);
			PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre, 0x01);
			PQ_RegisterWrite(VIP_reg_slr_dcti_c1_pre, 0xfa3);
			PQ_RegisterWrite(VIP_reg_slr_dcti_c2_pre, 0xed1);
			PQ_RegisterWrite(VIP_reg_slr_dcti_c3_pre, 0xfa3);
		}
        else if (VIP_IsPCSource() && VIP_GetInputHSize()==1440 && VIP_GetInputVSize()==900 && VIP_GetPanelWidth()==1366 && VIP_GetPanelHeight()==768)
        {
			PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_pre, 0x01);       //#51258
			PQ_RegisterWrite(VIP_reg_slr_pre_icp_alpha_pre, 0x00);
        }
        else if (VIP_IsPCSource() && VIP_GetInputHSize()==1920 && VIP_GetInputVSize()==1080)
        {
			PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_pre, 0x01);       //#52129
        }

		if(VIP_GetUserSource()==SOURCE_HDMI || VIP_IsPCSource())
		{
			// w422 set to 0 represent do low pass, or it will has issue 50186
			if(PQ_RegisterRead(VIP_reg_slr_dcti_en_pre)==0 && PQ_RegisterRead(VIP_reg_slr_pre_icp_en_pre)==0)
				PQ_RegisterWrite(VIP_reg_gfx_w422,0);
		}
		
        PQ_RegisterWrite(VIP_reg_slr_post_icp_en_pre, pSHARP_PREDCTI_DATA->iPostChromaFilterEnable);
        PQ_RegisterWrite(dwPreDCTIFacReg[0], pSharp_PRECTI_Reserve->iTagetFac0);
        PQ_RegisterWrite(dwPreDCTIFacReg[1], pSharp_PRECTI_Reserve->iTagetFac1);
        PQ_RegisterWrite(dwPreDCTIFacReg[2], pSharp_PRECTI_Reserve->iTagetFac2);
        PQ_RegisterWrite(dwPreDCTITHReg[0], pSharp_PRECTI_Reserve->iTagetTh0);
        PQ_RegisterWrite(dwPreDCTITHReg[1], pSharp_PRECTI_Reserve->iTagetTh1);
        PQ_RegisterWrite(dwPreDCTISlopeReg[0], pSharp_PRECTI_Reserve->iTagetSlp0);
        PQ_RegisterWrite(dwPreDCTISlopeReg[1], pSharp_PRECTI_Reserve->iTagetSlp1);
        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_lp_pre, pSharp_PRECTI_Reserve->iTargetGainLpTap);
        PQ_RegisterWrite(VIP_reg_slr_dcti_gain_slope_lp_pre, pSharp_PRECTI_Reserve->iTagetSlpLp);
       
	}

}

void PQ_Sharpness_POSTDCTI(BOOL bReset,UINT8 ucValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    SHARP_POSTDCTI* pSHARP_POSTDCTI = &pVtab->mSharpness_PostDCTI;
    SHARP_POSTDCTI_DATA* pPostDCTIData;
    SHARP_POSTDCTI_RESERVE *pSharp_POSTDCTI_Reserve;
    UINT8 ucCurrSrcIndex, ucTableIndex;
    static UINT8 bStart = FALSE;

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

    if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
    {
        PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
        return;
    }

    ucTableIndex = pSHARP_POSTDCTI->mGroupedIndex[ucCurrSrcIndex];
    pPostDCTIData = &pSHARP_POSTDCTI->mPostDCTIData[ucTableIndex];
    pSharp_POSTDCTI_Reserve = &pHwContext->mSharp_POSTDCTI_Reserve;

    if(bReset)
    {
        bStart = TRUE;
       

        if( ucValue>127 )
            ucValue= 127;
        
        PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);
        
        
        if( ucValue<64 )
        {
            pSharp_POSTDCTI_Reserve->iTagetFac0 = pPostDCTIData->iGain0[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iGain0[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iGain0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetFac1 = pPostDCTIData->iGain1[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iGain1[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iGain1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetFac2 = pPostDCTIData->iGain2[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iGain2[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iGain2[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetTh0 = pPostDCTIData->iTh0[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iTh0[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iTh0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetTh1 = pPostDCTIData->iTh1[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iTh1[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iTh1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetSlp0 = pPostDCTIData->iSlope0[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iSlope0[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iSlope0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetSlp1 = pPostDCTIData->iSlope1[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iSlope1[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iSlope1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
        }
        else
        {
            //from normal to strong
            ucValue-= 64;
            pSharp_POSTDCTI_Reserve->iTagetFac0 = pPostDCTIData->iGain0[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iGain0[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iGain0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetFac1 = pPostDCTIData->iGain1[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iGain1[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iGain1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetFac2 = pPostDCTIData->iGain2[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iGain2[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iGain2[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetTh0 = pPostDCTIData->iTh0[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iTh0[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iTh0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetTh1 = pPostDCTIData->iTh1[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iTh1[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iTh1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetSlp0 = pPostDCTIData->iSlope0[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iSlope0[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iSlope0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTagetSlp1 = pPostDCTIData->iSlope1[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iSlope1[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iSlope1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
        }

        pSharp_POSTDCTI_Reserve->iTargetScale = pPostDCTIData->iScale[PQ_SHARPNESS_50PERCENT];
        pSharp_POSTDCTI_Reserve->iTargetGainTap = pPostDCTIData->iGainTap[PQ_SHARPNESS_50PERCENT];
        pSharp_POSTDCTI_Reserve->iTargetShootTap = pPostDCTIData->iShootTap[PQ_SHARPNESS_50PERCENT];
        
        return;
    }

    if(bStart)
    {
        bStart = FALSE;

        if( pHwContext->bEnableColorProcess==FALSE )
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_0_post, 0);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_1_post, 0);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_2_post, 0);

            return;
        }
		if(_VIP_GetPreviewWndowStatus())
			PQ_RegisterWrite(VIP_reg_slr_dcti_en_post,0);
		else
        	PQ_RegisterWrite(VIP_reg_slr_dcti_en_post, pPostDCTIData->iPostDCTIEnable);
    	

        if(VIP_IsSourceDTV() || !utempCheckColorbarDTFunctionEN || VIP_RunDVIMode() || VIP_IsPCSource())
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_c1_post, pPostDCTIData->icoef[0]);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c2_post, pPostDCTIData->icoef[1]);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c3_post, pPostDCTIData->icoef[2]);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c4_post, pPostDCTIData->icoef[3]);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c5_post, pPostDCTIData->icoef[4]);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c6_post, pPostDCTIData->icoef[5]);
            PQ_RegisterWrite(VIP_reg_slr_post_icp_en_post, pPostDCTIData->iPostChromaFilterEnable);
            PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_post, pPostDCTIData->iPreChromaFilterEnable);
            PQ_RegisterWrite(VIP_reg_slr_pre_icp_alpha_post, pPostDCTIData->iPostChromaFilterLevel);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_0_post, pSharp_POSTDCTI_Reserve->iTagetFac0);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_1_post, pSharp_POSTDCTI_Reserve->iTagetFac1);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_2_post, pSharp_POSTDCTI_Reserve->iTagetFac2);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_th0_post, pSharp_POSTDCTI_Reserve->iTagetTh0);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_th1_post, pSharp_POSTDCTI_Reserve->iTagetTh1);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_slope0_post, pSharp_POSTDCTI_Reserve->iTagetSlp0);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_slope1_post, pSharp_POSTDCTI_Reserve->iTagetSlp1);
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post, pSharp_POSTDCTI_Reserve->iTargetScale);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, pSharp_POSTDCTI_Reserve->iTargetGainTap);
            PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post, pSharp_POSTDCTI_Reserve->iTargetShootTap);
        }
               
        if ( !utempCheckColorbarDTFunctionEN && VIP_IsAVSource() && (VIP_GetStdColorSystem() >= CVD2_STD_NTSC_443) && (VIP_GetStdColorSystem() <= CVD2_STD_PAL_CN) )
        {
            if ( VIP_GetStdColorSystem() == CVD2_STD_NTSC_443 )
            {
                PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,	 0x2);	  //#40362
                PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x5);
                PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x3);	  //#51589
            }
            PQ_RegisterWrite(VIP_reg_slr_dcti_c1_post, 0x173);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c2_post, 0x53);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c3_post, 0xf5b);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c4_post, 0xf0a);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c5_post, 0xf43);
            PQ_RegisterWrite(VIP_reg_slr_dcti_c6_post, 0xf98);
        }
        
        if (VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource() && VIP_GetInputVSize() > 700)  //#51277
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post, 0x0); 
        }   
        else if (VIP_IsPCSource() && VIP_GetInputHSize()==1920 && VIP_GetInputVSize()==1080)
        {
			PQ_RegisterWrite(VIP_reg_slr_pre_icp_en_post, 0x0);       //#52129
        }

        #ifdef CONFIG_APPLY_DIFFERENT_SHARPNESS_SETTING_IN_PANEL_INVERT
        if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
        {/* Add sharpness setting in invert panel here */
            if ((VIP_GetUserSource() == SOURCE_HDMI) && (VIP_GetInputVSize() < 600))
            {
                PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post, 0x3); //#42800
                PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post, 0x0);  //#48451
                }
            }
            else
            {/* Add sharpness setting in regular panel here */}
        #else	
        /* Check different setting status and remove same setting item to here */
        #endif
	  
    }
}


void PQ_Sharpness_PREDLTI(BOOL bReset, UINT8 ucValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    SHARP_PREDLTI* pSHARP_PREDLTI = &pVtab->mSharpness_PreDLTI;
    SHARP_PREDLTI_DATA* pSHARP_PREDLTI_DATA;
    SHARP_PREDLTI_RESERVE* pSharp_PREDLTI_Reserve;
    UINT8 ucCurrSrcIndex, ucTableIndex;

    static UINT32 dwPreDLTIFacReg[3] = {VIP_reg_slr_dlti_gain_0_pre,VIP_reg_slr_dlti_gain_1_pre,VIP_reg_slr_dlti_gain_2_pre};
    static UINT32 dwPreDLTITHReg[2] = {VIP_reg_slr_dlti_gain_th0_pre,VIP_reg_slr_dlti_gain_th1_pre};
    static UINT32 dwPreDLTISlopeReg[2] = {VIP_reg_slr_dlti_gain_slope0_pre,VIP_reg_slr_dlti_gain_slope1_pre};
    static UINT8 bStart = FALSE;

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

    if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
    {
        PQDebugPrint("%s: SrcIndex (%d) unknown/invalid!", __FUNCTION__, ucCurrSrcIndex);
        return;
    }

    ucTableIndex = pSHARP_PREDLTI->mGroupedIndex[ucCurrSrcIndex];
    pSHARP_PREDLTI_DATA = &pSHARP_PREDLTI->mPreDLTIData[ucTableIndex];
    pSharp_PREDLTI_Reserve = &pHwContext->mSharp_PREDLTI_Reserve;
	
    if(bReset)
    {
        bStart = TRUE;
        
        
        if( ucValue>127 )
            ucValue= 127;
        
        PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);
		
        if( ucValue<64 )
        {
            pSharp_PREDLTI_Reserve->iTagetFac0 = pSHARP_PREDLTI_DATA->iGain0[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDLTI_DATA->iGain0[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDLTI_DATA->iGain0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetFac1 = pSHARP_PREDLTI_DATA->iGain1[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDLTI_DATA->iGain1[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDLTI_DATA->iGain1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetFac2 = pSHARP_PREDLTI_DATA->iGain2[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDLTI_DATA->iGain2[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDLTI_DATA->iGain2[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetTh0 = pSHARP_PREDLTI_DATA->iTh0[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDLTI_DATA->iTh0[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDLTI_DATA->iTh0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetTh1 = pSHARP_PREDLTI_DATA->iTh1[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDLTI_DATA->iTh1[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDLTI_DATA->iTh1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetSlp0 = pSHARP_PREDLTI_DATA->iSlope0[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDLTI_DATA->iSlope0[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDLTI_DATA->iSlope0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetSlp1 = pSHARP_PREDLTI_DATA->iSlope1[PQ_SHARPNESS_0PERCENT]+ (pSHARP_PREDLTI_DATA->iSlope1[PQ_SHARPNESS_50PERCENT] - pSHARP_PREDLTI_DATA->iSlope1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
        }
        else
        {
            //from normal to strong
            ucValue-= 64;
            pSharp_PREDLTI_Reserve->iTagetFac0 = pSHARP_PREDLTI_DATA->iGain0[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDLTI_DATA->iGain0[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDLTI_DATA->iGain0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetFac1 = pSHARP_PREDLTI_DATA->iGain1[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDLTI_DATA->iGain1[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDLTI_DATA->iGain1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetFac2 = pSHARP_PREDLTI_DATA->iGain2[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDLTI_DATA->iGain2[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDLTI_DATA->iGain2[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetTh0 = pSHARP_PREDLTI_DATA->iTh0[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDLTI_DATA->iTh0[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDLTI_DATA->iTh0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetTh1 = pSHARP_PREDLTI_DATA->iTh1[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDLTI_DATA->iTh1[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDLTI_DATA->iTh1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetSlp0 = pSHARP_PREDLTI_DATA->iSlope0[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDLTI_DATA->iSlope0[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDLTI_DATA->iSlope0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_PREDLTI_Reserve->iTagetSlp1 = pSHARP_PREDLTI_DATA->iSlope1[PQ_SHARPNESS_50PERCENT]+ (pSHARP_PREDLTI_DATA->iSlope1[PQ_SHARPNESS_100PERCENT] - pSHARP_PREDLTI_DATA->iSlope1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
        }

        pSharp_PREDLTI_Reserve->iTargetScale = pSHARP_PREDLTI_DATA->iScale[PQ_SHARPNESS_50PERCENT];
        pSharp_PREDLTI_Reserve->iTargetGainTap = pSHARP_PREDLTI_DATA->iGainTap[PQ_SHARPNESS_50PERCENT];
        pSharp_PREDLTI_Reserve->iTargetShootTap = pSHARP_PREDLTI_DATA->iShootTap[PQ_SHARPNESS_50PERCENT];
        
        return;
    }

    if(bStart)
    {
        bStart = FALSE;
        
        if( pHwContext->bEnableColorProcess==FALSE )
        {
            PQ_RegisterWrite(dwPreDLTIFacReg[0], 0);
            PQ_RegisterWrite(dwPreDLTIFacReg[1], 0);
            PQ_RegisterWrite(dwPreDLTIFacReg[2], 0);

            return;
        }
		#ifdef CONFIG_APPLY_DIFFERENT_SHARPNESS_SETTING_IN_PANEL_INVERT
		if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
		{
		/* Add sharpness setting in invert panel here */
			PQ_RegisterWrite(dwPreDLTIFacReg[0], pSharp_PREDLTI_Reserve->iTagetFac0);
        	PQ_RegisterWrite(dwPreDLTIFacReg[1], pSharp_PREDLTI_Reserve->iTagetFac1);
        	PQ_RegisterWrite(dwPreDLTIFacReg[2], pSharp_PREDLTI_Reserve->iTagetFac2);
        	PQ_RegisterWrite(dwPreDLTITHReg[0], pSharp_PREDLTI_Reserve->iTagetTh0);
       		PQ_RegisterWrite(dwPreDLTITHReg[1], pSharp_PREDLTI_Reserve->iTagetTh1);
        	PQ_RegisterWrite(dwPreDLTISlopeReg[0], pSharp_PREDLTI_Reserve->iTagetSlp0);
        	PQ_RegisterWrite(dwPreDLTISlopeReg[1], pSharp_PREDLTI_Reserve->iTagetSlp1);
		}
		else
		{/* Add another sharpness setting in regular panel here */}
		#else
			    /* Check different setting status and remove same setting item to here */
		#endif

		if(!(PQ_IsColorBar()  && VIP_IsATVSource()))
        {
         	PQ_RegisterWrite(VIP_reg_slr_dlti_en_pre, pSHARP_PREDLTI_DATA->iPreDLTIEnable);
            PQ_RegisterWrite(VIP_reg_slr_dlti_scale_pre, pSharp_PREDLTI_Reserve->iTargetScale);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_tap_pre, pSharp_PREDLTI_Reserve->iTargetGainTap);
            PQ_RegisterWrite(VIP_reg_slr_dlti_shoot_tap_pre, pSharp_PREDLTI_Reserve->iTargetShootTap);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c1_pre, pSHARP_PREDLTI_DATA->icoef[0]);
        	PQ_RegisterWrite(VIP_reg_slr_dlti_c2_pre, pSHARP_PREDLTI_DATA->icoef[1]);
        	PQ_RegisterWrite(VIP_reg_slr_dlti_c3_pre, pSHARP_PREDLTI_DATA->icoef[2]);
      	  	PQ_RegisterWrite(dwPreDLTIFacReg[0], pSharp_PREDLTI_Reserve->iTagetFac0);
        	PQ_RegisterWrite(dwPreDLTIFacReg[1], pSharp_PREDLTI_Reserve->iTagetFac1);
        	PQ_RegisterWrite(dwPreDLTIFacReg[2], pSharp_PREDLTI_Reserve->iTagetFac2);
        	PQ_RegisterWrite(dwPreDLTITHReg[0], pSharp_PREDLTI_Reserve->iTagetTh0);
       		PQ_RegisterWrite(dwPreDLTITHReg[1], pSharp_PREDLTI_Reserve->iTagetTh1);
        	PQ_RegisterWrite(dwPreDLTISlopeReg[0], pSharp_PREDLTI_Reserve->iTagetSlp0);
        	PQ_RegisterWrite(dwPreDLTISlopeReg[1], pSharp_PREDLTI_Reserve->iTagetSlp1);
        }

    }

}


void PQ_Sharpness_POSTDLTI(BOOL bReset,UINT8 ucValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    SHARP_POSTDLTI* pSHARP_POSTDCTI = &pVtab->mSharpness_PostDLTI;
    SHARP_POSTDLTI_DATA* pPostDLTIData;
    SHARP_POSTDLTI_RESERVE *pSharp_POSTDLTI_Reserve;
    UINT8 ucCurrSrcIndex, ucTableIndex;
    static UINT8 bStart = FALSE;

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

    if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
    {
        PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
        return;
    }

    ucTableIndex = pSHARP_POSTDCTI->mGroupedIndex[ucCurrSrcIndex];
    pPostDLTIData = &pSHARP_POSTDCTI->mPostDLTIData[ucTableIndex];
    pSharp_POSTDLTI_Reserve = &pHwContext->mSharp_POSTDLTI_Reserve;

   	if(bReset)
   	{
       bStart = TRUE;
       

       if( ucValue>127 )
            ucValue= 127;

        PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);


        if( ucValue<64 )
        {
            pSharp_POSTDLTI_Reserve->iTagetFac0 = pPostDLTIData->iGain0[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iGain0[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iGain0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetFac1 = pPostDLTIData->iGain1[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iGain1[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iGain1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetFac2 = pPostDLTIData->iGain2[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iGain2[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iGain2[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetTh0 = pPostDLTIData->iTh0[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iTh0[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iTh0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetTh1 = pPostDLTIData->iTh1[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iTh1[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iTh1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetSlp0 = pPostDLTIData->iSlope0[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iSlope0[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iSlope0[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetSlp1 = pPostDLTIData->iSlope1[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iSlope1[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iSlope1[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCMode = pPostDLTIData->iDnamicClipMode[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iDnamicClipMode[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iDnamicClipMode[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCOverShoot = pPostDLTIData->iDnamicClipOverShoot[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iDnamicClipOverShoot[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iDnamicClipOverShoot[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCUnderShoot = pPostDLTIData->iDnamicClipUnderShoot[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iDnamicClipUnderShoot[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iDnamicClipUnderShoot[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCOverShootfac = pPostDLTIData->iDnamicClipOverShootfac[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iDnamicClipOverShootfac[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iDnamicClipOverShootfac[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCUnderShootfac = pPostDLTIData->iDnamicClipUnderShootfac[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iDnamicClipUnderShootfac[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iDnamicClipUnderShootfac[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetNorOverShoot = pPostDLTIData->iNormalOverShoot[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iNormalOverShoot[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iNormalOverShoot[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetNorlUnderShoot = pPostDLTIData->iNormalUnderShoot[PQ_SHARPNESS_0PERCENT]+ (pPostDLTIData->iNormalUnderShoot[PQ_SHARPNESS_50PERCENT] - pPostDLTIData->iNormalUnderShoot[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
        }
        else
        {
            //from normal to strong
            ucValue-= 64;
            pSharp_POSTDLTI_Reserve->iTagetFac0 = pPostDLTIData->iGain0[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iGain0[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iGain0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetFac1 = pPostDLTIData->iGain1[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iGain1[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iGain1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetFac2 = pPostDLTIData->iGain2[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iGain2[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iGain2[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetTh0 = pPostDLTIData->iTh0[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iTh0[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iTh0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetTh1 = pPostDLTIData->iTh1[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iTh1[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iTh1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetSlp0 = pPostDLTIData->iSlope0[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iSlope0[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iSlope0[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTagetSlp1 = pPostDLTIData->iSlope1[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iSlope1[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iSlope1[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCMode = pPostDLTIData->iDnamicClipMode[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iDnamicClipMode[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iDnamicClipMode[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCOverShoot = pPostDLTIData->iDnamicClipOverShoot[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iDnamicClipOverShoot[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iDnamicClipOverShoot[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCUnderShoot = pPostDLTIData->iDnamicClipUnderShoot[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iDnamicClipUnderShoot[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iDnamicClipUnderShoot[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCOverShootfac = pPostDLTIData->iDnamicClipOverShootfac[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iDnamicClipOverShootfac[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iDnamicClipOverShootfac[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetDCUnderShootfac = pPostDLTIData->iDnamicClipUnderShootfac[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iDnamicClipUnderShootfac[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iDnamicClipUnderShootfac[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetNorOverShoot = pPostDLTIData->iNormalOverShoot[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iNormalOverShoot[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iNormalOverShoot[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDLTI_Reserve->iTargetNorlUnderShoot = pPostDLTIData->iNormalUnderShoot[PQ_SHARPNESS_50PERCENT]+ (pPostDLTIData->iNormalUnderShoot[PQ_SHARPNESS_100PERCENT] - pPostDLTIData->iNormalUnderShoot[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;

        }

       pSharp_POSTDLTI_Reserve->iTargetScale = pPostDLTIData->iScale[PQ_SHARPNESS_50PERCENT];
       pSharp_POSTDLTI_Reserve->iTargetGainTap = pPostDLTIData->iGainTap[PQ_SHARPNESS_50PERCENT];
       pSharp_POSTDLTI_Reserve->iTargetShootTap = pPostDLTIData->iShootTap[PQ_SHARPNESS_50PERCENT];
       return;
   }

   if(bStart)
   {
       bStart = FALSE;

        if( pHwContext->bEnableColorProcess==FALSE )
        {
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_0_post, 0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_1_post, 0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_2_post, 0);

            return;
        }

        if(pHwContext->PqPatch.PostDLTIPatch == POST_DLTI_JPEG_THUMBNAIL_PATCH)
        {
            PQ_RegisterWrite(VIP_reg_slr_dlti_dclip_en_post, 1);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c1_post, 0x167);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c2_post, 0xe8d);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c3_post, 0xefc);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c4_post, 0xfd7);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c5_post, 0xfa7);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c6_post, 0xfad);
            PQ_RegisterWrite(VIP_reg_slr_dlti_scale_post, 0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_tap_post, 5);
            PQ_RegisterWrite(VIP_reg_slr_dlti_shoot_tap_post, 5);
            PQ_RegisterWrite(VIP_reg_slr_dlti_dclip_sel_post, 2);
            PQ_RegisterWrite(VIP_reg_slr_dlti_unsht_dclip_post, 4);
            PQ_RegisterWrite(VIP_reg_slr_dlti_ovsht_fac_post, 3);
            PQ_RegisterWrite(VIP_reg_slr_dlti_unsht_fac_post, 3);
            PQ_RegisterWrite(VIP_reg_slr_dlti_ovsht_clip_post, 0x20);
            PQ_RegisterWrite(VIP_reg_slr_dlti_unsht_clip_post, 0x20);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_0_post, 0x78);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_1_post, 0x78);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_th1_post, 0x64);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_slope1_post, 0x3a);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_slr_dlti_dclip_en_post, pPostDLTIData->iDynamicClipEnable);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c1_post, pPostDLTIData->icoef[0]);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c2_post, pPostDLTIData->icoef[1]);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c3_post, pPostDLTIData->icoef[2]);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c4_post, pPostDLTIData->icoef[3]);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c5_post, pPostDLTIData->icoef[4]);
            PQ_RegisterWrite(VIP_reg_slr_dlti_c6_post, pPostDLTIData->icoef[5]);
            PQ_RegisterWrite(VIP_reg_slr_dlti_scale_post, pSharp_POSTDLTI_Reserve->iTargetScale);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_tap_post, pSharp_POSTDLTI_Reserve->iTargetGainTap);
            PQ_RegisterWrite(VIP_reg_slr_dlti_shoot_tap_post, pSharp_POSTDLTI_Reserve->iTargetShootTap);
            PQ_RegisterWrite(VIP_reg_slr_dlti_dclip_sel_post, pSharp_POSTDLTI_Reserve->iTargetDCMode);
            PQ_RegisterWrite(VIP_reg_slr_dlti_unsht_dclip_post, pSharp_POSTDLTI_Reserve->iTargetDCUnderShoot);
            PQ_RegisterWrite(VIP_reg_slr_dlti_ovsht_fac_post, pSharp_POSTDLTI_Reserve->iTargetDCOverShootfac);
            PQ_RegisterWrite(VIP_reg_slr_dlti_unsht_fac_post, pSharp_POSTDLTI_Reserve->iTargetDCUnderShootfac);
            PQ_RegisterWrite(VIP_reg_slr_dlti_ovsht_clip_post, pSharp_POSTDLTI_Reserve->iTargetNorOverShoot);
            PQ_RegisterWrite(VIP_reg_slr_dlti_unsht_clip_post, pSharp_POSTDLTI_Reserve->iTargetNorlUnderShoot);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_0_post, pSharp_POSTDLTI_Reserve->iTagetFac0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_1_post, pSharp_POSTDLTI_Reserve->iTagetFac1);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_th1_post, pSharp_POSTDLTI_Reserve->iTagetTh1);
            PQ_RegisterWrite(VIP_reg_slr_dlti_gain_slope1_post, pSharp_POSTDLTI_Reserve->iTagetSlp1);
        }

        PQ_RegisterWrite(VIP_reg_slr_dlti_ovsht_dclip_post, pSharp_POSTDLTI_Reserve->iTargetDCOverShoot);
        PQ_RegisterWrite(VIP_reg_slr_dlti_gain_2_post, pSharp_POSTDLTI_Reserve->iTagetFac2);
        PQ_RegisterWrite(VIP_reg_slr_dlti_gain_th0_post, pSharp_POSTDLTI_Reserve->iTagetTh0);
        PQ_RegisterWrite(VIP_reg_slr_dlti_gain_slope0_post, pSharp_POSTDLTI_Reserve->iTagetSlp0);

        if (VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource() && VIP_GetInputVSize() > 700)   //#51277
        {
            PQ_RegisterWrite(VIP_reg_slr_dlti_scale_post, 0x0);
            PQ_RegisterWrite(VIP_reg_slr_dlti_shoot_tap_post, 0x0);
        }   
    }
}


void PQ_Sharpness_POST_2D(BOOL bReset,UINT8 ucValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    SHARP_POST2DSHARPNESS* pPost2DSharpness = &pVtab->mSharpness_Post2DSharpness;
    SHARP_POST2DSHARPNESS_DATA* pPost2DSharpData;
    SHARP_POST2D_RESERVE *pSharp_POST2D_Reserve;
    UINT8 ucCurrSrcIndex, ucTableIndex, ucUserSource, ucSubSource;
    static UINT8 bStart = FALSE;
    
    VIP_GetSource(&ucUserSource, &ucSubSource);

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

    if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
    {
        PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
        return;
    }

    ucTableIndex = pPost2DSharpness->mGroupedIndex[ucCurrSrcIndex];
    pPost2DSharpData = &pPost2DSharpness->mPost2DSharpData[ucTableIndex];
    pSharp_POST2D_Reserve = &pHwContext->mSharp_POST2D_Reserve;

    if(bReset)
    {
        bStart = TRUE;
        

        if( ucValue>127 )
            ucValue= 127;

        PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);


        if( ucValue<64 )
        {
            pSharp_POST2D_Reserve->iTagetFac0_L = pPost2DSharpData->iGain0_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGain0_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGain0_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac1_L = pPost2DSharpData->iGain1_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGain1_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGain1_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac2_L = pPost2DSharpData->iGain2_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGain2_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGain2_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh0_L = pPost2DSharpData->iTh0_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iTh0_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iTh0_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh1_L = pPost2DSharpData->iTh1_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iTh1_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iTh1_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp0_L = pPost2DSharpData->iSlope0_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iSlope0_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iSlope0_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp1_L = pPost2DSharpData->iSlope1_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iSlope1_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iSlope1_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetFM_L = pPost2DSharpData->iFilterMode_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iFilterMode_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iFilterMode_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetScale_L = pPost2DSharpData->iScale_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iScale_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iScale_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetGainTap_L = pPost2DSharpData->iGainTap_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGainTap_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGainTap_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetShootTap_L = pPost2DSharpData->iShootTap_Luma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iShootTap_Luma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iShootTap_Luma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;

            pSharp_POST2D_Reserve->iTargetNorOverShoot = pPost2DSharpData->iNormalOverShoot[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iNormalOverShoot[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iNormalOverShoot[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetNorlUnderShoot = pPost2DSharpData->iNormalUnderShoot[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iNormalUnderShoot[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iNormalUnderShoot[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetOverShootfac = pPost2DSharpData->iOverShootFactor[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iOverShootFactor[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iOverShootFactor[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetUnderShootfac = pPost2DSharpData->iUnderShootFactor[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iUnderShootFactor[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iUnderShootFactor[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;

            pSharp_POST2D_Reserve->iTagetFac0_C = pPost2DSharpData->iGain0_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGain0_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGain0_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac1_C = pPost2DSharpData->iGain1_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGain1_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGain1_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac2_C = pPost2DSharpData->iGain2_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGain2_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGain2_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh0_C = pPost2DSharpData->iTh0_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iTh0_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iTh0_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh1_C = pPost2DSharpData->iTh1_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iTh1_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iTh1_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp0_C = pPost2DSharpData->iSlope0_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iSlope0_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iSlope0_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp1_C = pPost2DSharpData->iSlope1_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iSlope1_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iSlope1_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetFM_C = pPost2DSharpData->iFilterMode_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iFilterMode_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iFilterMode_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetScale_C = pPost2DSharpData->iScale_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iScale_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iScale_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetGainTap_C = pPost2DSharpData->iGainTap_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iGainTap_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iGainTap_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetShootTap_C = pPost2DSharpData->iShootTap_Chroma[PQ_SHARPNESS_0PERCENT]+ (pPost2DSharpData->iShootTap_Chroma[PQ_SHARPNESS_50PERCENT] - pPost2DSharpData->iShootTap_Chroma[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;

        }
        else
        {
            //from normal to strong
            ucValue-= 64;
            pSharp_POST2D_Reserve->iTagetFac0_L = pPost2DSharpData->iGain0_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGain0_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGain0_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac1_L = pPost2DSharpData->iGain1_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGain1_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGain1_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac2_L = pPost2DSharpData->iGain2_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGain2_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGain2_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh0_L = pPost2DSharpData->iTh0_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iTh0_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iTh0_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh1_L = pPost2DSharpData->iTh1_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iTh1_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iTh1_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp0_L = pPost2DSharpData->iSlope0_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iSlope0_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iSlope0_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp1_L = pPost2DSharpData->iSlope1_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iSlope1_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iSlope1_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetFM_L = pPost2DSharpData->iFilterMode_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iFilterMode_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iFilterMode_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetScale_L = pPost2DSharpData->iScale_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iScale_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iScale_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetGainTap_L = pPost2DSharpData->iGainTap_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGainTap_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGainTap_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetShootTap_L = pPost2DSharpData->iShootTap_Luma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iShootTap_Luma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iShootTap_Luma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;

            pSharp_POST2D_Reserve->iTargetNorOverShoot = pPost2DSharpData->iNormalOverShoot[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iNormalOverShoot[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iNormalOverShoot[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetNorlUnderShoot = pPost2DSharpData->iNormalUnderShoot[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iNormalUnderShoot[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iNormalUnderShoot[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetOverShootfac = pPost2DSharpData->iOverShootFactor[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iOverShootFactor[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iOverShootFactor[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetUnderShootfac = pPost2DSharpData->iUnderShootFactor[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iUnderShootFactor[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iUnderShootFactor[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;

            pSharp_POST2D_Reserve->iTagetFac0_C = pPost2DSharpData->iGain0_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGain0_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGain0_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac1_C = pPost2DSharpData->iGain1_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGain1_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGain1_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetFac2_C = pPost2DSharpData->iGain2_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGain2_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGain2_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh0_C = pPost2DSharpData->iTh0_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iTh0_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iTh0_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetTh1_C = pPost2DSharpData->iTh1_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iTh1_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iTh1_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp0_C = pPost2DSharpData->iSlope0_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iSlope0_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iSlope0_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTagetSlp1_C = pPost2DSharpData->iSlope1_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iSlope1_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iSlope1_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetFM_C = pPost2DSharpData->iFilterMode_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iFilterMode_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iFilterMode_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetScale_C = pPost2DSharpData->iScale_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iScale_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iScale_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetGainTap_C = pPost2DSharpData->iGainTap_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iGainTap_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iGainTap_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POST2D_Reserve->iTargetShootTap_C = pPost2DSharpData->iShootTap_Chroma[PQ_SHARPNESS_50PERCENT]+ (pPost2DSharpData->iShootTap_Chroma[PQ_SHARPNESS_100PERCENT] - pPost2DSharpData->iShootTap_Chroma[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;

        }
        
        return;
    }

    if(bStart)
    {
        bStart = FALSE;

        if( pHwContext->bEnableColorProcess==FALSE )
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_0, 0);
            PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_1, 0);
            PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_2, 0);

            PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_0, 0);
            PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_1, 0);
            PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_2, 0);

            return;
        }

        if(_VIP_GetPreviewWndowStatus() || pHwContext->PqPatch.Post2DPatch == POST_2D_SHARPNESS_JPEG_THUMBNAIL_PATCH)
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en,0);
        }
        else
        {
        	PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en, pPost2DSharpData->iPost2DSharpEnable);
        }

        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_0, pSharp_POST2D_Reserve->iTagetFac0_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_1, pSharp_POST2D_Reserve->iTagetFac1_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_2, pSharp_POST2D_Reserve->iTagetFac2_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_th0, pSharp_POST2D_Reserve->iTagetTh0_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_th1, pSharp_POST2D_Reserve->iTagetTh1_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_slope0, pSharp_POST2D_Reserve->iTagetSlp0_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_slope1, pSharp_POST2D_Reserve->iTagetSlp1_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_sel, pSharp_POST2D_Reserve->iTargetFM_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, pSharp_POST2D_Reserve->iTargetScale_L); //replace set in PQ_DSSetting()
        PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_tap, pSharp_POST2D_Reserve->iTargetGainTap_L);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_shoot_tap, pSharp_POST2D_Reserve->iTargetShootTap_L);

        PQ_RegisterWrite(VIP_reg_slr_2d_l_ovsht_clip, pSharp_POST2D_Reserve->iTargetNorOverShoot);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_unsht_clip, pSharp_POST2D_Reserve->iTargetNorlUnderShoot);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_ovsht_fac, pSharp_POST2D_Reserve->iTargetOverShootfac);
        PQ_RegisterWrite(VIP_reg_slr_2d_l_unsht_fac, pSharp_POST2D_Reserve->iTargetUnderShootfac);

        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_0, pSharp_POST2D_Reserve->iTagetFac0_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_1, pSharp_POST2D_Reserve->iTagetFac1_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_2, pSharp_POST2D_Reserve->iTagetFac2_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_th0, pSharp_POST2D_Reserve->iTagetTh0_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_th1, pSharp_POST2D_Reserve->iTagetTh1_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_slope0, pSharp_POST2D_Reserve->iTagetSlp0_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_slope1, pSharp_POST2D_Reserve->iTagetSlp1_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_gain_tap, pSharp_POST2D_Reserve->iTargetGainTap_C);
        PQ_RegisterWrite(VIP_reg_slr_2d_c_shoot_tap, pSharp_POST2D_Reserve->iTargetShootTap_C);
        PQ_RegisterWrite(VIP_reg_slr_ds_cond1_sel3, 1);
        PQ_RegisterWrite(VIP_reg_slr_ds_sad_lr_max, 0);

        if(VIP_IsSourceDTV() || !PQ_IsColorBar() || VIP_RunDVIMode() || VIP_IsPCSource())
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_c_sel, pSharp_POST2D_Reserve->iTargetFM_C);
            PQ_RegisterWrite(VIP_reg_slr_2d_c_scale, pSharp_POST2D_Reserve->iTargetScale_C);
        }

        if (VIP_GetUserSource() == SOURCE_EXTS && VIP_GetInputVSize() < 600) 
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_l_ovsht_fac, 0x1); // #42296 & #42516
        }   

        if (VIP_IsSCARTSource() && VIP_IsAVSource())
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x00); //#40517  & #40758
        }
        else if (VIP_IsSVSource())
        {
        	PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x00); //#40955
        }
        else if (VIP_IsAVSource() && (VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK && VIP_GetStdColorSystem() <= CVD2_STD_SECAM))
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x0); //#40758
        }
        else if (VIP_RunDVIMode() && VIP_GetInputHSize()==1280 && VIP_GetInputVSize()==1024 && VIP_GetPanelWidth()==1366 && VIP_GetPanelHeight()==768)
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_l_shoot_tap, 0x0); //#51264
        }
    }
}


/*******************************************************************
//	function name		: PQ_Sharpness_Peaking_DLTI
//	input parameter	: bReset : for trigger in the vsync 
//	output parameter	: none
//	purpose			: HW SLR new function since chip 8506
//   return			: none
*******************************************************************/
void PQ_Sharpness_Peaking_DLTI(BOOL bReset,UINT8 ucValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    Peaking_DLTI_Setting* pPeakingDLTI = &pVtab->mPeakingDLTI;
    Peaking_DLTI_Data* pPeakingDLTIData;
    SHARP_PEAKING_DLTI_RESERVE *pPeaking_DLTI_Reserve;
    static UINT8 bStart = FALSE;
    UINT8 ucCurrSrcIndex, ucTableIndex, ucUserSource, ucSubSource, DLTI_Tap_Num = 1, V_Peaking_Tap_Num, Peaking_2D_Tap_Num, H_Peaking_Tap_Num;

    VIP_GetSource(&ucUserSource, &ucSubSource);

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

    if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
    {
        PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
        return;
    }

    ucTableIndex = pPeakingDLTI->mGroupedIndex[ucCurrSrcIndex];
    pPeakingDLTIData = &pPeakingDLTI->Peaking_DLTI[ucTableIndex];
    pPeaking_DLTI_Reserve = &pHwContext->mSharp_Peaking_DLTI_Reserve;

    if(bReset)
    {
        bStart = TRUE;

        if( ucValue>127 )
        {
            ucValue= 127;
        }

        PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);

        if( ucValue<64 )
        {
            pPeaking_DLTI_Reserve->SharpnessXp0Peak = pPeakingDLTIData->SharpnessXp0Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp0Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp0Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp1Peak = pPeakingDLTIData->SharpnessXp1Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp1Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp1Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp2Peak = pPeakingDLTIData->SharpnessXp2Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp2Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp2Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp3Peak = pPeakingDLTIData->SharpnessXp3Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp3Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp3Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp0Peak = pPeakingDLTIData->SharpnessYp0Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessYp0Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessYp0Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp1Peak = pPeakingDLTIData->SharpnessYp1Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessYp1Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessYp1Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp2Peak = pPeakingDLTIData->SharpnessYp2Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessYp2Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessYp2Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp1Peak = pPeakingDLTIData->SharpnessMp1Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessMp1Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessMp1Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp2Peak = pPeakingDLTIData->SharpnessMp2Peak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessMp2Peak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessMp2Peak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp0Lti = pPeakingDLTIData->SharpnessXp0Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp0Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp0Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp1Lti = pPeakingDLTIData->SharpnessXp1Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp1Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp1Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp2Lti = pPeakingDLTIData->SharpnessXp2Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp2Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp2Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp3Lti = pPeakingDLTIData->SharpnessXp3Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessXp3Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessXp3Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp0Lti = pPeakingDLTIData->SharpnessYp0Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessYp0Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessYp0Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp1Lti = pPeakingDLTIData->SharpnessYp1Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessYp1Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessYp1Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp2Lti = pPeakingDLTIData->SharpnessYp2Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessYp2Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessYp2Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp1Lti = pPeakingDLTIData->SharpnessMp1Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessMp1Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessMp1Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp2Lti = pPeakingDLTIData->SharpnessMp2Lti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessMp2Lti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessMp2Lti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainBPPeak1D = pPeakingDLTIData->SharpnessGainBPPeak1D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainBPPeak1D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainBPPeak1D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainEPPeak1D = pPeakingDLTIData->SharpnessGainEPPeak1D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainEPPeak1D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainEPPeak1D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHPPeak1D = pPeakingDLTIData->SharpnessGainHPPeak1D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainHPPeak1D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainHPPeak1D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainNegPeak = pPeakingDLTIData->SharpnessGainNegPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainNegPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainNegPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHPV31 = pPeakingDLTIData->SharpnessGainHPV31[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainHPV31[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainHPV31[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHPV51 = pPeakingDLTIData->SharpnessGainHPV51[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainHPV51[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainHPV51[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeak1D = pPeakingDLTIData->SharpnessCoringPeak1D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeak1D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessCoringPeak1D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeak = pPeakingDLTIData->SharpnessCoringPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessCoringPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeakV = pPeakingDLTIData->SharpnessCoringPeakV[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeakV[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessCoringPeakV[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessHiCoringPeak = pPeakingDLTIData->SharpnessHiCoringPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessHiCoringPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessHiCoringPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHP0Peak2D = pPeakingDLTIData->SharpnessGainHP0Peak2D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainHP0Peak2D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainHP0Peak2D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHP1Peak2D = pPeakingDLTIData->SharpnessGainHP1Peak2D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainHP1Peak2D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainHP1Peak2D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainBP0Peak2D = pPeakingDLTIData->SharpnessGainBP0Peak2D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainBP0Peak2D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainBP0Peak2D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainBP1Peak2D = pPeakingDLTIData->SharpnessGainBP1Peak2D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessGainBP1Peak2D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessGainBP1Peak2D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeak2D = pPeakingDLTIData->SharpnessCoringPeak2D[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeak2D[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessCoringPeak2D[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMaxMinHSLrTap = pPeakingDLTIData->SharpnessMaxMinHSLrTap[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessMaxMinHSLrTap[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessMaxMinHSLrTap[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMaxMinVSLrTap = pPeakingDLTIData->SharpnessMaxMinVSLrTap[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessMaxMinVSLrTap[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessMaxMinVSLrTap[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessAdjcentDiffTh = pPeakingDLTIData->SharpnessAdjcentDiffTh[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessAdjcentDiffTh[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessAdjcentDiffTh[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDLTIBpGain = pPeakingDLTIData->SharpnessDLTIBpGain[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessDLTIBpGain[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessDLTIBpGain[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDLTIEpGain = pPeakingDLTIData->SharpnessDLTIEpGain[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessDLTIEpGain[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessDLTIEpGain[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDLTIHpGain = pPeakingDLTIData->SharpnessDLTIHpGain[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessDLTIHpGain[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessDLTIHpGain[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringLti = pPeakingDLTIData->SharpnessCoringLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessCoringLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessCoringLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessHiCoringLti = pPeakingDLTIData->SharpnessHiCoringLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessHiCoringLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessHiCoringLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDeOvstNewMethodPeak = pPeakingDLTIData->SharpnessDeOvstNewMethodPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessDeOvstNewMethodPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessDeOvstNewMethodPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDeOvseNewMethodLti = pPeakingDLTIData->SharpnessDeOvseNewMethodLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessDeOvseNewMethodLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessDeOvseNewMethodLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMaxPeak = pPeakingDLTIData->SharpnessOverMaxPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOverMaxPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOverMaxPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMinPeak = pPeakingDLTIData->SharpnessOverMinPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOverMinPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOverMinPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMaxPeak = pPeakingDLTIData->SharpnessOvstGainMaxPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMaxPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOvstGainMaxPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMinPeak = pPeakingDLTIData->SharpnessOvstGainMinPeak[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMinPeak[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOvstGainMinPeak[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMaxLti = pPeakingDLTIData->SharpnessOverMaxLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOverMaxLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOverMaxLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMinLti = pPeakingDLTIData->SharpnessOverMinLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOverMinLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOverMinLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMaxLti = pPeakingDLTIData->SharpnessOvstGainMaxLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMaxLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOvstGainMaxLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMinLti = pPeakingDLTIData->SharpnessOvstGainMinLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMinLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessOvstGainMinLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMaxMinHSLrTapLti = pPeakingDLTIData->SharpnessMaxMinHSLrTapLti[PQ_SHARPNESS_0PERCENT]+ (pPeakingDLTIData->SharpnessMaxMinHSLrTapLti[PQ_SHARPNESS_50PERCENT] - pPeakingDLTIData->SharpnessMaxMinHSLrTapLti[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
        }
        else
        {
            ucValue-= 64;
            pPeaking_DLTI_Reserve->SharpnessXp0Peak = pPeakingDLTIData->SharpnessXp0Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp0Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp0Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp1Peak = pPeakingDLTIData->SharpnessXp1Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp1Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp1Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp2Peak = pPeakingDLTIData->SharpnessXp2Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp2Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp2Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp3Peak = pPeakingDLTIData->SharpnessXp3Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp3Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp3Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp0Peak = pPeakingDLTIData->SharpnessYp0Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessYp0Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessYp0Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp1Peak = pPeakingDLTIData->SharpnessYp1Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessYp1Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessYp1Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp2Peak = pPeakingDLTIData->SharpnessYp2Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessYp2Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessYp2Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp1Peak = pPeakingDLTIData->SharpnessMp1Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessMp1Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessMp1Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp2Peak = pPeakingDLTIData->SharpnessMp2Peak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessMp2Peak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessMp2Peak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp0Lti = pPeakingDLTIData->SharpnessXp0Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp0Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp0Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp1Lti = pPeakingDLTIData->SharpnessXp1Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp1Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp1Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp2Lti = pPeakingDLTIData->SharpnessXp2Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp2Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp2Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessXp3Lti = pPeakingDLTIData->SharpnessXp3Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessXp3Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessXp3Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp0Lti = pPeakingDLTIData->SharpnessYp0Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessYp0Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessYp0Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp1Lti = pPeakingDLTIData->SharpnessYp1Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessYp1Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessYp1Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessYp2Lti = pPeakingDLTIData->SharpnessYp2Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessYp2Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessYp2Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp1Lti = pPeakingDLTIData->SharpnessMp1Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessMp1Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessMp1Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMp2Lti = pPeakingDLTIData->SharpnessMp2Lti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessMp2Lti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessMp2Lti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainBPPeak1D = pPeakingDLTIData->SharpnessGainBPPeak1D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainBPPeak1D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainBPPeak1D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainEPPeak1D = pPeakingDLTIData->SharpnessGainEPPeak1D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainEPPeak1D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainEPPeak1D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHPPeak1D = pPeakingDLTIData->SharpnessGainHPPeak1D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainHPPeak1D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainHPPeak1D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainNegPeak = pPeakingDLTIData->SharpnessGainNegPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainNegPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainNegPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHPV31 = pPeakingDLTIData->SharpnessGainHPV31[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainHPV31[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainHPV31[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHPV51 = pPeakingDLTIData->SharpnessGainHPV51[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainHPV51[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainHPV51[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeak1D = pPeakingDLTIData->SharpnessCoringPeak1D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeak1D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessCoringPeak1D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeak = pPeakingDLTIData->SharpnessCoringPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessCoringPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeakV = pPeakingDLTIData->SharpnessCoringPeakV[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeakV[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessCoringPeakV[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessHiCoringPeak = pPeakingDLTIData->SharpnessHiCoringPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessHiCoringPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessHiCoringPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHP0Peak2D = pPeakingDLTIData->SharpnessGainHP0Peak2D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainHP0Peak2D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainHP0Peak2D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainHP1Peak2D = pPeakingDLTIData->SharpnessGainHP1Peak2D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainHP1Peak2D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainHP1Peak2D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainBP0Peak2D = pPeakingDLTIData->SharpnessGainBP0Peak2D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainBP0Peak2D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainBP0Peak2D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessGainBP1Peak2D = pPeakingDLTIData->SharpnessGainBP1Peak2D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessGainBP1Peak2D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessGainBP1Peak2D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringPeak2D = pPeakingDLTIData->SharpnessCoringPeak2D[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessCoringPeak2D[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessCoringPeak2D[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMaxMinHSLrTap = pPeakingDLTIData->SharpnessMaxMinHSLrTap[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessMaxMinHSLrTap[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessMaxMinHSLrTap[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMaxMinVSLrTap = pPeakingDLTIData->SharpnessMaxMinVSLrTap[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessMaxMinVSLrTap[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessMaxMinVSLrTap[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessAdjcentDiffTh = pPeakingDLTIData->SharpnessAdjcentDiffTh[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessAdjcentDiffTh[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessAdjcentDiffTh[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDLTIBpGain = pPeakingDLTIData->SharpnessDLTIBpGain[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessDLTIBpGain[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessDLTIBpGain[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDLTIEpGain = pPeakingDLTIData->SharpnessDLTIEpGain[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessDLTIEpGain[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessDLTIEpGain[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDLTIHpGain = pPeakingDLTIData->SharpnessDLTIHpGain[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessDLTIHpGain[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessDLTIHpGain[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessCoringLti = pPeakingDLTIData->SharpnessCoringLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessCoringLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessCoringLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessHiCoringLti = pPeakingDLTIData->SharpnessHiCoringLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessHiCoringLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessHiCoringLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDeOvstNewMethodPeak = pPeakingDLTIData->SharpnessDeOvstNewMethodPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessDeOvstNewMethodPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessDeOvstNewMethodPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessDeOvseNewMethodLti = pPeakingDLTIData->SharpnessDeOvseNewMethodLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessDeOvseNewMethodLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessDeOvseNewMethodLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMaxPeak = pPeakingDLTIData->SharpnessOverMaxPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOverMaxPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOverMaxPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMinPeak = pPeakingDLTIData->SharpnessOverMinPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOverMinPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOverMinPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMaxPeak = pPeakingDLTIData->SharpnessOvstGainMaxPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMaxPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOvstGainMaxPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMinPeak = pPeakingDLTIData->SharpnessOvstGainMinPeak[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMinPeak[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOvstGainMinPeak[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMaxLti = pPeakingDLTIData->SharpnessOverMaxLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOverMaxLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOverMaxLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOverMinLti = pPeakingDLTIData->SharpnessOverMinLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOverMinLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOverMinLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMaxLti = pPeakingDLTIData->SharpnessOvstGainMaxLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMaxLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOvstGainMaxLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessOvstGainMinLti = pPeakingDLTIData->SharpnessOvstGainMinLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessOvstGainMinLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessOvstGainMinLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pPeaking_DLTI_Reserve->SharpnessMaxMinHSLrTapLti = pPeakingDLTIData->SharpnessMaxMinHSLrTapLti[PQ_SHARPNESS_50PERCENT]+ (pPeakingDLTIData->SharpnessMaxMinHSLrTapLti[PQ_SHARPNESS_100PERCENT] - pPeakingDLTIData->SharpnessMaxMinHSLrTapLti[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
        }
        
        return;
    }

    if(bStart)
    {
        bStart = FALSE;

        switch(pHwContext->PqPatch.PeakLtiPatch){
            case    PEAKLTI_AV_IRE_PATCH:
            case    PEAKLTI_AV_GRAYSCALE_PATCH:
                PQ_RegisterWrite(VIP_REG_SLR_2D_SEL_SP, 1);
                PQ_RegisterWrite(VIP_REG_SLR_SHARPNESS_PEAK_EN, 1);
                PQ_RegisterWrite(VIP_REG_SLR_SHARPNESS_LTI_EN, 1);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_LR_TAP, 4);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_H_LR_TAP, 4);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_HS_LR_TAP, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_V_LR_TAP, 2);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_VS_LR_TAP, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ADJCENT_DIFF_TH, 0x20);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_FILTER_MODE_PEAK1D, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_LOW_PASS_PEAK1D, 1);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_BP_SEL_PEAK1D, 1);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_EP_SEL_PEAK1D, 0); 
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HP_SEL_PEAK1D, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP_PEAK1D, 0xc);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_EP_PEAK1D, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_PEAK1D, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAK1D, 0x8);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_LOW_PASS_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_BP_SEL_LTI, 1);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_EP_SEL_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HP_SEL_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ST_SEL, 2);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_EP_LTI, 0xa);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP0_PEAK2D, 0x7);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP1_PEAK2D, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP0_PEAK2D, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP1_PEAK2D, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_V31, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_V51, 7);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAKV, 0x8);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAK2D, 0x10);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ABS_LP_EN_PEAK, 1);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP0_PEAK, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP1_PEAK, 0x27);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP2_PEAK, 0xbe);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP3_PEAK, 0xff);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP0_PEAK, 0x23);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP1_PEAK, 0x53);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP2_PEAK, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP1_PEAK, 0x13);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP2_PEAK, 0x14);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAK, 20);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_NEG_PEAK, 0x7);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_DEOVST_NEW_METHOD_PEAK, 1);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MAX_PEAK, 3);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MIN_PEAK, 3);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MAX_PEAK, 0x60);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MIN_PEAK, 0x40);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HI_CORING_PEAK, 0x12);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ABS_LP_EN_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP0_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP1_LTI, 0x2a);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP2_LTI, 0xd6);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP3_LTI, 0xff);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP0_LTI, 0x33);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP1_LTI, 0x71);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP2_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP1_LTI, 0x17);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP2_LTI, 0x2c);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_LTI, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_DEOVST_NEW_METHOD_LTI, 1);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MAX_LTI, 3);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MIN_LTI, 3);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MAX_LTI, 0xc8);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MIN_LTI, 0xc8);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HI_CORING_LTI, 0x64);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_H_LR_TAP_LTI, 0x5);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_HS_LR_TAP_LTI, 0);
                break;
            default:
                if(pPeaking_DLTI_Reserve->SharpnessGainEPPeak1D != 0)
                {
                    if(pPeakingDLTIData->SharpnessPeakingEpTap[PQ_SHARPNESS_0PERCENT] == EP_11_TAP)
                    {
                        H_Peaking_Tap_Num = 5;	
                    }
                    else
                    {
                        H_Peaking_Tap_Num = 6;	
                    }
                }
                else if(pPeaking_DLTI_Reserve->SharpnessGainEPPeak1D == 0 && pPeaking_DLTI_Reserve->SharpnessGainBPPeak1D != 0)
                {
                    if(pPeakingDLTIData->SharpnessPeakingBpTap[PQ_SHARPNESS_0PERCENT] == BP_7_TAP)
                    {
                        H_Peaking_Tap_Num = 3;	
                    }
                    else
                    {
                        H_Peaking_Tap_Num = 4;	
                    }
                }
                else if(pPeaking_DLTI_Reserve->SharpnessGainEPPeak1D == 0 && pPeaking_DLTI_Reserve->SharpnessGainBPPeak1D == 0 && pPeaking_DLTI_Reserve->SharpnessGainHPPeak1D != 0)
                {
                    if(pPeakingDLTIData->SharpnessPeakingHpTap[PQ_SHARPNESS_0PERCENT] == HP_3_TAP)
                    {
                        H_Peaking_Tap_Num = 1;	
                    }
                    else
                    {
                        H_Peaking_Tap_Num = 2;	
                    }
                }
                else
                {
                    if(pPeaking_DLTI_Reserve->SharpnessGainHP1Peak2D != 0)
                    {
                        H_Peaking_Tap_Num = 2;	
                    }
                    else
                    {
                        H_Peaking_Tap_Num = 1;	
                    }	
                }
        
                // 2D
                if(pPeaking_DLTI_Reserve->SharpnessGainBP1Peak2D != 0)
                {
                    Peaking_2D_Tap_Num = 4;
                }
                else if(pPeaking_DLTI_Reserve->SharpnessGainBP1Peak2D == 0 && pPeaking_DLTI_Reserve->SharpnessGainBP0Peak2D != 0)
                {
                    Peaking_2D_Tap_Num = 3;
                }
                else if(pPeaking_DLTI_Reserve->SharpnessGainBP1Peak2D == 0 && pPeaking_DLTI_Reserve->SharpnessGainBP0Peak2D == 0 && pPeaking_DLTI_Reserve->SharpnessGainHP1Peak2D != 0)
                {
                    Peaking_2D_Tap_Num = 2;
                }
                else
                {
                    Peaking_2D_Tap_Num = 1;
                }

                if(pPeaking_DLTI_Reserve->SharpnessDLTIEpGain != 0)
                {
                    if(pPeakingDLTIData->SharpnessDLTIEpTap[PQ_SHARPNESS_0PERCENT] == EP_11_TAP)
                    {
                        DLTI_Tap_Num = 5;	
                    }
                    else
                    {
                        DLTI_Tap_Num = 6;	
                    }
                }
                else if(pPeaking_DLTI_Reserve->SharpnessDLTIEpGain == 0 && pPeaking_DLTI_Reserve->SharpnessDLTIBpGain != 0)
                {
                    if(pPeakingDLTIData->SharpnessDLTIBpTap[PQ_SHARPNESS_0PERCENT] == BP_7_TAP)
                    {
                        DLTI_Tap_Num = 3;	
                    }
                    else
                    {
                        DLTI_Tap_Num = 4;	
                    }
                }
                else if(pPeaking_DLTI_Reserve->SharpnessDLTIEpGain == 0 && pPeaking_DLTI_Reserve->SharpnessDLTIBpGain == 0 && pPeaking_DLTI_Reserve->SharpnessDLTIHpGain != 0)
                {
                    if(pPeakingDLTIData->SharpnessDLTIHpTap[PQ_SHARPNESS_0PERCENT] == HP_3_TAP)
                    {
                        DLTI_Tap_Num = 1;	
                    }
                    else
                    {
                        DLTI_Tap_Num = 2;	
                    }
                }

                //V Peaing
                if(pPeaking_DLTI_Reserve->SharpnessGainHPV51 != 0)
                {
                    V_Peaking_Tap_Num = 2;
                }
                else
                {
                    V_Peaking_Tap_Num = 1;
                }

                //hw request, if 2D tap > V peaking, use 2d tap number
                if(Peaking_2D_Tap_Num > V_Peaking_Tap_Num)
                {
                    V_Peaking_Tap_Num = 2;
                }

                PQ_RegisterWrite(VIP_REG_SLR_2D_SEL_SP, pPeakingDLTIData->SLR2DSelSp[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SLR_SHARPNESS_PEAK_EN, pPeakingDLTIData->SharpnessPeakingEn[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SLR_SHARPNESS_LTI_EN, pPeakingDLTIData->SharpnessLTIEn[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_LR_TAP, (H_Peaking_Tap_Num > Peaking_2D_Tap_Num)? H_Peaking_Tap_Num : Peaking_2D_Tap_Num);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_H_LR_TAP, (H_Peaking_Tap_Num > Peaking_2D_Tap_Num)? H_Peaking_Tap_Num : Peaking_2D_Tap_Num);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_HS_LR_TAP, pPeaking_DLTI_Reserve->SharpnessMaxMinHSLrTap);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_V_LR_TAP, V_Peaking_Tap_Num);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_VS_LR_TAP, pPeaking_DLTI_Reserve->SharpnessMaxMinVSLrTap);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ADJCENT_DIFF_TH, pPeaking_DLTI_Reserve->SharpnessAdjcentDiffTh);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_FILTER_MODE_PEAK1D, pPeakingDLTIData->SharpnessFilterModePeak1D[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_LOW_PASS_PEAK1D, pPeakingDLTIData->SharpnessLowPassPeak1D[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_BP_SEL_PEAK1D, pPeakingDLTIData->SharpnessPeakingBpTap[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_EP_SEL_PEAK1D, pPeakingDLTIData->SharpnessPeakingEpTap[PQ_SHARPNESS_0PERCENT]); 
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HP_SEL_PEAK1D, pPeakingDLTIData->SharpnessPeakingHpTap[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP_PEAK1D, pPeaking_DLTI_Reserve->SharpnessGainBPPeak1D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_EP_PEAK1D, pPeaking_DLTI_Reserve->SharpnessGainEPPeak1D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_PEAK1D, pPeaking_DLTI_Reserve->SharpnessGainHPPeak1D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAK1D, pPeaking_DLTI_Reserve->SharpnessCoringPeak1D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_LOW_PASS_LTI, pPeakingDLTIData->SharpnessLowPassLti[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_BP_SEL_LTI, pPeakingDLTIData->SharpnessDLTIBpTap[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_EP_SEL_LTI, pPeakingDLTIData->SharpnessDLTIEpTap[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HP_SEL_LTI, pPeakingDLTIData->SharpnessDLTIHpTap[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ST_SEL, pPeakingDLTIData->SharpnessStSel[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP_LTI, pPeaking_DLTI_Reserve->SharpnessDLTIBpGain);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_EP_LTI, pPeaking_DLTI_Reserve->SharpnessDLTIEpGain);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_LTI, pPeaking_DLTI_Reserve->SharpnessDLTIHpGain);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP0_PEAK2D, pPeaking_DLTI_Reserve->SharpnessGainBP0Peak2D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP1_PEAK2D, pPeaking_DLTI_Reserve->SharpnessGainBP1Peak2D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP0_PEAK2D, pPeaking_DLTI_Reserve->SharpnessGainHP0Peak2D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP1_PEAK2D, pPeaking_DLTI_Reserve->SharpnessGainHP1Peak2D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_V31, pPeaking_DLTI_Reserve->SharpnessGainHPV31);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_V51, pPeaking_DLTI_Reserve->SharpnessGainHPV51);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAKV, pPeaking_DLTI_Reserve->SharpnessCoringPeakV);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAK2D, pPeaking_DLTI_Reserve->SharpnessCoringPeak2D);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ABS_LP_EN_PEAK, pPeakingDLTIData->SharpnessAbsLpEnPeak[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP0_PEAK, pPeaking_DLTI_Reserve->SharpnessXp0Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP1_PEAK, pPeaking_DLTI_Reserve->SharpnessXp1Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP2_PEAK, pPeaking_DLTI_Reserve->SharpnessXp2Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP3_PEAK, pPeaking_DLTI_Reserve->SharpnessXp3Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP0_PEAK, pPeaking_DLTI_Reserve->SharpnessYp0Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP1_PEAK, pPeaking_DLTI_Reserve->SharpnessYp1Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP2_PEAK, pPeaking_DLTI_Reserve->SharpnessYp2Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP1_PEAK, pPeaking_DLTI_Reserve->SharpnessMp1Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP2_PEAK, pPeaking_DLTI_Reserve->SharpnessMp2Peak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAK, pPeaking_DLTI_Reserve->SharpnessCoringPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_NEG_PEAK, pPeaking_DLTI_Reserve->SharpnessGainNegPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_DEOVST_NEW_METHOD_PEAK, pPeaking_DLTI_Reserve->SharpnessDeOvstNewMethodPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MAX_PEAK, pPeaking_DLTI_Reserve->SharpnessOvstGainMaxPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MIN_PEAK, pPeaking_DLTI_Reserve->SharpnessOvstGainMinPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MAX_PEAK, pPeaking_DLTI_Reserve->SharpnessOverMaxPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MIN_PEAK, pPeaking_DLTI_Reserve->SharpnessOverMinPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HI_CORING_PEAK, pPeaking_DLTI_Reserve->SharpnessHiCoringPeak);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_ABS_LP_EN_LTI, pPeakingDLTIData->SharpnessAbsLpEnLti[PQ_SHARPNESS_0PERCENT]);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP0_LTI, pPeaking_DLTI_Reserve->SharpnessXp0Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP1_LTI, pPeaking_DLTI_Reserve->SharpnessXp1Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP2_LTI, pPeaking_DLTI_Reserve->SharpnessXp2Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_XP3_LTI, pPeaking_DLTI_Reserve->SharpnessXp3Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP0_LTI, pPeaking_DLTI_Reserve->SharpnessYp0Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP1_LTI, pPeaking_DLTI_Reserve->SharpnessYp1Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_YP2_LTI, pPeaking_DLTI_Reserve->SharpnessYp2Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP1_LTI, pPeaking_DLTI_Reserve->SharpnessMp1Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MP2_LTI, pPeaking_DLTI_Reserve->SharpnessMp2Lti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_LTI, pPeaking_DLTI_Reserve->SharpnessCoringLti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_DEOVST_NEW_METHOD_LTI, pPeaking_DLTI_Reserve->SharpnessDeOvseNewMethodLti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MAX_LTI, pPeaking_DLTI_Reserve->SharpnessOvstGainMaxLti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVST_GAIN_MIN_LTI, pPeaking_DLTI_Reserve->SharpnessOvstGainMinLti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MAX_LTI, pPeaking_DLTI_Reserve->SharpnessOverMaxLti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_OVER_MIN_LTI, pPeaking_DLTI_Reserve->SharpnessOverMinLti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_HI_CORING_LTI, pPeaking_DLTI_Reserve->SharpnessHiCoringLti);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_H_LR_TAP_LTI, DLTI_Tap_Num);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_MAX_MIN_HS_LR_TAP_LTI, pPeaking_DLTI_Reserve->SharpnessMaxMinHSLrTapLti);
                break;
        };

        PQ_RegisterWrite(VIP_REG_SHARPNESS_PEAKING_2D_OFF, 0);//tool don't control
        PQ_RegisterWrite(VIP_REG_SLR_SHARPNESS_EN, 1);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_MODE_SHARP_SEL, 0);//tool don't control
        PQ_RegisterWrite(VIP_REG_SLR_SHARPNESS_MAX_MIN_METHOD, 1);//tool don't control
        PQ_RegisterWrite(VIP_REG_SLR_SHARPNESS_MAX_MIN_2D_EN, 1);//tool don't control       
        PQ_RegisterWrite(VIP_REG_SHARPNESS_FLAT_TH, 0x1e);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_C0, 0xff);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_C1, 0xff);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_C2, 0xfe);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_C3, 0xff);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_C4, 0x1);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_C5, 0x2);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_C6, 0x4);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_PROG_FIL_GAIN, 3);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_CORING_PEAKS, 0); //tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_SN31, 0);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_SP31, 0);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_SN51, 0);//tool don't control
        PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_SP51, 0);//tool don't control
        
        if (VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource() && VIP_GetInputVSize() > 700)   //#51277
        {
            PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post, 0x0); 
            PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP_PEAK1D, 0x3);
            PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_PEAK1D, 0x2);
            PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP_LTI, 0x3);
            PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP_LTI, 0x2);
            PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP0_PEAK2D, 0x0);
            PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_HP0_PEAK2D,	0x7);
        }	 

        if(VIP_IsNetworkSource())
        {
            if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
            {
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_NEG_PEAK, 0);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_GAIN_BP_PEAK1D, 5);
                PQ_RegisterWrite(VIP_REG_SHARPNESS_BP_SEL_PEAK1D, 0);
            }
        }
         
    }
    
}


void PQ_HorSharpness(BOOL bReset,UINT8 ucValue)//horizontal sharpness
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	//VTAB_SRC_VALUE_DEFINE* pSrcVtab= pHwContext->pCurVtabSrcValue;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
	INT32 i, Res;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    HOR_SHARPNESS_DATA *pHOR_SHARPNESS_DATA;

	static UINT32 dwHorFacReg[6] = {
		VIP_reg_slr_hor_sharp_fac0,VIP_reg_slr_hor_sharp_fac1,VIP_reg_slr_hor_sharp_fac2,
		VIP_reg_slr_hor_sharp_fac0_c,VIP_reg_slr_hor_sharp_fac1_c,VIP_reg_slr_hor_sharp_fac2_c};
	static UINT32 dwHorTHReg[4] = {
		VIP_reg_slr_hor_sharp_th_0,VIP_reg_slr_hor_sharp_th_1,
		VIP_reg_slr_hor_sharp_th_0_c,VIP_reg_slr_hor_sharp_th_1_c};
	static UINT32 dwHorSlopeReg[4] = {
		VIP_reg_slr_hor_sharp_slope_0,VIP_reg_slr_hor_sharp_slope_1,
		VIP_reg_slr_hor_sharp_slope_0_c,VIP_reg_slr_hor_sharp_slope_1_c};

	static UINT32 dwHorOvershtReg[2] = {
		VIP_reg_slr_hor_sharp_oversht_ylmt,VIP_reg_slr_hor_sharp_oversht_clmt};
	static UINT32 dwHorUndershtReg[2] = {
		VIP_reg_slr_hor_sharp_undersht_ylmt,VIP_reg_slr_hor_sharp_undersht_clmt};
	DS_SHARP_INFO TargetInfo;
    static UINT8 bStart = FALSE;
	memset(&TargetInfo, 0, sizeof(DS_SHARP_INFO));//Ren request 20120724


    if(bReset)
    {
        bStart = TRUE;
        return;
    }

    if(bStart)
    {
        bStart = FALSE;

        if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
        if (pVtab->mHOR_Sharpenss.mGroupedIndex[ucCurrSrcIndex] >= 8) return;

        ucTableIndex = pVtab->mHOR_Sharpenss.mGroupedIndex[ucCurrSrcIndex];
        pHOR_SHARPNESS_DATA = &pVtab->mHOR_Sharpenss.mHOR_Sharpness_Data[ucTableIndex];


    	if( pHwContext->bEnableColorProcess==FALSE )
    	{
    		for(i = 0; i <2; i++)
    		{
    			PQ_RegisterWrite(dwHorFacReg[i*3], TargetInfo.fac0);
    			PQ_RegisterWrite(dwHorFacReg[i*3+1], TargetInfo.fac1);
    			PQ_RegisterWrite(dwHorFacReg[i*3+2], TargetInfo.fac2);
    		}
    		return;

    	}

    	if( ucValue>127 )
    		ucValue= 127;

    	PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);

    	if(900 < VIP_GetInputVSize()) // > (1080+720)/2
    		Res = 2;
    	else if((VIP_GetInputVSize() <= 900 && 648 < VIP_GetInputVSize()))  //  (720+576)/2 < X <= (1080+720)/2
    		Res = 1;
    	else //if((VIP_GetInputVSize() <= ((720+576) /2)))
    		Res = 0;

    	if (1!=pHOR_SHARPNESS_DATA->HorSharpNormal[0].undersht[3]) Res = 0;


    	if( ucValue<64 )
    	{
    		//from weak to normal
    		for(i = 0; i <2; i++)
    		{
    			TargetInfo.fac0 = pHOR_SHARPNESS_DATA->HorSharpWeak[i].fac0+ (pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac0-pHOR_SHARPNESS_DATA->HorSharpWeak[i].fac0) * ucValue / 63;
    			TargetInfo.fac1 = pHOR_SHARPNESS_DATA->HorSharpWeak[i].fac1+ (pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac1-pHOR_SHARPNESS_DATA->HorSharpWeak[i].fac1) * ucValue / 63;
    			TargetInfo.fac2 = pHOR_SHARPNESS_DATA->HorSharpWeak[i].fac2+ (pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac2-pHOR_SHARPNESS_DATA->HorSharpWeak[i].fac2) * ucValue / 63;
    			TargetInfo.th0 = pHOR_SHARPNESS_DATA->HorSharpWeak[i].th0 + (pHOR_SHARPNESS_DATA->HorSharpNormal[i].th0-pHOR_SHARPNESS_DATA->HorSharpWeak[i].th0) * ucValue / 63;
    			TargetInfo.th1 = pHOR_SHARPNESS_DATA->HorSharpWeak[i].th1 + (pHOR_SHARPNESS_DATA->HorSharpNormal[i].th1-pHOR_SHARPNESS_DATA->HorSharpWeak[i].th1) * ucValue / 63;
    			TargetInfo.slope0 = pHOR_SHARPNESS_DATA->HorSharpWeak[i].slope0 + (pHOR_SHARPNESS_DATA->HorSharpNormal[i].slope0-pHOR_SHARPNESS_DATA->HorSharpWeak[i].slope0) * ucValue / 63;
    			TargetInfo.slope1 = pHOR_SHARPNESS_DATA->HorSharpWeak[i].slope1 + (pHOR_SHARPNESS_DATA->HorSharpNormal[i].slope1-pHOR_SHARPNESS_DATA->HorSharpWeak[i].slope1) * ucValue / 63;
    			TargetInfo.oversht[Res]= pHOR_SHARPNESS_DATA->HorSharpWeak[i].oversht[Res] + (pHOR_SHARPNESS_DATA->HorSharpNormal[i].oversht[Res]-pHOR_SHARPNESS_DATA->HorSharpWeak[i].oversht[Res]) * ucValue / 63;
    			TargetInfo.undersht[Res]= pHOR_SHARPNESS_DATA->HorSharpWeak[i].undersht[Res] + (pHOR_SHARPNESS_DATA->HorSharpNormal[i].undersht[Res]-pHOR_SHARPNESS_DATA->HorSharpWeak[i].undersht[Res]) * ucValue / 63;
    			PQ_RegisterWrite(dwHorFacReg[i*3], TargetInfo.fac0);
    			PQ_RegisterWrite(dwHorFacReg[i*3+1], TargetInfo.fac1);
    			PQ_RegisterWrite(dwHorFacReg[i*3+2], TargetInfo.fac2);
    			PQ_RegisterWrite(dwHorTHReg[i*2], TargetInfo.th0);
    			PQ_RegisterWrite(dwHorTHReg[i*2+1], TargetInfo.th1);
    			PQ_RegisterWrite(dwHorSlopeReg[i*2], TargetInfo.slope0);
    			PQ_RegisterWrite(dwHorSlopeReg[i*2+1], TargetInfo.slope1);
    			PQ_RegisterWrite(dwHorOvershtReg[i], TargetInfo.oversht[Res]);
    			PQ_RegisterWrite(dwHorUndershtReg[i], TargetInfo.undersht[Res]);
    		}

    	}
    	else
    	{
    		//from normal to strong
    		ucValue-= 64;
    		for(i = 0; i <2; i++)
    		{
    			TargetInfo.fac0 = pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac0+ (pHOR_SHARPNESS_DATA->HorSharpStrong[i].fac0-pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac0) * ucValue / 63;
    			TargetInfo.fac1 = pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac1+ (pHOR_SHARPNESS_DATA->HorSharpStrong[i].fac1-pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac1) * ucValue / 63;
    			TargetInfo.fac2 = pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac2+ (pHOR_SHARPNESS_DATA->HorSharpStrong[i].fac2-pHOR_SHARPNESS_DATA->HorSharpNormal[i].fac2) * ucValue / 63;
    			TargetInfo.th0 = pHOR_SHARPNESS_DATA->HorSharpNormal[i].th0 + (pHOR_SHARPNESS_DATA->HorSharpStrong[i].th0-pHOR_SHARPNESS_DATA->HorSharpNormal[i].th0) * ucValue / 63;
    			TargetInfo.th1 = pHOR_SHARPNESS_DATA->HorSharpNormal[i].th1 + (pHOR_SHARPNESS_DATA->HorSharpStrong[i].th1-pHOR_SHARPNESS_DATA->HorSharpNormal[i].th1) * ucValue / 63;
    			TargetInfo.slope0 = pHOR_SHARPNESS_DATA->HorSharpNormal[i].slope0 + (pHOR_SHARPNESS_DATA->HorSharpStrong[i].slope0-pHOR_SHARPNESS_DATA->HorSharpNormal[i].slope0) * ucValue / 63;
    			TargetInfo.slope1 = pHOR_SHARPNESS_DATA->HorSharpNormal[i].slope1 + (pHOR_SHARPNESS_DATA->HorSharpStrong[i].slope1-pHOR_SHARPNESS_DATA->HorSharpNormal[i].slope1) * ucValue / 63;
    			TargetInfo.oversht[Res]= pHOR_SHARPNESS_DATA->HorSharpNormal[i].oversht[Res] + (pHOR_SHARPNESS_DATA->HorSharpStrong[i].oversht[Res]-pHOR_SHARPNESS_DATA->HorSharpNormal[i].oversht[Res]) * ucValue / 63;
    			TargetInfo.undersht[Res]= pHOR_SHARPNESS_DATA->HorSharpNormal[i].undersht[Res] + (pHOR_SHARPNESS_DATA->HorSharpStrong[i].undersht[Res]-pHOR_SHARPNESS_DATA->HorSharpNormal[i].undersht[Res]) * ucValue / 63;
    			PQ_RegisterWrite(dwHorFacReg[i*3], TargetInfo.fac0);
    			PQ_RegisterWrite(dwHorFacReg[i*3+1], TargetInfo.fac1);
    			PQ_RegisterWrite(dwHorFacReg[i*3+2], TargetInfo.fac2);
    			PQ_RegisterWrite(dwHorTHReg[i*2], TargetInfo.th0);
    			PQ_RegisterWrite(dwHorTHReg[i*2+1], TargetInfo.th1);
    			PQ_RegisterWrite(dwHorSlopeReg[i*2], TargetInfo.slope0);
    			PQ_RegisterWrite(dwHorSlopeReg[i*2+1], TargetInfo.slope1);
    			PQ_RegisterWrite(dwHorOvershtReg[i], TargetInfo.oversht[Res]);
    			PQ_RegisterWrite(dwHorUndershtReg[i], TargetInfo.undersht[Res]);
    		}


    	}

		#ifdef CONFIG_APPLY_DIFFERENT_SHARPNESS_SETTING_IN_PANEL_INVERT
		if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
		{/* Add sharpness setting in invert panel here */	 }
		else
		{/* Add sharpness setting in regular panel here */}
		#else
			    /* Check different setting status and remove same setting item to here */
		#endif
		
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_en, pHOR_SHARPNESS_DATA->HorSharpDark.enable);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_th0, pHOR_SHARPNESS_DATA->HorSharpDark.th[0]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_th1, pHOR_SHARPNESS_DATA->HorSharpDark.th[1]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_th2, pHOR_SHARPNESS_DATA->HorSharpDark.th[2]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_th3, pHOR_SHARPNESS_DATA->HorSharpDark.th[3]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_fac0, pHOR_SHARPNESS_DATA->HorSharpDark.fac[0]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_fac1, pHOR_SHARPNESS_DATA->HorSharpDark.fac[1]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_fac2, pHOR_SHARPNESS_DATA->HorSharpDark.fac[2]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_fac3, pHOR_SHARPNESS_DATA->HorSharpDark.fac[3]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_slope0, pHOR_SHARPNESS_DATA->HorSharpDark.slope[0]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_slope1, pHOR_SHARPNESS_DATA->HorSharpDark.slope[1]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_slope2, pHOR_SHARPNESS_DATA->HorSharpDark.slope[2]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_slope3, pHOR_SHARPNESS_DATA->HorSharpDark.slope[3]);
    	PQ_RegisterWrite(VIP_reg_slr_hor_dark_sharp_slope4, pHOR_SHARPNESS_DATA->HorSharpDark.slope[4]);

       }
}


void PQ_DSSharpness(BOOL bReset,UINT8 ucValue)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
	INT32 i, j, Res;
    static UINT8 bStart = FALSE;
    UINT32 SharpRatioTemp;

	static UINT32 dwDS_FacReg[6] = {
		VIP_reg_slr_sharp_fac0,VIP_reg_slr_sharp_fac1,VIP_reg_slr_sharp_fac2,
		VIP_reg_slr_sharp_fac0_c,VIP_reg_slr_sharp_fac1_c,VIP_reg_slr_sharp_fac2_c};
	static UINT32 dwDS_THReg[4] = {
		VIP_reg_slr_ds_sharp_th_0,VIP_reg_slr_ds_sharp_th_1,
		VIP_reg_slr_ds_sharp_th_0_c,VIP_reg_slr_ds_sharp_th_1_c};
	static UINT32 dwDS_SlopeReg[4] = {
		VIP_reg_slr_ds_sharp_slope_0,VIP_reg_slr_ds_sharp_slope_1,
		VIP_reg_slr_ds_sharp_slope_0_c,VIP_reg_slr_ds_sharp_slope_1_c};

    static UINT32 dwDS_OvershtReg[2] = {
		VIP_reg_slr_dscale_sharp_oversht_ylmt,VIP_reg_slr_dscale_sharp_oversht_clmt};
    static UINT32 dwDS_UndershtReg[2] = {
		VIP_reg_slr_dscale_sharp_undersht_ylmt,VIP_reg_slr_dscale_sharp_undersht_clmt};
        
    static UINT32 dwDS_Y_RatioReg[7] = 	{
		VIP_reg_slr_ds_sharp_ratio_0,VIP_reg_slr_ds_sharp_ratio_1,VIP_reg_slr_ds_sharp_ratio_2,
		VIP_reg_slr_ds_sharp_ratio_3,VIP_reg_slr_ds_sharp_ratio_4,VIP_reg_slr_ds_sharp_ratio_5,
		VIP_reg_slr_ds_sharp_ratio_6};

	static UINT32 dwDS_C_RatioReg[6] = 	{
		VIP_reg_slr_ds_sharp_ratio_0_c,VIP_reg_slr_ds_sharp_ratio_1_c,VIP_reg_slr_ds_sharp_ratio_2_c,
		VIP_reg_slr_ds_sharp_ratio_3_c,VIP_reg_slr_ds_sharp_ratio_4_c,VIP_reg_slr_ds_sharp_ratio_5_c};
        
	DS_SHARP_INFO TargetInfo;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    DS_SHARPNESS_DATA *pDS_SHARPNESS_DATA;


    if(bReset)
	{
		bStart = TRUE;
        PQ_HorSharpness(TRUE, ucValue);
		return;
	}

	if(bStart)
	{
		bStart = FALSE;
        if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
        if (pVtab->mDS_Sharpenss.mGroupedIndex[ucCurrSrcIndex] >= 8) return;

        ucTableIndex = pVtab->mDS_Sharpenss.mGroupedIndex[ucCurrSrcIndex];
        pDS_SHARPNESS_DATA = &pVtab->mDS_Sharpenss.mDS_Sharpness_Data[ucTableIndex];
        
    	memset(&TargetInfo, 0, sizeof(DS_SHARP_INFO));//Ren request 20120724


    	//===================start ds sharpness==========================================
    	if( pHwContext->bEnableColorProcess==FALSE )
    	{
    		for(j = 0; j <2; j++)
    		{
    			PQ_RegisterWrite(dwDS_FacReg[j*3], TargetInfo.fac0);
    			PQ_RegisterWrite(dwDS_FacReg[j*3+1], TargetInfo.fac1);
    			PQ_RegisterWrite(dwDS_FacReg[j*3+2], TargetInfo.fac2);
    		}
    		return;
    	}

    	if( ucValue>127 )
    		ucValue= 127;

    	PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);
    	    	
    	if(900 < VIP_GetInputVSize()) // > (1080+720)/2
    		Res = 2;
    	else if((VIP_GetInputVSize() <= 900 && 648 < VIP_GetInputVSize()))  //  (720+576)/2 < X <= (1080+720)/2
    		Res = 1;
    	else //if((VIP_GetInputVSize() <= ((720+576) /2)))
    		Res = 0;

    	if (1!=pDS_SHARPNESS_DATA->DSSharpNormal[0].undersht[3]) Res = 0;


    	if( ucValue<64 )
    	{
    		//from weak to normal
    		for(j = 0; j <2; j++)
    		{
    			TargetInfo.fac0 = pDS_SHARPNESS_DATA->DSSharpWeak[j].fac0+ (pDS_SHARPNESS_DATA->DSSharpNormal[j].fac0-pDS_SHARPNESS_DATA->DSSharpWeak[j].fac0) * ucValue / 63;
    			TargetInfo.fac1 = pDS_SHARPNESS_DATA->DSSharpWeak[j].fac1+ (pDS_SHARPNESS_DATA->DSSharpNormal[j].fac1-pDS_SHARPNESS_DATA->DSSharpWeak[j].fac1) * ucValue / 63;
    			TargetInfo.fac2 = pDS_SHARPNESS_DATA->DSSharpWeak[j].fac2+ (pDS_SHARPNESS_DATA->DSSharpNormal[j].fac2-pDS_SHARPNESS_DATA->DSSharpWeak[j].fac2) * ucValue / 63;
    			TargetInfo.th0 = pDS_SHARPNESS_DATA->DSSharpWeak[j].th0 + (pDS_SHARPNESS_DATA->DSSharpNormal[j].th0-pDS_SHARPNESS_DATA->DSSharpWeak[j].th0) * ucValue / 63;
    			TargetInfo.th1 = pDS_SHARPNESS_DATA->DSSharpWeak[j].th1 + (pDS_SHARPNESS_DATA->DSSharpNormal[j].th1-pDS_SHARPNESS_DATA->DSSharpWeak[j].th1) * ucValue / 63;
    			TargetInfo.slope0 = pDS_SHARPNESS_DATA->DSSharpWeak[j].slope0 + (pDS_SHARPNESS_DATA->DSSharpNormal[j].slope0-pDS_SHARPNESS_DATA->DSSharpWeak[j].slope0) * ucValue / 63;
    			TargetInfo.slope1 = pDS_SHARPNESS_DATA->DSSharpWeak[j].slope1 + (pDS_SHARPNESS_DATA->DSSharpNormal[j].slope1-pDS_SHARPNESS_DATA->DSSharpWeak[j].slope1) * ucValue / 63;
    			TargetInfo.oversht[Res]= pDS_SHARPNESS_DATA->DSSharpWeak[j].oversht[Res] + (pDS_SHARPNESS_DATA->DSSharpNormal[j].oversht[Res]-pDS_SHARPNESS_DATA->DSSharpWeak[j].oversht[Res]) * ucValue / 63;
    			TargetInfo.undersht[Res]= pDS_SHARPNESS_DATA->DSSharpWeak[j].undersht[Res] + (pDS_SHARPNESS_DATA->DSSharpNormal[j].undersht[Res]-pDS_SHARPNESS_DATA->DSSharpWeak[j].undersht[Res]) * ucValue / 63;
    			PQ_RegisterWrite(dwDS_FacReg[j*3], TargetInfo.fac0);
    			PQ_RegisterWrite(dwDS_FacReg[j*3+1], TargetInfo.fac1);
    			PQ_RegisterWrite(dwDS_FacReg[j*3+2], TargetInfo.fac2);
    			PQ_RegisterWrite(dwDS_THReg[j*2], TargetInfo.th0);
    			PQ_RegisterWrite(dwDS_THReg[j*2+1], TargetInfo.th1);
    			PQ_RegisterWrite(dwDS_SlopeReg[j*2], TargetInfo.slope0);
    			PQ_RegisterWrite(dwDS_SlopeReg[j*2+1], TargetInfo.slope1);
                   PQ_RegisterWrite(dwDS_OvershtReg[j], TargetInfo.oversht[Res]);
    			PQ_RegisterWrite(dwDS_UndershtReg[j], TargetInfo.undersht[Res]);
    		}
    	}
    	else
    	{
    		//from normal to strong
    		ucValue-= 64;
    		for(j = 0; j <2; j++)
    		{
    			TargetInfo.fac0 = pDS_SHARPNESS_DATA->DSSharpNormal[j].fac0+ (pDS_SHARPNESS_DATA->DSSharpStrong[j].fac0-pDS_SHARPNESS_DATA->DSSharpNormal[j].fac0) * ucValue / 63;
    			TargetInfo.fac1 = pDS_SHARPNESS_DATA->DSSharpNormal[j].fac1+ (pDS_SHARPNESS_DATA->DSSharpStrong[j].fac1-pDS_SHARPNESS_DATA->DSSharpNormal[j].fac1) * ucValue / 63;
    			TargetInfo.fac2 = pDS_SHARPNESS_DATA->DSSharpNormal[j].fac2+ (pDS_SHARPNESS_DATA->DSSharpStrong[j].fac2-pDS_SHARPNESS_DATA->DSSharpNormal[j].fac2) * ucValue / 63;
    			TargetInfo.th0 = pDS_SHARPNESS_DATA->DSSharpNormal[j].th0 + (pDS_SHARPNESS_DATA->DSSharpStrong[j].th0-pDS_SHARPNESS_DATA->DSSharpNormal[j].th0) * ucValue / 63;
    			TargetInfo.th1 = pDS_SHARPNESS_DATA->DSSharpNormal[j].th1 + (pDS_SHARPNESS_DATA->DSSharpStrong[j].th1-pDS_SHARPNESS_DATA->DSSharpNormal[j].th1) * ucValue / 63;
    			TargetInfo.slope0 = pDS_SHARPNESS_DATA->DSSharpNormal[j].slope0 + (pDS_SHARPNESS_DATA->DSSharpStrong[j].slope0-pDS_SHARPNESS_DATA->DSSharpNormal[j].slope0) * ucValue / 63;
    			TargetInfo.slope1 = pDS_SHARPNESS_DATA->DSSharpNormal[j].slope1 + (pDS_SHARPNESS_DATA->DSSharpStrong[j].slope1-pDS_SHARPNESS_DATA->DSSharpNormal[j].slope1) * ucValue / 63;
    			TargetInfo.oversht[Res]= pDS_SHARPNESS_DATA->DSSharpNormal[j].oversht[Res] + (pDS_SHARPNESS_DATA->DSSharpStrong[j].oversht[Res]-pDS_SHARPNESS_DATA->DSSharpNormal[j].oversht[Res]) * ucValue / 63;
    			TargetInfo.undersht[Res]= pDS_SHARPNESS_DATA->DSSharpNormal[j].undersht[Res] + (pDS_SHARPNESS_DATA->DSSharpStrong[j].undersht[Res]-pDS_SHARPNESS_DATA->DSSharpNormal[j].undersht[Res]) * ucValue / 63;
    			PQ_RegisterWrite(dwDS_FacReg[j*3], TargetInfo.fac0);
    			PQ_RegisterWrite(dwDS_FacReg[j*3+1], TargetInfo.fac1);
    			PQ_RegisterWrite(dwDS_FacReg[j*3+2], TargetInfo.fac2);
    			PQ_RegisterWrite(dwDS_THReg[j*2], TargetInfo.th0);
    			PQ_RegisterWrite(dwDS_THReg[j*2+1], TargetInfo.th1);
    			PQ_RegisterWrite(dwDS_SlopeReg[j*2], TargetInfo.slope0);
    			PQ_RegisterWrite(dwDS_SlopeReg[j*2+1], TargetInfo.slope1);
                   PQ_RegisterWrite(dwDS_OvershtReg[j], TargetInfo.oversht[Res]);
    			PQ_RegisterWrite(dwDS_UndershtReg[j], TargetInfo.undersht[Res]);
    		}
    	}

        //ratio
        SharpRatioTemp = pDS_SHARPNESS_DATA->SlrSharpRatio.Degree[Res];
		
      	#ifdef CONFIG_APPLY_DIFFERENT_SHARPNESS_SETTING_IN_PANEL_INVERT
		if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
			{/* Add sharpness setting in invert panel here */	 }
		else
			{/* Add sharpness setting in regular panel here */}
		#else
 		    /* Check different setting status and remove same setting item to here */
		#endif
		
    	for(i=0; i<7; i++)
    	{
    		PQ_RegisterWrite(dwDS_Y_RatioReg[i], SharpRatioTemp & 0xf);
    		SharpRatioTemp = SharpRatioTemp >> 4;
    	}

    	for(i = 0; i <6; i++)
    	{
    		PQ_RegisterWrite(dwDS_C_RatioReg[i], pVtab->mSharpRatio[1].ratio[i]);
    	}
		
        PQ_RegisterWrite(VIP_reg_slr_ds_sharp_ratio_6_c, pVtab->iSharpRatio6_c);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_en, pDS_SHARPNESS_DATA->DSSharpDark.enable);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_th0, pDS_SHARPNESS_DATA->DSSharpDark.th[0]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_th1, pDS_SHARPNESS_DATA->DSSharpDark.th[1]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_th2, pDS_SHARPNESS_DATA->DSSharpDark.th[2]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_th3, pDS_SHARPNESS_DATA->DSSharpDark.th[3]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_fac0, pDS_SHARPNESS_DATA->DSSharpDark.fac[0]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_fac1, pDS_SHARPNESS_DATA->DSSharpDark.fac[1]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_fac2, pDS_SHARPNESS_DATA->DSSharpDark.fac[2]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_fac3, pDS_SHARPNESS_DATA->DSSharpDark.fac[3]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_slope0, pDS_SHARPNESS_DATA->DSSharpDark.slope[0]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_slope1, pDS_SHARPNESS_DATA->DSSharpDark.slope[1]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_slope2, pDS_SHARPNESS_DATA->DSSharpDark.slope[2]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_slope3, pDS_SHARPNESS_DATA->DSSharpDark.slope[3]);
        PQ_RegisterWrite(VIP_reg_slr_ds_dark_sharp_slope4, pDS_SHARPNESS_DATA->DSSharpDark.slope[4]);

        if((pHwContext->PqPatch.DsSharpnessPatch == DS_SHARPNESS_AV_IRE_PATCH) || (pHwContext->PqPatch.DsSharpnessPatch == DS_SHARPNESS_AV_GRAYSCALE_PATCH))
        {
            PQ_RegisterWrite(VIP_reg_slr_dscale_sharp_oversht_ylmt, 0);
            PQ_RegisterWrite(VIP_reg_slr_dscale_sharp_undersht_ylmt, 0);        
        }      

    }
}



void PQ_DPYSharpness(BOOL bReset,UINT8 ucValue)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
	SHARP_INFO target,*strong,*normal,*weak;
	INT32 i, Res;

    UINT8 ucTableIndex;

    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

	static UINT32 dwTransReg[8]= {
		VIP_reg_dpy_filter_hl_trans1, VIP_reg_dpy_filter_hl_trans2, VIP_reg_dpy_filter_hc_trans1, VIP_reg_dpy_filter_hc_trans2,
		VIP_reg_dpy_filter_vl_trans1, VIP_reg_dpy_filter_vl_trans2, VIP_reg_dpy_filter_vc_trans1, VIP_reg_dpy_filter_vc_trans2};
	static UINT32 dwSmoothReg[4]= {
		VIP_reg_dpy_filter_hl_smooth1, VIP_reg_dpy_filter_hc_smooth1, VIP_reg_dpy_filter_vl_smooth, VIP_reg_dpy_filter_vc_smooth};
	static UINT32 dwSharpReg[4]= {
		VIP_reg_dpy_filter_hl_sharp, VIP_reg_dpy_filter_hc_sharp, VIP_reg_dpy_filter_vl_sharp, VIP_reg_dpy_filter_vc_sharp};
	static UINT32 dwLimitLReg[4]= {
		VIP_reg_dpy_filter_hl_limit_undershoot, VIP_reg_dpy_filter_hc_limit_undershoot, VIP_reg_dpy_filter_vl_limit, VIP_reg_dpy_filter_vc_limit};
	static UINT32 dwLimitHReg[4]= {
		VIP_reg_dpy_filter_hl_limit_overshoot, VIP_reg_dpy_filter_hc_limit_overshoot, VIP_reg_dpy_filter_vl_limit, VIP_reg_dpy_filter_vc_limit};
	static UINT32 dwPivotReg[8]= {
		VIP_reg_dpy_filter_hl_pivotx, VIP_reg_dpy_filter_hl_pivoty, VIP_reg_dpy_filter_hc_pivotx, VIP_reg_dpy_filter_hc_pivoty,
		VIP_reg_dpy_filter_vl_pivotx, VIP_reg_dpy_filter_vl_pivoty, VIP_reg_dpy_filter_vc_pivotx, VIP_reg_dpy_filter_vc_pivoty};

    SHARPNESS_DATA *pSharpness_setting;

    static UINT8 bStart = FALSE;
    static UINT8 bFisrtBoot = TRUE;	

	if(bReset)
	{
		bStart = TRUE;
		return;
	}

	if(bStart)
	{
		bStart = FALSE;

        if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
        if (pVtab->mSharpenss.mGroupedIndex[ucCurrSrcIndex] >= 8) return;

        ucTableIndex = pVtab->mSharpenss.mGroupedIndex[ucCurrSrcIndex];
        pSharpness_setting = &pVtab->mSharpenss.mSharpness_Data[ucTableIndex];

	  if(bFisrtBoot) //init for the alternative overshoot and undershoot setting
	  {
	  	PQ_RegisterWrite(VIP_reg_dpy_filter_hl_limit_undershoot, 0x0);
		PQ_RegisterWrite(VIP_reg_dpy_filter_hc_limit_undershoot, 0x0);

		PQ_RegisterWrite(VIP_reg_dpy_filter_hl_limit_overshoot, 0x0);
		PQ_RegisterWrite(VIP_reg_dpy_filter_hc_limit_overshoot, 0x0);

		bFisrtBoot = FALSE;
	  }

    	if( pHwContext->bEnableColorProcess==FALSE )
    	{
    		for(i=0; i<4; i++)
    		{
    			PQ_RegisterWrite(dwSmoothReg[i], 0);
    			PQ_RegisterWrite(dwSharpReg[i], 0);
    		}
    		return;

    	}

    	pHwContext->menu_sharpness=1;

    	if( ucValue>127 )
    		ucValue= 127;

    	PQDebugPrint("%s:ucValue=%d", __FUNCTION__, ucValue);

    	if((((DRV_SLR_GetFactor_HFactor())*(DRV_SLR_GetFactor_HFactor_6HV())*100)/(2048*2048))>90)
    		Res = 2;
    	else if(VIP_GetInputVSize() >= 1000)	//1080
    		Res = 2;
    	else if(VIP_GetInputVSize() >= 700) 	//720
    		Res = 1;
    	else
    		Res = 0;

    	if (1!=pSharpness_setting->sharp_normal[0].limit[3]) Res = 0;

    	if( ucValue<64 )
    	{
    		//from weak to normal
    		for(i=0; i<4; i++)
    		{
                weak = &pSharpness_setting->sharp_weak[i];
                normal = &pSharpness_setting->sharp_normal[i];
    			//target.x1= weak->x1 + (normal->x1-weak->x1) * ucValue / 63;
    			target.m1= weak->m1 + (normal->m1-weak->m1) * ucValue / 63;
    			//target.x2= weak->x2 + (normal->x2-weak->x2) * ucValue / 63;
    			target.m2= weak->m2 + (normal->m2-weak->m2) * ucValue / 63;
    			target.smooth= weak->smooth + (normal->smooth-weak->smooth) * ucValue / 63;
    			target.sharp= weak->sharp + (normal->sharp-weak->sharp) * ucValue / 63;
    			target.limit[Res]= weak->limit[Res] + (normal->limit[Res]-weak->limit[Res]) * ucValue / 63;
    			target.pivotx= weak->pivotx + (normal->pivotx-weak->pivotx) * ucValue / 63;
    			target.pivoty= weak->pivoty + (normal->pivoty-weak->pivoty) * ucValue / 63;
    			PQ_RegisterWrite(dwTransReg[i*2], target.m1);
    			PQ_RegisterWrite(dwTransReg[i*2+1], target.m2);
    			PQ_RegisterWrite(dwSmoothReg[i], target.smooth);
    			PQ_RegisterWrite(dwSharpReg[i], target.sharp);
    			PQ_RegisterWrite(dwLimitLReg[i], target.limit[Res]);
    			PQ_RegisterWrite(dwLimitHReg[i], target.limit[Res]);
    			PQ_RegisterWrite(dwPivotReg[i*2], target.pivotx);
    			PQ_RegisterWrite(dwPivotReg[i*2+1], target.pivoty);
    		}
    	}
    	else
    	{
    		//from normal to strong
    		ucValue-= 64;
    		for(i=0; i<4; i++)
    		{
                strong = &pSharpness_setting->sharp_strong[i];
    			normal = &pSharpness_setting->sharp_normal[i];
    			//target.x1= normal->x1 + ( strong->x1-normal->x1) * ucValue / 63;
    			target.m1= normal->m1 + ( strong->m1-normal->m1) * ucValue / 63;
    			//target.x2= normal->x2 + ( strong->x2-normal->x2) * ucValue / 63;
    			target.m2= normal->m2 + ( strong->m2-normal->m2) * ucValue / 63;
    			target.smooth= normal->smooth + ( strong->smooth-normal->smooth) * ucValue / 63;
    			target.sharp= normal->sharp + ( strong->sharp-normal->sharp) * ucValue / 63;
    			target.limit[Res]= normal->limit[Res] + ( strong->limit[Res]-normal->limit[Res]) * ucValue / 63;
    			target.pivotx= normal->pivotx + ( strong->pivotx-normal->pivotx) * ucValue / 63;
    			target.pivoty= normal->pivoty + ( strong->pivoty-normal->pivoty) * ucValue / 63;
    			PQ_RegisterWrite(dwTransReg[i*2], target.m1);
    			PQ_RegisterWrite(dwTransReg[i*2+1], target.m2);
    			PQ_RegisterWrite(dwSmoothReg[i], target.smooth);
    			PQ_RegisterWrite(dwSharpReg[i], target.sharp);
				PQ_RegisterWrite(dwLimitLReg[i], target.limit[Res]);
    			PQ_RegisterWrite(dwLimitHReg[i], target.limit[Res]);
    			PQ_RegisterWrite(dwPivotReg[i*2], target.pivotx);
    			PQ_RegisterWrite(dwPivotReg[i*2+1], target.pivoty);
    		}
    	}

	#ifdef CONFIG_APPLY_DIFFERENT_SHARPNESS_SETTING_IN_PANEL_INVERT
	if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
		{/* Add sharpness setting in invert panel here */	 }
	else
		{/* Add sharpness setting in regular panel here */}
	#else
    	PQ_RegisterWrite(VIP_reg_dpy_filter_y_v1, 16);
    	PQ_RegisterWrite(VIP_reg_dpy_filter_cb_v1, 16);
    	PQ_RegisterWrite(VIP_reg_dpy_filter_cr_v1, 16);
    	PQ_RegisterWrite(VIP_reg_dpy_filter_vl_hp_limit, 0xff);
	#endif
    
    if(pHwContext->PqPatch.DPYSharpnessPatch == DPY_SHARPNESS_JPEG_THUMBNAIL_PATCH)
    {
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_trans1, 5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_trans2, 0x3ffc);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hc_trans1, 0x3);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hc_trans2, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_smooth1, 0x14);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_sharp, 0x14);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_pivotx, 0xa7);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_pivoty, 0xcc);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hc_pivotx, 0x58);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hc_pivoty, 0x3f);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_limit_overshoot, 0x3e);
    }

    	pHwContext->menu_sharpness=0;
    	pHwContext->hc_sharp=(INT8)PQ_RegisterRead(VIP_reg_dpy_filter_hc_sharp);
    	pHwContext->hl_sharp=(INT8)PQ_RegisterRead(VIP_reg_dpy_filter_hl_sharp);
    	pHwContext->hc_menu_sharp=PQ_RegisterRead(VIP_reg_dpy_filter_hc_sharp);
    	pHwContext->hl_menu_sharp=PQ_RegisterRead(VIP_reg_dpy_filter_hl_sharp);
    	pHwContext->hc_smooth=(INT8)PQ_RegisterRead(VIP_reg_dpy_filter_hc_smooth1);
    	pHwContext->hl_smooth=(INT8)PQ_RegisterRead(VIP_reg_dpy_filter_hl_smooth1);

    }
}



void PQ_CalcPivotxy(SHARP_INFO* sharp_info)
{
#if 0
	INT32 x1,m1,x2,m2,sharp;
	INT32* pivotx= &sharp_info->pivotx;
	INT32* pivoty= &sharp_info->pivoty;
	x1= sharp_info->x1;
	m1= sharp_info->m1;
	x2= sharp_info->x2;
	m2= sharp_info->m2;
	sharp= sharp_info->sharp;
	if(m1==m2) {printk(KERN_EMERG"ERROR!! /0\n");m1=m2+1;}

	*pivotx= (m1*x1 - m2*x2) / (m1-m2);
	*pivoty= ((*pivotx- x1)*m1 + sharp * 8) / 8;
	*pivotx= *pivotx/2;
#endif
}

//****************************************************************************
//
//   Function   : PQ_Sharpness
//   Params    :
//   Description:
//   Returns    : void
//	P.S only for YUV in no effect in RGB
//****************************************************************************
void PQ_Sharpness(BOOL bReset,UINT8 ucValue)//-128~+127 =>0~127
{
	//ds sharpness(365 new function)
	PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
	UINT32 DS_Sharp_Control;
	INT32 HD_Ds, HD_Angle, MD_Ds, MD_Angle, SD_Ds, SD_Angle;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    DS_SHARPNESS_DATA *pDS_SHARPNESS_DATA;

    static UINT8 bStart = FALSE;

	if(bReset)
	{
		bStart = TRUE;
        PQ_DSSharpness(TRUE, ucValue);
        PQ_DPYSharpness(TRUE, ucValue);
        PQ_Sharpness_POSTDLTI(TRUE, ucValue);
	 PQ_Sharpness_PREDLTI(TRUE, ucValue);	
		if(!utempCheckColorbarDTFunctionEN || VIP_IsSourceDTV())
		 	{
				PQ_Sharpness_PREDCTI(TRUE, ucValue);
       	 		PQ_Sharpness_POSTDCTI(TRUE,ucValue);
				PQ_Sharpness_POST_2D(TRUE, ucValue);
                         PQ_Sharpness_Peaking_DLTI(TRUE, ucValue);
		 	}
		return;
	}

    if(bStart)
	{
		bStart = FALSE;

        if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
        if (pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex] >= 8) return;

        ucTableIndex = pVtab->mDS_Sharpenss.mGroupedIndex[ucCurrSrcIndex];
        pDS_SHARPNESS_DATA = &pVtab->mDS_Sharpenss.mDS_Sharpness_Data[ucTableIndex];

    	DS_Sharp_Control = pDS_SHARPNESS_DATA->DS_Sharp_Angle;
    	//PQDebugPrint("%s: DS_Sharp_Control=%d", __FUNCTION__, (INT32)DS_Sharp_Control);

    	SD_Ds = (DS_Sharp_Control & 0x3);
    	SD_Angle = ((DS_Sharp_Control >> 2) & 0x3);
    	MD_Ds = ((DS_Sharp_Control >> 8) & 0x3);
    	MD_Angle = ((DS_Sharp_Control >> 10) & 0x3);
    	HD_Ds = ((DS_Sharp_Control >> 16) & 0x3);
    	HD_Angle = ((DS_Sharp_Control >> 18) & 0x3);

    	//PQDebugPrint("%s: SD_Ds=%d SD_Angle=%d MD_Ds=%d MD_Angle=%d HD_Ds=%d HD_Angle=%d ", __FUNCTION__, SD_Ds ,SD_Angle ,MD_Ds ,MD_Angle ,HD_Ds ,HD_Angle);
	#ifdef CONFIG_APPLY_DIFFERENT_SHARPNESS_SETTING_IN_PANEL_INVERT
	if(VIP_GetFlipMode()==HV_FLIP || VIP_GetFlipMode() == H_FLIP || VIP_GetFlipMode() == V_FLIP || VIP_GetPanelInvert())
	{/* Add another sharpness setting in invert panel here */	 }
	else
	{
		/* Add sharpness setting in regular panel here */
	}
	#else
		    /* Check different setting status and remove same setting item to here */
	#endif
	
    	if(900 < VIP_GetInputVSize()) // > (1080+720)/2
    	{
    		PQ_RegisterWrite(VIP_reg_ds_disable_func_en, HD_Ds);
    		PQ_RegisterWrite(VIP_reg_ds_disable_angle_sel, HD_Angle);
    	}
    	else if((VIP_GetInputVSize() <= 900 && 648 < VIP_GetInputVSize()))  //  (720+576)/2 < X <= (1080+720)/2
    	{
    		PQ_RegisterWrite(VIP_reg_ds_disable_func_en, MD_Ds);
    		PQ_RegisterWrite(VIP_reg_ds_disable_angle_sel, MD_Angle);
    	}
        else //if((VIP_GetInputVSize() <= ((720+576) /2)))
    	{
    		PQ_RegisterWrite(VIP_reg_ds_disable_func_en, SD_Ds);
    		PQ_RegisterWrite(VIP_reg_ds_disable_angle_sel, SD_Angle);
    	}

    	//lower ds sharpness to avoid detail lose in high frequency (chroma pattern 1)

    	//weifeng, modify by sharlen request, for DTV image interlace
    	//Mantis 25083,25909 Lack of sharpness
        if(VIP_GetUserSource()== SOURCE_MPEG && VIP_GetInputVSize() > 600)
        {
            PQ_RegisterWrite(VIP_reg_slr_comb_slope_2_nom	,0x3);//0x0 Jagged edge
            PQ_RegisterWrite(VIP_reg_slr_comb_th_nom		,0x8);
    //      PQ_RegisterWrite(VIP_reg_slr_mesh_filter_en		,1);
        }

    	if(VIP_GetInputHSize()<=400)
    	{
    		PQ_RegisterWrite(VIP_reg_ds_disable_func_en		,0x1);
    		PQ_RegisterWrite(VIP_reg_ds_disable_angle_sel	,0x1);
    	}

    }
	ucTempds_disable_func_en = PQ_RegisterRead(VIP_reg_ds_disable_func_en);
}

//****************************************************************************
//
//   Function   : PQ_Saturation
//   Params    :
//   Description:
//   Returns    : void
//****************************************************************************
void PQ_Saturation(INT32 iValue) // 0 ~ 127
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

    pHwContext->iSaturation = iValue<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
    PQ_ColorMatrixSetup(TRUE, 1);
    PQ_ColorMatrixSetup(TRUE, 2);
    PQ_ColorMatrixSetup(TRUE, 4);
    PQ_ColorMatrixSetup(TRUE, 5);
    PQ_ColorMatrixSetup(TRUE, 7);
    PQ_ColorMatrixSetup(TRUE, 8);

    if (VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource() && VIP_GetInputVSize() > 700) //#51277
    {
        PQ_RegisterWrite(VIP_reg_dpy_mtx_sat_limit_fac0,(((PQ_RegisterRead(VIP_reg_dpy_mtx_sat_limit_fac0))&0xffffff00)|(0xd6<<0)));
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_dpy_mtx_sat_limit_fac0,(((PQ_RegisterRead(VIP_reg_dpy_mtx_sat_limit_fac0))&0xffffff00)|(0x0d<<0)));
    }
}

void PQ_ColorStyleSaturation(UINT8 ucType)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
	pMenuValue->ucColorStyle = ucType;
	PQ_Saturation(pMenuValue->iSaturation);
}

//****************************************************************************
//
//   Function   : PQ_Hue
//   Params    :
//   Description: Powers up/down  the panel as per the given power sequence timings
//   Returns    : void
//****************************************************************************
void PQ_Hue(UINT8 ucIndex) // 0 ~ 31 ->0 ~ 100
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;

	if( pHwContext->bEnableColorProcess==FALSE )
		ucIndex= 50;//16;

	PQDebugPrint("%s: ucIndex=%d", __FUNCTION__, ucIndex);

	if( ucIndex<101 ) //sizeof(HueSetting)/sizeof(HUE)=33
	{
		pHwContext->iHue = ucIndex;
		PQ_ColorMatrixSetup(TRUE, 1);
		PQ_ColorMatrixSetup(TRUE, 2);
		PQ_ColorMatrixSetup(TRUE, 4);
		PQ_ColorMatrixSetup(TRUE, 5);
		PQ_ColorMatrixSetup(TRUE, 7);
		PQ_ColorMatrixSetup(TRUE, 8);
		PQ_PureColorControl(ucIndex-100, 3);		
	}

}

int ValueChange=FALSE;

void PQ_ColorTempGainALL(INT16 bRgain, INT16 bGgain,INT16 bBgain,UINT8 bGammaSwitch,UINT8 bGammaIndex)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	//int ValueChange=FALSE;
	int RGBValueChange=FALSE;

	if( pHwContext->bEnableColorProcess==FALSE )
	{
		bRgain= 1<<COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM;
		bGgain= 1<<COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM;
		bBgain= 1<<COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM;
	}
		if(pHwContext->iRGain!=bRgain)
		{
	    	pHwContext->iRGain=bRgain<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
			RGBValueChange=TRUE;
		}
		
		if(pHwContext->iGGain!=bGgain)
		{
			pHwContext->iGGain=bGgain<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
			RGBValueChange=TRUE;
		}

		if(pHwContext->iBGain!=bBgain)
		{
			pHwContext->iBGain=bBgain<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
			RGBValueChange=TRUE;
		}
        #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX
			PQ_ColorMatrixSetup(TRUE, 0);
			PQ_ColorMatrixSetup(TRUE, 1);
			PQ_ColorMatrixSetup(TRUE, 2);
			
			PQ_ColorMatrixSetup(TRUE, 3);
			PQ_ColorMatrixSetup(TRUE, 4);
			PQ_ColorMatrixSetup(TRUE, 5);
			
			PQ_ColorMatrixSetup(TRUE, 6);
			PQ_ColorMatrixSetup(TRUE, 7);
			PQ_ColorMatrixSetup(TRUE, 8);
		#endif	

		if(pHwContext->GammaIndex != bGammaIndex)
			ValueChange=TRUE;

		//printk("\n\n\n  bRgain = 0x%0x  g = = 0x%0x  b = = 0x%0x   \n\n\n",bRgain,bGgain,bBgain);
		
		//printk("\n\n\n  HW CONTEXT bRgain = 0x%0x  g = = 0x%0x  b = = 0x%0x   \n\n\n",pHwContext->iRGain,pHwContext->iGGain,pHwContext->iBGain);
		//printk("\n\n\n   ValueChange = %d   bGammaSwitch = %d    bGammaIndex= %d    \n\n",ValueChange,bGammaSwitch,bGammaIndex);

	if(ValueChange==TRUE || RGBValueChange == TRUE)
	{
		if(ValueChange)
		{
		#ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
			PQ_ColorMatrixComp(TRUE);
		#else
			PQ_SetupGammaTable(bGammaSwitch, bGammaIndex, FALSE);
		#endif
		}
		else
		{
			PQ_SetupGammaTable(bGammaSwitch, bGammaIndex, TRUE);
		}
	}
}

//****************************************************************************
//
//   Function   : PQ_ColorTempGain
//   Params    :
//   Description: Powers up/down  the panel as per the given power sequence timings
//   Returns    : void
//****************************************************************************
void PQ_ColorTempGain(PQ_COLOR_TEMP_GAIN ucType, INT32 iValue)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;


	if( pHwContext->bEnableColorProcess==FALSE )
		iValue= 1<<COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM;
	switch(ucType){
		case PQ_CT_GAIN_R:
		    pHwContext->iRGain=iValue<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
            #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX
			PQ_ColorMatrixSetup(TRUE, 0);
			PQ_ColorMatrixSetup(TRUE, 1);
			PQ_ColorMatrixSetup(TRUE, 2);
		#endif	
			break;
		case PQ_CT_GAIN_G:
			pHwContext->iGGain=iValue<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
            #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX
			PQ_ColorMatrixSetup(TRUE, 3);
			PQ_ColorMatrixSetup(TRUE, 4);
			PQ_ColorMatrixSetup(TRUE, 5);
            #endif
			break;
		case PQ_CT_GAIN_B:
			pHwContext->iBGain=iValue<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
            #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX
			PQ_ColorMatrixSetup(TRUE, 6);
			PQ_ColorMatrixSetup(TRUE, 7);
			PQ_ColorMatrixSetup(TRUE, 8);
            #endif
			break;
	}
       #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
	PQ_ColorMatrixComp(TRUE);
	#else

	PQ_SetupGammaTable(ENABLE, 0xff, TRUE);
      #endif
}

static UINT8 bShift = 0;
static UINT16 bHsize,bVsize;
UINT16 bHStart_t = 0,bVStart_t = 0;
void PQ_regionLumaAverage(UINT8 bRegionIndex,UINT8 bTotalHnum,UINT8 bTotalVnum)
{
	UINT16 bOUTH = 0, bOUTV = 0;
	UINT16 bHStart,bVStart;
	UINT16 bHStartTemp = 0;
	UINT8 bnumber = 0;
	if((bRegionIndex + 1) > (bTotalHnum * bTotalVnum))
	{
		return;
	}
	
	bOUTH = VIP_GetOutputHSize();
	bOUTV = VIP_GetOutputVSize();
	
	if((bOUTH== 0) || (bOUTV == 0))
	{
		return;
	}

	if(bTotalHnum > 0)
	{
		bnumber = bRegionIndex / bTotalHnum;
		bHsize = bOUTH / bTotalHnum;
		bVsize = bOUTV / bTotalVnum;
	}
	
	bHStart = bHsize * (bRegionIndex - bnumber * bTotalHnum);
	bVStart = bVsize * bnumber;
	
	if(bHStart > 1)
		bHStart = bHStart - 1;
	if (bVStart > 1)
		bVStart = bVStart - 1;	
	

	if(PQ_RegisterRead( VIP_reg_dpy_rgbstat_en) == 0)
	{
		PQ_RegisterWrite( VIP_reg_dpy_rgbstat_en, 1);
	}

	if((bHStart >= bHsize) && (bHStart <= bOUTH/2))
	{
		bHStartTemp = bOUTH - (bHStart + bHsize);
				
		PQ_RegisterWrite( VIP_reg_dpy_rgbstat_rhs, bHStartTemp);
		PQ_RegisterWrite( VIP_reg_dpy_rgbstat_rvs, bVStart);
		
		if((bHStartTemp + bHsize) > (bOUTH- 1))
		{
			bHsize = bOUTH - bHStartTemp;
		}
	}
	else
	{
		
		PQ_RegisterWrite( VIP_reg_dpy_rgbstat_lhs, bHStart);
		PQ_RegisterWrite( VIP_reg_dpy_rgbstat_lvs, bVStart);
		
		if((bHStart + bHsize) > (bOUTH- 1))
		{
			bHsize = bOUTH - bHStart;
		}
	}
	
	if((bVStart + bVsize) > (bOUTV - 1))
	{
		bVsize = bOUTV - bVStart;
	}


	PQ_RegisterWrite( VIP_reg_dpy_rgbstat_hsize, bHsize-1);
	PQ_RegisterWrite( VIP_reg_dpy_rgbstat_vsize, bVsize-1);
	if((bHsize * bVsize) < (1024 * 8))// 2 13
	{
		bShift = 11;
		PQ_RegisterWrite(VIP_reg_dpy_rgbstat_sft, 0);	
	}
	else if((bHsize * bVsize) < (1024 * 32))
	{
			bShift = 13;
			PQ_RegisterWrite(VIP_reg_dpy_rgbstat_sft, 1);	
	}
	else if((bHsize * bVsize) < (1024 * 128))
	{
			bShift = 15;
			PQ_RegisterWrite(VIP_reg_dpy_rgbstat_sft, 2);	
	}

	else
	{
			bShift = 17;
			PQ_RegisterWrite(VIP_reg_dpy_rgbstat_sft, 3);	
	}

	if((bRegionIndex>=1)&&(bHStart > 1))
	{
		bHStart_t = bHStart + 1;
	}
	else
	{
		bHStart_t = bHStart;
	}
	
	if(bHStart_t >= bOUTH)
	{
		bHStart_t = bOUTH - 1;
	}

	if((bRegionIndex>=1)&&(bVStart > 1))
	{
		bVStart_t = bVStart + 1;
	}
	else
	{
		bVStart_t = bVStart;
	}
	
	if(bVStart_t >= bOUTV)
	{
		bVStart_t = bOUTV - 1;
	}
	
	mdelay(15);

}

void PQ_GetRegionLumaAverage(UINT16* bRegionYaverage)
{
	UINT32 ulValue = 0;
	UINT32 bRed = 0,bGreen = 0,bBlue = 0;
	UINT16 temp = 0;
	
	mdelay(10);
	ulValue = PQ_RegisterRead(VIP_reg_dpy_blkl0_dout);

	if((bHsize * bVsize) > 0)
	{
		bRed = ((ulValue&0x3ff)<<bShift )/(bHsize * bVsize);
		bGreen = (((ulValue>>20)&0x3ff)<<bShift)/(bHsize * bVsize) ;
		bBlue = (((ulValue>>10)&0x3ff)<<bShift)/(bHsize * bVsize);
	}

	temp = (299 * bRed)/1000 + (587 * bGreen)/1000 + (114 * bBlue)/1000;
	if(temp > 255)
	 temp = 255;

	*bRegionYaverage = temp;

}

void PQ_GetRegionvalue(RegionHVStartSize* bRegionvalue)
{
	bRegionvalue->bHsize = bHsize;
	bRegionvalue->bVsize = bVsize;
	bRegionvalue->bHstart = bHStart_t;
	bRegionvalue->bVstart = bVStart_t;
}

void PQ_UltraLowSetting(UINT8 ucEnable)
{
	if(ucEnable)
	{
		PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_color_hl_coring, 0x50);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_lb_1, 0x12c);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_rb_1, 0x15e);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_min_1, 0x1900);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_max_1, 0x19000);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_lb_2, 175);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_hue_rb_2, 270);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_min_2, 400);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_sat_max_2, 0xfffff);
		PQ_RegisterWrite(VIP_reg_vdi_color_cnt_th, 0);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_color_hl_coring2, (VIP_GetInputVSize()<720)?32:0);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_color_vl_coring2, (VIP_GetInputVSize()<720)?32:0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_color_en, 1);
/*
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_debug, 0);
		PQ_RegisterWrite(VIP_reg_vdi_colorHsulowL1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_colorHsulowL2, 1);
		PQ_RegisterWrite(VIP_reg_vdi_colorHtulowL1, 0);
		PQ_RegisterWrite(VIP_reg_vdi_colorHtulowL2, 0);
*/
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_color_th1, 0x24);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_color_th2, 0x3);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_color_th3, 0x850);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_color_th4, 0);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_color_th1, 0x22);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_color_th2, 0x02);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_color_th3, 0x850);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_color_th4, 0x00);


#if 0
		if(VIP_IsPCSource())
		{
			PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th1, 64);
			PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th2, 8);
			PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th4, 0);
			PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th3, 3600);
			PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th1, 64);
			PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th2, 8);
			PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th4, 0);
			PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_bmax_sel, 1);
		}
		else
#endif
		{
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th1, 0x24);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th2, 0x2);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_bmax_sel, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th3, 0x800);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_th4, 0x0);

		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th1, 0x24);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th2, 0x02);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th4, 0x00);
		}


		//PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_alpha, 0x10);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_lp_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_bmax_sel, 1);
		//PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_alpha, 0x10);




		PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dyn_adj, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_th_dyn_adj, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dith_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_mbw_en, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_sel, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_sel, 0);

	}
	else
	{
		PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dyn_adj, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_th_dyn_adj, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dith_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_en, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_mbw_en, 0);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_sel, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_sel, 0);

		PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_color_en, 0);
	}
	PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dyn_adj, (VIP_GetInputVSize()<720)?0:1);
	PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_en, (VIP_GetInputVSize()<720)?1:0);
	PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_mbw_en, 1);


}

void PQ_NRLevel(UINT32 nr_level, UINT32 vdi_total)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    #ifndef ADJUST_NR_By_Yavg
    VTAB_CMN_VALUE_DEFINE* pVtabCmnValue= &pHwContext->VtabCmnValue;
    UINT8 ucCurrSrcIndex,ucTableIndex;
    UINT8 ucLevel= nr_level;

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

	if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
	{
		PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
		return;
	}

	ucTableIndex = pVtabCmnValue->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex];
    #endif
	pHwContext->iAdjustNRCounter = 0;
	///if(vdi_total>=4095) vdi_total=4095;
	PQ_RegisterWrite(VIP_reg_vdi_tnr_v_ref, 8);
	PQ_RegisterWrite(VIP_reg_vdi_tnr_u_ref, 8);
	PQ_RegisterWrite(VIP_reg_vdi_tnr_u_ref, (VIP_GetInputVSize()<720)?40:24);;
	PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_en, (VIP_GetInputVSize()<720)?1:0);

	
	if( nr_level == OFF && 
		(VIP_GetUserSource() == SOURCE_JPEG ||
		VIP_GetUserSource() == SOURCE_HDMI ||
		VIP_GetUserSource() == SOURCE_MPEG ||
		VIP_IsPCSource())
	)
	{
		PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, 0);
		PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH, 0);
		PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_CORING, 0);
		PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, 0);
		PQ_SetupStrength(PQ_ITEM_TNR_ULTRA_LOW, 0);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING,  0);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH,		0);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING,  0);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH,		0);
		PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, 0);
		PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH,   0);
	}
#ifndef ADJUST_NR_By_Yavg
	else if(ucLevel>=WEAK && ucLevel<=STRONG )
	{
		ucLevel-= 1;

		PQDebugPrint("%s: nr degrees= %d %d %d %d %d %d %d %d %d %d    %d %d %d\n", __FUNCTION__,
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaTnrCoring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaTnrStrength.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaTnrCoring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaTnrStrength.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr1Coring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr1Strength.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr2Coring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr2Strength.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaSnrCoring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaSnrStrength.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].TnrUltraLowAlpha.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].Snr1UltraLowCoring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].Snr2UltraLowCoring.Degree[ucLevel]
		);

		PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaTnrCoring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaTnrStrength.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_CORING, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaTnrCoring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaTnrStrength.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_TNR_ULTRA_LOW, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].TnrUltraLowAlpha.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr1Coring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr1Strength.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr2Coring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].LumaSnr2Strength.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaSnrCoring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].ChromaSnrStrength.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_SNR1_ULTRA_LOW, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].Snr1UltraLowCoring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_SNR2_ULTRA_LOW, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].Snr2UltraLowCoring.Degree[ucLevel]);
	}
#endif

	PQ_UltraLowSetting(ENABLE);
}

//****************************************************************************
//
//   Function   : PQ_3DNoiseReductoin
//   Params    :
//   Description:
//   Returns    : void
//****************************************************************************

void PQ_3DNoiseReductoin(UINT8 ucMode,UINT8 iUserMin, UINT8 iUserMax )
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT32 vdi_hsize_i,vdi_vsize,vdi_total;
	BOOL bNrEnable;

	if( pHwContext->bEnableColorProcess==FALSE )
		ucMode= OFF;

	PQDebugPrint("%s:nNRLevel=%d\n", __FUNCTION__, ucMode);

	pHwContext->nNRLevel= ucMode;

	pHwContext->ucNRUserMin = iUserMin;
	pHwContext->ucNRUserMax = iUserMax;
	bNrEnable= (pHwContext->nNRLevel>OFF) ? ENABLE : DISABLE;

#ifdef ADJUST_NR_By_Yavg
    if (VIP_GetUserSource()!= SOURCE_HDMI && VIP_GetUserSource()!= SOURCE_MPEG)
	{
        bNrEnable = ENABLE;
    }
#endif

    if(VIP_IsPCSource()|| VIP_RunDVIMode())
	{
	    bNrEnable=DISABLE;
    }


	PQ_RegisterWrite(VIP_reg_vdi_tnr_en, bNrEnable); //always open to let VIP_field_diff_cnt can work
	PQ_RegisterWrite(VIP_reg_vdi_snr_hfil_en, bNrEnable);
	PQ_RegisterWrite(VIP_reg_vdi_snr_vfil_en, bNrEnable);
	if (VIP_GetUserSource()==SOURCE_CVD2)
	PQ_RegisterWrite(VIP_reg_vdi_sigmanr_en, 0);
	else
	PQ_RegisterWrite(VIP_reg_vdi_sigmanr_en, bNrEnable);


	vdi_hsize_i= VIP_GetScalerPreScaleH();
	vdi_vsize= PQ_Get_VDI_VSize();
	vdi_total= vdi_hsize_i*vdi_vsize;
#if 0
	if (VIP_GetUserSource()==1 && VIP_IsATVSource())
		PQ_NRLevel(ucMode + 1, vdi_total);
	else
#endif
	PQ_NRLevel(ucMode, vdi_total);
}




void PQ_MPEGNRLevel(UINT32 nr_level, UINT32 vdi_total)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtabCmnValue= &pHwContext->VtabCmnValue;
	UINT8 ucLevel= nr_level;
	//if(vdi_total>=4095) vdi_total=4095;
	UINT32 maxedgev_th;
    UINT8 ucCurrSrcIndex,ucTableIndex;

    ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

	if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
	{
		PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
		return;
	}

	ucTableIndex = pVtabCmnValue->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex];

	maxedgev_th=vdi_total/337;

	if(maxedgev_th>=4095) maxedgev_th=4095;
	if( nr_level==WEAK )
	{
		//DeBlock
		PQ_RegisterWrite(VIP_reg_vdi_maxedgev_th, maxedgev_th);
		//MNR
		PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_thd, 6);

	}
	else if( nr_level==STRONG )
	{
		//DeBlock
		PQ_RegisterWrite(VIP_reg_vdi_maxedgev_th, maxedgev_th);
		//MNR
		PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_thd, 4);
	}
	else
	{
		//DeBlock
		PQ_RegisterWrite(VIP_reg_vdi_maxedgev_th, maxedgev_th);
		//MNR
		PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_thd, 4);
	}

	if( ucLevel>=WEAK && ucLevel<=STRONG )
	{
		ucLevel-= 1;
		PQDebugPrint("%s: mpeg nr degrees= %d %d %d %d", __FUNCTION__,
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].BlockNrCoring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].BlockNrStrength.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].MosquitoNrCoring.Degree[ucLevel],
			pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].MosquitoNrStrength.Degree[ucLevel]
			);

		PQ_SetupStrength(PQ_ITEM_BLOCK_NR_CORING, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].BlockNrCoring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_BLOCK_NR_STRENGTH, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].BlockNrStrength.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_MOSQUITO_NR_CORING, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].MosquitoNrCoring.Degree[ucLevel]);
		PQ_SetupStrength(PQ_ITEM_MOSQUITO_NR_STRENGTH, pVtabCmnValue->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex].MosquitoNrStrength.Degree[ucLevel]);
	}

}


void PQ_MPEGNoiseReductoin(UINT8 ucLevel,UINT8 iUserMin, UINT8 iUserMax )
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT32 vdi_hsize_i,vdi_vsize,vdi_total;
	BOOL bNrEnable;
	BOOL bDeblockEnable;

	if( pHwContext->bEnableColorProcess==FALSE )
		ucLevel= OFF;

	PQDebugPrint("%s:nMpegNRLevel=%d", __FUNCTION__, ucLevel);

	pHwContext->nMPEGNRLevel= ucLevel;
	pHwContext->ucMPEGNRUserMax = iUserMax;
	pHwContext->ucMPEGNRUserMin = iUserMin;
	bNrEnable= (pHwContext->nMPEGNRLevel>OFF) ? ENABLE : DISABLE;
	bNrEnable= (bNrEnable) && (!VIP_IsPCSource() || !VIP_RunDVIMode());
	bDeblockEnable=(!VIP_IsPCSource()) && (!VIP_RunDVIMode());
	PQ_RegisterWrite(VIP_reg_gfx_dbk_en, bNrEnable && bDeblockEnable);
#if 0
	if(pHwContext->cInputDataFormat == RGB && !VIP_IsPCSource())
		PQ_RegisterWrite(VIP_reg_vdi_mnr_fil_en, 0);
	else
		PQ_RegisterWrite(VIP_reg_vdi_mnr_fil_en, bNrEnable);
#else
	PQ_RegisterWrite(VIP_reg_vdi_mnr_fil_en, bNrEnable && (VIP_GetInputDataFormat()!=RGB));
#endif

	if( bNrEnable )
	{
		vdi_hsize_i= VIP_GetScalerPreScaleH();
		vdi_vsize= PQ_Get_VDI_VSize();
		vdi_total= vdi_hsize_i*vdi_vsize;
		PQ_MPEGNRLevel(ucLevel, vdi_total);
	}
}

//****************************************************************************
//
//   Function   : PQ_sigmaNR
//   Params     
//   Description: 
//   Returns    : 
//****************************************************************************

void PQ_SigmaNR(BOOL bReset, UINT8 ucLevel,UINT8 iUserMin, UINT8 iUserMax )
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    	UINT8 ucTableIndex;
	UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
	Sigama_NR_Data *pSigama_NR;
	int uiSigamaNRMiscCtl, i;
      static UINT8 bStart = FALSE;

       if(bReset)
       {
           bStart = TRUE;
           return;
        } 
    

     if(bStart)
    {
        bStart = FALSE;
        
        if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
        if (pVtab->mSigama_NR.mGroupedIndex[ucCurrSrcIndex] >= 8) return;

        ucTableIndex = pVtab->mSigama_NR.mGroupedIndex[ucCurrSrcIndex];
        pSigama_NR = &pVtab->mSigama_NR.Sigama_NR[ucTableIndex];
        uiSigamaNRMiscCtl = pVtab->Sigma_NR_Misc_Ctl[ucTableIndex];
        
        if(ucLevel == 0)
        {
             //PQ_RegisterWrite(VIP_reg_vdi_sigma_en, OFF);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_EN, pSigama_NR->sigama_NR_opt);

            
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_EN_W, 0);//pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bTemporal);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_SEL_W, 0);//pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bVarScale);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_FIL_GAIN_W, 0);//pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bGain);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMOT_SEL_W,0);// pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bVMotScale);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VREF_SEL_W, 0);//pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bVRefScale);
            
            //normal region
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_EN_N, 0);//pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bTemporal);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_SEL_N, 0);//pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bVarScale);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_FIL_GAIN_N, 0);//pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bGain);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMOT_SEL_N, 0);//pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bVMotScale);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VREF_SEL_N, 0);//pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bVRefScale);
            
            //normal region
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_EN_S, 0);//pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bTemporal);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_SEL_S, 0);//pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bVarScale);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_FIL_GAIN_S, 0);//pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bGain);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMOT_SEL_S, 0);//pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bVMotScale);
            PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VREF_SEL_S,0);// pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bVRefScale);
        }
        else
        {
       	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_EN, pSigama_NR->sigama_NR_opt);
       
               PQ_RegisterWrite(VIP_REG_VDI_SIGMA_IN_SEL, pSigama_NR->sigama_NR_mode);

        	//weak region
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_EN_W, pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bTemporal);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_SEL_W, pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bVarScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_FIL_GAIN_W, pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bGain);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMOT_SEL_W, pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bVMotScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VREF_SEL_W, pSigama_NR->SigamaNR_Region[WEAK_LEVEL].bVRefScale);

        	//normal region
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_EN_N, pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bTemporal);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_SEL_N, pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bVarScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_FIL_GAIN_N, pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bGain);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMOT_SEL_N, pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bVMotScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VREF_SEL_N, pSigama_NR->SigamaNR_Region[NORMAL_LEVEL].bVRefScale);

        	//strong region
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_EN_S, pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bTemporal);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_SEL_S, pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bVarScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_FIL_GAIN_S, pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bGain);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMOT_SEL_S, pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bVMotScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VREF_SEL_S, pSigama_NR->SigamaNR_Region[STRONG_LEVEL].bVRefScale);

        	//complexity level
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMAX_TH_LO, pSigama_NR->SigamaNR_Complexity_level.bLowTH);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMAX_TH_MD, pSigama_NR->SigamaNR_Complexity_level.bMiddleTH);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMAX_TH_HI, pSigama_NR->SigamaNR_Complexity_level.bHighTH);

        	//adaptive static th
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_STATIC_TH_W, pSigama_NR->SigamaNR_Adaptive_Static_TH.bWeak);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_STATIC_TH_N, pSigama_NR->SigamaNR_Adaptive_Static_TH.bNormal);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_STATIC_TH_S, pSigama_NR->SigamaNR_Adaptive_Static_TH.bStrong);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMIN_TH, pSigama_NR->SigamaNR_Adaptive_Static_TH.bLowNoiseTH);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_STATIC_TH, pSigama_NR->SigamaNR_Adaptive_Static_TH.bStaticTH);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_DTL_TH_LO, pSigama_NR->SigamaNR_Adaptive_Static_TH.bDetailTH);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMAX_SH, pSigama_NR->SigamaNR_Adaptive_Static_TH.bComplexScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VMIN_SH, pSigama_NR->SigamaNR_Adaptive_Static_TH.bVarScale);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VDTL_SH, pSigama_NR->SigamaNR_Adaptive_Static_TH.bDetailScale);

        	//post-tnr gain
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_GAIN_W, pSigama_NR->SigamaNR_Post_TNR_Gain.bWeak);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_GAIN_N, pSigama_NR->SigamaNR_Post_TNR_Gain.bNormal);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_TNR_GAIN_S, pSigama_NR->SigamaNR_Post_TNR_Gain.bStrong);

        	//variance upper bound
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_MANUAL_W, pSigama_NR->SigamaNR_Variance_Upper_Bound.bWeak[0] + (pSigama_NR->SigamaNR_Variance_Upper_Bound.bWeak[1]<<16));
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_MANUAL_N, pSigama_NR->SigamaNR_Variance_Upper_Bound.bNormal[0] + (pSigama_NR->SigamaNR_Variance_Upper_Bound.bNormal[1]<<16));
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_MANUAL_S, pSigama_NR->SigamaNR_Variance_Upper_Bound.bStrong[0] + (pSigama_NR->SigamaNR_Variance_Upper_Bound.bStrong[1]<<16));

        	//base & bound
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_MOTION_TH_BASE, pSigama_NR->SigamaNRBase);
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_MOTION_TH_BND, pSigama_NR->SigamaNRBound);

        	//variance th
        	for(i = 0; i< 7; i++)
        	{
        		PQ_RegisterWrite(VIP_REG_VDI_SIGMA_VAR_TH1 + i, pSigama_NR->Variance_TH[i]);
        	}

        	//variance th
        	for(i = 0; i< 7; i++)
        	{
        		PQ_RegisterWrite(VIP_REG_VDI_SIGMA_MOTION_TH1 + i, pSigama_NR->Motion_TH[i]);
        	}
            
        	PQ_RegisterWrite(VIP_REG_VDI_SIGMA_MISC_CTRL, uiSigamaNRMiscCtl);	
        	}

        }
}

//****************************************************************************
//
//   Function   : PQ_SetGammaTable
//   Params    : *pulAddr
//   Description: For pqtool set gamma table to VIP (related to WriteGammaToSiSCmd())
//   Returns    : 0=fail ,1=success
//****************************************************************************
BOOL PQ_SetGammaTable(UINT32 *pulAddr)
{
	INT32 iTableCnt;

	PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr,0);		//initial index for gamma table write

	for (iTableCnt=0;iTableCnt<GAMMA_RGB_MAXINDEX;iTableCnt++){
		PQ_RegisterWrite(VIP_reg_dpy_gmlut_data, *pulAddr );
		pulAddr++;
	}

	return TRUE;
}

//****************************************************************************
//
//   Function   : PQ_LoadGammaTable
//   Params    : *pulAddr
//   Description: read out gamma table form VIP
//   Returns    : table data size
//****************************************************************************
UINT32 PQ_LoadGammaTable(UINT32 *pulAddr)
{
	INT32 iTableCnt;

	PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr,0);		//initial index for gamma table write

	for (iTableCnt=0;iTableCnt<GAMMA_RGB_MAXINDEX_512;iTableCnt++){
		*pulAddr=PQ_RegisterRead(VIP_reg_dpy_gmlut_data);
		pulAddr++;
	}

	*pulAddr=0x35536953;	//identify gamma table string
	pulAddr++;
	*pulAddr=0x475f3631;
	pulAddr++;
	*pulAddr=0x616d6d61;

	return 4108;	//gamma talbe total size
}

void PQ_DisableGammaTable(BOOL b12BitGammaTable)
{
	UINT32 ulCounter,ulDataValue;
	PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr,0); 	//initial index for gamma table write
	for (ulCounter=0;ulCounter<GAMMA_RGB_MAXINDEX;ulCounter++)	//input data 10/12 bits
	{
		//short setting time to avoid setting error
		if(!b12BitGammaTable)
		{
			ulDataValue = (ulCounter<<20) | (ulCounter<<10) |(ulCounter);
			PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,ulDataValue);
		}
		else
		{
			ulDataValue = (ulCounter<<20) | (ulCounter<<10) |(ulCounter);
			PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,ulDataValue);
			ulDataValue = ((ulCounter+1)<<20) | ((ulCounter+1)<<10) |(ulCounter+1);
			PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,ulDataValue);
		}
	}

}

BOOL PQ_GetGammaChange(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    return pHwContext->bGammaChange;
}

void PQ_WriteGammaTable(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    UINT32 i;

    if((*((UINT8*)(0xbe1cd688))) == 0x5) 
    {
        return;
    }

    PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr, 0);
    
    for (i=0; i<GAMMA_RGB_MAXINDEX; i++)
    {
        #ifdef CONFIG_SWITCH_GAMMA_TABLE_WITHOUT_RESET
        PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr, i);
        #endif
        PQ_RegisterWrite(VIP_reg_dpy_gmlut_data, pHwContext->Gammatable[i]);
    }
        
    PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr,0);
	PQ_RegisterWrite(VIP_reg_dpy_no_gamma, DISABLE);
    pHwContext->bGammaChange=FALSE;
}

UINT8 PQ_GetGammaIndex(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    
    return pHwContext->GammaIndex;
}

/**
 * @brief Setup gamma setting
 *
 * This function sets Gamma setting form bin file, the number of setting had increase to 1024, 
 * different from previous 512 set
 *
 * @param : ucEnable to control enable/disable gamma function
 * @param : ucTableIndex to select which set of gamma table setting (all 3 set)
 * @return : n/a
 * @note 1 : chagne tne number of set from 512 to 1024 from 8506
 * @To Do : 1. remove 12 bit flow since no longer use
*/
void PQ_SetupGammaTable(UINT8 ucEnable, UINT8 ucTableIndex, UINT8 ucRGBGainAdjust)
{
    volatile UINT32 *pGammaTable = NULL;
    UINT8 pGammaTableID[15];
    UINT32 ulCounter;
    BOOL b12BitGammaTable= FALSE;
    PQHW_CONTEXT* pHwContext= &PQHwContext;

    #ifndef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
    UINT16 TempR,TempB,TempG;
    INT32 bTempRGain,bTempGGain,bTempBGain;
    bTempRGain = pHwContext->iRGain;
    bTempGGain = pHwContext->iGGain;
    bTempBGain = pHwContext->iBGain;

    if((pHwContext->iRGain == 0) && (pHwContext->iGGain == 0) && (pHwContext->iBGain == 0))
    {
    	bTempRGain = 1024;
    	bTempGGain = 1024;
    	bTempBGain = 1024;
    }
    #endif   
#ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
    if(pHwContext->GammaIndex != ucTableIndex || pHwContext->GammaEnable != ucEnable || ucRGBGainAdjust == TRUE)//prevent blanking from duplicate setting
#else
    if(pHwContext->GammaIndex != ucTableIndex || pHwContext->GammaEnable != ucEnable || ucRGBGainAdjust == TRUE || ValueChange ==TRUE)//prevent blanking from duplicate setting
#endif
	{
        if(ucEnable == ENABLE)
        {

            pHwContext->bGammaChange=FALSE;
            
            if(ucRGBGainAdjust == FALSE && ucTableIndex>2) // gamma table index is out of range
            {
            PQDebugPrint("%s: [ERROR!!] ucTableIndex is illegal(out of range: 0~2)", __FUNCTION__);
            return;
            }

            if(ucRGBGainAdjust)
            {
                pGammaTable = (volatile UINT32*) (SPI_GAMMATABLE_SHADOWADDR+(SPI_GAMMATABLE_SIZE*pHwContext->GammaIndex));
            }
            else
            {
                pGammaTable = (volatile UINT32*) (SPI_GAMMATABLE_SHADOWADDR+(SPI_GAMMATABLE_SIZE*ucTableIndex));
            }
   
            memcpy(pGammaTableID, ((UINT8 *)pGammaTable)+0x1000, 14);
            memset(&pGammaTableID[14], 0, 1);

            PQDebugPrint("%s: tag of table %d is %s", __FUNCTION__, ucTableIndex, pGammaTableID);

            if( memcmp(pGammaTableID, ID_GammaString12, 14)==0 )
            {
                b12BitGammaTable= TRUE;
            }
            else if( memcmp(pGammaTableID, ID_GammaString10, 12)==0 ) //recognize prefix 12 characters
            {
                b12BitGammaTable= FALSE;
            }
            else
            {
                PQDebugPrint("%s: Gamma Table ID is illegal, diable gamma table!!", __FUNCTION__);
                pHwContext->GammaEnable = DISABLE;
                PQ_DisableGammaTable(FALSE);
                return;
            }
   
            // start to setup gamma table as following if ucTableIndex and GammaTableID are correct

            if(!ucRGBGainAdjust)
            {
                pHwContext->GammaIndex=ucTableIndex;
                pHwContext->GammaEnable = ENABLE;
            }
            
            #ifndef CONFIG_SWITCH_GAMMA_TABLE_WITHOUT_RESET 
            PQ_RegisterWrite(VIP_reg_dpy_no_gamma, ENABLE);	//disable gamma function
            mdelay(20); //the timing can check with HW, the dpy_gmlut_data will work at next Vsync after disable gamma, so wait a fream then sart set data
            PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr,0);		//initial index for gamma table write
            #endif
          
            for (ulCounter=0; ulCounter<GAMMA_RGB_MAXINDEX; ulCounter++)	//input data 10/12 bits
            {
                #ifdef CONFIG_PANEL_LM201WE3_TLF5_1680X1050__S2TEK_IS_DEFAULT
                TempR = 1023 - ((pGammaTable[ulCounter] & 0x3ff00000) >> 20);
                TempG = 1023 - ((pGammaTable[ulCounter] & 0xFFC00) >> 10);
                TempB = 1023 - (pGammaTable[ulCounter] & 0x3FF);
                pHwContext->Gammatable[ulCounter] = (TempR << 20) + (TempG << 10) + TempB;
                #else
                //short setting time to avoid setting error
                #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
                pHwContext->Gammatable[ulCounter] = pGammaTable[ulCounter];
                #else
                TempG= (pGammaTable[ulCounter] & 0x3ff00000) >> 20;
                TempB = (pGammaTable[ulCounter] & 0xFFC00) >> 10;
                TempR = pGammaTable[ulCounter] & 0x3FF;
                TempR = max(0, min(1023, TempR*((bTempRGain*1000+512)/1024)/1000));
                TempG = max(0, min(1023, TempG*((bTempGGain*1000+512)/1024)/1000));
                TempB = max(0, min(1023, TempB*((bTempBGain*1000+512)/1024)/1000));
                pHwContext->Gammatable[ulCounter]=((TempG << 20) + (TempB << 10) + TempR);
                #endif
                #endif
            }

            pHwContext->bGammaChange=TRUE;
   
        }
        else
        {
            pHwContext->GammaEnable = DISABLE;
            PQ_DisableGammaTable(b12BitGammaTable);
            PQDebugPrint("Without Gamma Table.......Turn off Gamma correction.");
        }
    }

}


#define VIP_COLOR_SPACE_RGB	0
#define VIP_COLOR_SPACE_YUV444	1
#define VIP_COLOR_SPACE_YUV422	2

void ADI_ReadPixelfortest(UINT32 bHstart,UINT32 bHend,UINT32 bVstart,UINT32 bVend,COLORYUV **bYUV)
{	

	UINT32 nWidth,nHeight,nColorSpace=VIP_COLOR_SPACE_RGB;
	UINT32 nValue,i = 0;
	UINT8 nValue1;
	UINT32 nHStart = 0, nVStart = 0;
	UINT32 fY,fU,fV;
	//UINT32 x1, y1, x2, y2;
	UINT32 x,y;
	BOOL bInterlace;
	
	COLORYUV bYUVTemp={0};
	bInterlace= FALSE;
	
	//bY = malloc(((bHend - bHstart) * (bVend - bVstart)) * sizeof(UINT32));

	nValue1 = VIP_GetUserSource();


	if( nValue1==SOURCE_EXTS )
	{
		nValue1 = PQ_RegisterRead(VIP_reg_adi_exts_vid_in);
		if( (nValue1&0x1)==0 )
		{
			nColorSpace= VIP_COLOR_SPACE_RGB;
		}
		else
		{
		nValue1 = PQ_RegisterRead(VIP_reg_adi_exts_vid601);
			nColorSpace= (nValue1&0x2) ? VIP_COLOR_SPACE_YUV422 : VIP_COLOR_SPACE_YUV444;
		}
	}
	else if( nValue1==SOURCE_MPEG )
	{
		nColorSpace= VIP_COLOR_SPACE_YUV422;
	}
	else if( nValue1==SOURCE_CVD2 )
	{
		nValue1 = PQ_RegisterRead(VIP_reg_adi_exts_vid601);
		nColorSpace= (nValue1&0x1) ? VIP_COLOR_SPACE_YUV422 : VIP_COLOR_SPACE_YUV444;
	}
	else if( nValue1==SOURCE_HDMI )
	{
		nValue1 = PQ_RegisterRead(VIP_reg_adi_hdmi_vid_in );		
		if( (nValue1&0x1)==0 )
		{
			nColorSpace= VIP_COLOR_SPACE_RGB;
		}
		else
		{
			nValue1 = PQ_RegisterRead(VIP_reg_adi_hdmi_vid601);
			nColorSpace= (nValue1&0x1) ? VIP_COLOR_SPACE_YUV422 : VIP_COLOR_SPACE_YUV444;
		}		
	}
	else if( nValue1==SOURCE_PATTERN )
	{
		nColorSpace= VIP_COLOR_SPACE_RGB;
	}	
	else
	{
		return;
	}
	

	nWidth = PQ_RegisterRead(VIP_reg_adix_che);
	nValue = PQ_RegisterRead(VIP_reg_adix_chs);
	 
	if( nWidth && nValue )
	{
		nWidth&= 0x2fff;
		nWidth-= nValue&0x2fff;
		nHStart = nValue;
	}

	nHeight = PQ_RegisterRead(VIP_reg_adix_cve);
	nValue = PQ_RegisterRead(VIP_reg_adix_cvs);

	
	if( nHeight && nValue )
	{
		nHeight&= 0x7ff;
		nHeight-= nValue&0x7ff;
		nVStart = nValue;
	}
	printk("\n\n nHeight =%d  nVStart =%d   nHStart = %d  nWidth = %d    \n\n",nHeight,nVStart,nHStart,nWidth);

	nValue1 = PQ_RegisterRead(VIP_reg_vdi_interlace);
	
	if( nValue1 )
	{
		bInterlace= (nValue1 & 0x1)?TRUE:FALSE;
		nValue1 = PQ_RegisterRead(VIP_reg_adi_sch_top);
		if(nValue1)
		{
			if( bInterlace==false )
			{
				nValue1|= 0x1;
			}
			else
			{
				nValue1&= ~0x1;
			}
			PQ_RegisterWrite(VIP_reg_adi_sch_top, nValue1);
		}
	}

	if(bVstart < nVStart)
		bVstart = nVStart;

	if(bHstart < nHStart)
		bHstart = nHStart;

	for(y=bVstart; y<=bVend && y<nHeight+nVStart; y++)
	{
	//printk("\n=======bVstart = %d====\n",bVstart);
		PQ_RegisterWrite(VIP_reg_adix_pix_y, y);
		for(x=bHstart; x<=bHend && x<nWidth+nHStart; x++)
		{	
			PQ_RegisterWrite(VIP_reg_adix_pix_x, x);
		
			PQ_RegisterWrite(VIP_reg_adix_pix_color_show_en, 1);
			mdelay(50);
			if( nColorSpace==VIP_COLOR_SPACE_YUV444 || nColorSpace==VIP_COLOR_SPACE_YUV422 )
			{
				nValue = PQ_RegisterRead(VIP_sta_xp_adi_pix_gcolor);
				//printk("\n nValue y =%d\n",nValue);
				fY= nValue & 0x3ff;
				
				nValue = PQ_RegisterRead(VIP_sta_xp_adi_pix_bcolor);
				fU= nValue & 0x3ff;
				nValue = PQ_RegisterRead(VIP_sta_xp_adi_pix_rcolor);
				fV= nValue & 0x3ff;
			}
			else 
			{
				nValue = PQ_RegisterRead(VIP_sta_xp_adi_pix_rcolor);
				fY= nValue & 0x3ff;
				nValue = PQ_RegisterRead(VIP_sta_xp_adi_pix_gcolor);
				fU= nValue & 0x3ff;
				nValue = PQ_RegisterRead(VIP_sta_xp_adi_pix_bcolor);
				fV= nValue & 0x3ff;
			}	
			//printk("\n	5	fY=%d	fU =%d fV = %d \n",fY,fU,fV);
		memset(&bYUVTemp,0,sizeof(COLORYUV));
		bYUVTemp.dU = fU/4;
		bYUVTemp.dY = fY/4;
		bYUVTemp.dV = fV/4;
		*(bYUV[i]) = bYUVTemp;
		i++;
			PQ_RegisterWrite(VIP_reg_adix_pix_color_show_en, 0);

		}
	}

}



/**
 * @brief Enable/Disable PQ function or adjust the PQ setting to medium/orignal value
 *
 * This function Enable/Disable PQ function or adjust the PQ setting to medium/orignal value, list he function as below
 * brightness, contrast, sharpness, saturation, hue, color tempurature, NR
 * color LUT, cross Luma & Chroma
 *
 * @param : ucEnable to control enable/disable function
 * @return : n/a
*/
void PQ_ColorProcesser(UINT8 ucEnable)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;

    PQ_ADVANCE_HWPrint( "%s: ucEnable=%d", __FUNCTION__, ucEnable);

    pHwContext->bEnableColorProcess= ucEnable;

    if( ucEnable==DISABLE )
    {
        //Set Normal values
        PQ_Brightness(TRUE, 1024);
        PQ_Contrast(TRUE, 1024);
        PQ_Sharpness(TRUE, 0);	//64 //should set 0 to disable sharpness by ren's request
        PQ_Saturation(1024);
        PQ_Hue(50);

        //Disable ypp mode
        //PQ_RegisterWrite(VIP_reg_dpy_ypp, DISABLE);	//should before brightness setting

        //Disable color temp
        PQ_ColorTempGain(PQ_CT_GAIN_R, 1024);
        PQ_ColorTempGain(PQ_CT_GAIN_G, 1024);
        PQ_ColorTempGain(PQ_CT_GAIN_B, 1024);
        PQ_ColorTempBias(PQ_CT_BIAS_R, 0);
        PQ_ColorTempBias(PQ_CT_BIAS_G, 0);
        PQ_ColorTempBias(PQ_CT_BIAS_B, 0);

        //bypass color processer
        PQ_RegisterWrite(VIP_reg_dpy_hsy_bypass,1);

        //Disable dynamic saturationm, in fact it disable the hw saturation
        PQ_RegisterWrite(VIP_reg_dpy_hsv,0);

        //Clear sharpness value
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_smooth1, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hc_smooth1, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_vl_smooth, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_vc_smooth, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hl_sharp, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_hc_sharp, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_vl_sharp, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_vc_sharp, 0);

        //Disable NR
        PQ_3DNoiseReductoin(OFF, 0, 0);
        PQ_MPEGNoiseReductoin(OFF, 0, 0);
        PQ_RegisterWrite(VIP_REG_VDI_SIGMA_EN, FALSE);

        //Disable LUT
        PQ_SetupLUTTable(DISABLE);

        //cross luma
        PQ_SetColorCross(DISABLE);

        //post-dcti
        PQ_RegisterWrite(VIP_reg_slr_dcti_en_post, FALSE);
        PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en,0);
    }
    else
    {
        //Restore menu values
        PQ_Brightness(TRUE, pMenuValue->iBrightness);
        PQ_Contrast(TRUE, pMenuValue->iContrast);
        PQ_Sharpness(TRUE, pMenuValue->iSharpness);
        PQ_Saturation(pMenuValue->iSaturation);
        PQ_Hue(pMenuValue->iHue);
        PQ_Sharpness_POSTDCTI(TRUE, pMenuValue->iSharpness);
        PQ_Sharpness_POST_2D(TRUE, pMenuValue->iSharpness);
        

        //Restore ypp mode
        //#if prevent_DPY_from_clamping_input_YCC_16_235
        //PQ_RegisterWrite(VIP_reg_dpy_ypp, ENABLE);		//should before brightness setting
        //#endif

        //Enable color temp
        PQ_ColorTempGain(PQ_CT_GAIN_R, pMenuValue->iColorTemp[0]);
        PQ_ColorTempGain(PQ_CT_GAIN_G, pMenuValue->iColorTemp[1]);
        PQ_ColorTempGain(PQ_CT_GAIN_B, pMenuValue->iColorTemp[2]);
        PQ_ColorTempBias(PQ_CT_BIAS_R, pMenuValue->iColorBias[0]);
        PQ_ColorTempBias(PQ_CT_BIAS_G, pMenuValue->iColorBias[1]);
        PQ_ColorTempBias(PQ_CT_BIAS_B, pMenuValue->iColorBias[2]);

        //Restore dynamic contrast

        //Enable color processer
        PQ_RegisterWrite(VIP_reg_dpy_hsy_bypass,0);

        //Enable dynamic saturation, in fact it enable the hw saturation
        PQ_RegisterWrite(VIP_reg_dpy_hsv,1);

        //Enable NR
        PQ_3DNoiseReductoin(pMenuValue->ucNRLevel, pHwContext->ucNRUserMin, pHwContext->ucNRUserMax);
        PQ_MPEGNoiseReductoin(pMenuValue->ucMPEGNRLevel, pHwContext->ucMPEGNRUserMin, pHwContext->ucMPEGNRUserMax);
        #ifdef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION			
        PQ_SigmaNR(TRUE, 0xff, 0xff, 0xff);
        #else
        PQ_SigmaNR(TRUE, pHwContext->nNRLevel, 0xff, 0xff);
        #endif

        //Enable LUT
        PQ_SetupLUTTable(ENABLE);
    }
}


void PQ_ColorProcesserDisable(void)
{
	PQ_ColorProcesser(DISABLE);
}


void PQ_DemoModeWidth(void)
{
	UINT32 split_width,vdi_hsize_i,vdi_hds;
	UINT32 dpy_hds;

	dpy_hds= PQ_RegisterRead(VIP_reg_dpy_hds)*2;
	vdi_hsize_i= VIP_GetScalerPreScaleH();
	vdi_hds= 0;
	split_width= 0;
	if( PQ_RegisterRead(VIP_reg_vdi_tnr_debug_en)!=0 )
	{
		split_width= (dpy_hds+(VIP_GetOutputHSize()/2))/2;

		PQDebugPrint("split width=%d ", split_width);
		PQ_RegisterWrite(VIP_reg_dpy_split_width, split_width);//Dynamic Contrast
		if( VIP_GetOutputHSize()>=1920 && split_width==1023 )
		{
			if(VIP_GetOutputHSize()> 0)
			{
				vdi_hds= (1023-(dpy_hds)) * vdi_hsize_i / VIP_GetOutputHSize();
			}
		}
		else
			vdi_hds= vdi_hsize_i /2;

		PQ_RegisterWrite(VIP_reg_vdi_tnr_dbg_offset, vdi_hds);
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_dpy_split_width, 0);//Dynamic Contrast
		PQ_RegisterWrite(VIP_reg_vdi_tnr_dbg_offset, 0);
	}
}


void PQ_NERegion(BOOL bDemoMode, UINT32 vdi_hsize_i, UINT32 vdi_vsize)
{
	UINT32 vdi_hds,vdi_ne_total;
	UINT32 vdi_hsize;
	PQ_RegisterWrite(VIP_reg_vdi_ne_field_diff_th, 10);
	PQ_RegisterWrite(VIP_reg_vdi_ne_static_u0, 0x20);
	PQ_RegisterWrite(VIP_reg_vdi_ne_static_v0, 0x40);
	PQ_RegisterWrite(VIP_reg_vdi_ne_static_u1, 0x10);
	PQ_RegisterWrite(VIP_reg_vdi_ne_static_v1, 0x20);
	PQ_RegisterWrite(VIP_reg_vdi_ne_alpha,4);
	//set ne estimate
	vdi_hds= bDemoMode ? PQ_RegisterRead(VIP_reg_vdi_tnr_dbg_offset): 0;
	vdi_hsize= vdi_hsize_i - vdi_hds;
	vdi_ne_total= vdi_hsize * vdi_vsize;

	if(bDemoMode)
		PQ_RegisterWrite(VIP_reg_vdi_ne_hds, vdi_hds + 2);
	else
		PQ_RegisterWrite(VIP_reg_vdi_ne_hds, 2);
	PQ_RegisterWrite(VIP_reg_vdi_ne_hde, vdi_hsize_i - 3);
	PQ_RegisterWrite(VIP_reg_vdi_ne_vds, 1);
	PQ_RegisterWrite(VIP_reg_vdi_ne_vde, vdi_vsize - 2);
	PQ_RegisterWrite(VIP_reg_vdi_ne_fd_chg_thd, vdi_ne_total *2 / 17);
	PQ_RegisterWrite(VIP_reg_vdi_ne_invald_thd, vdi_ne_total *2 / 17);
	PQ_RegisterWrite(VIP_reg_vdi_ne_fd_chg_thd_cur, vdi_ne_total *2 / 17);
	//981113 hw design
	PQ_RegisterWrite(VIP_reg_vdi_ne_mot_th1, 0xc0);
	PQ_RegisterWrite(VIP_reg_vdi_ne_mot_th2, 0xffffffff);
	PQ_RegisterWrite(VIP_reg_vdi_ne_fd_chg_mbw_thd, (VIP_GetInputVSize()<720 )?0x546:0x1feb);
	PQ_RegisterWrite(VIP_reg_vdi_ne_total_th, vdi_ne_total/87);
	//UINT32 ne_reliable_th = (vdi_ne_total * 3)/100;
	PQ_RegisterWrite(VIP_reg_vdi_ne_reliable_th, 3456);//ne_reliable_th);


	//PC Modified 2008-12-05 update
	//1.set ne_dth_min 4 (UINT8 0xbe1c6324 4)
	//2.set ne_dth_max 32 (UINT8 0xbe1c6325 32)

	PQ_RegisterWrite(VIP_reg_vdi_ne_block_dth_min, 4);
	PQ_RegisterWrite(VIP_reg_vdi_ne_block_dth_max, 40);//2008-12-08 PC
	PQ_RegisterWrite(VIP_reg_vdi_ne_block_cth_max, 0x0);

	//# block_std_th = 4^2 * 15 ^2
	PQ_RegisterWrite(VIP_reg_vdi_ne_blk_std_thd, 3600);

}

void PQ_DPYDemoModeEnable(UINT8 demo_enable)
{
	UINT32 split_width;
	UINT32 dpy_hds;
	PQDebugPrint("demo_enable=%d ", demo_enable);

	if( demo_enable)
	{
		dpy_hds= PQ_RegisterRead(VIP_reg_dpy_hds)*2;
		split_width= (dpy_hds+(VIP_GetOutputHSize()/2))/2;

		PQDebugPrint("split width=%d ", split_width);
		PQ_RegisterWrite(VIP_reg_dpy_split_width, split_width);
	}
	else
		PQ_RegisterWrite(VIP_reg_dpy_split_width, 0);
}


void PQ_DemoModeEnable(UINT8 demo_enable)
{
	UINT32 vdi_hsize_i,vdi_vsize;

	PQDebugPrint("demo_enable=%d ", demo_enable);

	vdi_hsize_i= VIP_GetScalerPreScaleH();
	vdi_vsize= PQ_Get_VDI_VSize();
	if(demo_enable)
	{
		PQ_RegisterWrite(VIP_reg_slr_dbg_view, 1);   //  Lowangle
		PQ_RegisterWrite(VIP_reg_vdi_tnr_debug_en, 0x1);   //  Tnr
		PQ_RegisterWrite(VIP_reg_vdi_snr_debug_en, 0x1);   //  Snr
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_slr_dbg_view, 0);   //  Lowangle
		PQ_RegisterWrite(VIP_reg_vdi_tnr_debug_en, 0);   //  Tnr
		PQ_RegisterWrite(VIP_reg_vdi_snr_debug_en, 0);   //  Snr
		PQ_RegisterWrite(VIP_reg_dpy_split_width, 0);//Dynamic Contrast
	}
	PQ_DemoModeWidth();
	if(DRV_SLR_GetConfig() == eSLR_CONFIG_PRE_6HV_POST_H)
	{
	    if(DRV_SLR_GetFactor_VFactor() > 0)
	    {
	    	vdi_vsize*=2048/DRV_SLR_GetFactor_VFactor();
	    }
	}
	PQ_NERegion(demo_enable, vdi_hsize_i, vdi_vsize);
}



void PQ_StaticGammaSetup(INT8 cOffset)
{


}

void PQ_DynamicGammaSetting_ISR(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

    pHwContext->GammaCount = (pHwContext->GammaCount+1)%16;
}

UINT8 PQ_GetGammaEnableSt(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

    return pHwContext->GammaEnable;
}


/**
 * @brief Set Dither OFF, method 1 or method 2
 *
 * This function select the Dither method or disable. There are 2 different dither method : method 1 & method 2,
 * or user can disable the dither function by select dither OFF
 * 
 * @param ucStatus means select dither method 1, dither method 2 or Disable dither function
 * @note : method 1 set c346 to 0, method set C346 = 1 & C342 = 1, Disable set C346 = 1 & C342 = 2
 * @return n/a
 */
void PQ_SetDithering(UINT8 ucStatus)
{
    if(ucStatus == PQ_DITHER_METHOD_1)
    {
        PQ_RegisterWrite(VIP_reg_dpy_dither_sel, 0);
    }
    else
    {
         PQ_RegisterWrite(VIP_reg_dpy_dither_sel, 1);
         if(ucStatus == PQ_DITHER_DISABLE)
         {
            PQ_RegisterWrite(VIP_reg_dpy_dither_v2, DISABLE);
         }
         else
         {
            PQ_RegisterWrite(VIP_reg_dpy_dither_v2, ENABLE);
         }
    }
}

/**
 * @brief Set Dither level
 *
 * This function set the Dither level
 * dither method 1 
 *  0: 12bit => 12bit panel dither
 *  1: 12bit => 10bit panel dither
 *  2: 12bit =>  9bit panel dither
 *  3: 12bit =>  8bit panel dither
 *  4: 12bit =>  7bit panel dither
 *  5: 12bit =>  6bit panel dither
 *  0xbe1cc000[4] -    1: 3D    0: 2D
 *
 * dither method 2
 *  0: (12 -> 10)- level1 
 *  1: (12 -> 9) �Vlevel2
 *  2: (12 -> 8) �Vlevel3 
 *  3: (12 -> 6) �Vlevel4
 *  level = auto : depend on panel bits define
 * 
 * 3D : involve time difference (the dither effect of each pixel in each frame will be different)
 *
 * @param ucLevel means dither setting in different panel bit
 * @return n/a
*/
void PQ_DitheringLevel(UINT8 ucLevel)
{
    UINT32 autoulPanelBits;
    UINT8 ucDitherSel;

    ucDitherSel = PQ_RegisterRead(VIP_reg_dpy_dither_sel);

    if(ucDitherSel) //method 2
    {
        if(ucLevel == PQ_Panel_10_BITS)
        {
            PQ_RegisterWrite(VIP_reg_dpy_data_type_v2, 0);
        }
        else if(ucLevel == PQ_Panel_9_BITS)
        {
            PQ_RegisterWrite(VIP_reg_dpy_data_type_v2, 1);
        }
        else if(ucLevel == PQ_Panel_8_BITS)
        {
            PQ_RegisterWrite(VIP_reg_dpy_data_type_v2, 2);
        }
        else if(ucLevel == PQ_Panel_6_BITS)
        {
            PQ_RegisterWrite(VIP_reg_dpy_data_type_v2, 3);
        }
        else // dither level = auto
        {
            //vip's output is 12bit, the transform is dependent on lvds's resolution.
		autoulPanelBits = PQ_RegisterRead(REGISTER_ADDRESS_LVDS_MAPPING); // 0xC1B4[13:12] : lvds bit-per-pixel type
		autoulPanelBits = ((autoulPanelBits >> 12) & 0x3);

            if( autoulPanelBits == 0 ) // 18bpp -> 6bit
		{
			PQ_RegisterWrite(VIP_reg_dpy_data_type_v2, 3);
		}
		else if( autoulPanelBits == 1 ) // 24bpp -> 8bit
		{
			PQ_RegisterWrite(VIP_reg_dpy_data_type_v2, 2);
		}
		else if( autoulPanelBits == 2 ) // 30bpp -> 10bit
		{
			PQ_RegisterWrite(VIP_reg_dpy_data_type_v2, 0);
		}
        }
    }
    else //method 1
    {
        if(ucLevel != PQ_AUTO_DETECT_Panel_BITS)
        {
            PQ_RegisterWrite(VIP_reg_dpy_dither, ucLevel);
        }
        else // dither level = auto
        {
            //vip's output is 12bit, the transform is dependent on lvds's resolution.
		autoulPanelBits = PQ_RegisterRead(REGISTER_ADDRESS_LVDS_MAPPING); // 0xC1B4[13:12] : lvds bit-per-pixel type
		autoulPanelBits = ((autoulPanelBits >> 12) & 0x3);

            if( autoulPanelBits == 0 ) // 18bpp -> 6bit
		{
			PQ_RegisterWrite(VIP_reg_dpy_dither, PQ_Panel_6_BITS);
		}
		else if( autoulPanelBits == 1 ) // 24bpp -> 8bit
		{
			PQ_RegisterWrite(VIP_reg_dpy_dither, PQ_Panel_8_BITS);
		}
		else if( autoulPanelBits == 2 ) // 30bpp -> 10bit
		{
			PQ_RegisterWrite(VIP_reg_dpy_dither, PQ_Panel_10_BITS);
		}
		else if( autoulPanelBits == 3 ) // 36bpp -> 12bit
		{
			PQ_RegisterWrite(VIP_reg_dpy_dither, PQ_Panel_12_BITS);
		}
        }
    }
}


/**
 * @brief Set Dither algorithm
 *
 * This function set the Dither algoritm
 * 2D : regular algoritm (the dither effect of each pixel in each frame will be the same)
 * 3D : involve time difference (the dither effect of each pixel in each frame will be different)
 *
 * @param ucAlgo means type of dither algorithm, can be 0 for 2D, 1 for 3D
 * @note : method 1 control c000[4], method 2 control C344
 * @return n/a
 */
void PQ_DitheringAlgo(UINT8 ucAlgo)
{
    UINT8 ucDitherSel;

    ucDitherSel = PQ_RegisterRead(VIP_reg_dpy_dither_sel);

    if(ucDitherSel) // dither ethod 2
    {
        PQ_RegisterWrite(VIP_reg_dpy_tmp_dither_v2, ucAlgo);
    }
    else //method 1
    {
        PQ_RegisterWrite(VIP_reg_dpy_tmp_dither, ucAlgo);
    }
	
}


//****************************************************************************
//
//   Function   : PQ_AccessColorMatrix
//   Params    : pulData = point of data, AcessMode=Read 0 Write 1, dwDataSize=size of pData
//   Description: Access ColorMatrix for PQ Tool I/O (include brightness, contrast, ColorTemp, Saturation, Hue)
//   Returns    : 0=fail ,1=success
//****************************************************************************
BOOL PQ_AccessColorMatrix(UINT32 *pulData, INT32 AccessMode, UINT32 dwDataSize)
{
	INT32 i;
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	ST_PQ_CMDSET_CLR_MATRIX_EX* pclrMatrix = (ST_PQ_CMDSET_CLR_MATRIX_EX*)pulData;
	BOOL isEx = sizeof(ST_PQ_CMDSET_CLR_MATRIX_EX) == dwDataSize;

	if (AccessMode) //write to TV
	{
		memcpy(pHwContext->CurColorMatrix, &pclrMatrix->curMatrix, sizeof(CSC_SETTING));
		pHwContext->iColorMatrixC1 = pclrMatrix->iMatrixC[0];
		pHwContext->iColorMatrixC2 = pclrMatrix->iMatrixC[1];
		pHwContext->iColorMatrixC3 = pclrMatrix->iMatrixC[2];
		pHwContext->iBrightness = pclrMatrix->iBrightness;
		pHwContext->iContrast = pclrMatrix->iContrast;
		pHwContext->iRGain = pclrMatrix->iCTRGBGain[0];
		pHwContext->iGGain = pclrMatrix->iCTRGBGain[1];
		pHwContext->iBGain = pclrMatrix->iCTRGBGain[2];
		pHwContext->iRBias = pclrMatrix->iCTRGBBias[0];
		pHwContext->iGBias = pclrMatrix->iCTRGBBias[1];
		pHwContext->iBBias = pclrMatrix->iCTRGBBias[2];
		pHwContext->iHue = pclrMatrix->iHue;
		pHwContext->iSaturation = pclrMatrix->iSaturation;

		for (i = 0; i < 9; i++)
			PQ_ColorMatrixSetup(TRUE, i);
		PQ_ColorMatrixComp(TRUE);
	}
	else //read from TV
	{
		memcpy(&pclrMatrix->curMatrix, pHwContext->CurColorMatrix, sizeof(CSC_SETTING));
		pclrMatrix->iMatrixC[0] = pHwContext->iColorMatrixC1;
		pclrMatrix->iMatrixC[1] = pHwContext->iColorMatrixC2;
		pclrMatrix->iMatrixC[2] = pHwContext->iColorMatrixC3;
		pclrMatrix->iBrightness = pHwContext->iBrightness;
		pclrMatrix->iContrast= pHwContext->iContrast;
		pclrMatrix->iCTRGBGain[0] = pHwContext->iRGain;
		pclrMatrix->iCTRGBGain[1] = pHwContext->iGGain;
		pclrMatrix->iCTRGBGain[2] = pHwContext->iBGain;
		pclrMatrix->iCTRGBBias[0] = pHwContext->iRBias;
		pclrMatrix->iCTRGBBias[1] = pHwContext->iGBias;
		pclrMatrix->iCTRGBBias[2] = pHwContext->iBBias;
		pclrMatrix->iHue = pHwContext->iHue;
		pclrMatrix->iSaturation= pHwContext->iSaturation;
		if (isEx)
		{
			pclrMatrix->iOSDGainBit=COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM;
			pclrMatrix->iOSDBiasBit=COLOR_MATRIX_BIAS_OSD_BIT_SYSTEM;
		}
	}
	return TRUE;
}
//****************************************************************************
//
//   Function   : VIP_AcessColorLUT
//   Params    : *pulAddr, AcessMode=Read0Write1, bNew=if 330C's LUT, LUTBlockIndex=330C's LUT EvenOdd Block index
//   Description: set color LUT to VIP or get color LUT from VIP
//   Returns    : 0=fail ,1=success
//****************************************************************************

BOOL PQ_AccessColorLUT(UINT32 *pulAddr, INT32 AccessMode, BOOL bNew, INT32 LUTBlockIndex)
{
	INT32 ColorLUT330C_Block_PointNum[8] = {729, 648, 648, 576, 648, 576, 576, 512}; // 8 block
	INT32 iTableCnt;
	INT32 DataNum = 512; // for 330A
	INT32 DataStartAddr = 0; // for 330A
	if (bNew)
	{
		DataNum = ColorLUT330C_Block_PointNum[LUTBlockIndex]; // for 330C
		DataStartAddr = LUTBlockIndex<<10; // for 330C
	}

	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,DataStartAddr);
	if (1 == AccessMode)
	{
		for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++){
			PQ_RegisterWrite(VIP_reg_dpy_rgn_data, *pulAddr);
		pulAddr++;
		}
	}
	else
	{
		for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++){
			*pulAddr=PQ_RegisterRead(VIP_reg_dpy_rgn_data);
		pulAddr++;
		}
	}
	return TRUE;
}

BOOL PQ_AccessColorLUT64Bit(UINT32 *pulAddr, INT32 AccessMode, BOOL bNew, INT32 LUTBlockIndex)
{
	UINT32 ColorLUT64Bit_Block_PointNum[16] = {640, 640,640, 640, 768, 768,768, 768, 640, 640,640, 640, 768, 768, 768, 768}; // 16 block
	INT32 iTableCnt;
	INT32 DataNum ;
	INT32 DataStartAddr = 0;

	DataNum = ColorLUT64Bit_Block_PointNum[LUTBlockIndex]; 

	if(LUTBlockIndex%2 !=0)
		DataStartAddr = 1024*(LUTBlockIndex-1)+ColorLUT64Bit_Block_PointNum[LUTBlockIndex-1];
	else
		DataStartAddr = LUTBlockIndex<<10;
	
	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,DataStartAddr);

	if (1 == AccessMode)
	{
		for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++){
			*(volatile unsigned long*)(0xbe1cc184)=(*pulAddr);//+0x80);
			pulAddr++;

		}
		if(LUTBlockIndex%2 !=0)
		{
			DataNum= 2048 - (DataNum*2);
			for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++)
			{
				*(volatile unsigned long*)(0xbe1cc184)=0;
			}
		}
	}
	else
	{
		for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++){
			*pulAddr=PQ_RegisterRead(VIP_reg_dpy_rgn_data);
			pulAddr++;
		}
	}
	return TRUE;
}


BOOL PQ_AccessColorLUTV3(UINT32 *pulAddr, INT32 AccessMode, BOOL bNew, INT32 LUTBlockIndex)
{
	UINT32 ColorLUT531_Block_PointNum[8] = {640, 640, 768, 768, 640, 640, 768, 768}; // 8 block
	INT32 iTableCnt;
	INT32 DataNum ;
	INT32 DataStartAddr = 0; // for 330A

	//if (bNew)
	//{
		DataNum = ColorLUT531_Block_PointNum[LUTBlockIndex]; // for 330C
		DataStartAddr = LUTBlockIndex<<10; // for 330C
	//	*(unsigned long*)(0xbe1c0000)=LUTBlockIndex;
	//	*(unsigned long*)(0xbe1c0004)=DataStartAddr;
	//}
	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,DataStartAddr);

	if (1 == AccessMode)
	{
	     // unsigned long tt;
	     // tt=DataNum;

	     // *(volatile unsigned char*)(0xbe1cc6a9)=0;
	  //     msleep(1000);
	      //DataNum=10;
		for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++){
			//PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,iTableCnt);
			*(volatile unsigned long*)(0xbe1cc184)=((*pulAddr));//+0x80);
			pulAddr++;

		}
	//*(unsigned char*)(0xbe1cc6a9)=1;
	//return TRUE;


	//	for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++){
	//		PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,DataStartAddr+iTableCnt);
	//		mytemp=PQ_RegisterRead(VIP_reg_dpy_rgn_data);
	//		if(mytemp!=0x80) tt=0xfff;
	//	}

	//	*(unsigned long*)(0xbe1c0000)=(LUTBlockIndex<<12)+tt;
	//	*(unsigned char*)(0xbe1cc6a9)=1;
	}
	else
	{
		for (iTableCnt=0;iTableCnt<DataNum;iTableCnt++){
			*pulAddr=PQ_RegisterRead(VIP_reg_dpy_rgn_data);
			pulAddr++;
		}
	}
	return TRUE;
}
//****************************************************************************
//
//   Function   : PQ_SetColorLUTStr
//   Params    : *pulAddr
//   Description: set color LUT strength to VIP
//   Returns    : 0=fail ,1=success
//****************************************************************************

BOOL PQ_SetColorLUTStr(UINT16 *pwAddr)
{
	INT32 iTableCnt;

	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,512);

	for (iTableCnt=0;iTableCnt<512;iTableCnt++){
		PQ_RegisterWrite(VIP_reg_dpy_rgn_data, *pwAddr );
		pwAddr++;
	}
	return TRUE;
}

//****************************************************************************
//
//   Function   : PQ_GetColorLUTStr
//   Params    : *pulAddr
//   Description: get color LUT strength from VIP
//   Returns    : 0=fail ,1=success
//****************************************************************************

BOOL PQ_GetColorLUTStr(UINT16 *pwAddr)
{
	INT32 iTableCnt;

	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,512);

	for (iTableCnt=0;iTableCnt<512;iTableCnt++){
		*pwAddr=PQ_RegisterRead(VIP_reg_dpy_rgn_data);
		pwAddr++;
	}
	return TRUE;
}

UINT8 indexi = 0;
void PQ_GetHistBin(UINT32 *Y_Hist)
{
    UINT32 ulHistBin ;
    ulHistBin  = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+indexi*4) << 1;
	*Y_Hist = ulHistBin;
}

void PQ_SetHistBinindex(UINT8 index)
{
	indexi = index;
}

void PQ_GetYavg(UINT32 *Y_AVG)
{
    UINT32 dwTotalPixel = 0;
    UINT32 ulHistBin[16];
	int i;
    for(i = 0; i <16; i++)
    {
        ulHistBin[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
        dwTotalPixel += ulHistBin[i];
    }

    if(dwTotalPixel ==0)
    {
    	*Y_AVG = 0;
    }
	else
	{
    	*Y_AVG = PQ_RegisterRead(VIP_reg_dpy_y_sum)*256 / dwTotalPixel;
	}

}


int PQ_GetYHistOverValueCount(int YValue)
{
	int HistStart=YValue/16;
	int dwTotalPixel = 0;
	int i;
	for(i=HistStart;i<16;i++)
	{
        dwTotalPixel += PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
	}

	return dwTotalPixel;
}


UINT8 PQ_GetAvgY_Value(void)
{
    UINT32 dwTotalPixel = 0;
    UINT32 ulHistBin[16];
	int i;
	UINT8 ucavgY = 0;
	
    for(i = 0; i <16; i++)
    {
        ulHistBin[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
        dwTotalPixel += ulHistBin[i];
    }

    if(dwTotalPixel ==0)
    {
    	ucavgY = 0;
    }
	else
	{
    	ucavgY = PQ_RegisterRead(VIP_reg_dpy_y_sum)*256 / dwTotalPixel;
	}
	
	return ucavgY;
}


//****************************************************************************
//
//   Function   : PQ_ParsePQCmdSet
//   Params    : *pulAddr, data format [size][cmd][data(size UINT8)] = [4bytes][4bytes][nbytes]
//   Description: Parse PQ Command Set. This function will be called by PQ tool, please don't remove it // by ren
//   Returns    : 0=fail ,1=success
//****************************************************************************

BOOL PQ_ParsePQCmdSet(UINT32 *pulAddr)
{

   // MultiPanelHeader_t *MultiPanelHeader = (void *)(SPI_PANELSET_FLASHADDR);
	UINT32 ColorLUT330C_Block_PointNum[8] = {729, 648, 648, 576, 648, 576, 576, 512}; // 8 block
	UINT32 ColorLUT531_Block_PointNum[8] = {640, 640, 768, 768, 640, 640, 768, 768}; // 8 block
	UINT32 ColorLut64Bit_Block_PointNum[16] = {640, 640,640, 640, 768, 768,768, 768, 640, 640,640, 640, 768, 768, 768, 768};
	UINT32 dwTotalSize = pulAddr[0];
	UINT32 dwDataSize = dwTotalSize-8; // 8 = sizeof(Size_DWORD)+sizeof(Cmd_DWORD);
	INT32 Cmd = pulAddr[1]&0xffff;
	INT32 SubCmd = pulAddr[1]>>16;
	UINT32 *pDataSatrt = pulAddr+2;

	switch(Cmd)
	{
	case PQ_CMDSET_GET_RGN_LUT:
		if (0x800 != dwDataSize) return FALSE; // 800 = LUT size(UINT32*8*8*8)
		else
		{
			pulAddr[0] = 0x800; // must fill data size on size colum when get function
			return PQ_AccessColorLUT(pDataSatrt, 0/*Read*/, FALSE, 0);
		}
		break;
	case PQ_CMDSET_SET_RGN_LUT:
		if (0x800 != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill 0 when set funtion
			return PQ_AccessColorLUT(pDataSatrt, 1/*Write*/, FALSE, 0);
		}
		break;
	case PQ_CMDSET_GET_RGN_LUT_STR:
		if (0x400 != dwDataSize) return FALSE; // 400 = LUT Str size(UINT16*8*8*8)
		else
		{
			pulAddr[0] = 0x400; // must fill data size on size colum when get function
			return PQ_GetColorLUTStr((UINT16*)pDataSatrt);
		}
		break;
	case PQ_CMDSET_SET_RGN_LUT_STR:
		if (0x400 != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill 0 when set funtion
			return PQ_SetColorLUTStr((UINT16*)pDataSatrt);
		}
		break;
	case PQ_CMDSET_GET_RGN_LUT_330C:
		if (SubCmd >= 8) return FALSE; // only 0~7 block
		if ((ColorLUT330C_Block_PointNum[SubCmd]*4) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = ColorLUT330C_Block_PointNum[SubCmd]*4; // must fill data size on size colum when get function
			return PQ_AccessColorLUT(pDataSatrt, 0/*Read*/, TRUE, SubCmd);
		}
		break;
	case PQ_CMDSET_SET_RGN_LUT_330C:
		if (SubCmd >= 8) return FALSE; // only 0~7 block
		if ((ColorLUT330C_Block_PointNum[SubCmd]*4) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill 0 when set funtion
			return PQ_AccessColorLUT(pDataSatrt, 1/*Write*/, TRUE, SubCmd);
		}
		break;
	case  PQ_CMDSET_GET_RGN_LUT_V3:
	     //*(unsigned long*)(0xbe1c0000)=0x135;
	     if (SubCmd >= 8) return FALSE; // only 0~7 block
		if ((ColorLUT531_Block_PointNum[SubCmd]*4) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = ColorLUT531_Block_PointNum[SubCmd]*4; // must fill data size on size colum when get function
			return PQ_AccessColorLUTV3(pDataSatrt, 0/*Read*/, TRUE, SubCmd);
		}
	     break;

	case PQ_CMDSET_SET_RGN_LUT_V3:


	    //--------- Set V3 LUT ------------
	    if (SubCmd >= 8)
		{
			*(unsigned long*)(0xbe1c0000)=0x136;
			return FALSE; // only 0~7 block
			}
	 	if ((ColorLUT531_Block_PointNum[SubCmd]*4) != dwDataSize)
		{
			*(unsigned long*)(0xbe1c0000)=dwDataSize;
			*(unsigned long*)(0xbe1c0004)=ColorLUT531_Block_PointNum[SubCmd]*4;
			return FALSE;
			}
		else
		{
			*(unsigned long*)(0xbe1c0000)=0x138;
			pulAddr[0] = 0; // must fill 0 when set funtion
			return PQ_AccessColorLUTV3(pDataSatrt, 1/*Write*/, TRUE, SubCmd);
		}
		break;
	
	case  PQ_CMDSET_GET_RGN_LUT_64Bit:
		if (SubCmd >= 16) return FALSE; // only 0~7 block
		if ((ColorLut64Bit_Block_PointNum[SubCmd]*4) != dwDataSize) return FALSE;
		else
		{
			*(unsigned long*)(0xbe1c0000) = SubCmd;
			pulAddr[0] = ColorLut64Bit_Block_PointNum[SubCmd]*4; // must fill data size on size colum when get function
			return PQ_AccessColorLUT64Bit(pDataSatrt, 0/*Read*/, TRUE, SubCmd);
		}
		 break;

	case PQ_CMDSET_SET_RGN_LUT_64Bit:
	    if (SubCmd >= 16)
		{
			*(unsigned long*)(0xbe1c0000)=0x136;
			return FALSE;
		}
	 	if ((ColorLut64Bit_Block_PointNum[SubCmd]*4) != dwDataSize)
		{
			*(unsigned long*)(0xbe1c0000)=dwDataSize;
			*(unsigned long*)(0xbe1c0004)=ColorLut64Bit_Block_PointNum[SubCmd]*4;
			return FALSE;
		}
		else
		{
			*(unsigned long*)(0xbe1c0000)=0x140;
			pulAddr[0] = 0; // must fill 0 when set funtion
			return PQ_AccessColorLUT64Bit(pDataSatrt, 1/*Write*/, TRUE, SubCmd);
		}
		break;
	case PQ_CMDSET_GET_COLOR_MATRIX:
		if (sizeof(ST_PQ_CMDSET_CLR_MATRIX) != dwDataSize && sizeof(ST_PQ_CMDSET_CLR_MATRIX_EX) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			return PQ_AccessColorMatrix(pDataSatrt, 0/*Read*/, dwDataSize);
		}
		break;
	case PQ_CMDSET_SET_COLOR_MATRIX:
		if (sizeof(ST_PQ_CMDSET_CLR_MATRIX) != dwDataSize && sizeof(ST_PQ_CMDSET_CLR_MATRIX_EX) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill 0 when set funtion
			return PQ_AccessColorMatrix(pDataSatrt, 1/*Write*/, dwDataSize);
		}
		break;

//#ifdef  VIP_SW_DC
#if 1

	case PQ_CMDSET_GET_SW_DC_SCENE_DET_SLOPE:
		if (sizeof(ST_SWDC_Slope) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetSWDCSlopeCmd((ST_SWDC_Slope*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_SET_SW_DC_SCENE_DET_SLOPE:
		if (sizeof(ST_SWDC_Slope) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill 0 when set funtion
			PQ_SetSWDCSlopeCmd((ST_SWDC_Slope*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_GET_SW_DC_SCENE_DET_CHROMA:
		if (sizeof(ST_SWDC_Chroma) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetSWDCChromaCmd((ST_SWDC_Chroma*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_SET_SW_DC_SCENE_DET_CHROMA:
		if (sizeof(ST_SWDC_Chroma) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill 0 when set funtion
			PQ_SetSWDCChromaCmd((ST_SWDC_Chroma*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_GET_SW_DC_SCENE_DET_PARAM:
		if (sizeof(ST_SWDC_Param) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetSWDCParamCmd((ST_SWDC_Param*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_SET_SW_DC_SCENE_DET_PARAM:
		if (sizeof(ST_SWDC_Param) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill data size on size colum when get function
			PQ_SetSWDCParamCmd((ST_SWDC_Param*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_GET_SW_DC_SCENE_DET_INFO:
		if (sizeof(ST_SWDC_Info) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetSWDCInfoCmd((ST_SWDC_Info*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_SET_SW_DC_SCENE_DET_SOURCE:
		if (sizeof(UINT8) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = 0; // must fill data size on size colum when get function
			PQ_SetSWDCSourceCmd((UINT8*)pDataSatrt);
			return TRUE;
		}
		break;
	case PQ_CMDSET_GET_SW_DC_SCENE_DET_SOURCE:
		if (sizeof(UINT8) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetSWDCSourceCmd((UINT8*)pDataSatrt);

			return TRUE;
		}
		break;


#endif

	case PQ_CMDSET_GET_VIP_FLASH_INFO:
		if (sizeof(VIP_FLASH_INFO) < dwDataSize) return FALSE;
		else
		{
			VIP_FLASH_INFO FlashInfo;
			memset(&FlashInfo, 0, sizeof(VIP_FLASH_INFO));

			if (SubCmd) { //get size
				FlashInfo.PANELSET_SHADOWADDR = SPI_PANELSET_FLASHSIZE;
				FlashInfo.VIPTABLE_SHADOWADDR = SPI_VIPTABLE_FLASHSIZE;
				FlashInfo.GAMMATABLE_SHADOWADDR = SPI_GAMMATABLE_FLASHSIZE;
				#ifdef SPI_LOGO_FLASHSIZE
				FlashInfo.LOGO_SHADOWADDR = SPI_LOGO_FLASHSIZE;
				#endif
				#ifdef SPI_COLORLUTTABLE_SHADOWADDR
				FlashInfo.LUTTABLE_SHADOWADDR = SPI_COLORLUTTABLE_FLASHSIZE;
				#endif

			} else { //get addr
				FlashInfo.PANELSET_SHADOWADDR = SPI_PANELSET_SHADOWADDR;
				FlashInfo.VIPTABLE_SHADOWADDR = SPI_VIPTABLE_SHADOWADDR;
				FlashInfo.GAMMATABLE_SHADOWADDR = SPI_GAMMATABLE_SHADOWADDR;
				#ifdef SPI_LOGO_FLASHADDR
				FlashInfo.LOGO_SHADOWADDR = SPI_LOGO_FLASHADDR;
				#endif
				#ifdef SPI_COLORLUTTABLE_SHADOWADDR
				FlashInfo.LUTTABLE_SHADOWADDR = SPI_COLORLUTTABLE_SHADOWADDR;
				#endif
			}
			memcpy(pDataSatrt, &FlashInfo, dwDataSize);
			pulAddr[0] = dwDataSize;
			return TRUE;
		}
    case PQ_CMDSET_GET_DRV_CURRENT_SOURCE:
        if (sizeof(UINT8) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetDrvCurrentSourceCmd((UINT8*)pDataSatrt);

			return TRUE;
		}
        break;
    case PQ_CMDSET_SET_NR_ADJUST_STATUS:
        if (sizeof(UINT8) != dwDataSize)
        {
            return FALSE;
        }
        else
        {
		    VIP_SetStopNRAdjustFlag((BOOL*)pDataSatrt);
		    return TRUE;
        }
        break;
       case PQ_CMDSET_GET_RGB_GAIN_ADJUST_MODULE:
        if (sizeof(UINT8) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetRGBGainAdjustModuleCmd((UINT8*)pDataSatrt);

			return TRUE;
		}
            break;
       case PQ_CMDSET_GET_RGB_GAIN_PARAM:
		if (sizeof(RGB_GAIN) != dwDataSize) return FALSE;
		else
		{
			pulAddr[0] = dwDataSize; // must fill data size on size colum when get function
			PQ_GetRGBGainParamCmd((RGB_GAIN*)pDataSatrt);
			return TRUE;
		}
		break;      
	default:
		return FALSE;
	}
    return FALSE;
}

//dpy peaking filter is required to reference to scalling factor
void PQ_PeakingFilterSetup(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    PEAKING_SETTING *pPeaking;
    PEAKING_SETTING_EXT *pPeakingExt;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
    if (pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex] >= 8) return;

    ucTableIndex = pVtab->mPeaking.mGroupedIndex[ucCurrSrcIndex];

    #ifdef CONFIG_SUPPORT_TCON //#51239
    if((((DRV_SLR_GetFactor_HFactor())*(DRV_SLR_GetFactor_HFactor_6HV())*100)/(2048*2048))>90 &&( !VIP_RunDVIMode()))
    #else
    if((((DRV_SLR_GetFactor_HFactor())*(DRV_SLR_GetFactor_HFactor_6HV())*100)/(2048*2048))>90)
    #endif    
    {
        pPeaking= &pVtab->mPeaking.mPeaking_Data[ucTableIndex].Peaking[2];
        pPeakingExt = &pVtab->mPeakingExt[ucTableIndex].Peaking[2];
    }
    else if(VIP_GetInputVSize() >= 1000)	//1080
    {
        pPeaking= &pVtab->mPeaking.mPeaking_Data[ucTableIndex].Peaking[2];
        pPeakingExt = &pVtab->mPeakingExt[ucTableIndex].Peaking[2];
    }
    else if(VIP_GetInputVSize() >= 700) 	//720
    {
        pPeaking= &pVtab->mPeaking.mPeaking_Data[ucTableIndex].Peaking[1];
        pPeakingExt = &pVtab->mPeakingExt[ucTableIndex].Peaking[1];
    }
    else
    {
        pPeaking= &pVtab->mPeaking.mPeaking_Data[ucTableIndex].Peaking[0];
        pPeakingExt = &pVtab->mPeakingExt[ucTableIndex].Peaking[0];
    }

    PQDebugPrint("%s: filter=%d %d %d %d",__FUNCTION__, pPeaking->filter_y_h1, pPeaking->filter_y_h2, pPeaking->filter_y_h3, pPeaking->filter_y_h4);
	
    if(PQ_GetNotFullScreenPatchStatus() == TRUE)//patch for 131, reove while HW fix it
    {
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, pPeaking->filter_y_h1);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, pPeaking->filter_y_h2);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, pPeaking->filter_y_h3);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, pPeaking->filter_y_h4);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h5, pPeakingExt->filter_y_h5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h6, pPeakingExt->filter_y_h6);
    
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, 0);

        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h6, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h6, 0);
    }
    else if (VIP_RunDVIMode() && VIP_GetInputHSize()==1360 && VIP_GetInputVSize()==768)
    {
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, 0x80);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, 0x20);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, 0x0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, 0x0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, 0x80);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, 0x20);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, 0x0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, 0x0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, 0x80);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, 0x20);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, 0x0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, 0x0);
    }
    else if(VIP_Jpeg_GetDisplayMode() == VIP_THUMBNAIL&& VIP_GetInputVSize() >= 768)
    {
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, 0x80);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, 0x20);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h6, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, 0x80);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, 0x20);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, 0x80);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, 0x20);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h6, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h6, 0);
    }
    #ifdef CONFIG_CSOT_ST3151A05_C
    else if(VIP_GetUserSource() == SOURCE_EXTS && ((DRV_SLR_GetFactor_HFactor() == 0xacd && DRV_SLR_GetFactor_HFactor_6HV() == 0x800) 
        ||(DRV_SLR_GetFactor_HFactor() == 0x800 && DRV_SLR_GetFactor_HFactor_6HV() == 0x5ff)))
    {
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, 0x778);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, 0x3a);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, 0x7f5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, 0x5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_y_h6, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, 0x778);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, 0x3a);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, 0x7f5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, 0x5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, 0x778);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, 0x3a);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, 0x7f5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, 0x5);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h6, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h5, 0);
        PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h6, 0);
    }
    #endif
    else
    {
        if(pHwContext->PqPatch.DpyPeakingPatch == DPY_PEAKING_AV_IRE_PATCH || pHwContext->PqPatch.DpyPeakingPatch == DPY_PEAKING_AV_GRAYSCALE_PATCH)        
        {
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h5, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h6, 0);

            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h5, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h6, 0);

            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h5, 0);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h6, 0);
            
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, pPeaking->filter_y_h1);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, pPeaking->filter_y_h2);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, pPeaking->filter_y_h3);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, pPeaking->filter_y_h4);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h5, pPeakingExt->filter_y_h5);
            PQ_RegisterWrite(VIP_reg_dpy_filter_y_h6, pPeakingExt->filter_y_h6);

            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, pPeaking->filter_y_h1);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, pPeaking->filter_y_h2);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, pPeaking->filter_y_h3);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, pPeaking->filter_y_h4);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h5, pPeakingExt->filter_y_h5);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h6, pPeakingExt->filter_y_h6);

            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, pPeaking->filter_y_h1);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, pPeaking->filter_y_h2);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, pPeaking->filter_y_h3);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, pPeaking->filter_y_h4);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h5, pPeakingExt->filter_y_h5);
            PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h6, pPeakingExt->filter_y_h6);
        }     
        
    }

}


void PQ_SetMotionThreshold(void)
{
	//for # 50126 : fix sawtooth issue 
	if(VIP_GetUserSource()==SOURCE_HDMI && VIP_GetInputVSize()==576 && VIP_GetInterlaceMode())
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_lmot_thd,0x13);
		PQ_RegisterWrite(VIP_reg_vdi_mad_mot_pthd,0x3c);
		PQ_RegisterWrite(VIP_reg_vdi_mad_hmot_lthd,0x88);
		PQ_RegisterWrite(VIP_reg_vdi_mad_mmot_lthd,0x68);
	}
	else if(VIP_IsAVSource() && (VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK && VIP_GetStdColorSystem() <= CVD2_STD_PAL_60))
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_lmot_thd,0x13);
		PQ_RegisterWrite(VIP_reg_vdi_mad_mot_pthd,0x3c);
		PQ_RegisterWrite(VIP_reg_vdi_mad_hmot_lthd,0x88);
		PQ_RegisterWrite(VIP_reg_vdi_mad_mmot_lthd,0x68);
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_lmot_thd,0xC);
		PQ_RegisterWrite(VIP_reg_vdi_mad_mot_pthd,0x20);
		PQ_RegisterWrite(VIP_reg_vdi_mad_hmot_lthd,0x60);
		PQ_RegisterWrite(VIP_reg_vdi_mad_mmot_lthd,0x40);
	}
}

//================================================================================
//	function name		: PQ_FilterSetup
//	input parameter	: ucSource,ucSubSource,cInterlaceMode
//	output parameter	: none
//	purpose			: setup mesh filter and icp filter
//   return			: none
void PQ_FilterSetup(UINT8 ucSource, UINT8 ucSubSource)
{

	typedef struct _REG
	{
		UINT32 hds, hde, vds, vde;
	}REG;

	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT8 ucDisableICP,i;
	PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
	REG LowMbwReg[3];
	UINT32  tmp;
	//ucDisableICP= (pHwContext->cInterlaceMode==FALSE && ucSource!=SOURCE_MPEG) ||
	//			(ucSource==SOURCE_PATTERN) ||
	//			(ucSource==SOURCE_JPEG) ||
	//			(ucSource==SOURCE_EXTS && ucSubSource==RGB);
	//CJ changed rule at 2009/06/24
	//ICP function For p338, p358 :
	//1. ATV :
	//UINT8 0xbe1cd0b0 0x1          ------------- enable
	//UINT16 0xbe1cd0b4 0x100   ------------- alpha
	//2. PC,   ADI Pattern  :
	//UINT8 0xbe1cd0b0 0x0
	//3. Others: (interlace and progressive)
	//UINT8 0xbe1cd0b0 0x1
	//UINT16 0xbe1cd0b4 0x200
	//
	ucDisableICP= 	(ucSource==SOURCE_PATTERN) ||
		      	(ucSource==SOURCE_JPEG) ||
				(ucSource==SOURCE_EXTS && ucSubSource==RGB); //990924 hdhi-rgb needs mesh filter to remove for PQ request
				//|| (pHwContext->cInputDataFormat==RGB); //pc, dvi or hdmi-rgb

       //dpy peaking filter is required to reference to scalling factor
	PQ_PeakingFilterSetup();
	PQ_DeinterlaceFilter();

	if( ucDisableICP )
	{
		PQ_RegisterWrite(VIP_reg_slr_mesh_filter_en, 0);
		PQ_RegisterWrite(VIP_reg_slr_icp_fix_en, 0);
	}
	else
	{
	    if(ucSource==SOURCE_HDMI||ucSource==SOURCE_MPEG)
	    {
	        PQ_RegisterWrite(VIP_reg_slr_mesh_filter_en, 3);
	    }
        else if(ucSource==SOURCE_CVD2 || (VIP_GetUserSource() == EXTS && (VIP_GetInputVSize() < 500)))
        {
            //fix roof scene not clear in av & atv
            PQ_RegisterWrite(VIP_reg_slr_mesh_filter_en, 2);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_slr_mesh_filter_en, 1);
        }
		PQ_RegisterWrite(VIP_reg_slr_icp_fix_en, 1);
		PQ_RegisterWrite(VIP_reg_slr_mesh_filter_expand, 4);
		PQ_RegisterWrite(VIP_reg_slr_mesh_filter_ver_expand, 1);
		PQ_RegisterWrite(VIP_reg_slr_comb_th_1_nom, 0);
		PQ_RegisterWrite(VIP_reg_slr_comb_slope_1_nom, 1023);
		PQ_RegisterWrite(VIP_reg_slr_comb_min_nom, 4);
		PQ_RegisterWrite(VIP_reg_slr_comb_th_2_nom, 48);
		PQ_RegisterWrite(VIP_reg_slr_comb_slope_2_nom, 28);
		if(ucSource == CVD2)
			PQ_RegisterWrite(VIP_reg_slr_comb_th_nom, 0x2);//0xa);//20111228 request from Bonnie
		else if( ucSource == EXTS && !VIP_IsPCSource())
			PQ_RegisterWrite(VIP_reg_slr_comb_th_nom,0x3); //4);//20111228 request from Bonnie
		else
			PQ_RegisterWrite(VIP_reg_slr_comb_th_nom, 3);
		PQ_RegisterWrite(VIP_reg_slr_comb_th_1_mesh, 0);
		PQ_RegisterWrite(VIP_reg_slr_comb_slope_1_mesh, 1023);
		PQ_RegisterWrite(VIP_reg_slr_comb_min_mesh, 0);
		PQ_RegisterWrite(VIP_reg_slr_comb_th_2_mesh, 48);
	    PQ_RegisterWrite(VIP_reg_slr_comb_slope_2_mesh, 28);
	    PQ_RegisterWrite(VIP_reg_slr_comb_th_mesh, 3);
	    PQ_RegisterWrite(VIP_reg_slr_icp_fix_expand, 4);

		if(VIP_GetUserSource() == CVD2 || (VIP_GetUserSource() == EXTS && (!VIP_IsPCSource())))
			PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th, 9);	//111114:show modify
		else
			PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th, 0);


		if(VIP_GetUserSource()==SOURCE_HDMI)
		{
			PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_h, 256);
		}
		else if(VIP_IsATVSource()==1)
		{
			PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_h, 10);
		}
		else
		{
			PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_h, ((VIP_GetUserSource() == CVD2) && !VIP_IsATVSource())?10:310);
		}

		if ( ( ucSource == HDMI && !VIP_RunDVIMode()) || ucSource == MPEG )//|| ( ucSource == EXTS && !pHwContext->bPCSource) )
		{
			if (abs(VIP_GetInputVSize() - 480) < 15 || abs(VIP_GetInputVSize() - 576) < 15 )
			{
				PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_h, 0xa);
			}
		}
		else if( ucSource == EXTS && !VIP_IsPCSource())
			PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_h, 0xa);
		PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_v, 48);
		PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_hv, 48);
		PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor, 8);
		PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_h, 48);
		PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_v, 8);
		PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_hv, 8);
		PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_h_inc, 8);

		if ( VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource() && VIP_GetInputVSize() > 700 ) 
		{
			PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_option, 0x0); //40861
		}
	}

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th, 9);
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_h, 0xf);
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_v, 0x5a);
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_hv, 0x5a);

	PQ_RegisterWrite(VIP_reg_slr_icp_th, 2);
	PQ_SLR_ColorBarDetailSet();
	PQ_DSSetting();
	PQ_Sharpness(TRUE, pMenuValue->iSharpness); // 20110929 shanlene

	//low angle disable and BMBW disable  for 9561
	PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn1_en,0);
	PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn2_en,0);
	PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn3_en,0);
	PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn1_en, 0);
	PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn2_en, 0);
	PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn3_en, 0);
	PQ_RegisterWrite(VIP_reg_slr_mbw_en,1);

	LowMbwReg[0].hds = 0xf;
	LowMbwReg[0].hde = 0x55;
	LowMbwReg[0].vds = 0xa;
	LowMbwReg[0].vde = 0x1a4;
	LowMbwReg[1].hds = 0x5;
	LowMbwReg[1].hde = VIP_GetScalerPreScaleH();
	LowMbwReg[1].vds = 0x19a;
	LowMbwReg[1].vde = 0x1bd;
	LowMbwReg[2].hds = 0x5;
	LowMbwReg[2].hde = VIP_GetScalerPreScaleH();
	LowMbwReg[2].vds = 0x2;
	LowMbwReg[2].vde = 0x3c;


	if(ucSource == CVD2 && VIP_IsATVSource() )
	{

    	VTAB_CMN_VALUE_DEFINE* pVtabCmnValue= &pHwContext->VtabCmnValue;
		UINT32 selectRigester = pVtabCmnValue->SlrLowAngleOrMBWDisable;

		PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn1_en,1);
		PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn2_en,1);
		PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn3_en,1);

		PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn1_en, 0);
		PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn2_en, 0);
		PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn3_en, 0);

		if(!PQ_NtscPalDetect()){
			//PAL
			LowMbwReg[0].vde = 0x230;
			LowMbwReg[1].hds = 0x2;
			LowMbwReg[1].vde = 0x2bc;
			LowMbwReg[1].vds = 0x1f4;
			LowMbwReg[1].vde = 0x230;
			LowMbwReg[2].hds = 0x2;
			/*
			PQ_RegisterWrite(VIP_reg_slr_low_dis1_vde, 0x230);
			PQ_RegisterWrite(VIP_reg_slr_low_dis2_hds, 0x02);
			PQ_RegisterWrite(VIP_reg_slr_low_dis2_hde, 0x2BC);
			PQ_RegisterWrite(VIP_reg_slr_low_dis2_vds, 0x1F4);
			PQ_RegisterWrite(VIP_reg_slr_low_dis2_vde, 0x230);
			PQ_RegisterWrite(VIP_reg_slr_low_dis3_hds, 0x02);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis1_vde, 0x230);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis2_hds, 0x02);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis2_hde, 0x2BC);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis2_vds, 0x1F4);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis2_vde, 0x230);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis3_hds, 0x02);
			*/
		}


		PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn1_en, (0x1 == (selectRigester&0x1)) ? 1 : 0);
		PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn2_en, (0x2 == (selectRigester&0x2)) ? 1 : 0);
		PQ_RegisterWrite(VIP_reg_slr_low_dis_rgn3_en, (0x4 == (selectRigester&0x4)) ? 1 : 0);
		PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn1_en, (0x8 == (selectRigester&0x8))? 1 : 0);
		PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn2_en, (0x10 == (selectRigester&0x10)) ? 1 : 0);
		PQ_RegisterWrite(VIP_reg_slr_mbw_dis_rgn3_en, (0x20 == (selectRigester&0x20)) ? 1 : 0);


#if VIP_FLIP_FUN
		if(VIP_GetPanelInvert())
		{
			for(i=0;i<3;i++)
			{
				tmp = LowMbwReg[i].hds;
				LowMbwReg[i].hds = VIP_GetScalerPreScaleH()- LowMbwReg[i].hde;
				LowMbwReg[i].hde = VIP_GetScalerPreScaleH()- tmp;
				tmp = LowMbwReg[i].vds;
				LowMbwReg[i].vds = VIP_GetScalerPreScaleV()- LowMbwReg[i].vde;
				LowMbwReg[i].vde = VIP_GetScalerPreScaleV()- tmp;
			}
		}
#endif

		for(i = 0;i <3 ; i++)
		{
			PQ_RegisterWrite(VIP_reg_slr_low_dis1_hds + i*16, LowMbwReg[i].hds);
			PQ_RegisterWrite(VIP_reg_slr_low_dis1_hde + i*16, LowMbwReg[i].hde);
			PQ_RegisterWrite(VIP_reg_slr_low_dis1_vds + i*16, LowMbwReg[i].vds);
			PQ_RegisterWrite(VIP_reg_slr_low_dis1_vde + i*16, LowMbwReg[i].vde);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis1_hds + i*16, LowMbwReg[i].hds);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis1_hde + i*16, LowMbwReg[i].hde);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis1_vds + i*16, LowMbwReg[i].vds);
			PQ_RegisterWrite(VIP_reg_slr_mbw_dis1_vde + i*16, LowMbwReg[i].vde);
		}

        PQ_RegisterWrite(VIP_reg_vdi_mad_fc_mbw_lth, 0x100);//fix roof scene not clarity in av

	}
    else
    {
        PQ_RegisterWrite(VIP_reg_vdi_mad_fc_mbw_lth, 0x10);//fix roof scene not clarity
    }
    
	if(abs(VIP_GetInputVSize())<10 && VIP_GetInterlaceMode()) //sharlene //PQ2009 ��r���ʴ��u
	{
		PQ_RegisterWrite(VIP_reg_slr_mix_mbw_limit, 0x8);
	}
	else if(ucSource==SOURCE_HDMI && VIP_GetInputVSize()==576 && VIP_GetInterlaceMode())
	{
		PQ_RegisterWrite(VIP_reg_slr_mix_mbw_limit, 0x1);
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_slr_mix_mbw_limit, 0x4);
	}

#if 1 //130903 sony_PQ_PAL P#73 move mesh for atv
	PQ_RegisterWrite(VIP_reg_slr_mix_edge_ach, 2);
	PQ_RegisterWrite(VIP_reg_slr_mix_acv, 4);
	PQ_RegisterWrite(VIP_reg_slr_mix_edge_bch, 2);
	PQ_RegisterWrite(VIP_reg_slr_mbw_expand_sel, 1);
#else
	PQ_RegisterWrite(VIP_reg_slr_mix_edge_ach, VIP_IsATVSource()?3:2);
	PQ_RegisterWrite(VIP_reg_slr_mix_acv, VIP_IsATVSource()?1:4);
	PQ_RegisterWrite(VIP_reg_slr_mix_edge_bch, VIP_IsATVSource()?3:2);
	PQ_RegisterWrite(VIP_reg_slr_mbw_expand_sel, VIP_IsATVSource()?3:1);
#endif
	PQ_SetMotionThreshold();
	PQ_LowAngleSetting();

}


void PQ_LowAngleSetting(void)
{
	PQ_RegisterWrite(VIP_reg_slr_mix_sad0_factor			,32);
	PQ_RegisterWrite(VIP_reg_slr_mix_sad1_factor			,64);
	PQ_RegisterWrite(VIP_reg_slr_mix_ext_angle_en			,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_diff_value		,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_en 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_th 	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle90_aug_th		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle90_aug_limit 	,36);
	PQ_RegisterWrite(VIP_reg_slr_mix_hedge_th				,40);
	PQ_RegisterWrite(VIP_reg_slr_mix_no_favor_angle90_en	,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_sad_diff_th1			,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_sad_diff_th2			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_dir90_diff_th 		,10);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_th				,20);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_num_th			,8);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_angle_th		,21);
	PQ_RegisterWrite(VIP_reg_slr_mix_detail_hedge_en		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_detail_hedge_clipth	,64);
	PQ_RegisterWrite(VIP_reg_slr_mix_high_angle_th 		,5);
	PQ_RegisterWrite(VIP_reg_slr_mix_low_angle_th			,21);
	PQ_RegisterWrite(VIP_reg_slr_mix_dir_conflict_en		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_conflict_mth			,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_good_dir_th1			,80);
	PQ_RegisterWrite(VIP_reg_slr_mix_good_dir_th2			,50);
	PQ_RegisterWrite(VIP_reg_slr_mix_check_angle_th		,8);
	PQ_RegisterWrite(VIP_reg_slr_mix_smooth_check_en		,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_forward_com_en		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_forward_com_stage 	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_fc_lost_angle_th1 	,100);
	PQ_RegisterWrite(VIP_reg_slr_mix_fc_lost_angle_th2 	,20);
	PQ_RegisterWrite(VIP_reg_slr_mix_fc_lost_angle_th3 	,48);
	PQ_RegisterWrite(VIP_reg_slr_mix_fc_hedge_th			,48);
	PQ_RegisterWrite(VIP_reg_slr_mix_backward_com_en		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_backward_com_stage	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_bc_lost_angle_th1 	,120);
	PQ_RegisterWrite(VIP_reg_slr_mix_bc_lost_angle_th2 	,50);
	PQ_RegisterWrite(VIP_reg_slr_mix_bc_lost_angle_th3 	,36);
	PQ_RegisterWrite(VIP_reg_slr_mix_bc_hedge_th			,48);
	PQ_RegisterWrite(VIP_reg_slr_mix_median_filter_mth 	,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_col_size				,720);
	PQ_RegisterWrite(VIP_reg_slr_mix_dir_diff_th			,36);
	PQ_RegisterWrite(VIP_reg_slr_mix_big_dir_diff_th		,80);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_01			,7);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_02			,8);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_03			,9);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_04			,10);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_05			,11);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_06			,12);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_07			,13);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_08			,14);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_09			,15);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_10			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_11			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_12			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_13			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_14			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_15			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_16			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_17			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_18			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_19			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_20			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_21			,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_store_post_en 		,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_nan_en				,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_ana_en				,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_hlh_en				,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_eup					,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_edn					,16);
	PQ_RegisterWrite(VIP_reg_slr_mix_center_com_en 		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_center_com_stage		,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_cnf_win5				,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_detail_hedge_win		,6);
	PQ_RegisterWrite(VIP_reg_slr_mix_fix_ccom_a90_en		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_fix_ccom_a90_th		,32);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_sel_sub 		,1048575);

	//for atv ���\����issue  low angle adjust to 0xff from hw suggest
	if(VIP_IsATVSource())
		PQ_RegisterWrite(VIP_reg_slr_mix_angle_sel_main		,0xff);
	else 
		PQ_RegisterWrite(VIP_reg_slr_mix_angle_sel_main		,1048575);
	
	PQ_RegisterWrite(VIP_reg_slr_mix_lr_dec_en 			,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_chk_confidence_en 	,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_last_2n1a_en			,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_last_5n3a_en			,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_00 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_01 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_02 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_03 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_04 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_05 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_06 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_07 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_08 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_09 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_10 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_11 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_12 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_13 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_14 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_15 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_16 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_17 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_18 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_19 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_angle_distance_20 	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_en		,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_th2		,10);
	PQ_RegisterWrite(VIP_reg_slr_mix_invalid_la_th1		,1);
	PQ_RegisterWrite(VIP_reg_slr_mix_invalid_la_th2		,5);
	PQ_RegisterWrite(VIP_reg_slr_mix_chroma_diff_th1		,24);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_01_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_02_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_03_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_04_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_05_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_06_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_07_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_08_th1	,2);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_09_th1	,3);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_10_th1	,3);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_11_th1	,3);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_12_th1	,3);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_13_th1	,3);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_14_th1	,4);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_15_th1	,4);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_16_th1	,4);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_17_th1	,5);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_18_th1	,5);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_19_th1	,5);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_20_th1	,5);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_dis_en	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_dis_th1	,3);
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_dis_th2	,96);
	PQ_RegisterWrite(VIP_reg_slr_mix_dir_diff_th2			,50);
	PQ_RegisterWrite(VIP_reg_slr_mix_big_dir_diff_th2		,100);
	PQ_RegisterWrite(VIP_reg_slr_mix_dir_diff_bound		,6);	//*((BYTE*)(0xbe1cd388)) = 6;
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_en_hw 	,1);	//*((BYTE*)(0xbe1cd389)) = 1;
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_en_th 	,50);	//*((BYTE*)(0xbe1cd38a)) = 50;
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_en_th2	,1);	//*((BYTE*)(0xbe1cd38b)) = 1;
	PQ_RegisterWrite(VIP_reg_slr_mix_break_angle_en_win	,5);	//*((BYTE*)(0xbe1cd38c)) = 5;
	PQ_RegisterWrite(VIP_reg_slr_mix_sad2_factor			,32);	//*((BYTE*)(0xbe1cd38d)) = 32;
	PQ_RegisterWrite(VIP_reg_slr_mix_sad3_factor			,16);	//*((BYTE*)(0xbe1cd38e)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sad4_factor			,16);	//*((BYTE*)(0xbe1cd38f)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sad5_factor			,16);	//*((BYTE*)(0xbe1cd390)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sad6_factor			,16);	//*((BYTE*)(0xbe1cd391)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sad7_factor			,16);	//*((BYTE*)(0xbe1cd392)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sad8_factor			,16);	//*((BYTE*)(0xbe1cd393)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx01_factor 		,0);	//*((BYTE*)(0xbe1cd394)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx02_factor 		,0);	//*((BYTE*)(0xbe1cd395)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx03_factor 		,16);	//*((BYTE*)(0xbe1cd396)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx04_factor 		,16);	//*((BYTE*)(0xbe1cd397)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx05_factor 		,12);	//*((BYTE*)(0xbe1cd398)) = 12;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx06_factor 		,12);	//*((BYTE*)(0xbe1cd399)) = 12;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx07_factor 		,8);	//*((BYTE*)(0xbe1cd39a)) = 8;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx08_factor 		,8);	//*((BYTE*)(0xbe1cd39b)) = 8;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx09_factor 		,4);	//*((BYTE*)(0xbe1cd39c)) = 4;
	PQ_RegisterWrite(VIP_reg_slr_mix_sadx10_factor 		,4);	//*((BYTE*)(0xbe1cd39d)) = 4;
	PQ_RegisterWrite(VIP_reg_slr_low_angle_dis 			,255);	//*((BYTE*)(0xbe1cd39e)) = 255;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada01_factor 		,16);	//*((BYTE*)(0xbe1cd39f)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada02_factor 		,16);	//*((BYTE*)(0xbe1cd3a0)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada03_factor 		,32);	//*((BYTE*)(0xbe1cd3a1)) = 32;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada04_factor 		,32);	//*((BYTE*)(0xbe1cd3a2)) = 32;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada05_factor 		,16);	//*((BYTE*)(0xbe1cd3a3)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada06_factor 		,16);	//*((BYTE*)(0xbe1cd3a4)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada07_factor 		,16);	//*((BYTE*)(0xbe1cd3a5)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada08_factor 		,16);	//*((BYTE*)(0xbe1cd3a6)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada09_factor 		,16);	//*((BYTE*)(0xbe1cd3a7)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada10_factor 		,16);	//*((BYTE*)(0xbe1cd3a8)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada11_factor 		,16);	//*((BYTE*)(0xbe1cd3a9)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada12_factor 		,16);	//*((BYTE*)(0xbe1cd3aa)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada13_factor 		,16);	//*((BYTE*)(0xbe1cd3ab)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada14_factor 		,16);	//*((BYTE*)(0xbe1cd3ac)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada15_factor 		,16);	//*((BYTE*)(0xbe1cd3ad)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada16_factor 		,16);	//*((BYTE*)(0xbe1cd3ae)) = 16;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada17_factor 		,32);	//*((BYTE*)(0xbe1cd3af)) = 32;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada18_factor 		,32);	//*((BYTE*)(0xbe1cd3b0)) = 32;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada19_factor 		,32);	//*((BYTE*)(0xbe1cd3b1)) = 32;
	PQ_RegisterWrite(VIP_reg_slr_mix_sada20_factor 		,32);	//*((BYTE*)(0xbe1cd3b2)) = 32;
	PQ_RegisterWrite(VIP_reg_slr_min_sad_sft				,0);	//*((BYTE*)(0xbe1cd3b3)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_01		,0);	//*((DWORD*)(0xbe1cd3b4)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_02		,0);	//*((DWORD*)(0xbe1cd3b8)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_03		,0);	//*((DWORD*)(0xbe1cd3bc)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_04		,0);	//*((DWORD*)(0xbe1cd3e0)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_05		,0);	//*((DWORD*)(0xbe1cd3e4)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_06		,0);	//*((DWORD*)(0xbe1cd3e8)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_07		,0);	//*((DWORD*)(0xbe1cd3ec)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_08		,0);	//*((DWORD*)(0xbe1cd3f0)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_09		,0);	//*((DWORD*)(0xbe1cd3f4)) = 0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_10		,0xa);	//*((DWORD*)(0xbe1cd3f8)) = 0xa;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_11		,0x14); //*((DWORD*)(0xbe1cd3fc)) = 0x14;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_12		,0x28); //*((DWORD*)(0xbe1cd430)) = 0x28;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_13		,0x50); //*((DWORD*)(0xbe1cd434)) = 0x50;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_14		,0xa0); //*((DWORD*)(0xbe1cd438)) = 0xa0;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_15		,0x140);	//*((DWORD*)(0xbe1cd43c)) = 0x140;
	PQ_RegisterWrite(VIP_reg_slr_mix_max_sad_add_16		,0x258);	//*((DWORD*)(0xbe1cd450)) = 0x258;

	PQ_RegisterWrite(VIP_reg_la_flat_length_max			,0x10); 	//*((DWORD*)(0xbe1cd929)) = 0x10;
	PQ_RegisterWrite(VIP_reg_slr_la_sad_maxh			,0x60); 	//*((DWORD*)(0xbe1cd92d)) = 0x60;
}


void PQ_ConditionSetting(UINT8 ucMode)
{
    ///////////////////////////////////////////////////////////
    // From MAD Setup on 7 Places
    ///////////////////////////////////////////////////////////
    PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 0x1);
    PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_slope1, 0x10);
    PQ_RegisterWrite(VIP_reg_slr_mix_mbw_max_th, 0x0);
    PQ_RegisterWrite(VIP_reg_vdi_mad_tpcw_xoff, 0xa);
    PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 0x5);
    PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1s,0x8);
    PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 13);
    PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2s,0x18);
		
    if(VIP_GetUserSource()==SOURCE_MPEG && VIP_GetInputHSize()<800 && VIP_GetInterlaceMode())
    {
        // for eric request to improve the sd quality like mantis  43324
        PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 0);

        // # 48358 : fix flicker issue fro AV source
        PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_slope1, 0x2);
        PQ_RegisterWrite(VIP_reg_slr_mix_mbw_max_th, 0x2);

        // NTSC building horizontal line flicker issue  #45589	
        PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 0);
        PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 8);
    }
    else if(VIP_IsAVSource() || VIP_IsATVSource())
    {
        // for eric request to improve the sd quality like mantis  43324
        PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 0);

        // # 48358 : fix flicker issue fro AV source
		if(PQ_GetMotionStatusByMethod2())
		{
    	    PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_slope1, 0x2);
	        PQ_RegisterWrite(VIP_reg_slr_mix_mbw_max_th, 0x2);
		}

        if(VIP_GetStdColorSystem() <= CVD2_STD_NTSC_443)
        {
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 5);
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 9);
        }
        else if(VIP_GetStdColorSystem() <= CVD2_STD_PAL_60)
        {
            //for # 50126 : fix sawtooth issue 
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpcw_xoff,0x6);
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1s, 4);
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 4);
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2s,0x10);
            // for #51046 : fix white noise point 
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_yoff2, 4);
        }
        else
        {		
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 0);
            PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 8);
        }
    }
    else if(VIP_GetUserSource()==SOURCE_HDMI && (VIP_GetInputVSize() <= (480+24))) 
    {
               // for Toshiba3 chapter 7 issue
	        PQ_RegisterWrite(VIP_reg_slr_mix_mbw_max_th, 0x2);   	
    }

    ///////////////////////////////////////////////////////////
    // From FilterSetup ach on 6 places, bch on 2 places
    ///////////////////////////////////////////////////////////

}


void PQ_VDeblockFilterEnable(void)
{
    if(VIP_IsATVSource() || ((VIP_GetUserSource()==SOURCE_HDMI || VIP_GetUserSource() == SOURCE_EXTS) && VIP_GetInterlaceMode() && (VIP_GetInputVSize() < 600)))
       	PQ_RegisterWrite(VIP_reg_vdi_block_vfil_en, 0);
	else
		PQ_RegisterWrite(VIP_reg_vdi_block_vfil_en, 1);
}


BOOL PQ_NtscPalDetect(void)
{
	BOOL bNtscMode= FALSE;
	UINT8 ucSource,ucNtscPalStatus= 0;
	UINT32 Hin_total,Vin_total;
	UINT32 InputFrameRate= 0;

	ucSource=VIP_GetUserSource();

	switch (ucSource){
		case SOURCE_HDMI:
			ucNtscPalStatus=PQ_RegisterRead(VIP_sta_hdmi_frmrate);
			break;
		case SOURCE_MPEG:
			ucNtscPalStatus=PQ_RegisterRead(VIP_sta_mpga_frmrate);
			break;
		case SOURCE_CVD2:
			ucNtscPalStatus=PQ_RegisterRead(VIP_sta_cvd2_frmrate);
			break;
		case SOURCE_EXTS:
			ucNtscPalStatus=PQ_RegisterRead(VIP_sta_exts_frmrate);
			break;
	}

	//PQDebugPrint("ucNtscPalStatus=%d", ucNtscPalStatus);

	if( ucNtscPalStatus==1 || ucNtscPalStatus==2 ) //50Hz
	{
		bNtscMode= FALSE;
	}
	else if( ucNtscPalStatus==4 || ucNtscPalStatus==5 ) //60Hz
	{
		bNtscMode= TRUE;
	}
	else
	{
		VIP_GetSyncLatchCount(DRV_ADI_GetSourceSelect(), &Hin_total, &Vin_total);
		if( (Hin_total>0) && (Vin_total>0) )
			InputFrameRate=((SYSTEM_CLK)/(Hin_total*Vin_total));
		if((abs(60-InputFrameRate)<5)/*||(InputFrameRate<44)*/)
			bNtscMode=TRUE;
		else
			bNtscMode=FALSE;
	}


	PQDebugPrint("%s bNtscMode=%d", __FUNCTION__,bNtscMode);
	return bNtscMode;
}

void PQ_DS_Init(void)
{

	PQ_RegisterWrite(VIP_reg_slr_ds_full_angle, 0);
	PQ_RegisterWrite(VIP_reg_slr_dscale_cross_shoot_ctrl_taps, 1);
	PQ_RegisterWrite(VIP_reg_slr_dscale_other_shoot_ctrl_taps, 1);
	PQ_RegisterWrite(VIP_reg_slr_dscale_cross_shoot_ctrl_taps_c, 2);
	PQ_RegisterWrite(VIP_reg_slr_dscale_other_shoot_ctrl_taps_c, 2);
	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_gain_ctrl_en, 1);
	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_gain_ctrl_tap, 0);
	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_gain_ctrl_en_c, 1);
	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_gain_ctrl_tap_c, 0);
	PQ_RegisterWrite(VIP_reg_slr_motion_cond, 4);
	PQ_RegisterWrite(VIP_reg_slr_h_salt_fil_en  ,0x0);
}

void PQ_DSSetting(void)
{
	//531 Test#################################################################################
	if (VIP_IsPCSource() && VIP_GetInputVSize() <= 500)    //#51243
	{
		PQ_RegisterWrite(VIP_reg_slr_ds_angle_0_weight,0x2);//			0x0140D250	// 16		 , "N"
	}
	else if (VIP_GetUserSource() == SOURCE_HDMI && VIP_GetInputHSize()<1900)  //#51302 & #51333
	{
		PQ_RegisterWrite(VIP_reg_slr_ds_angle_0_weight,0x3); 
	}
	else if (VIP_GetUserSource() == SOURCE_EXTS && VIP_GetInputVSize() == 576)   //#51680
	{
		PQ_RegisterWrite(VIP_reg_slr_ds_angle_0_weight,0x2); 
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_slr_ds_angle_0_weight,0x10);// 			0x0140D250	// 16		 , "N"
	}

	PQ_RegisterWrite(VIP_reg_slr_ds_angle_90_weight,0x10);//				0x0140D251	// 16		 , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_67_weight,0x10);//				0x0140D252	// 16		 , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_113_weight,0x10);//				0x0140D253	// 16		 , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_angle_45_weight,0x10);//         		0x0140D254	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_135_weight,0x10);//        		0x0140D255	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_23_weight,0x10);//         		0x0140D256	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_157_weight,0x10);//        		0x0140D257	// 16        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_angle_16_weight,0x10);//         		0x0140D258	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_164_weight,0x10);//        		0x0140D259	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_56_weight,0x10);//         		0x0140D25A	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_124_weight,0x10);//        		0x0140D25B	// 16        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_angle_34_weight,0x10);//         		0x0140D25C	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_146_weight,0x10);//        		0x0140D25D	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_74_weight,0x10);//          		0x0140D25E	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_106_weight,0x10);//         		0x0140D25F	// 16        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_dbg_en,0x0);//                   		0x0040D260	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_dbg_en,0x0);//            		0x0040D261	// 0         , "N"

	//D262 for Chroma Pattern#1, Sharpness smooth
	PQ_RegisterWrite(VIP_reg_slr_ds_angle_limit_en,0x72);//          		0x01C0D262	// 0         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_hp_fix_mth,0x3);//              		0x0080D264	// 3         , "N"

	//add this condition because of mantis 51218
	if(VIP_GetInputHSize()==1280 && VIP_GetInputVSize()==960 && VIP_GetPanelWidth()==1366 && VIP_GetPanelHeight()==768)
		PQ_RegisterWrite(VIP_reg_slr_ds_hp_clip_sel,0x0);
	else if (VIP_GetUserSource() == SOURCE_HDMI)
		PQ_RegisterWrite(VIP_reg_slr_ds_hp_clip_sel,0x0);     // #51302
	else
		PQ_RegisterWrite(VIP_reg_slr_ds_hp_clip_sel,0x1);//             		0x0040D265	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_ver_sht,	2);

	PQ_RegisterWrite(VIP_reg_slr_ds_hp_clip_th,0x18);//              		0x0240D268	// 24        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_hp_hsum_max_th,0x480);//          		0x0380D26C	// 1152      , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_hp_hsum_min_th,0x180);//          		0x0380D270	// 384       , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_hp_vsum_max_th,0x480);//          		0x0380D274	// 1152      , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_hp_vsum_min_th,0x180);//          		0x0380D278	// 384       , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_hp_mixsum_max_th,0x600);//        		0x03C0D27C	// 1536      , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_hp_vsum_hsum_ratio,0x06);//      		0x0140D280	// 6         , "N"


	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th,0x9);//            		0x0240D2B0	// 60        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_h,0xf);//          		0x0240D2B4	// 15        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_v,0x5a);//          		0x0240D2B8	// 90        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_th_hv,0x5a);//         		0x0240D2BC	// 90        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor,0x08);//        		0x01C0D2C0	// 24        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_h,0x30);//      		0x01C0D2C1	// 48        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_v,0x08);//      		0x01C0D2C2	// 8         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_hv,0x08);//     		0x01C0D2C3	// 8         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_cross_factor_h_inc,0x08);//  		0x01C0D2C4	// 8         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_lr_lp,0x01);//               		0x0040D2D0	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_cross_alpha_th,0x03);//          		0x0100D2D1	// 3         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_lr_restrict,0x01);//         		0x0040D2D2	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_strong_lr_th1,0x30);//           		0x0200D2D3	// 48        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_strong_lr_th2,0x30);//           		0x0200D2D4	// 48        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_strong_lr_ratio1,0x8);//        		0x0100D2D5	// 8         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_strong_lr_ratio2,0x8);//        		0x0100D2D6	// 8         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_weak_lr_th1,0x10);//             		0x0200D2D7	// 16        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_weak_lr_th2,0x10);//             		0x0200D2D8	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_weak_lr_ratio1,0x05);//          		0x0100D2D9	// 5         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_weak_lr_ratio2,0x04);//          		0x0100D2DA	// 4         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sum_lr_ratio1,0x05);//           		0x0100D2DB	// 5         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sum_lr_ratio2,0x05);//           		0x0100D2DC	// 5         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_l_r_min,0x10);//             		0x0200D2DD	// 16        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_lr_min,0x60);//              		0x0200D2DE	// 96        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_max,0xc8);//                 		0x0240D2E0	// 200       , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_med,0x88);//                 		0x0240D2E4	// 136       , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_min1,0xff);//                		0x0200D2E8	// 48        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_min2,0x0);//                		0x0200D2E9	// 0         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_margin,0x18);//              		0x0200D2EC	// 24        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sumsad_ratio,0x06);//            		0x0100D2F0	// 6         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_factor1,0x30);//             		0x01C0D2F2	// 48        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_factor2_1,0x5);//           		0x01C0D2F3	// 5         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_factor2_2,0x20);//           		0x01C0D2F4	// 32        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_factor3,0x4);//             		0x01C0D2F5	// 4         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_factor4_1,0x1);//           		0x0100D2F6	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_factor4_2,0x2);//           		0x0100D2F7	// 2         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_factor3_lmt,0x18);//         		0x0140D2F8	// 24        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_dis_subsad,0x01);//              		0x0040D2F9	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_ratio1,0x0a);//              		0x0100D2FA	// 10        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_ratio2,0x06);//              		0x0100D2FB	// 6         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_ratio3,0x02);//              		0x0140D2FC	// 2         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sad_ratio4,0x08);//              		0x0140D2FD	// 8         , "N"
//	PQ_RegisterWrite(VIP_reg_ds_disable_angle_sel,0x0);//           		0x0040D2FE	// 0         , "N"
//	PQ_RegisterWrite(VIP_reg_ds_disable_func_en,0x0);//             		0x0080D2FF	// 0         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_dis_blending,0x0);//             		0x0040D300	// 0         , "N"
//	PQ_RegisterWrite(VIP_reg_slr_dscale_strong_edge_lp,0x0);//       		0x0040D301	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_dscale_cross_shoot_ctrl_taps,0x1);// 	0x0080D302	// 1         , "N
	PQ_RegisterWrite(VIP_reg_slr_dscale_other_shoot_ctrl_taps,0x1);// 	0x0080D303	// 1         , "N

	PQ_RegisterWrite(VIP_reg_slr_dbg_angle_en,0xffff);//                		0x0400D308	// 65535     , "N"

	PQ_RegisterWrite(VIP_reg_slr_dbg_dis_color,0x01000000);//               		0x0040D30C	// 0         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_gain_ctrl_tap,0x0);//     		0x0040D31C	// 0         , "E"

	PQ_RegisterWrite(VIP_reg_slr_ds_salt_filter_en,0x07);//          		0x00C0D330	// 7         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_salt_diff_th1,0x0a);//           		0x0200D331	// 10        , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_salt_diff_th2,0x05);//          		0x0200D332	// 5         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_salt_diff_th3,0x05);//           		0x0200D333	// 5         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_salt_comb_th,0x0);//            		0x0240D334	// 0         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_salt_comb_slope,0x100);//         		0x02C0D338	// 256       , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_sad_noise_level,0x20);//         		0x0200D358	// 35        , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_border_h_en,0x0);//             		0x0040D364	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_border_h_th,0x04);//             		0x0100D365	// 4         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_border_v_en,0x0);//             		0x0040D366	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_border_v_th,0x03);//             		0x0100D367	// 3         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_dis_min_diff,0x0);//            		0x0040D368	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_cond1_sel1,0x01);//              		0x0040D36A	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_cond1_sel2,0x01);//              		0x0040D36B	// 1         , "N"

	PQ_RegisterWrite(VIP_reg_slr_ds_neg_factor1,0x01);//             		0x0040D36C	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_cross_blend,0x1);//             		0x0040D36E	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_dis_74d,0x0);//                 		0x0040D36F	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_dis_74_sum,0x1);//              		0x0041D36F	// 0         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sumsad_limit,0x1);//            		0x0042D36F	// 1         , "N"
	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_gain_ctrl_tap_c,0x0);//   		0x0040D41C	// 0         , "E"
	PQ_RegisterWrite(VIP_reg_slr_ds_sharp_gain_ctrl_tap_c,0x0);// 		0x0040D41C	// 0         , "E"

	//531 settings
	if(VIP_IsATVSource())
	{
		PQ_RegisterWrite(VIP_reg_slr_ds_ultra_sharp	,0x0);//             		0x0100D36D	// 15        , "N"
		PQ_RegisterWrite(VIP_reg_slr_h_salt_fil_th	,0x1);
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_slr_ds_ultra_sharp	,0x0f);//             		0x0100D36D	// 15        , "N"
		PQ_RegisterWrite(VIP_reg_slr_h_salt_fil_th	,0x10);
	}

	if(VIP_GetInputVSize()<=576)
		PQ_RegisterWrite(VIP_reg_slr_ds_full_angle,0x0);
	else
		PQ_RegisterWrite(VIP_reg_slr_ds_full_angle,0x1);

//Temp settings for 533
	if(VIP_IsATVSource())
	{
		PQ_RegisterWrite(VIP_reg_slr_dlti_gain_0_post	,0x20); //0x0200DF0C
		PQ_RegisterWrite(VIP_reg_slr_dlti_gain_1_post	,0x40); //0x0200DF10
		PQ_RegisterWrite(VIP_reg_slr_dlti_gain_2_post	,0x40); //0x0200DF14
		PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_2		,0xf0); //0x0200DD14
		PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_1		,0xf0);	//0x0200DD10
		PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_0		,0x60); //0x0200DD0C
		//PQ_RegisterWrite(VIP_reg_slr_2d_l_scale			,0x01);	//0x0080DD54
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_slr_dlti_gain_0_post	,0x40); //0x0200DF0C
		PQ_RegisterWrite(VIP_reg_slr_dlti_gain_1_post	,0x80); //0x0200DF10
		PQ_RegisterWrite(VIP_reg_slr_dlti_gain_2_post	,0x80); //0x0200DF14
		PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_2		,0x80); //0x0200DD14
		PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_1		,0x80);	//0x0200DD10
		PQ_RegisterWrite(VIP_reg_slr_2d_l_gain_0		,0x40); //0x0200DD0C
		/*if(VIP_IsSCARTSource() && VIP_IsAVSource())
		{
			PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x00);	//#40517  & #40758
		}
		else if (VIP_IsAVSource())
		{
			if (VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK && VIP_GetStdColorSystem() <= CVD2_STD_SECAM)
		    {
 			     PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x0);	//#40758
		    }
			else
			{
                 PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x01); //#40758			
			}
		}
		else if (VIP_GetUserSource() == SOURCE_HDMI || ((VIP_GetUserSource() == SOURCE_EXTS || VIP_IsPCSource()) && VIP_GetInputVSize() > 700)) 
		{
			PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x01);	//#40619 & #40860 & #41344
		}
        else if (VIP_IsSVSource())
        {
        	PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x00); //#40955
        }
	    else if (VIP_IsSourceDTV() || VIP_IsATVSource())
	    {
	    	//PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x01);	//0x0080DD54   ;   #42964    controlled by VIP Table
	    }
		else
		{
			PQ_RegisterWrite(VIP_reg_slr_2d_l_scale, 0x02);	//0x0080DD54
		} */
	}

}


void PQ_SLR_ColorBarDetailSet(void)
{
	UINT32 CaptureWindowSize=0;

	CaptureWindowSize = (PQ_RegisterRead(VIP_reg_adix_che) - PQ_RegisterRead(VIP_reg_adix_chs))*(PQ_RegisterRead(VIP_reg_adix_cve) - PQ_RegisterRead(VIP_reg_adix_cvs));

	PQ_RegisterWrite(VIP_reg_slr_valid_bin_th	, ((4*CaptureWindowSize)/100)); //sonyPQ(NTSC) 720P colorbar 5 to 4
	PQ_RegisterWrite(VIP_reg_slr_gray_bin_th	, ((5*CaptureWindowSize)/10));

	PQ_RegisterWrite(VIP_reg_slr_dcti_scale_color	,0);
	PQ_RegisterWrite(VIP_reg_slr_null_bin_th		,0x100);

	if (VIP_GetUserSource() == EXTS && !VIP_IsPCSource())
		PQ_RegisterWrite(VIP_reg_slr_detail_bin_th	, ((7*CaptureWindowSize)/10));
	else
		PQ_RegisterWrite(VIP_reg_slr_detail_bin_th	, ((5*CaptureWindowSize)/10));

	PQDebugPrint("\033[1m\033[40;35m%s:CaptureWindowSize = %d\033[0m\n", __FUNCTION__,CaptureWindowSize);
	PQDebugPrint("\033[1m\033[40;35m%s:VIP_reg_slr_valid_bin_th = %d\033[0m\n", __FUNCTION__,PQ_RegisterRead(VIP_reg_slr_valid_bin_th));
	PQDebugPrint("\033[1m\033[40;35m%s:VIP_reg_slr_detail_bin_th = %d\033[0m\n", __FUNCTION__,PQ_RegisterRead(VIP_reg_slr_detail_bin_th));
	PQDebugPrint("\033[1m\033[40;35m%s:VIP_reg_slr_gray_bin_th = %d\033[0m\n", __FUNCTION__,PQ_RegisterRead(VIP_reg_slr_gray_bin_th));
}


void PQ_DeinterlaceFilter(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;

	INT32 Val1,Val2,Val3;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    DEIN_FILTER_DATA *pDEIN_FILTER_DATA;

    if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
    if (pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex] >= 8) return;

    ucTableIndex = pVtab->mDeinterlaceFilter.mGroupedIndex[ucCurrSrcIndex];
    pDEIN_FILTER_DATA = &pVtab->mDeinterlaceFilter.mDeIN_Fil_Data[ucTableIndex];

	if( VIP_GetInputHSize()>=1900 )
	{
		Val1 = pDEIN_FILTER_DATA->hd_vdi_mad_hlp_en;
		Val2 = pDEIN_FILTER_DATA->hd_slr_mix_ach;
		Val3 = pDEIN_FILTER_DATA->hd_slr_mix_bch;
	}
	else if( VIP_GetInputHSize()<800 )
	{
		Val1 = pDEIN_FILTER_DATA->sd_vdi_mad_hlp_en;
		Val2 = pDEIN_FILTER_DATA->sd_slr_mix_ach;
		Val3 = pDEIN_FILTER_DATA->sd_slr_mix_bch;
	}
	else
	{
		Val1 = pDEIN_FILTER_DATA->md_vdi_mad_hlp_en;
		Val2 = pDEIN_FILTER_DATA->md_slr_mix_ach;
		Val3 = pDEIN_FILTER_DATA->md_slr_mix_bch;
	}

	PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, Val1);
	PQ_RegisterWrite(VIP_reg_slr_mix_smooth_ach, Val2);
	PQ_RegisterWrite(VIP_reg_slr_mix_smooth_bch, Val3);
#if 0
	PQ_RegisterWrite(VIP_reg_slr_mix_smooth_ach, 2);
	PQ_RegisterWrite(VIP_reg_slr_mix_smooth_bch, 2);
#else
	PQ_RegisterWrite(VIP_reg_slr_mix_smooth_ach, VIP_IsATVSource()?3:2);
	PQ_RegisterWrite(VIP_reg_slr_mix_smooth_bch, VIP_IsATVSource()?3:2);
#endif
#if 0
	if(VIP_GetUserSource()==SOURCE_HDMI && pHwContext->cInterlaceMode)
	{
		PQ_RegisterWrite(VIP_reg_slr_mix_smooth_ach, 1);
		PQ_RegisterWrite(VIP_reg_slr_mix_smooth_bch, 1);
	}
#endif
	PQ_ConditionSetting(MODE_DeinterlaceFilter);   //#48358 

	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_acw_en	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_acw_sel	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_bw_en	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_bw_sel	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_mbw_en	,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_vedge_mbw_sel	,0);

}


VTAB_SRC_VALUE_DEFINE* PQ_GetSourceVTab(UINT8 ucSource, UINT8 ucSubSource)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_SRC_VALUE_DEFINE* pVtab= &pHwContext->VtabSrcValue[0];
	VTAB_CMN_VALUE_DEFINE* pVtabCmnValue= &pHwContext->VtabCmnValue;

	switch(ucSource)
	{
	case EXTS:
		if( ucSubSource==YPP1 || ucSubSource==YPP2)
        {

            if(PQ_GetDefinitionIndex())
            {
                pVtab= &pHwContext->VtabSrcValue[VTAB_EXTS_YPP_HD_VALUE-VTAB_EXTS_YPP_VALUE]; //YPP_HD
            }
            else
            {
                pVtab= &pHwContext->VtabSrcValue[0]; //YPP
            }
		    #if SEPERATE_YPBPR1_YPBPR2
            if(ucSubSource==YPP2 && VIP_JudgeDVDSource())
            {
               if(PQ_GetDefinitionIndex())
               {
                pVtab= &pHwContext->VtabSrcValue[VTAB_EXTS_YPP2_HD_VALUE-VTAB_EXTS_YPP_VALUE]; //YPP2_HD(DVD)
               }
               else
               {
                   pVtab= &pHwContext->VtabSrcValue[VTAB_EXTS_YPP2_SD_VALUE-VTAB_EXTS_YPP_VALUE]; //YPP2_SD(DVD)
               }
            }
            #endif
        }
		else if( ucSubSource==DSUB )
        {
			pVtab= &pHwContext->VtabSrcValue[VTAB_EXTS_RGB_VALUE-VTAB_EXTS_YPP_VALUE]; //RGB
		}

		if(ucSubSource==SCART_RGB1)
		{
			PQDebugPrint("%s: load %s table",__FUNCTION__, pVtabCmnValue->ucLoadScartRGBTab?"Scart RGB":"YPP");
			if(pVtabCmnValue->ucLoadScartRGBTab)
            {
				pVtab= &pHwContext->VtabSrcValue[VTAB_SCART_RGB_VALUE-VTAB_EXTS_YPP_VALUE];//SCART_RGB
			}
			else
            {
				pVtab= &pHwContext->VtabSrcValue[VTAB_EXTS_YPP_VALUE-VTAB_EXTS_YPP_VALUE];//YPP
			}
		}
		break;
	case CVD2:
		if( ucSubSource==TV_INPUT_CHANNEL )
        {
			pVtab= &pHwContext->VtabSrcValue[VTAB_CVD2_TV_VALUE-VTAB_EXTS_YPP_VALUE];
        }
		else if( ucSubSource==AV1_INPUT_CHANNEL || ucSubSource==AV2_INPUT_CHANNEL || ucSubSource==AV3_INPUT_CHANNEL )
        {
			pVtab= &pHwContext->VtabSrcValue[VTAB_CVD2_AV_VALUE-VTAB_EXTS_YPP_VALUE];
        }
		if( ucSubSource==S1_INPUT_CHANNEL || ucSubSource==S2_INPUT_CHANNEL || ucSubSource==S3_INPUT_CHANNEL )
        {
			pVtab= &pHwContext->VtabSrcValue[VTAB_CVD2_SV_VALUE-VTAB_EXTS_YPP_VALUE];
        }
		break;
	case MPEG:
        if(PQ_GetDefinitionIndex())
        {
            pVtab= &pHwContext->VtabSrcValue[VTAB_MPEG_HD_VALUE-VTAB_EXTS_YPP_VALUE]; //MPEG_HD
        }
        else
        {
            pVtab= &pHwContext->VtabSrcValue[VTAB_MPEG_VALUE-VTAB_EXTS_YPP_VALUE]; //MPEG_SD
        }
        if(VIP_IsNetworkSource())
        {
            pVtab= &pHwContext->VtabSrcValue[VTAB_MPEG_VALUE-VTAB_EXTS_YPP_VALUE]; //MPEG_SD
        }
        break;
	case HDMI:
        if(VIP_RunDVIMode())
        {
			pVtab= &pHwContext->VtabSrcValue[VTAB_EXTS_RGB_VALUE-VTAB_EXTS_YPP_VALUE];
        }
		else
        {
            if(PQ_GetDefinitionIndex())
            {
			    pVtab= &pHwContext->VtabSrcValue[VTAB_HDMI_HD_VALUE-VTAB_EXTS_YPP_VALUE]; //HDMI_HD
            }
            else
            {
                pVtab= &pHwContext->VtabSrcValue[VTAB_HDMI_VALUE-VTAB_EXTS_YPP_VALUE]; //HDMI_SD
            }
        }
		break;
	case JPEG:
	case PATN:
		pVtab= &pHwContext->VtabSrcValue[VTAB_EXTS_RGB_VALUE-VTAB_EXTS_YPP_VALUE];
        break;
	}
	return pVtab;
}


void PQ_DeblockFilterAndDetect(BOOL bDemoMode, UINT32 vdi_hsize_i, UINT32 vdi_vsize)
{
	UINT32 vdi_hds,vdi_ne_total;
	UINT32 vdi_hsize;
	BOOL bNrEnable;
	BOOL bDeblockEnable;
	UINT8 ucTmp;
	PQHW_CONTEXT* pHwContext = &PQHwContext;
	//set ne estimate
	vdi_hds= bDemoMode ? PQ_RegisterRead(VIP_reg_vdi_tnr_dbg_offset): 0;
	vdi_hsize= vdi_hsize_i - vdi_hds;
	vdi_ne_total= vdi_hsize * vdi_vsize;

	bNrEnable= (pHwContext->nMPEGNRLevel>OFF) ? ENABLE : DISABLE;
	bNrEnable= (bNrEnable) && (!VIP_IsPCSource() && !VIP_RunDVIMode());
	bDeblockEnable=(!VIP_IsPCSource()) && (!VIP_RunDVIMode());

	//## horizontal detection and filter enable
	//0x4128
	PQ_RegisterWrite(VIP_reg_gfx_dbk_en, bNrEnable && bDeblockEnable);
	PQ_RegisterWrite(VIP_reg_gfx_dbk_fil_en, bNrEnable);// && (pHwContext->cInputDataFormat!=RGB));
	PQ_RegisterWrite(VIP_reg_gfx_dbk_filc_en, 1);
	PQ_RegisterWrite(VIP_reg_gfx_dbk_lp_sel, 0);
	PQ_RegisterWrite(VIP_reg_gfx_dbk_fil_dbg_en, 0);
	PQ_RegisterWrite(VIP_reg_gfx_dbk_ratio_dis, 0);

	PQ_RegisterWrite(VIP_reg_gfx_maxedgeh_th, vdi_ne_total/ 225);
	PQ_RegisterWrite(VIP_reg_gfx_maxedgeh_ratio_th, 3);
	PQ_RegisterWrite(VIP_reg_gfx_maxedgeh_scale_th, 0x2fff);
	PQ_RegisterWrite(VIP_reg_gfx_blockedgeh_fil_th_min, VIP_GetUserSource() == SOURCE_MPEG?0:2);
	PQ_RegisterWrite(VIP_reg_gfx_maxedgeh2_minth, 0xc);
	PQ_RegisterWrite(VIP_reg_gfx_dbk_hdiff_th3, 0x8);

	//## vertical deblock detection and filter

	PQ_RegisterWrite(VIP_reg_vdi_maxedgev_ratio_th, 16);

	PQ_RegisterWrite(VIP_reg_vdi_maxedgev_th, vdi_ne_total/348);
	//0x6060
    PQ_VDeblockFilterEnable();

	PQ_RegisterWrite(VIP_reg_vdi_dbk_ratio_dis, 0);
	PQ_RegisterWrite(VIP_reg_vdi_dbk_vqh_dis, 1);
	PQ_RegisterWrite(VIP_reg_vdi_dbk_vdet_4tap, 1);

	PQ_RegisterWrite(VIP_reg_vdi_dbk_vfil_minth, 0);
	PQ_RegisterWrite(VIP_reg_vdi_dbk_vfil_maxth, 0xff);

	PQ_RegisterWrite(VIP_reg_vdi_dbk_hmot_th, (vdi_ne_total* 15)/ 100);
	PQ_RegisterWrite(VIP_reg_vdi_dbk_mot_th, (vdi_ne_total* 5)/ 100);


	//330
	ucTmp = PQ_RegisterRead(VIP_reg_gfx_dbk_mode_force);
	if(abs(VIP_GetInputVSize() -1080)<10)
        PQ_RegisterWrite(VIP_reg_gfx_dbk_mode_force , ucTmp&(~0x4));
	else
		 PQ_RegisterWrite(VIP_reg_gfx_dbk_mode_force , ucTmp|0x4);

	//PQ_RegisterWrite(VIP_reg_gfx_blockedgeh_minth, 0x3);//SonyPQ Menu vertical border discontinuity
	PQ_RegisterWrite(VIP_reg_gfx_blockedgeh_minth, 0x9);//HiVi Case#20 H Line resolution blur

}

void PQ_HmeSetup(UINT32 vdi_hsize_i, UINT32 vdi_vsize)
{
	//new mad setting for kw

	if(VIP_GetInterlaceMode())
	{
		UINT32 slr_hds, slr_hde,slr_vds,slr_vde,hme_height, tmp, vdi_hds, vdi_hde, vdi_vds, vdi_vde, gmv_vds, gmv_vde;
		//disable full screen hme to avoid 330C,HDMI-480i,2d>3d,MEMC Disk->MovingPlaneBuildings,�ؿv���|�ö}
		/*
		if( (VIP_GetUserSource() == SOURCE_CVD2&& !VIP_IsATVSource() && abs(pHwContext->ulInputHSize-720)<50 ) || (VIP_GetUserSource() == SOURCE_HDMI&& pHwContext->ulInputHSize<=720 ))
		{

			slr_hds = 2 ;
			slr_hde = 2*(vdi_hsize_i-1)+1;
			slr_vds = 5;
			slr_vde = 2*(vdi_vsize-2)-1;
#if VIP_FLIP_FUN
			if(VIP_GetPanelInvert())
			{
				tmp = slr_hds;
				slr_hds = vdi_hsize_i - slr_hde;
				slr_hde = vdi_hsize_i - tmp;
				tmp = slr_vds;
				slr_vds = vdi_vsize - slr_vde;
				slr_vde = vdi_vsize - tmp;

			}
#endif

			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_en, 1);
			PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 1);

			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_hs, 1);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_he, vdi_hsize_i-1);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_vs, 1);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_ve, vdi_vsize-1);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_det_vs, 2);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_det_ve, vdi_vsize-2);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_r_cnt_h, 100);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_r_cnt_m, 100);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_r_cnt_l, 100);

			PQ_RegisterWrite(VIP_reg_slr_hme_hds, slr_hds);
			PQ_RegisterWrite(VIP_reg_slr_hme_hde, slr_hde);
			PQ_RegisterWrite(VIP_reg_slr_hme_vds, slr_vds);
			PQ_RegisterWrite(VIP_reg_slr_hme_vde, slr_vde);
			PQ_RegisterWrite(VIP_reg_slr_gmv_comb_en, 1);
			PQ_RegisterWrite(VIP_reg_slr_gmv_comb_th, 0);
		}
		else */
		if(VIP_IsATVSource() || VIP_IsAVSource() || (VIP_GetUserSource()==SOURCE_HDMI && (VIP_GetInputVSize() <= (480+24))) || (VIP_IsSourceDTV() && PQ_GetDefinitionIndex() != PQ_HIGH_DEFINITION))
		{
			slr_hds = 2 ;
			slr_hde = vdi_hsize_i-2;
			hme_height = vdi_vsize/4;
			slr_vds = 2*(vdi_vsize-hme_height)+3;
			slr_vde = 2*(vdi_vsize-2)-1;

                   vdi_hds = 180;
                   vdi_hde = vdi_hsize_i - 180;
                   vdi_vds = vdi_vsize - hme_height + 1;
                   vdi_vde = vdi_vsize -1;

                   gmv_vds = vdi_vsize - hme_height;
                   gmv_vde = vdi_vsize - 2;
#if VIP_FLIP_FUN
			if(VIP_GetPanelInvert() == HV_FLIP || VIP_GetPanelInvert() == V_FLIP)
			{
				tmp = slr_hds;
				slr_hds = vdi_hsize_i - slr_hde;
				slr_hde = vdi_hsize_i - tmp;
				tmp = slr_vds;
				//slr_vds = 2*vdi_vsize - slr_vde;
				slr_vds = 2*vdi_vsize - slr_vde+1;//20130102 CJ&KW--GME window setup
				//slr_vde = 2*vdi_vsize - tmp;
				slr_vde = 2*vdi_vsize - tmp-3;//20130102 CJ&KW--GME window setup

                         if((*((UINT8*)(0xbe0b0080)) & 0x04) == 0x4) //VDI HME window adjusted only when source already invert(ex. invert by VOF) 
                         {
                             vdi_vds = 1;
                             vdi_vde = hme_height -1;
                             
                             gmv_vds = 0;
                             gmv_vde = hme_height - 2;
                         }

			}
#endif

			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_hs, vdi_hds);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_he, vdi_hde);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_vs, vdi_vds);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_ve, vdi_vde);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_det_vs, gmv_vds);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_det_ve, gmv_vde);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_r_minus, 0);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_ambg_th, 8192);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_vldcnt_th,3);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_r_cnt_h, 2);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_r_cnt_m, 2);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_r_cnt_l, 2);

			PQ_RegisterWrite(VIP_reg_slr_hme_hds, slr_hds);
			PQ_RegisterWrite(VIP_reg_slr_hme_hde, slr_hde);
			PQ_RegisterWrite(VIP_reg_slr_hme_vds, slr_vds);
			PQ_RegisterWrite(VIP_reg_slr_hme_vde, slr_vde);
			/*
			PQ_RegisterWrite(VIP_reg_slr_hme_hds, 2);
			PQ_RegisterWrite(VIP_reg_slr_hme_hde, VIP_GetScalerPreScaleH()-2);
			PQ_RegisterWrite(VIP_reg_slr_hme_vds, 2*(vdi_vsize-28)+1);
			PQ_RegisterWrite(VIP_reg_slr_hme_vde, 2*(vdi_vsize-2)-1);
			*/
			PQ_RegisterWrite(VIP_reg_slr_gmv_comb_en, 1);
			PQ_RegisterWrite(VIP_reg_slr_gmv_comb_th, 0);
			PQ_RegisterWrite(VIP_reg_slr_gmv_hedge_th,0x8);

                   if(VIP_IsSourceDTV() || ((VIP_IsATVSource() || VIP_IsAVSource()) && (VIP_GetStdColorSystem()==CVD2_STD_PAL_IBGDK)))
                   {
						PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_en, 1);
						PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 1);
                        PQ_HmeDeMesh(ENABLE);
                   }
                   else if((VIP_GetUserSource()==SOURCE_HDMI && (VIP_GetInputVSize() <= (480+24))) || ((VIP_IsATVSource() || VIP_IsAVSource()) && (VIP_GetStdColorSystem()==CVD2_STD_NTSC_M)))
                   {
					    PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_en, 0);
					    PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 0);
						PQ_HmeDeMesh(DISABLE);
               	   }
				   else
				   {
						PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_en, 0);
						PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 0);
					    PQ_HmeDeMesh(DISABLE);
				   }

		}
		else
		{
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_en, 0);
			PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 0);
                   PQ_HmeDeMesh(DISABLE);

		}
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_en, 0);
		PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 0);
             PQ_HmeDeMesh(DISABLE);

	}


}

void PQ_HmeControl(void)
{
	UINT32 motionFlag=0;
	static int flagcount=0;
	
	if ((VIP_IsATVSource() || VIP_IsAVSource()) && (VIP_GetStdColorSystem()==CVD2_STD_PAL_IBGDK))
	{
		motionFlag = PQ_GetMotionStatus();
		if (motionFlag==0 && flagcount==150)
		{
			if (VIP_IsATVSource()) 
			{
				mips1_byte_nodelay(0xbe1cd685, 0xf); //r_slr_hme_mesh_slop
			}
			else
			{
				mips1_byte_nodelay(0xbe1cd685, 0x8); //r_slr_hme_mesh_slop
			}
			mips1_byte_nodelay(0xbe1cD684, 0x68); //r_slr_hme_mesh_yoff
			mips1_byte_nodelay(0xbe1cD683, 0xa0); //r_slr_hme_mesh_xoff
	        	mips1_byte_nodelay(0xbe1cD682, 0x30); //r_slr_hme_mesh_hedg_max
	        	mips1_byte_nodelay(0xbe1cD681, 0xf); //r_slr_hme_mesh_hedg_gain
			flagcount=0;
		}
		else if (motionFlag==1 && flagcount==75)
		{
			if (VIP_IsATVSource())
			{
				mips1_byte_nodelay(0xbe1cd685, 0x9);  //r_slr_hme_mesh_slop
			}
			else 
			{
				mips1_byte_nodelay(0xbe1cd685, 0x4); //r_slr_hme_mesh_slop
			}
			mips1_byte_nodelay(0xbe1cD684, 0x40); //r_slr_hme_mesh_yoff
			mips1_byte_nodelay(0xbe1cD683, 0xa0); //r_slr_hme_mesh_xoff
	       	 mips1_byte_nodelay(0xbe1cD682, 0x3c); //r_slr_hme_mesh_hedg_max
			mips1_byte_nodelay(0xbe1cD681, 0xc); //r_slr_hme_mesh_hedg_gain
			flagcount=76;
		}
		else if (motionFlag==1 && flagcount<=74)
		{
			if ( flagcount==74 && VIP_IsAVSource())
			{
				mips1_byte_nodelay(0xbe1cd685, 0x6);  //r_slr_hme_mesh_slop
				mips1_byte_nodelay(0xbe1cD684, 0x54); //r_slr_hme_mesh_yoff
			}
		       flagcount++;
		}
		else if (motionFlag==0 && flagcount>=76)
		{
			if ( flagcount==76 && VIP_IsAVSource())
			{
				mips1_byte_nodelay(0xbe1cd685, 0x6);  //r_slr_hme_mesh_slop
				mips1_byte_nodelay(0xbe1cD684, 0x54); //r_slr_hme_mesh_yoff
			}
		       flagcount++;
		}
	}
}

/**
 * @brief : mainly for new ticker demesh function
 *
 * This function apply demesh function within the HME window, so only work while HME eable
 *
 * @param bEnable, 1 for enable function, 0 for disable function
 * @return n/a
 * @note : wait HW provide registre define data, and only enable in DTV(#47893) & ATV-PAL(#48698)
*/
void PQ_HmeDeMesh(UINT8 bEnable)
{
    if(bEnable)
    {
        mips1_byte_nodelay(0xbe1cD67C, 0x0); //r_slr_hme_mesh_diff_offset
        mips1_byte_nodelay(0xbe1cD67D, 0x4); //r_slr_hme_mesh_diff_gain
        mips1_byte_nodelay(0xbe1cD67E, 0x4); //r_slr_hme_mesh_same_offset
        mips1_byte_nodelay(0xbe1cD67F, 0x8); //r_slr_hme_mesh_same_gain
        mips1_byte_nodelay(0xbe1cD680, 0x8); //r_slr_hme_mesh_hedg_offset
        mips1_byte_nodelay(0xbe1cD681, 0xf); //r_slr_hme_mesh_hedg_gain
        mips1_byte_nodelay(0xbe1cD682, 0x30); //r_slr_hme_mesh_hedg_max
        mips1_byte_nodelay(0xbe1cD683, 0xc0); //r_slr_hme_mesh_xoff
        mips1_byte_nodelay(0xbe1cD684, 0x40); //r_slr_hme_mesh_yoff

		if(VIP_IsATVSource() && (VIP_GetStdColorSystem()<=CVD2_STD_NTSC_M))
		{
	        mips1_byte_nodelay(0xbe1cD685, 0x8); //r_slr_hme_mesh_slop
		}
		else if((VIP_IsAVSource() && (VIP_GetStdColorSystem()<=CVD2_STD_NTSC_M)) || (VIP_GetUserSource()==SOURCE_HDMI && (VIP_GetInputVSize() <= (480+24))))
		{
	        mips1_byte_nodelay(0xbe1cD685, 0x8); //r_slr_hme_mesh_slop
			mips1_byte_nodelay(0xbe1cD684, 0x30); //r_slr_hme_mesh_yoff
	        mips1_byte_nodelay(0xbe1cD681, 0x1f); //r_slr_hme_mesh_hedg_gain			
		}
        else
       	{
	        mips1_byte_nodelay(0xbe1cD685, 0x2); //r_slr_hme_mesh_slop
       	}
        
        mips1_byte_nodelay(0xbe1cd686, 0x1); //reg_slr_hme_mesh_en
    }
    else
    {
        mips1_byte_nodelay(0xbe1cd686, 0x0); //reg_slr_hme_mesh_en
    }
}

void PQ_TpwControl(void)
{
	//for weave & bob issue
	static int flagcount=0;
    UINT32 ucvdi_field_diff_cnt_lp = PQ_RegisterRead(VIP_field_diff_cnt_lp);
    static UINT32 VDIStaticCnt = 0;
	UINT32 GrayFlag=0;	

	if( VIP_IsATVSource() && (VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK))  // ATV PAL, SECAM
	{
		if((ucvdi_field_diff_cnt_lp <= 0x5fff) && (ucvdi_field_diff_cnt_lp > 0x2ff) && (VDIStaticCnt < 30))
		{
			VDIStaticCnt ++;
		}
		else if((ucvdi_field_diff_cnt_lp <= 0xcfff) && (ucvdi_field_diff_cnt_lp > 0x5fff) && (VDIStaticCnt < 31))
		{
			flagcount=2;
			VDIStaticCnt --;
		}
		else if((ucvdi_field_diff_cnt_lp <= 0x2ff) && (ucvdi_field_diff_cnt_lp > 0xff) && (VDIStaticCnt < 31))
		{
			flagcount=2;
			VDIStaticCnt --;
		}
		else if(ucvdi_field_diff_cnt_lp > 0xcfff)
       	{
			VDIStaticCnt --;
			if (VDIStaticCnt < 20 && VDIStaticCnt > 1)
			{
				VDIStaticCnt=2;
				flagcount=1;
			}
       	}
		else if(ucvdi_field_diff_cnt_lp <= 0xff && VDIStaticCnt < 31)
		{
			VDIStaticCnt --;
			if (VDIStaticCnt < 20)
			{
				VDIStaticCnt=1;
			}
		}
	}
	else if( VIP_IsATVSource() && (VIP_GetStdColorSystem() < CVD2_STD_PAL_IBGDK)) // ATV NTSC
	{
		if((ucvdi_field_diff_cnt_lp <= 0x3fff) && (ucvdi_field_diff_cnt_lp > 0x2ff) && (VDIStaticCnt < 30))
		{
			VDIStaticCnt ++;
		}
		else if((ucvdi_field_diff_cnt_lp <= 0x9fff) && (ucvdi_field_diff_cnt_lp > 0x3fff) && (VDIStaticCnt < 31))
		{
			flagcount=2;
			VDIStaticCnt --;
		}
		else if((ucvdi_field_diff_cnt_lp <= 0x2ff) && (ucvdi_field_diff_cnt_lp > 0xff) && (VDIStaticCnt < 31))
		{
			flagcount=2;
			VDIStaticCnt --;
		}
		else if(ucvdi_field_diff_cnt_lp > 0x9fff)
       	{
			VDIStaticCnt --;
			if (VDIStaticCnt < 20 && VDIStaticCnt > 1)
			{
				VDIStaticCnt=2;
				flagcount=1;
			}
       	}
        else if(ucvdi_field_diff_cnt_lp <= 0xff && VDIStaticCnt < 31)
		{
			VDIStaticCnt --;
			if (VDIStaticCnt < 20)
			{
				VDIStaticCnt=1;
			}
		}
	}
	else  // AV
	{
		if((ucvdi_field_diff_cnt_lp <= 0x6fff) && (ucvdi_field_diff_cnt_lp > 0x3ff) && (VDIStaticCnt < 30))
		{
			VDIStaticCnt ++;
		}
		else if((ucvdi_field_diff_cnt_lp <= 0xcfff) && (ucvdi_field_diff_cnt_lp > 0x6fff) && (VDIStaticCnt < 31))
		{
			flagcount=2;
			VDIStaticCnt --;
		}
		else if((ucvdi_field_diff_cnt_lp <= 0x3ff) && (ucvdi_field_diff_cnt_lp > 0xff) && (VDIStaticCnt < 31))
		{
			flagcount=2;
			VDIStaticCnt --;
		}
		else if(ucvdi_field_diff_cnt_lp > 0xcfff)
       	{
			VDIStaticCnt --;
			if (VDIStaticCnt < 20 && VDIStaticCnt > 1)
			{
				VDIStaticCnt=2;
				flagcount=1;
			}
       	}
        else if(ucvdi_field_diff_cnt_lp <= 0xff && VDIStaticCnt < 31)
		{
			VDIStaticCnt --;
			if (VDIStaticCnt < 20)
			{
				VDIStaticCnt=1;
			}
		}
	}

	if(VDIStaticCnt >= 30) VDIStaticCnt=30;

	GrayFlag = PQ_PureColorPatternDetect(21);

	if( VIP_IsAVSource() && (VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK))  //#52938
	{
		if ( GrayFlag == 2 && VDIStaticCnt > 10 && flagcount <= 4)
		{
			PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_yoff2, 4);
			PQ_RegisterWrite(VIP_reg_slr_mix_smooth_ach, 3);
			flagcount=7;
			return;
		}
		else if ( GrayFlag != 2 && VDIStaticCnt < 26 && flagcount == 7) 
		{
			PQ_RegisterWrite(VIP_reg_slr_mix_smooth_ach, 2);
			flagcount=0;
		}
		else if (flagcount <= 2)
		{
			PQ_RegisterWrite(VIP_reg_slr_mix_smooth_ach, 2);
		}
	}
	

	if(VDIStaticCnt > 10 && (flagcount < 2 || flagcount >= 4))			// 2ff ~ 3fff
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_yoff2, 9);
		flagcount=3;
	}
	else if(VDIStaticCnt < 20 && flagcount == 2)	// ff ~ 2ff , 3fff ~ 9fff
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_yoff2, 9);
		flagcount=4;
	}                                                                   
	else if(VDIStaticCnt == 2 && flagcount == 1)	// > 9fff
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_yoff2, 8);
		flagcount=5;
	}                                                                   
	else if(VDIStaticCnt == 1 && flagcount > 0 && flagcount < 6)		// < ff
	{
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_yoff2, 4);
		flagcount=6;
	}                                                                   
	
}

UINT8 PQ_GetMotionStatus(void)
{
    UINT32 ucvdi_mot_cnt = PQ_RegisterRead(VIP_vdi_mot_cnt);
    UINT32 ucvdi_vdbk_sts = PQ_RegisterRead(VIP_vdi_vdbk_sts);

    if(ucvdi_mot_cnt == 0 && ucvdi_vdbk_sts < 32) // ucvdi_vdbk_sts<32 mean ucvdi_field_diff_cnt_lp < thr
    {
        return STATIC_FRAME;
    }
    else
    {
        return MOTION_FRAME;
    }
}


void PQ_CheckMotionStatusMethod2(BOOL reset)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    static UINT32 DiffCntSum[3] = {0};
    static UINT8 i = 0;

    if(reset)
    {
        pHwContext->VDIMotionStatusByMethod2 = STATIC_FRAME;
    }
    else
    {
        if(i >= 3)
        {
            i = 0;
        }

        DiffCntSum[i] = abs(PQ_RegisterRead(VIP_field_diff_cnt)-PQ_RegisterRead(VIP_field_diff_cnt_lp));
        i++;
        
        if((DiffCntSum[0]+DiffCntSum[1]+DiffCntSum[2]) > 4000) //the 4000 threshold depend on NR setting
        {
            pHwContext->VDIMotionStatusByMethod2 = MOTION_FRAME;
        }
        else
        {
            pHwContext->VDIMotionStatusByMethod2 = STATIC_FRAME;
        }

        //if((*((UINT8*)(0xbe1cd688))) == 0x19) myprintk("ucTempM = %d, diff_cnt = %d, diff_cnt_lp = %d, diff = %ld, sum = %d, motionflag = %d",  ucTempM, PQ_RegisterRead(VIP_field_diff_cnt), PQ_RegisterRead(VIP_field_diff_cnt_lp), abs(PQ_RegisterRead(VIP_field_diff_cnt)-PQ_RegisterRead(VIP_field_diff_cnt_lp)), (DiffCntSum[0]+DiffCntSum[1]+DiffCntSum[2]), pHwContext->VDIMotionStatusByMethod2);    
    }
    
}


BOOL PQ_GetMotionStatusByMethod2(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    
    return pHwContext->VDIMotionStatusByMethod2;
}


void PQ_CheckMotionStatusMethod3(BOOL reset)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    static UINT32 VDIStaticCnt = 0;
    UINT32 ucvdi_field_diff_cnt_lp = PQ_RegisterRead(VIP_field_diff_cnt_lp);

    if(reset)
    {
        VDIStaticCnt = 0;
        pHwContext->VDIMotionStatusByMethod3 = STATIC_FRAME;
    }
    else
    {
        if( VIP_IsATVSource() && (VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK)) // PAL & SECAM
        {
            if(ucvdi_field_diff_cnt_lp >= 0x2fff && VDIStaticCnt <30)
            {
                VDIStaticCnt++;
            }
            else if(ucvdi_field_diff_cnt_lp < 0x2fff && VDIStaticCnt > 0)
            {
                VDIStaticCnt--;
            }
        } 
        else if( VIP_IsATVSource() && (VIP_GetStdColorSystem() < CVD2_STD_PAL_IBGDK) )  // NTSC
        {
            if(ucvdi_field_diff_cnt_lp >= 0x2dff && VDIStaticCnt <30)
            {
                VDIStaticCnt++;
            }
            else if(ucvdi_field_diff_cnt_lp < 0x2dff && VDIStaticCnt > 0)
            {
                VDIStaticCnt--;
            }
        }  
        else if(VIP_IsSourceDTV() || VIP_IsAVSource())
        {
            if(ucvdi_field_diff_cnt_lp >= 0x1ff && VDIStaticCnt <30)
            {
                VDIStaticCnt++;
            }
            else if(ucvdi_field_diff_cnt_lp < 0x1ff && VDIStaticCnt > 0)
            {
                VDIStaticCnt--;
            }
        }
        else
        {
            if(ucvdi_field_diff_cnt_lp >= 0xff && VDIStaticCnt <30)
            {
                VDIStaticCnt++;
            }
            else if(ucvdi_field_diff_cnt_lp < 0xff && VDIStaticCnt > 0)
            {
                VDIStaticCnt--;
            }
        }

        if(VDIStaticCnt > 10)
        {
            pHwContext->VDIMotionStatusByMethod3 = MOTION_FRAME;
        }
        else
        {
            pHwContext->VDIMotionStatusByMethod3 = STATIC_FRAME;
        }
    }
}


BOOL PQ_GetMotionStatusByMethod3(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    
    return pHwContext->VDIMotionStatusByMethod3;
}


void PQ_SetMotioncond(void)
{
    UINT32 ucvdi_mot_cnt = PQ_RegisterRead(VIP_vdi_mot_cnt);

    if (ucvdi_mot_cnt < STATIC_FRAME_THRESHOLD)
    {
        PQ_RegisterWrite(VIP_reg_slr_motion_cond, 0);
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_slr_motion_cond, 4);
    }
}

//****************************************************************************
//
//   Function   : PQ_GmeEnableControl
//   Params    : none
//   Description: enable /disable GME function in specific status
//   Returns    : void
//   note :VIP_reg_vdi_mad_mcd_en must sync with VIP_reg_slr_gme_en
//            1. all color syste in CVD2 output within display and scan channel is 720 width in 533, the condiction VIP_GetScalerPreScaleH()<=720 will
//                always true, mean GME will always enable in 533/CVD2, disable GME in CVD2 source to sync the behavior with 331
//            2. NOTE!!! VIP_reg_vdi_lb_c422in (6002[2] should set 0/1 sync with 6002[0] after 6710)
//           
//****************************************************************************

void PQ_GmeEnableControl(void)
{
    UINT8 ucUserSource;
    UINT8 ucSubSource;
    UINT8 ucSD;
    UINT8 uDisableFlag = FALSE;

    VIP_GetSource(&ucUserSource, &ucSubSource);

	/*MPEG has MHEG5  it will cut edge cause the HD detect to SD, cause some video fuzzy. like mantis 0038744 */
	if(ucUserSource == SOURCE_MPEG)
		ucSD = (VIP_GetInputHSize()<=720 && VIP_GetInterlaceMode())?1:0;
	else
    	ucSD = (VIP_GetScalerPreScaleH()<=720 && VIP_GetInterlaceMode())?1:0;

	
    if(ucUserSource == SOURCE_MPEG|| ucUserSource == SOURCE_CVD2)
    {
        uDisableFlag = TRUE;
    }

	/*[20160328] close gme in dtv beacuse it has too many garbage issue in ff/fb when playing like mantis 35178/34491*/
    if((ucSD) && !VIP_GetBobTopSt()&& (!uDisableFlag))// Set GME ON
    {
        PQ_RegisterWrite(VIP_reg_slr_gme_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_mad_mcd_en, 1);// must sync with VIP_reg_slr_gme_en
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_slr_gme_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_mad_mcd_en, 0);// must sync with VIP_reg_slr_gme_en
    }


    if(ucUserSource == SOURCE_CVD2)
    {
        PQ_RegisterWrite(VIP_reg_vdi_lb_double_en, 0);
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_vdi_lb_double_en, ucSD?1:0);
    }
    
   
}


void PQ_GmeSetupWritePath(void)
{
    if(((VIP_GetScalerPreScaleH()<=720 && VIP_GetInterlaceMode())) && !VIP_GetBobTopSt())
    {
        UINT8 ucSD;
        UINT32 ulHsize, ulVsize;

        ucSD = (VIP_GetScalerPreScaleH()<=720 && VIP_GetInterlaceMode())?1:0;
        ulHsize = PQ_RegisterRead(VIP_reg_slr_out_width);//VIP_GetScalerPreScaleH();
        ulVsize = PQ_Get_VDI_VSize();

        PQ_RegisterWrite(VIP_reg_vdi_mad_mc_comb_c1th1  ,((28000 *(( ulHsize * ulVsize*10) / (720 *480)))/10));
        PQ_RegisterWrite(VIP_reg_vdi_mad_mc_comb_c2th1  ,((7000* (( ulHsize * ulVsize*10) / (720 *480)))/10));
        PQ_RegisterWrite(VIP_reg_vdi_mad_mc_comb_c2th2  ,((500 * (( ulHsize * ulVsize*10) / (720 *480)))/10));
        PQ_RegisterWrite(VIP_reg_vdi_mad_mc_comb_c3th1  ,((38 * (( ulHsize * ulVsize*10) / (720 *480)))/10));
        PQ_RegisterWrite(VIP_reg_vdi_mad_mc_comb_th     ,((1050 * (( ulHsize * ulVsize*10) / (720 *480)))/10));

        
        PQ_RegisterWrite(VIP_reg_picx_ynx_en, 0); //chienjen

        if((ucSD) && !VIP_GetBobTopSt())
        {
            PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hsize , ulHsize/8);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mc_0ve , ulVsize/6-1);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mc_1ve ,(ulVsize/6-1) + ulVsize/6);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mc_2ve ,(ulVsize/6-1) + ulVsize/6 * 2);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mc_3ve ,(ulVsize/6-1) + ulVsize/6 * 3);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mc_4ve ,(ulVsize/6-1) + ulVsize/6 * 4);
            PQ_RegisterWrite(VIP_reg_vdi_mad_mc_5ve , ulVsize-1); 

        }

    }

    PQ_GmeEnableControl();
}


void PQ_GmeSetupReadPath(void)
{
    if(((VIP_GetScalerPreScaleH()<=720 && VIP_GetInterlaceMode())) && !VIP_GetBobTopSt())
    {
        UINT32 ulHsize, ulVsize;
        ulHsize = PQ_RegisterRead(VIP_reg_slr_out_width);//VIP_GetScalerPreScaleH();
        ulVsize = PQ_Get_VDI_VSize();

        PQ_RegisterWrite(VIP_reg_slr_gme_block_hnum, ulHsize/8);
        PQ_RegisterWrite(VIP_reg_slr_gme_block_hnum_last, ulHsize - 7*(ulHsize/8));
        PQ_RegisterWrite(VIP_reg_slr_gme_block_vnum,  ulVsize/6);
        PQ_RegisterWrite(VIP_reg_slr_gme_block_vnum_last, ulVsize- 5*(ulVsize/6));


        PQ_RegisterWrite(VIP_reg_slr_gme_mvx_limit, 9);
        PQ_RegisterWrite(VIP_reg_slr_gme_ysht_pol, 1);
        PQ_RegisterWrite(VIP_reg_slr_gme_mvx_pol, 0);
        PQ_RegisterWrite(VIP_reg_slr_gme_mvy_pol, 1);
        PQ_RegisterWrite(VIP_reg_slr_gme_sel_pol, 1);
        PQ_RegisterWrite(VIP_reg_slr_gme_blend_sel, 0);
        PQ_RegisterWrite(VIP_reg_slr_gme_mvcnt_yth, 10);
        PQ_RegisterWrite(VIP_reg_slr_3field_diff_th, 0x100);
        PQ_RegisterWrite(VIP_reg_slr_sd_3field_mix_en, 0);
    
    }

    PQ_RegisterWrite(VIP_reg_slr_sd_3field_en, 0);

}

void PQ_MADSetup(UINT32 vdi_hsize_i, UINT32 vdi_vsize, UINT32 vdi_total)
{
	UINT32 rscomb_hsize,rscomb_vsize,rscomb_total;


	//Enable all MAD function
	//0x6070
	//PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 1);
	//PQ_RegisterWrite(VIP_reg_vdi_mad_tpc_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mot_diff_dis, 1);
	if((VIP_GetUserSource()==MPEG) && (VIP_GetInputResMode() == RESMODE_1920X1080) && (VIP_GetInterlaceMode()))
		PQ_RegisterWrite(VIP_reg_vdi_mad_iir_en, 0);
	else
		PQ_RegisterWrite(VIP_reg_vdi_mad_iir_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_smw_en, 1);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_smw_sel, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_sb_iir_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_comb_en, 1);

	//--------------------------------------------------------------------------------------------------


	//0x6071
	PQ_RegisterWrite(VIP_reg_vdi_mad_stc_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_dyn_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_det_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_fil_mth, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_32cmp_sel, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_comb_rgn_en, 1);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_hfil_en, 0);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_hfil_sel, 0);

	//0x6072
	PQ_RegisterWrite(VIP_reg_vdi_mad_loa_pol, 0);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mot_sel, 0);

	PQ_RegisterWrite(VIP_reg_vdi_mad_pix32_dyn_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_32mot_sel, 0);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_m2s_adj_en, 0);
	PQ_RegisterWrite(VIP_reg_vdi_mad_m2sg_alpha_adj_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_c_en, 0);


	//0x6073

	PQ_RegisterWrite(VIP_reg_vdi_mad_tp_vfil_coef, 3);

	//Comb detection
	rscomb_hsize= (vdi_hsize_i+3)/4;
	rscomb_vsize= (vdi_vsize+3)/4;
	rscomb_total= rscomb_hsize * rscomb_vsize;
	PQ_RegisterWrite(VIP_reg_vdi_mad_comb_th2, 32);
	PQ_RegisterWrite(VIP_reg_vdi_mad_comb_th1, 8); //2009-01-05 pc update

	if((VIP_GetInputResMode() == RESMODE_720X480) && (VIP_GetInterlaceMode()))
		PQ_RegisterWrite(VIP_reg_vdi_mad_scomb_th1, 0xa); //2015-01-06 HiviCase Mobile subtitles 
	else	
		PQ_RegisterWrite(VIP_reg_vdi_mad_scomb_th1, 32); //2009-01-05 pc update

	PQ_RegisterWrite(VIP_reg_vdi_mad_scomb_th2, 64);
	PQ_RegisterWrite(VIP_reg_vdi_mad_rscomb_hsize, rscomb_hsize);
	PQ_RegisterWrite(VIP_reg_vdi_mad_rscomb_vsize, rscomb_vsize);
	PQ_RegisterWrite(VIP_reg_vdi_mad_rscomb_nrthd, rscomb_total/80); //x0.125
	PQ_RegisterWrite(VIP_reg_vdi_mad_rscomb_ucthd, rscomb_total/200);//x0.005
	PQ_RegisterWrite(VIP_reg_vdi_mad_rscomb_bcthd, rscomb_total/200);//x0.005

	//set field_compare
	PQ_RegisterWrite(VIP_reg_vdi_ne_vds, 1);
	PQ_RegisterWrite(VIP_reg_vdi_ne_vde, vdi_vsize-2);
	PQ_RegisterWrite(VIP_reg_vdi_mad_fc_hds, 2);
    if(VIP_IsAVSource() && (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M || VIP_GetStdColorSystem() == CVD2_STD_NTSC_443))
    {
        //PQ_RegisterWrite(VIP_reg_vdi_mad_fc_hde, 0x318); //mantis #35655
        PQ_RegisterWrite(VIP_reg_vdi_mad_fc_hde, 0x39d); //video book deinterlace#1 ch#6 text comb issue, trade off behavior between #35655 and text issue        
    }
    else
    {
	    PQ_RegisterWrite(VIP_reg_vdi_mad_fc_hde, vdi_hsize_i-3);
    }
	PQ_RegisterWrite(VIP_reg_vdi_mad_himotfd_thd, vdi_total/10);
	PQ_RegisterWrite(VIP_reg_vdi_mad_lomotfd_thd, vdi_total/540);

	{
	UINT8 ucHDMI1080i = (VIP_GetUserSource()==SOURCE_HDMI && VIP_GetInterlaceMode());
	//# gdet setting
	PQ_RegisterWrite(VIP_reg_vdi_mad_gdet_period, ucHDMI1080i?4:1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_gdet_th, ucHDMI1080i?0xca80:vdi_total/16);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2sg_a, 16);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2sg_b, 0);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_m2sg_a, 16);
//	PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_m2sg_b, 0);
	PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_s2mg_alpha, 3);
	PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2sg_alpha, 8);
	}
	//static degree th
	PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_static_th, 9);
	PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_iir_stc_th, 7);
	//6501 0x35
	PQ_RegisterWrite(VIP_reg_vdi_mad_sd_denom_max_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_sd_denom_hhp_en, 0);
	PQ_RegisterWrite(VIP_reg_vdi_mad_tpc_w_adj_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_field_block_choice, 0);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_absdiff_en, VIP_IsATVSource()?0:1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mot_diff_dis, 1);
	PQ_RegisterWrite(VIP_reg_vdi_mad_pix_stc_sel, 0);
	PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2sg_alpha, 8);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_m2sg_alpha, 8);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope, VIP_IsAVSource()?4:2);
	if(VIP_IsAVSource() && VIP_GetStdColorSystem() == CVD2_STD_NTSC_443)
	{
		 PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_slope, 2);
	}
	if((VIP_IsAVSource() || VIP_IsATVSource()) && (VIP_GetStdColorSystem() <= CVD2_STD_NTSC_443))
	{
		 PQ_RegisterWrite(VIP_reg_vdi_mad_mbw_xoff, 1);
	}

#if 0
	if(VIP_GetUserSource()==SOURCE_HDMI && pHwContext->cInterlaceMode)
		PQ_RegisterWrite(VIP_reg_slr_spw_lp_mth, 1);
	else
		PQ_RegisterWrite(VIP_reg_slr_spw_lp_mth,  VIP_IsATVSource()?1:0);
#elif 0
	PQ_RegisterWrite(VIP_reg_slr_spw_lp_mth, 0);
#else
	PQ_RegisterWrite(VIP_reg_slr_spw_lp_mth,  VIP_IsATVSource()?1:0);
#endif
	if(VIP_GetUserSource() == SOURCE_MPEG || (VIP_GetInterlaceMode() && abs(VIP_GetInputVSize() -1080)<20))
	{
		PQ_RegisterWrite(VIP_reg_slr_mix_static_feature, 0);
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2ss_alpha, 3);
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2s_alpha, 3);

	}else
	{
		PQ_RegisterWrite(VIP_reg_slr_mix_static_feature, 1);
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2ss_alpha, 8);
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_m2s_alpha, 4);

	}

	if(VIP_GetInterlaceMode() && abs(VIP_GetInputVSize() -1080)<20)
		PQ_RegisterWrite(VIP_reg_slr_static_en2, 0);
	else
		PQ_RegisterWrite(VIP_reg_slr_static_en2, 1);

	PQ_HmeSetup(vdi_hsize_i, vdi_vsize);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_mins_thz, 4);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_meds_thz, 3);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_maxs_thz, 6);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_mins_th1, 4);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_meds_th1, 7);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_mins_th2, 7);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_min_thz,	0);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_med_thz,	2);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_max_thz,	3);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_min_th1,	3);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_med_th1,	4);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mc_hdiff_min_th2,	6);

}

void PQ_2232DetSetup(UINT32 vdi_total)
{
	//Dynamic 32 detection
	PQ_RegisterWrite(VIP_reg_vdi_mad_pixel32_thd, 40);
	PQ_RegisterWrite(VIP_reg_vdi_mad_pixel32_minthd, 20);
	PQ_RegisterWrite(VIP_reg_vdi_mad_pixel32_maxthd, 80);
	PQ_RegisterWrite(VIP_reg_vdi_mad_pixel32_motthd, 32);

	PQ_RegisterWrite(VIP_reg_vdi_mad_mchfield_thd, vdi_total/1200);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mchfield_minthd, vdi_total/2400);
	PQ_RegisterWrite(VIP_reg_vdi_mad_mchfield_maxthd, vdi_total/800);

	if(VIP_GetUserSource() == SOURCE_CVD2 && VIP_IsAVSource())//KW request 2012/11/06
	{
		PQ_RegisterWrite(VIP_reg_vdi_fastmotion_thd, 0x4500); //yj, 20160121
		PQ_RegisterWrite(VIP_reg_vdi_combcnt_fm_same_thd, 0x450);
		PQ_RegisterWrite(VIP_reg_vdi_combcnt_hm_fs_thd, 0x450);
		PQ_RegisterWrite(VIP_reg_vdi_fm_miss_comb_min, 0x90f);
		PQ_RegisterWrite(VIP_reg_vdi_22movie_verfy_thd, 0xa);
	}
	else
	{
	    if(VIP_GetUserSource() == SOURCE_HDMI && VIP_GetInterlaceMode() && (VIP_GetInputVSize() <= (480+24)))
        {
            PQ_RegisterWrite(VIP_reg_vdi_fastmotion_thd, 0x3300);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_vdi_fastmotion_thd, vdi_total/14);
        }
		//Dynamic 22 detection
		PQ_RegisterWrite(VIP_reg_vdi_combcnt_fm_same_thd, vdi_total/115);
		PQ_RegisterWrite(VIP_reg_vdi_combcnt_hm_fs_thd, vdi_total/58);
		//PQ_RegisterWrite(VIP_reg_vdi_fm_miss_comb_min, vdi_total/675);
		PQ_RegisterWrite(VIP_reg_vdi_fm_miss_comb_min, (vdi_total-2800)/132);
		PQ_RegisterWrite(VIP_reg_vdi_22movie_verfy_thd, 0x5);
	}
	//if(VIP_GetUserSource() == SOURCE_CVD2 || pHwContext->bScartRGBMode)
	//	PQ_RegisterWrite(VIP_reg_vdi_22fastmotion_thd, 0xfb0);	//to fix 45 degree white line is borken in 22 issue
	//else
//		PQ_RegisterWrite(VIP_reg_vdi_22fastmotion_thd, vdi_total/5);
	PQ_RegisterWrite(VIP_reg_vdi_22fastmotion_thd		,0xffff);
	PQ_RegisterWrite(VIP_reg_vdi_combratio_fm_same 	,0x10);
	PQ_RegisterWrite(VIP_reg_vdi_combratio_fm_miss 	,0x80);
	PQ_RegisterWrite(VIP_reg_vdi_combratio_hm_fm_same	,0x10);
	PQ_RegisterWrite(VIP_reg_vdi_combratio_hm_fm_miss	,0x80);

	PQ_RegisterWrite(VIP_reg_vdi_ad_break_fc_thd, vdi_total/1350);
	PQ_RegisterWrite(VIP_reg_vdi_ad_break_comb_thd, vdi_total/45);
	PQ_RegisterWrite(VIP_reg_vdi_stc_break_fc_thd, vdi_total/1350);
	PQ_RegisterWrite(VIP_reg_vdi_22fastback_off, 0);
	PQ_RegisterWrite(VIP_reg_vdi_22fast_break, 1);
	PQ_RegisterWrite(VIP_reg_vdi_22static_break, 1);
	PQ_RegisterWrite(VIP_reg_vdi_22fastsim_kikin, 0);
	//0x6141
	//PQ_RegisterWrite(VIP_reg_vdi_dyn32_en,1);
	PQ_RegisterWrite(VIP_reg_vdi_last_mov32_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_fsame32_sel, 1);
	PQ_RegisterWrite(VIP_reg_vdi_dyn32_en, 1);
	PQ_RegisterWrite(VIP_reg_vdi_fast_syncback, 1);
	PQ_RegisterWrite(VIP_reg_vdi_fastsim_kikin, 0);
	PQ_RegisterWrite(VIP_reg_vdi_32qual_22result, 0);
	PQ_RegisterWrite(VIP_reg_vdi_32subt_break_en, 0);

	PQ_RegisterWrite(VIP_reg_slr_mesh_en,	0);

	PQ_RegisterWrite(VIP_reg_vdi_sameframe_thd, 0x24);
}


void PQ_VDISize(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	BOOL bDemoMode,bMpegNrEnable;
	UINT32 vdi_hsize_i,vdi_vsize,vdi_total;

	bDemoMode= PQ_RegisterRead(VIP_reg_vdi_tnr_debug_en);
	bMpegNrEnable= (pHwContext->nMPEGNRLevel>OFF) ? ENABLE : DISABLE;
	vdi_hsize_i= VIP_GetScalerPreScaleH(); //= (reg_adix_che-reg_adix_chs) * 2048 / reg_slr_hfactor
	vdi_vsize= PQ_Get_VDI_VSize(); //= reg_adix_cve-reg_adix_cvs
	vdi_total= vdi_hsize_i*vdi_vsize;

	PQ_MADSetup(vdi_hsize_i, vdi_vsize, vdi_total);

    if(VIP_GetFrameBufferNum() == 1 || VIP_IsATVSource() || VIP_IsSourceDTV())
    {
        PQ_SetFilmMode(DISABLE);
    }
    else
    {
        PQ_2232DetSetup(vdi_total);
    }

	PQ_NERegion(bDemoMode, vdi_hsize_i, vdi_vsize); //NR relative setting


	PQ_NRLevel(pHwContext->nNRLevel, vdi_total);


	if( bMpegNrEnable )
	{
		PQ_MPEGNRLevel(pHwContext->nMPEGNRLevel, vdi_total);
	}

	//Deblock filter
	PQ_DeblockFilterAndDetect(bDemoMode, vdi_hsize_i, vdi_vsize);
}


BOOL PQ_CheckTableCheckSum(UINT8* pVipTable)
{
	PQ_TABLE_BOOK* pTableBook= (PQ_TABLE_BOOK*) pVipTable;
	UINT32 ulCheckSum,i;

	ulCheckSum= 0;
	for(i=pTableBook->nChkFrom; i<pTableBook->nChkTo; i++)
	{
		ulCheckSum+= pVipTable[i];
	}

	if(ulCheckSum == pTableBook->nChkSum )
		return TRUE;
	else
		return FALSE;
}


void PQ_LoadSettingTable(UINT8* pVipTable, UINT8 ucTableIndex)
{
	PQ_TABLE_BOOK* pTableBook= (PQ_TABLE_BOOK*) pVipTable;
	UINT32 ulTableOffset,ulTableCount,ulRegister,ulValue,i;
	volatile UINT32* pAddr;

	if( ucTableIndex>=pTableBook->nTotalTable )
		return;

	ulTableOffset= pTableBook->TableIndex[ucTableIndex].nOffset + (UINT32)pVipTable;
	ulTableCount= pTableBook->TableIndex[ucTableIndex].nSize >> 3;
	pAddr= (volatile UINT32*) ulTableOffset;

	for (i=0; i<ulTableCount; i++)
	{
		ulRegister= *pAddr;
		if((ulRegister & PQ_REG_END_OF_SUB_TAB) != PQ_REG_END_OF_SUB_TAB)
		{
			ulValue= *(pAddr+1);
			//PQDebugPrint("%s: i=0x%lx ulRegister=0x%8.8lx ulValue=0x%8.8lx", __FUNCTION__, i, ulRegister, ulValue);

			PQ_RegisterWrite(ulRegister, ulValue);
			//printk("Register:0x%x,Value:0x%x \n",ulRegister,ulValue);

		}
		pAddr+= 2;
	}
}


void PQ_DefaultSetting(void)
{
	UINT8* pVipTable= (UINT8*) SPI_VIPTABLE_SHADOWADDR;
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT8 i;

    //new function since 533
    *(volatile unsigned char*)(0xbe1cddfd)=0x0; // suggest by JengYun 20160713

	/*Some common settings initialize here*/

	//for Constrast
	PQ_RegisterWrite(VIP_reg_dpy_rgb_int, 1);
	//for Saturation
	PQ_RegisterWrite(VIP_reg_dpy_hsv, 0x1);
	//for Hue, Flesh-tone, ColorRegion, Dynamic Constrast
	PQ_RegisterWrite(VIP_reg_dpy_yuv_int, 0x1);
	PQ_RegisterWrite(VIP_reg_dpy_rgn_int, 0x1);
	//PQ_RegisterWrite(VIP_reg_dpy_u_reset, 0x0);

	PQ_RegisterWrite(VIP_reg_dpy_rgb_int, 0);


	if( PQ_CheckTableCheckSum(pVipTable) )
	{
		PQDebugPrint("%s: Load VipTable from flash rom", __FUNCTION__);
		PQ_LoadSettingTable(pVipTable, VTAB_INITIAL_TALBE);
		PQ_LoadSettingValue(pVipTable, VTAB_INITIAL_VALUE);
		for(i=0; i<VTAB_MAX_SOURCE; i++)
			PQ_LoadSettingValue(pVipTable, VTAB_EXTS_YPP_VALUE+i);
	}
	else
	{
		PQDebugPrint("%s: VipTable is not loaded, using default setting.", __FUNCTION__);

		/*Some initial values not adjustable in menu*/

		//Sync Detection range for cnt H-V
		PQ_RegisterWrite(VIP_reg_adi_exts_hs_thd, 0xf);
		PQ_RegisterWrite(VIP_reg_adi_exts_vs_thd, 0x7);

		/*Init Brightness*/

		/*Init Constrast*/

		/*Init Sharpness*/
		//Luma Sharpness filter
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hl_smooth, 0x8); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hl_sharp, 0x20); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hl_pivotx, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hl_pivoty, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hl_trans1, 2); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hl_trans2, -2); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hl_limit, 0x0); //menu adjust
		//Protect strong vertical edge from jaggy
		PQ_RegisterWrite(VIP_reg_dpy_filter_hl_alpha_th, 0x18);
		PQ_RegisterWrite(VIP_reg_dpy_filter_hl_alpha_trans, 0);
		PQ_RegisterWrite(VIP_reg_dpy_filter_hl_alpha_limit, 0x8);

		//PQ_RegisterWrite(VIP_reg_dpy_filter_hc_smooth, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hc_sharp, 0x10); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hc_pivotx, 0x0c); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hc_pivoty, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hc_trans1, 2); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hc_trans2, -2); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_hc_limit, 0x0);//menu adjust

		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_pivotx, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_pivoty, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_smooth, 0x8); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_sharp, 0x8);  //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_trans1, 2); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_trans2, -2); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_limit, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vl_hp_limit, 0x14); //menu adjust

		//PQ_RegisterWrite(VIP_reg_dpy_filter_vc_smooth, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vc_sharp, 0x10); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vc_pivotx, 0x0c); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vc_pivoty, 0x0); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vc_trans1, 2); //menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vc_trans2, -2);//menu adjust
		//PQ_RegisterWrite(VIP_reg_dpy_filter_vc_limit, 0x0); //menu adjust
		PQ_RegisterWrite(VIP_reg_dpy_filter_chroma, 0x1);

		//VIP_ProgramColorProcess() setup this
		//PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, 0x78);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, 0x8);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, 0x0);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, 0x4);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, 0x78);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, 0x8);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, 0x0);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, 0x4);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, 0x78);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, 0x8);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, 0x0);
		//PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, 0x4);

		//VIP_ProgramColorProcess() setup this
		PQ_RegisterWrite(VIP_reg_dpy_filter_y_h1, 0x778);
		PQ_RegisterWrite(VIP_reg_dpy_filter_y_h2, 0x3a);
		PQ_RegisterWrite(VIP_reg_dpy_filter_y_h3, 0xb);
		PQ_RegisterWrite(VIP_reg_dpy_filter_y_h4, 0x7fb);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h1, 0x778);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h2, 0x3a);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h3, 0xb);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cb_h4, 0x7fb);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h1, 0x778);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h2, 0x3a);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h3, 0xb);
		PQ_RegisterWrite(VIP_reg_dpy_filter_cr_h4, 0x7fb);
		PQ_RegisterWrite(VIP_reg_dpy_filter_hl_smooth1, 64); //menu adjust
		PQ_RegisterWrite(VIP_reg_dpy_filter_hl_sharp, 64); //menu adjust
		PQ_RegisterWrite(VIP_reg_dpy_filter_hc_smooth1, 64); //menu adjust
		PQ_RegisterWrite(VIP_reg_dpy_filter_hc_sharp, 64); //menu adjust


		/*Init Dynamic Contrast */
		//PQ_RegisterWrite(VIP_reg_dpy_hist_en,DISABLE);
		//PQ_RegisterWrite(VIP_reg_dpy_hist_dyn_bp, 0x0);
		PQ_RegisterWrite(VIP_reg_dpy_hist_int, ENABLE);
		PQ_RegisterWrite(VIP_reg_dpy_hist_chroma_en, 0x1);
	}

	PQ_3DNoiseReductoin(OFF, 0, 0);
	PQ_MPEGNoiseReductoin(OFF,0,0);

	PQ_RegisterWrite(VIP_reg_dpy_u_reset, 0x0);
	PQ_RegisterWrite(VIP_reg_slr_hme_22det_en,0x0);

	pHwContext->LoadPQTable=1;

	//330
	PQ_Default_Color_Lut_Setting();
	PQ_RegisterWrite(VIP_reg_dpy_first_layer, 3);

}


//================================================================================
//	function name		: PQ_VideoDetectionSetup
//	input parameter	:
//	output parameter	: none
//	purpose			: setup vdi control register
//   return			: none

void PQ_VideoDetectionSetup(UINT8 ucSource, UINT8 ucSubSource, BOOL bFunctionEnable)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    UINT32 vdi_hsize_i,vdi_vsize,vdi_total;
    BOOL bDemoMode,bNrEnable,bMpegNrEnable,bATVSource,bPCSource;
    BOOL bDeblockEnable;

    PQDebugPrint("%s: InterlaceMode=%d", __FUNCTION__, VIP_GetInterlaceMode());

    DRV_VDI_Reset(TRUE);

    //deinterlace setup
    if(VIP_GetInterlaceMode())
    {
        PQ_RegisterWrite(VIP_reg_vdi_interlace, 1);    
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_vdi_interlace, 0);  
    }

    PQ_RegisterWrite(VIP_reg_gfx_buf_bypass,0);
    
    if( bFunctionEnable )
    {
        bATVSource= (ucSource==CVD2) && (ucSubSource==TV_INPUT_CHANNEL);
        bPCSource= (ucSource==EXTS) && (ucSubSource==DSUB);
	
        bDemoMode= PQ_RegisterRead(VIP_reg_vdi_tnr_debug_en);
        bNrEnable= (pHwContext->nNRLevel>OFF) ? ENABLE :DISABLE;
        bMpegNrEnable= (pHwContext->nMPEGNRLevel>OFF) ? ENABLE : DISABLE;
        bDeblockEnable= (!VIP_IsPCSource()) && (!VIP_RunDVIMode()) && (VIP_GetInputResMode()!=RESMODE_NON_STD);
        vdi_hsize_i= VIP_GetScalerPreScaleH(); //= (reg_adix_che-reg_adix_chs) * 2048 / reg_slr_hfactor
        vdi_vsize= PQ_Get_VDI_VSize(); //= reg_adix_cve-reg_adix_cvs
        vdi_total= vdi_hsize_i*vdi_vsize;

        if(ucSource==SOURCE_HDMI && (Panel_H_Start_Offset>10 || Panel_H_End_Offset>10 || Panel_V_Start_Offset>10 || Panel_V_End_Offset>10) && (VIP_GetSourcePixelClock()>165000000))
        {
            DRV_VDI_MemReadEn(DISABLE);  
        }
        else
        {
            DRV_VDI_MemReadEn(ENABLE);
        }
        PQ_RegisterWrite(VIP_reg_vdi_nomrd_4prev1, VIP_GetInterlaceMode()?0:1);
        PQ_RegisterWrite(VIP_reg_vdi_take_m32, 0);

        // from Eric  to fix ATV NTSC ���u�а{�G�I like mantis 0045141
        if(VIP_IsATVSource() && (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M || VIP_GetStdColorSystem() == CVD2_STD_NTSC_443))
            PQ_RegisterWrite(VIP_reg_vdi_take_m22, 1);
        else
        	PQ_RegisterWrite(VIP_reg_vdi_take_m22, 0);

        if (VIP_GetUserSource()!= SOURCE_HDMI && VIP_GetUserSource()!= SOURCE_MPEG)
            bNrEnable = ENABLE;

        if(VIP_IsPCSource() || VIP_RunDVIMode())
            bNrEnable=DISABLE;

        PQ_RegisterWrite(VIP_reg_vdi_tnr_en, bNrEnable); //always enable in ATV, AV
        PQ_RegisterWrite(VIP_reg_vdi_dbk_en, bMpegNrEnable && bDeblockEnable); //PC-2008-12-18
        #ifdef VIP_SCALER_3D
        if(VIP_GetInput3dType() == INPUT_3D_INTERLEAVING)
            PQ_RegisterWrite(VIP_reg_vdi_mad_en,DISABLE);
        else
        #endif
        PQ_RegisterWrite(VIP_reg_vdi_mad_en, VIP_GetInterlaceMode() ? ENABLE: DISABLE);
        PQ_RegisterWrite(VIP_reg_vdi_snr_hfil_en, bNrEnable);
        PQ_RegisterWrite(VIP_reg_vdi_snr_vfil_en, bNrEnable);

        if(ucSource==CVD2)
            PQ_RegisterWrite(VIP_reg_vdi_sigmanr_en,0);//to reduce edge for CVD2 2009-03-09 requested by PC/Henry
        else
        	PQ_RegisterWrite(VIP_reg_vdi_sigmanr_en, bNrEnable);

        PQ_RegisterWrite(VIP_reg_vdi_sigmanr_opt1, 1);

        if((VIP_GetInputDataFormat()==RGB) || bPCSource )
            PQ_RegisterWrite(VIP_reg_vdi_mnr_fil_en, 0);
        else
            PQ_RegisterWrite(VIP_reg_vdi_mnr_fil_en, bMpegNrEnable);

        PQ_RegisterWrite(VIP_reg_vdi_mad_loa_en, 1);

        PQ_MADSetup(vdi_hsize_i, vdi_vsize, vdi_total);

        if(VIP_GetFrameBufferNum() == 1 || VIP_IsATVSource() || VIP_IsSourceDTV())
        {
            PQ_SetFilmMode(DISABLE);
        }
        else
        {
            PQ_2232DetSetup(vdi_total);
        }

        PQ_NERegion(bDemoMode, vdi_hsize_i, vdi_vsize); //NR relative setting
        PQ_NRLevel(pHwContext->nNRLevel, vdi_total);

        if( bMpegNrEnable )
        {
        	PQ_MPEGNRLevel(pHwContext->nMPEGNRLevel, vdi_total);
        }

        //TNR, SNR adjust by NE
        //0x6020=0x2f
        PQ_RegisterWrite(VIP_reg_vdi_tnr_th_dyn_adj, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dith_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_sel, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_7tap, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_sel, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_dyn_adj, VIP_GetInputVSize()<720?0:1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_low_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_ultra_mbw_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_snr_adj_en,1);
        PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_lp_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_snr_hor_mix_en, 1);

        //0x6032, 0x6035, 0x6026,
        PQ_RegisterWrite(VIP_reg_vdi_snr_h_fact0, 0x08);
        PQ_RegisterWrite(VIP_reg_vdi_snr_h_fact1, 0x04);
        PQ_RegisterWrite(VIP_reg_vdi_snr_h_fact2, 0x00); //Lee Sir-2009-02-10
        PQ_RegisterWrite(VIP_reg_vdi_snr_filter_sel_slope, bATVSource ? 0x3c : 0x20); //Lee Sir-2009-02-10
        PQ_RegisterWrite(VIP_reg_vdi_sigmanr_strength, bATVSource ? 0x4 : 0x3); //Lee Sir-2009-02-10

        PQ_RegisterWrite(VIP_reg_vdi_tnr_th1_s, 0);
        PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_bmax_sel, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_slope, VIP_GetInputVSize()<720?79:0x7f);

        PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s, VIP_GetInputVSize()<720?3:2);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s, VIP_GetInputVSize()<720?3:2);

        if(VIP_IsATVSource() && (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M))
			PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_chroma, 0x10);   // for blue sky noise issue #51967
		else
        	PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_chroma, VIP_GetUserSource()==SOURCE_CVD2?31:48);
       
        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_th1_s, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_slope_s, 2);
   
        //Deblock filter
        PQ_DeblockFilterAndDetect(bDemoMode, vdi_hsize_i, vdi_vsize);


        //MNR filter
        PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_hedge_th, 80);
        PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_vedge_th, 80);

        PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_3pixdet_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_mad_mnr_hexpn_en, 1);
    }

    VIP_SetVDIMode();
    PQ_RegisterWrite(VIP_reg_vdi_bypass, bFunctionEnable ? 0 : 1);	//always open in 9561
    DRV_VDI_Reset(FALSE);
    PQ_RegisterWrite(VIP_reg_vdi_sigmanr_factor,2);//2009-07-14 yuling adjust the factor to pass some ADC pattern shake issue.
    PQ_RegisterWrite(VIP_reg_gfx_dummy2, 0);

    if(VIP_GetBWModeStatus())
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_en, DISABLE);			
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_en, DISABLE);
    }
}


void PQ_ChromaMotionDetectControl(void)
{
	UINT32 uc_field_diff_cnt = PQ_RegisterRead(VIP_field_diff_cnt_lp);
	if(VIP_GetBWModeStatus() || (uc_field_diff_cnt< 0x1ff))
	{
		DRV_VDI_EnableChromaForMotionDetection(DISABLE);
	}
	else
	{
		DRV_VDI_EnableChromaForMotionDetection(ENABLE);
	}
}

void PQ_SetMenuValueCT(UINT8 ucFunID, INT32 iValue1,INT32 iValue2,INT32 iValue3 )
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;

	if( ucFunID==PQ_COLORTEMPGAIN)
	{
		pMenuValue->iColorTemp[0]= iValue1;//R GAIN
		pMenuValue->iColorTemp[1]= iValue2;//G GAIN
		pMenuValue->iColorTemp[2]= iValue3;//B GAIN

	//printk("\n\n\n\n    PQ_SetMenuValueCT R= 0X%0x,   G= 0X%0x,B= 0X%0x,     \n\n\n\n",iValue1,iValue2,iValue3);
	}

}

void PQ_SetUserCurve(UINT8 ucFunID, UINT8 ucPointIdx, INT16 iValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

    pHwContext->mCurveSetting[ucFunID].iValue[ucPointIdx] = iValue;
}

//remappig drvier value to OSD value by curve setting adjust
INT32 _MappingDrvValToOSD(UINT8 ucFunID, INT32 iDrvVal)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    INT16 OsdMax = 100, OsdNor = 50, OsdMin = 0;
    INT16 Curv_point0, Curv_point25, Curv_point50, Curv_point75, Curv_point100;

    if(ucFunID >= PQ_CT_R_GAIN && ucFunID <= PQ_CT_B_GAIN)
    {
        Curv_point0 =  0;
        Curv_point25 =  512;
        Curv_point50 =  1024;
        Curv_point75 =  1536;
        Curv_point100 =  2047;
    }
    else if(ucFunID >= PQ_CT_R_BIAS && ucFunID <= PQ_CT_B_BIAS)
    {
        Curv_point0 =  -1024;
        Curv_point25 =  -512;
        Curv_point50 =  0;
        Curv_point75 =  512;
        Curv_point100 =  1023;
    }
    else
    {
        Curv_point0 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_0];
        Curv_point25 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_25];
        Curv_point50 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_50];
        Curv_point75 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_75];
        Curv_point100 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_100];
    }

    if(iDrvVal == Curv_point100)
    {
        return 100;
    }
    else if(iDrvVal > Curv_point75 && iDrvVal < Curv_point100)
    {
        return (((iDrvVal - Curv_point75) * (OsdMax - 75)  +((Curv_point100 - Curv_point75)/2)) / (Curv_point100 - Curv_point75)) + 75;
    }
    else if(iDrvVal == Curv_point75)
    {
        return 75;
    }
    else if(iDrvVal > Curv_point50 && iDrvVal < Curv_point75)
    {
        return (((iDrvVal - Curv_point50) * (75 - OsdNor)  +((Curv_point75 - Curv_point50)/2)) / (Curv_point75 - Curv_point50)) + 50;        
    }
    else if(iDrvVal == Curv_point50)
    {
        return 50;
    }
    else if(iDrvVal > Curv_point25 && iDrvVal < Curv_point50)
    {
        return (((iDrvVal - Curv_point25) * ( OsdNor - 25)  +((Curv_point50 - Curv_point25)/2)) / (Curv_point50 - Curv_point25)) + 25;        
    }
    else if(iDrvVal == Curv_point25)
    {
        return 25;
    }
    else if(iDrvVal > Curv_point0 && iDrvVal < Curv_point25)
    {
        return (iDrvVal * ( 25 - OsdMin)  +((Curv_point25 - Curv_point0)/2)) / (Curv_point25 - Curv_point0);
    }
    else
    {
        return 0;
    }    
   
    
}


INT32 _MappingOSDValToDrv(UINT8 ucFunID, INT32 iOsdVal)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    INT16 OsdMax = 100, OsdNor = 50, OsdMin = 0;
    INT16 Curv_point0, Curv_point25, Curv_point50, Curv_point75, Curv_point100;
    INT16 iRealVal = 0;

    Curv_point0 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_0];
    Curv_point25 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_25];
    Curv_point50 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_50];
    Curv_point75 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_75];
    Curv_point100 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_100];

    if(ucFunID >= PQ_CT_R_GAIN && ucFunID <= PQ_CT_B_GAIN)
    {
        Curv_point0 =  0;
        Curv_point25 =  512;
        Curv_point50 =  1024;
        Curv_point75 =  1536;
        Curv_point100 =  2047;
    }
    else if(ucFunID >= PQ_CT_R_BIAS && ucFunID <= PQ_CT_B_BIAS)
    {
        Curv_point0 =  -1024;
        Curv_point25 =  -512;
        Curv_point50 =  0;
        Curv_point75 =  512;
        Curv_point100 =  1023;
    }
    else
    {
        Curv_point0 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_0];
        Curv_point25 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_25];
        Curv_point50 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_50];
        Curv_point75 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_75];
        Curv_point100 =  pHwContext->mCurveSetting[ucFunID].iValue[CURVE_SETTING_POINT_100];
    }

    if(ucFunID == PQ_CONTRAST)
    {
        OsdMax = 75;
        OsdMin = 25;
    }

    if (iOsdVal < 25)
    {
        iRealVal = (iOsdVal - OsdMin ) * (Curv_point25 - Curv_point0) / (25 - OsdMin ) + Curv_point0;
    }
    else if (iOsdVal == 25)
    {
        iRealVal = Curv_point25;
    }
    else if (25 < iOsdVal && iOsdVal < OsdNor)
    {
        iRealVal = (iOsdVal - 25) * (Curv_point50 - Curv_point25) / (OsdNor - 25) + Curv_point25;
    }
    else if (iOsdVal == OsdNor)
    {
        iRealVal = Curv_point50;
    }
    else if (OsdNor < iOsdVal && iOsdVal < 75)
    {
        iRealVal = (iOsdVal - OsdNor) * (Curv_point75 - Curv_point50) / (75 - OsdNor) + Curv_point50;
    }
    else if (iOsdVal == 75)
    {
        iRealVal = Curv_point75;
    }
    else if (75 < iOsdVal && iOsdVal < OsdMax)
    {
        iRealVal = (iOsdVal - 75) * (Curv_point100 - Curv_point75) / (OsdMax - 75) + Curv_point75;
    }
    else
    {
        iRealVal = Curv_point100;
    }

    return iRealVal;
    
}

INT32 PQ_GetMenuValue(UINT8 ucFunID)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    INT32* pMenuValueArray= (INT32*) (&pHwContext->MenuValue);

    if( ucFunID<=PQ_HUE )
    {
        return pMenuValueArray[ucFunID-PQ_BRIGHTNESS];
    }
    else if( ucFunID>=PQ_CT_R_GAIN && ucFunID<=PQ_CT_B_GAIN )
    {
        return pMenuValue->iColorTemp[ucFunID-PQ_CT_R_GAIN];
    }
    else if( ucFunID>=PQ_CT_R_BIAS && ucFunID<=PQ_CT_B_BIAS )
    {
        return pMenuValue->iColorBias[ucFunID-PQ_CT_R_BIAS];
    }
    else if( ucFunID==PQ_DYNAMIC_CONTRAST )
    {
        return pMenuValue->ucDCLevel;
    }
    else if( ucFunID==PQ_STATIC_GAMMA )
    {
        return pMenuValue->cSGOffset;
    }
    else if( ucFunID==PQ_DIGITAL_NR )
    {
        return pMenuValue->ucNRLevel;
    }
    else if( ucFunID==PQ_MPEG_NOISE_FILTER )
    {
        return pMenuValue->ucMPEGNRLevel;
    }
    else if( ucFunID==PQ_GAMMATABLE)
    {
        return pMenuValue->bNoGamma;
    }
    else if( ucFunID==PQ_COLOR_LUT_R_SAT_GAIN)
    {
        return lut_rgn_sat_gain[0];
    }

    return 0;
}

void PQ_SetMenuValue(UINT8 ucFunID, INT32 iValue)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    INT32* pMenuValueArray= (INT32*) (&pHwContext->MenuValue);

    if( ucFunID<=PQ_HUE )
    {
        pMenuValueArray[ucFunID-PQ_BRIGHTNESS]= iValue;
        #ifdef DynamicBacklight_EnergyEfficiency
        if(ucFunID - PQ_BRIGHTNESS == PQ_CONTRAST)
        {
            if(PQ_GetDynamicBLType()==DYNAMIC_BL_ENERGY_EFFICIENCY)
                PQ_EEBackLightDetect(TRUE);
        }
        #endif
    }
    else if( ucFunID>=PQ_CT_R_GAIN && ucFunID<=PQ_CT_B_GAIN )
    {
        pMenuValue->iColorTemp[ucFunID-PQ_CT_R_GAIN]= iValue;
    }
    else if( ucFunID>=PQ_CT_R_BIAS && ucFunID<=PQ_CT_B_BIAS )
    {
        pMenuValue->iColorBias[ucFunID-PQ_CT_R_BIAS]= iValue;
    }
    else if( ucFunID==PQ_DYNAMIC_CONTRAST )
    {
        pMenuValue->ucDCLevel= iValue;
    }
    else if( ucFunID==PQ_STATIC_GAMMA )
    {
        pMenuValue->cSGOffset= iValue;
    }
    else if( ucFunID==PQ_DIGITAL_NR )
    {
        pMenuValue->ucNRLevel= iValue;
    }
    else if( ucFunID==PQ_MPEG_NOISE_FILTER )
    {
        pMenuValue->ucMPEGNRLevel= iValue;
    }
    else if( ucFunID==PQ_GAMMATABLE)
    {
        if (iValue == 0xff)
            pMenuValue->bNoGamma=TRUE;
        else
            pMenuValue->bNoGamma=FALSE;
    }

}


void PQ_SourceSetting(UINT8 ucSource, UINT8 ucSubSource)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_SRC_VALUE_DEFINE* pVtab= PQ_GetSourceVTab(ucSource, ucSubSource);
    VTAB_CMN_VALUE_DEFINE* pVtabCmnValue= &pHwContext->VtabCmnValue;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    #ifndef MENU_SET_ENHANCED_COLOR
    INT8 cSG;
    #endif

    pHwContext->pCurVtabSrcValue= pVtab;
    pHwContext->PqPatch.Post2DPatch = POST_2D_SHARPNESS_DEFAULT;
    pHwContext->PqPatch.PostDLTIPatch = POST_DLTI_DEFAULT;
    pHwContext->PqPatch.DPYSharpnessPatch = DPY_SHARPNESS_DEFAULT;
    #ifndef MENU_SET_ENHANCED_COLOR
    //some enhanced setting not appearing in menu are setup here
    pHwContext->nMPEGNRLevel= MEDIUM;
    pHwContext->bNR_Reset_by_changeSrc = TRUE;
    cSG= 0;
    PQ_ColorSpaceMode(PQ_COLOR_SPACE_AUTO, ucSource);

    PQ_SetMenuValue(PQ_MPEG_NOISE_FILTER, MEDIUM);
    PQ_SetMenuValue(PQ_STATIC_GAMMA, cSG);
    #endif

    if (pVtabCmnValue->mGmaOpt.pc_no_gamma)
    {

        if (VIP_RunDVIMode() || VIP_IsPCSource())
        {
            PQDebugPrint("VTab, PC or DVI Turn off Gamma correction.");			
            PQ_DisableGammaTable(FALSE);//disable gamma function
        }
        else
        {
            if(pMenuValue->bNoGamma)
                PQ_DisableGammaTable(FALSE);
            else
                PQ_RegisterWrite(VIP_reg_dpy_no_gamma, FALSE);

        }
    }

    if( VIP_IsAVSource())// request by kent, can mmigrate to pqtool
    {
        PQ_RegisterWrite(VIP_REG_VDI_SIGMA_MISC_CTRL, 0x0);
    }
    else
    {
        PQ_RegisterWrite(VIP_REG_VDI_SIGMA_MISC_CTRL, 0x20);
    }

    PQ_SW_DynamicContrast_Param(0);
    PQ_Set_UV_Coring();
    PQ_Set_UV_Offset();
    PQ_SetFuzzyEliminate(DISABLE);
    ucVDI_Static_Cnt_2 = 0; //reset after change source
    PQ_SetColorBarFnFlag(DISABLE);

}

void PQ_SourceSelect(UINT8 ucUserInputSource)
{
	//Default Value_331
	PQ_RegisterWrite(VIP_reg_slr_yout_lw_limit	,0x0);
	/*switch(ucUserInputSource)
	{
		case SOURCE_MPEG:
			break;

		case SOURCE_CVD2:
			PQ_RegisterWrite(VIP_reg_slr_yout_lw_limit	,0x40);
			break;

		case SOURCE_HDMI:
			break;

		case SOURCE_EXTS:
			break;

		case SOURCE_PATTERN:
			break;

		case SOURCE_JPEG:
			break;
	}*/
}


void PQ_DPYSetup(UINT8 ucUserSource,UINT8 ucSubSource)
{
	PQ_SetupLUTTable(ENABLE);
	PQ_SetupSaturationGainCurve(SAT_GAIN_NORMAL);

	//sharp if dbk
	PQ_RegisterWrite(VIP_reg_dpy_hfil_dbk_ctl,VIP_IsAVSource()?1:0);
	PQ_RegisterWrite(VIP_reg_dpy_half_dbk_opt,VIP_IsAVSource()?1:2);
	PQ_RegisterWrite(VIP_reg_dpy_filter_hl_sharp_dbk, VIP_IsAVSource()?0x20:0);
	PQ_RegisterWrite(VIP_reg_dpy_filter_hc_sharp_dbk, VIP_IsAVSource()?0x20:0);


	#if 0
		//for bonnie request to avoid color noise in atv
		PQ_RegisterWrite(VIP_reg_dpy_uv_coring_th,VIP_IsATVSource()?7:4);
	#endif

}

void PQ_EnNRWorkQue_ISR(void)
{
    PQHW_CONTEXT* pHwContext = &PQHwContext;

    if (pHwContext->bSceneChg)
    	queue_work(WQ_Struct_NRAdjust,&WQ_NRAdjust);
    else
    {
    	if((++pHwContext->iAdjustNRCounter)>=0) //250
    	{
    		pHwContext->iAdjustNRCounter = 0;
		queue_work(WQ_Struct_NRAdjust,&WQ_NRAdjust);
    	}
    }

}




INT32 PQ_GetMenuHueValue(void)
{
	PQHW_CONTEXT* pHwContext = &PQHwContext;
	return pHwContext->MenuValue.iHue;
}

void PQ_SetLocationMode(UINT8 ucMode)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	pHwContext->ucLocationMode = ucMode;
}

void PQ_SetCurrContrastValue(INT32 iValue)
{
    PQHW_CONTEXT* pHwContext = &PQHwContext;
    pHwContext->iCurrContrastValue = iValue;
}


INT32 PQ_GetCurrContrastValue(void)
{
	PQHW_CONTEXT* pHwContext = &PQHwContext;
	return pHwContext->iCurrContrastValue;
}

void PQ_AdjustNRCounter_ISR(INT32 AdjustNRCounter)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	pHwContext->iAdjustNRCounter = AdjustNRCounter;
}


INT32 PQ_GetMenuColorBias(UINT8 index)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    return pHwContext->MenuValue.iColorBias[index];
}


void PQ_SetColorProcessor(BOOL bEnable)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	pHwContext->bEnableColorProcess= bEnable;
}

BOOL PQ_GetColorProcessor(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	return pHwContext->bEnableColorProcess;
}

UINT8 PQ_GetColorBarStatus(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	return pHwContext->bIsColorBar;
}

BOOL PQ_GetMatrixbypassCtl(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	return pHwContext->ucMatrixbypassCtl;
}

UINT8 PQ_Get_Source_Grouped_Index(void)
{
    UINT8 ucCurrSrcIndex=SRC_INDEX_UNKNOWN;
    UINT8 ucNTSC;
    UINT8 ucUserSource;
    UINT8 ucSubSource;
    UINT8 bDVDSource;
    bDVDSource = VIP_JudgeDVDSource();//Differentiate YPbPr and DVD

    VIP_GetSource(&ucUserSource, &ucSubSource);

    switch(VIP_GetUserSource())
    {
        case SOURCE_CVD2:
            ucNTSC = (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M || VIP_GetStdColorSystem() == CVD2_STD_NTSC_443);
            if (VIP_IsATVSource())
            {
                if (ucNTSC)
                {
                    ucCurrSrcIndex = SRC_INDEX_ATV_NTSC;
                }
                else
                {
                    ucCurrSrcIndex = SRC_INDEX_ATV_PAL;
                }
            }
            else if (VIP_IsAVSource())
            {
                if (ucNTSC)
                {
                    ucCurrSrcIndex = SRC_INDEX_AV_NTSC;
                }
                else
                {
                    ucCurrSrcIndex = SRC_INDEX_AV_PAL;
                }
            }
            else if (VIP_IsSVSource())
            {
                if (ucNTSC)
                {
                    ucCurrSrcIndex = SRC_INDEX_SVideo_NTSC;
                }
                else
                {
                    ucCurrSrcIndex = SRC_INDEX_SVideo_PAL;
                }
            }
            break;
        case SOURCE_EXTS:
            if (VIP_IsPCSource())
            {
                ucCurrSrcIndex = SRC_INDEX_PC;
            }
            else if(ucSubSource==SCART_RGB1)
            {
                ucCurrSrcIndex = SRC_INDEX_SCART_RGB;
            }
            else
            {
                /* tune for ypp source */
                if(bDVDSource)
                {
                    ucCurrSrcIndex = SRC_INDEX_DVD;
                }
                else
                {
                    if (VIP_GetInputVSize()>576+24) /* safer boundary */
                    {
                        ucCurrSrcIndex = SRC_INDEX_Component_HD;
                    }
                    else
                    {
                        ucCurrSrcIndex = SRC_INDEX_Component_SD;
                    }
                }
            }
            break;
        case SOURCE_HDMI:
            if (VIP_RunDVIMode())
            {
                ucCurrSrcIndex = SRC_INDEX_DVI;
            }
            else
            {
                if(VIP_GetInputVSize()>576+24) /* safer boundary */
                {
                    ucCurrSrcIndex = SRC_INDEX_HDMI_HD;
                }
                else
                {
                    ucCurrSrcIndex = SRC_INDEX_HDMI_SD;
                }
            }
            break;
        case SOURCE_MPEG:
            if(VIP_GetInputVSize()>576+24) /* safer boundary */
            {
                ucCurrSrcIndex = SRC_INDEX_DTV_HD;
            }
            else
            {
                ucCurrSrcIndex = SRC_INDEX_DTV_SD;
            }
            if(VIP_IsNetworkSource())
            {
                ucCurrSrcIndex = SRC_INDEX_NETEORK;
            }
            break;
        case SOURCE_JPEG:
        case SOURCE_PATTERN:
            ucCurrSrcIndex = SRC_INDEX_JPEG;
            break;
    }

    return ucCurrSrcIndex;

}


void PQ_Default_Color_Lut_Setting(void)
{
	volatile UINT8 * pLUT = (volatile UINT8*) SPI_COLORLUTTABLE_SHADOWADDR;
	PLUTTable pLUTTable = (PLUTTable) pLUT;
    INT32 i;

	#ifdef CONFIG_SUPPORT_64BIT_LUT
		printk("<0>---function=%s line=%d use 64bit lut--- \n",__FUNCTION__,t_64bit, 0x1);
	#endif
    PQ_RegisterWrite(VIP_reg_dpy_yuv_lut_en, 1);
    PQ_RegisterWrite(VIP_reg_dpy_first_layer, 0);
    PQ_RegisterWrite(VIP_reg_dpy_outer_index, 0);

	if(pLUTTable->HueScale==1)
		PQ_RegisterWrite(VIP_reg_dpy_diff_level, 0x41);
	else
    	PQ_RegisterWrite(VIP_reg_dpy_diff_level, 0x40);
    PQ_RegisterWrite(VIP_reg_dpy_sat_outer_min, 0xa0);
    PQ_RegisterWrite(VIP_reg_dpy_sat_inner_min, 0xa0);
	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr, 0x0);

	//add init lut value, because not all lut reg will use.
	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr, 0);

	#ifdef CONFIG_SUPPORT_64BIT_LUT
		for(i=0; i< 16384; i++)
		{
			PQ_RegisterWrite(VIP_reg_dpy_rgn_data, 0);//COLOR_LUTABLE[i]);
		}
	#else
    	for(i=0; i< 7936; i++)
		{
			PQ_RegisterWrite(VIP_reg_dpy_rgn_data, 0);//COLOR_LUTABLE[i]);
		}
	#endif

	/*for(i=0; i< 16384; i++)
	{
		PQ_RegisterWrite(VIP_reg_dpy_rgn_addr, i);
		value = PQ_RegisterRead(VIP_reg_dpy_rgn_data);
		if(value!=0)
			printk("<0>\e[31m---[TingWei]function=%s line=%d i=%d value=%d---\e[0m\n",__FUNCTION__,__LINE__,i,value);
	}*/

}


int GetHwAddr(int HValue,int SValue,int YValue,int AddrOffset,int type)
{
	int Addr=0;
	//TRACE("H=%d S=%d Y=%d",HValue,SValue,YValue);
	if(type==1)
	{
		Addr = HValue + (SValue<<4) + (16*6*YValue);
		if(Addr>767)
			Addr = 767;
	}
	else if(type==2)
	{
		Addr = HValue + (SValue<<4) + (16*5*YValue);
		if(Addr>639)
			Addr = 639;
	}

	Addr = (AddrOffset << 10) | Addr;

	return Addr;
}

void GetHueMapValue(int Index,int *index_hue_e,int *index_hue_o,int *hue_e)
{
	int HueValue;
	int index_hue;
	int BaseHueValue=45;

	if(Index>31)
		Index=Index-32;

	HueValue = Index*BaseHueValue;
	
	index_hue=(HueValue*91+32)/4096;

	*hue_e = (index_hue%2 ==0) ?1 :0;
	
	if(index_hue>=31)
		*index_hue_e=0;
	else if(*hue_e==0)
		*index_hue_e = (index_hue+1)/2;
	else
		*index_hue_e = index_hue/2;

	if(index_hue>=32)
		*index_hue_o=15;
	else
		*index_hue_o= index_hue/2;
	
}

void GetLumaMapValue(int Index,int *index_luma_e,int *index_luma_o,int *luma_e)
{	
	int LumaValue;
	int index_luma;
	int BaseLumaValue=64;

	LumaValue = (Index+1)*BaseLumaValue;
	
	index_luma = LumaValue/64;

	*luma_e = (index_luma%2 ==0) ?1 :0;

	if(*luma_e==0)
		*index_luma_e = (index_luma+1)/2 - 1;
	else
		*index_luma_e = index_luma/2 - 1;

	*index_luma_o = index_luma/2;

}

void GetSatMapValue(int Index,int *index_sat_e,int *index_sat_o,int *sat_e)
{
	int SatValue;
	int index_sat;
	int BaseSatValue=64;
	
	SatValue = Index*BaseSatValue+64;   //64~704
	
	index_sat = (SatValue-64)/64;

	*sat_e = (index_sat%2==1) ?1 :0;

	*index_sat_e = 	index_sat/2;

	if(*sat_e==1)
		*index_sat_o=(index_sat+1)/2;
	else
		*index_sat_o= index_sat/2;


	if (*index_sat_e>4)
		*index_sat_e = 4;

	if (*index_sat_o>5)
		*index_sat_o = 5;

	//TRACE("sat %d %d %d",*index_sat_e,*index_sat_o,*sat_e);	
}

int GetLutHwAddress(int HueIndex,int SatIndex,int LumaIndex)
{
	int dwAddr=0;

	int hw_hue_e;
	int hw_hue_o;
	int hue_e;

	int hw_luma_e;
	int hw_luma_o;
	int luma_e;

	int hw_sat_e;
	int hw_sat_o;
	int sat_e;

	GetHueMapValue(HueIndex,&hw_hue_e,&hw_hue_o,&hue_e);
	GetLumaMapValue(LumaIndex,&hw_luma_e,&hw_luma_o,&luma_e);
	GetSatMapValue(SatIndex,&hw_sat_e,&hw_sat_o,&sat_e);
	
	if ((hue_e==1)&& (sat_e==1) &&( luma_e==1))
	   dwAddr = GetHwAddr(hw_hue_e,hw_sat_e,hw_luma_e,0,2);
	else if ((hue_e==1)&& (sat_e==1) &&(luma_e==0))
	   dwAddr = GetHwAddr(hw_hue_e,hw_sat_e,hw_luma_o,1,2);
	else if ((hue_e==1)&& (sat_e==0) &&(luma_e==1))
	   dwAddr = GetHwAddr(hw_hue_e,hw_sat_o,hw_luma_e,2,1);
	else if ((hue_e==1)&& (sat_e==0) &&(luma_e==0))
	   dwAddr = GetHwAddr(hw_hue_e,hw_sat_o,hw_luma_o,3,1);
	else if ((hue_e==0)&& (sat_e==1) &&(luma_e==1))
	   dwAddr = GetHwAddr(hw_hue_o,hw_sat_e,hw_luma_e,4,2);
	else if ((hue_e==0)&& (sat_e==1) &&(luma_e==0))
	   dwAddr = GetHwAddr(hw_hue_o,hw_sat_e,hw_luma_o,5,2);
	else if ((hue_e==0)&& (sat_e==0) &&(luma_e==1))
	   dwAddr = GetHwAddr(hw_hue_o,hw_sat_o,hw_luma_e,6,1);
	else if ((hue_e==0)&& (sat_e==0) &&(luma_e==0))
	   dwAddr = GetHwAddr(hw_hue_o,hw_sat_o,hw_luma_o,7,1);

	return dwAddr;


}


void PQ_ColorLUTSortOffsetToPt(UINT32 *dwOffsetSort, LUT_OFFSET ptLUTout[16][11][32])
{
	//int i, j, x, y, z, xv=0, yv=0, zv=0;
	int x,y,z;
	int HValue=0,SValue=0,YValue=0;
	UINT32 dwAddr;
	UINT32 dwOffset;

	//int DiffLevel=0;//g_SiSUart.ReadFromSiS(0xbe1ccb54)&0x3;
	for (z = 0; z < 16; z++)
	{
		for (y = 0; y < 11; y++)
		{
			for (x = 0; x < 32; x++)
			{
				dwAddr = GetLutHwAddress(x,y,z);
				
				if(dwOffsetSort != NULL)
				{
					dwOffset = dwOffsetSort[dwAddr];

					HValue = (dwOffset>>11)&0x1f;	   //H
					if((HValue>>4)==1)
						HValue=(-1)*(16-(HValue&0xf));

					SValue = ((dwOffset>>6)&0x1f)-m_Global_S_offset; //S
					YValue = (dwOffset)&0x3f; //Y
					if((YValue>>5)==1)//Y<0
					{//2+
					YValue=(-1)*(32-(YValue&0x1f));
					//if(zv==0)
					//	zv=-32;
					}//2-

					if(ptLUTout !=NULL)
					{
						ptLUTout[z][y][x].Hoffset = HValue;
						ptLUTout[z][y][x].Soffset = SValue;
						ptLUTout[z][y][x].Yoffset = YValue;
					}
				}
			}
		}
	}



	//DiffLevel=1<<DiffLevel;
	/*for (i = 0; i < 8; i++)
	{//0+
		for (j = 0; j < st_nCubePtCount[i]; j++)
		{//1+
			dwAddr = (i<<10)+j;
			PQ_ColorLUTGetXYZFromAddress(dwAddr, &x, &y, &z);
			dwOffset = dwOffsetSort[st_nCubePtIdxStart[i]+j];


			xv = (dwOffset>>11)&0x1f;	   //H
			if((xv>>4)==1)
			{//2+
			xv=(-1)*(16-(xv&0xf));

		//	if(xv==0)
		//		xv=-16;
			}//2-
			//S:0~31

			yv = ((dwOffset>>6)&0x1f)-m_Global_S_offset; //S
			zv = (dwOffset)&0x3f; //Y
			if((zv>>5)==1)//Y<0
			{//2+
			zv=(-1)*(32-(zv&0x1f));
			//if(zv==0)
			//	zv=-32;
			}//2-
			ptLUTout[z][y][x].Hoffset = xv;
			ptLUTout[z][y][x].Soffset = yv;
			ptLUTout[z][y][x].Yoffset = zv;

		}//1-
	}//0-*/
	//	AfxMessageBox("exit here............2");

}



void PQ_ColorLUTSortLUTV3(LUT_OFFSET ptLUTout[16][11][32], UINT32 *dwOffsetSort)
{
	int x, y, z;
	int iHdiff, iSdiff, iYdiff;
	//INT32 xd, yd, zd;
	UINT32 dwAddr;
	//int nCount[8];
	//int nMax[8];
	UINT32 nMax[8];
	UINT32 dwOffset;

	//memset(nCount, 0, sizeof(nCount));
	memset(nMax, 0, sizeof(nMax));


	for (z = 0; z < 16; z++)
	{
		for (y = 0; y < 11; y++)
		{
			for (x = 0; x < 32; x++)
			{


				iHdiff=ptLUTout[z][y][x].Hoffset;
				iSdiff=ptLUTout[z][y][x].Soffset+m_Global_S_offset;
				iYdiff=ptLUTout[z][y][x].Yoffset;



				//if((iHdiff!=0)||(iSdiff!=0)||(iYdiff!=0))
				//{fprintf(fp,"1.(%d,%d,%d) diff = (%d,%d,%d)=%d\n", x, y, z, iHdiff&0x0000001f, iSdiff, iYdiff,dwOffset[z][y][x]);}


				if (iHdiff > 15)
				{
					//fprintf(fp,"x,y,z(%d,%d,%d) diff = (%d,%d,%d), out of range\n", x, y, z, iHdiff, iSdiff, iYdiff);
					iHdiff = 15;
				}
				if(iHdiff < -16)
				{
					//fprintf(fp,"x,y,z(%d,%d,%d) diff = (%d,%d,%d), out of range\n", x, y, z, iHdiff, iSdiff, iYdiff);
					iHdiff = -16;
				}
				if (iSdiff > 31)
				{
					//TRACE("x,y,z(%d,%d,%d) diff = (%d,%d,%d), out of range\n", x, y, z, iHdiff, iSdiff, iYdiff);
					iSdiff = 31;
				}
				if(iSdiff < 0)
				{
					//TRACE("x,y,z(%d,%d,%d) diff = (%d,%d,%d), out of range\n", x, y, z, iHdiff, iSdiff, iYdiff);
					iSdiff = 0;
				}
				if (iYdiff > 31)
				{
					//TRACE("x,y,z(%d,%d,%d) diff = (%d,%d,%d), out of range\n", x, y, z, iHdiff, iSdiff, iYdiff);
					iYdiff = 31;
				}
				if(iYdiff < -32)
				{
					//TRACE("x,y,z(%d,%d,%d) diff = (%d,%d,%d), out of range\n", x, y, z, iHdiff, iSdiff, iYdiff);
					iYdiff = -32;
				}

				//        Y		  S       H
				//	      6		  5		  5
				//     -32~+31   0~31  -16~+15
				//if(b_Set180Degree)
				//dwOffset[z][y][(x+16)%32] = ((iHdiff&0x3f)<<10)+((iSdiff&0x1f)<<5)+(iYdiff&0x1f);
				//else
				dwOffset = ((iHdiff&0x1f)<<11) | ((iSdiff&0x1f)<<6) |(iYdiff&0x3f);
				//dwOffset = 0xA1B2C3D4;


				dwAddr = GetLutHwAddress(x, y, z);
				dwOffsetSort[dwAddr] = dwOffset;


				//nCount[dwAddr>>10]++;
				//if ((dwAddr&0x3ff)>nMax[dwAddr>>10]) nMax[dwAddr>>10] = dwAddr&0x3ff;
			}
		}
	}

}


BOOL PQ_ColorLUT_CalcRegion(
	UINT8 *hue_max, UINT8 *hue_min, UINT8 *sat_max, UINT8 *sat_min, UINT8 *y_max, UINT8 *y_min,
	INT8 *hue_gain, INT8 *sat_gain, INT8 *y_gain,
	UINT8 *en, INT32 regnum, UINT32* dwDataAddr, UINT32* dwDataAddrOut)
{
	static COLORLUT_BUF *pbuf = NULL;
	INT32 y, h, s, ridx;

	int st_hLevel[32] = {0, 45, 90,	135, 180, 225, 270, 315, 360, 405,
						450, 495, 540, 585, 630, 675, 720, 765, 810, 855,
						900, 945, 990, 1035, 1080, 1125, 1170, 1215, 1260,
						1305, 1350, 1395};
	int st_sLevel[11] = {0, 64, 128, 192, 256, 320, 384, 448, 512, 576, 640};
	int st_vLevel[16] = {64, 128, 192, 256, 320, 384, 448, 512, 576, 640 ,704, 768, 832, 896, 960, 1024};

	pbuf = (COLORLUT_BUF*)drv_vmalloc(sizeof(COLORLUT_BUF),MODULEID_VIP);
	if (NULL == pbuf || NULL == dwDataAddr) return FALSE;

	memset(pbuf, 0, sizeof(COLORLUT_BUF));

	PQ_ColorLUTSortOffsetToPt(dwDataAddr, pbuf->lutOffset);

	for (ridx = 0; ridx < regnum; ridx++)
	{
		if (en[ridx]) {
			int Yc, Hc, Sc, Ymin, Ymax, Hmin, Hmax, Smin, Smax;
			int Yration = 0, Hration = 0, Sration = 0;
			int fac;

			Ymin = st_vLevel[y_min[ridx]];
			Ymax = st_vLevel[y_max[ridx]];
			Yc = (Ymin + Ymax)/2;

			Hmin = st_hLevel[hue_min[ridx]];
			Hmax = st_hLevel[hue_max[ridx]];
			if (Hmax > Hmin) {
				Hc = (Hmin + Hmax)/2;
			}else {
				int  max, tmp;
				tmp = 1440 - Hmin;
				max = Hmax + tmp;

				Hc = (max/2) + Hmin;
				if (Hc >= 1440) {
					Hc = Hc - 1440;
				}
			}

			Smin = st_sLevel[sat_min[ridx]];
			Smax = st_sLevel[sat_max[ridx]];
			Sc = (Smin + Smax)/2;


			for (y = 0; y < 16; y++)
			{
				if (y >= y_min[ridx] && y <= y_max[ridx])
				{

					if (st_vLevel[y] >= Yc)
					{
						if((Ymax-Yc) > 0)
						{
							Yration = ((st_vLevel[y] - Yc)*100)/(Ymax-Yc);
						}
					}
					else
					{
						if((Ymax-Yc) > 0)
						{
							Yration = ((Yc - st_vLevel[y])*100)/(Ymax-Yc);
						}
					}

					for (s = 0; s < 11; s++)
					{
						if (s >= sat_min[ridx] && s <= sat_max[ridx])
						{
							if (st_sLevel[s] >= Sc)
							{
								if((Smax-Sc) > 0)
								{
									Sration = ((st_sLevel[s] - Sc)*100)/(Smax-Sc);
								}
							}
							else
							{
								if((Smax-Sc) > 0)
								{
									Sration = ((Sc - st_sLevel[s])*100)/(Smax-Sc);
								}
							}

							for (h = 0; h < 32; h++)
							{
								int inrange = FALSE;

								if (Hmin <= Hmax)
								{
									if (h >= hue_min[ridx] && h <= hue_max[ridx])
									{
										inrange = TRUE;
									}
								}
								else
								{
									if (h >= hue_min[ridx] && h >= hue_max[ridx])
									{
										inrange = TRUE;
									}
									else if (h <= hue_min[ridx] && h <= hue_max[ridx])
									{
										inrange = TRUE;
									}
								}



								if (inrange)
								{
									int upper, lower;

									if (Hmin < Hmax)
									{
										if (st_hLevel[h] >= Hc ) {
											upper = st_hLevel[h] - Hc;
										}else {
											upper = Hc - st_hLevel[h];
										}

										lower = Hmax - Hc;

									}
									else
									{
										int shift, tmpmax_angle, tmplevel, tmp_Hc;

										shift = 1440 - Hmin;

										tmpmax_angle = Hmax + shift;
										if (Hc > Hmax)
										{
											tmp_Hc = Hc + shift - 1440;
										}
										else
										{
											tmp_Hc = Hc + shift;
										}

										if (st_hLevel[h] > Hmax)
										{
											tmplevel = st_hLevel[h] + shift - 1440;
										}
										else
										{
											tmplevel = st_hLevel[h]+ shift;
										}

										if (tmplevel >= tmp_Hc ) {
											upper = tmplevel - tmp_Hc;
										}else {
											upper = tmp_Hc - tmplevel;
										}

										lower = tmpmax_angle - tmp_Hc;

									}

									if(lower > 0)
									{
										Hration = (upper*100)/(lower);
									}

									fac = Yration > Hration ? Yration : Hration;
									fac = Sration > fac ? Sration : fac;

									fac = 100 - ((fac*lut_smooth_level)/100);

									//printk("y = %d, h = %d, s =%d, Yration = %d, Hration = %d, Sration =%d,  fac = %d\n", y, h, s, Yration, Hration, Sration, fac);
									if (lut_make[ridx])
									{
										pbuf->lutOffset[y][s][h].Hoffset = -32;
										pbuf->lutOffset[y][s][h].Soffset = -32;
										pbuf->lutOffset[y][s][h].Yoffset = -32;
									}
									else
									{
										pbuf->lutOffset[y][s][h].Hoffset += (hue_gain[ridx]*fac)/100;
										pbuf->lutOffset[y][s][h].Soffset += (sat_gain[ridx]*fac)/100;
										pbuf->lutOffset[y][s][h].Yoffset += (y_gain[ridx]*fac)/100;
									}
								}
							}
						}
					}
				}
			}
		}
	}

	PQ_ColorLUTSortLUTV3(pbuf->lutOffset,dwDataAddrOut);
	drv_vfree(pbuf, MODULEID_VIP);
	return TRUE;
}

unsigned long pqcrcTable[256] = {
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};

unsigned long CountCRC32(char *pData, int len)
{
    unsigned long crc;
    int i;
    unsigned long c;

    crc = 0xFFFFFFFF;
    for(i=0; i<len; i++)
    {
        c = (unsigned long)pData[i];
        crc = ((crc>>8) & 0x00FFFFFF) ^ pqcrcTable[ (crc^c) & 0xFF ];
    }
    return( crc^0xFFFFFFFF );
}

BOOL CheckLutCRC(UINT32 FileSize)
{
    volatile UINT8 * pLUT = (volatile UINT8*) SPI_COLORLUTTABLE_SHADOWADDR;
    char *DataStart = (char *)pLUT;
    int CRCSize;
    unsigned long CRCValue;
    int CRCAddr;
    unsigned long dwCRC;
    int ret=FALSE;

    CRCSize = FileSize - sizeof(LUTHead)-16;
    CRCValue = CountCRC32(DataStart+sizeof(LUTHead),CRCSize);

    CRCAddr= CRCSize+sizeof(LUTHead)+12;
    dwCRC = ((DataStart[CRCAddr+3]&0xff)<<24)|((DataStart[CRCAddr+2]&0xff)<<16)|((DataStart[CRCAddr+1]&0xff)<<8)|(DataStart[CRCAddr]&0xff);

    //printk(KERN_EMERG"\e[31m---[TingWei]function=%s line=%d %x %lx %lx %x %x %x %x---\e[0m\n",__FUNCTION__,__LINE__,CRCSize,CRCValue,dwCRC,DataStart[CRCAddr]&0xff,DataStart[CRCAddr+1]&0xff,DataStart[CRCAddr+2]&0xff,DataStart[CRCAddr+3]&0xff);

    if(CRCValue==dwCRC)
    {
        ret=TRUE;
    }
    return ret;
        
}


/*void PQ_CheckLutCheckSum(UINT32* dwDataAddr,UINT32 DataSize)
{
	UINT32 DataSum=0; 
	UINT32 i;
	
	for(i=0;i<DataSize;i++)
		DataSum +=dwDataAddr[i];

	printk("<0>\e[31m===>DataSum=%x DataSize=%d\e[0m\n",DataSum,DataSize);
}*/


BOOL PQ_SetupLUTTable(UINT8 ucEnable)
{
	volatile UINT8 * pLUT = (volatile UINT8*) SPI_COLORLUTTABLE_SHADOWADDR;
	UINT32 *pdwLUT = (UINT32 *) pLUT;
	PLUTTable pLUTTable = (PLUTTable) pLUT;
	LUTTableInfo *pTblInfo;
	UINT32 * pLUTPivotTable ;
	UINT16 IndexOffset;
	UINT32 ulXorCRC;
	UINT8 ucCurrSrcIndex, ucTableIndex;
	UINT32 i;
	//UINT8 Is330C=0;
	//INT32 ColorLUT330C_Block_PointNum[8] = {729, 648, 648, 576, 648, 576, 576, 512}; /* 8 block */
	INT32 ColorLUT531_Block_PointNum[8] = {640, 640, 768, 768,640, 640, 768, 768}; /* 8 block */
	INT32 DataNum;
	INT32 iTableCnt;

	*(volatile unsigned char*)(0xbe1c0000)=0x13;
	/* validate table */
	if (memcmp(pLUTTable->LUTID,"LUT",3))
	{
		printk(KERN_EMERG"%s: LUT Table ID incorrect!", __FUNCTION__);
		return FALSE;
	}

	ulXorCRC = 0;
	for (i=0;i<pLUTTable->FileSize/sizeof(UINT32);i++)
	{
		ulXorCRC ^= pdwLUT[i];
	}
	if (ulXorCRC && CheckLutCRC(pLUTTable->FileSize)==FALSE)
	{
		printk(KERN_EMERG"%s: XorCRC invalid!", __FUNCTION__);
		return FALSE;
	}

	if (pLUTTable->IndexOffset!= offsetof(LUTTable,TblInfo))
	{
		printk(KERN_EMERG"%s: Table (version %d) format changed!", __FUNCTION__, pLUTTable->Version);
	}
	if (pLUTTable->IndexOffset > pLUTTable->HeadLength)
	{
		printk(KERN_EMERG"%s: Table Index offset %d > HeadLength %d !", __FUNCTION__, pLUTTable->IndexOffset, pLUTTable->HeadLength);
	}

	ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();

	if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN) || (ucCurrSrcIndex >= pLUTTable->SrcCount))
	{
		printk(KERN_EMERG"%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
		return FALSE;
	}
      
	ucTableIndex = pLUTTable->SrcIndex[ucCurrSrcIndex];

	if (ucTableIndex >= pLUTTable->TableCount)
	{
		printk(KERN_EMERG"%s: SrcIndex value (%d) > TableCount (%d)!", __FUNCTION__, ucCurrSrcIndex, pLUTTable->TableCount);
		return FALSE;
	}

	#ifdef CONFIG_SUPPORT_64BIT_LUT
		printk("<0>---function=%s line=%d 64bit lut can't setup lut--- \n",__FUNCTION__,__LINE__);
		return FALSE;
	#endif
	/*
	if(pHwContext->LUTIndex != ucTableIndex || pHwContext->LUTEnable != ucEnable)//prevent blanking from duplicate setting
	*/
	{

		/*
		pHwContext->LUTIndex = ucTableIndex;
		pHwContext->LUTEnable = ucEnable;
		*/


		if( ucEnable!=DISABLE )
		{
			IndexOffset = pLUTTable->IndexOffset;
			pTblInfo = (LUTTableInfo *) (pLUT+IndexOffset);

			pLUTPivotTable = (UINT32 *)(pLUT + pTblInfo[ucTableIndex].TableOffset);
			
			down(&LutTableLock);
			
			//printk(KERN_EMERG"Loading LUT Table from table index %d start.......", ucTableIndex);
			{
				BOOL bCalcRegionOK = FALSE;
				static UINT32 *dwDataNew = NULL;

				if(dwDataNew==NULL)
					dwDataNew = (UINT32*)drv_vmalloc(7936*4,MODULEID_VIP);

				if (NULL != dwDataNew) 
				{

					//PQ_CheckLutCheckSum(pLUTPivotTable,7936);

					memset(dwDataNew, 0, 7936*4);
					bCalcRegionOK = PQ_ColorLUT_CalcRegion(
						lut_rgn_hue_max, lut_rgn_hue_min, lut_rgn_sat_max, lut_rgn_sat_min, lut_rgn_y_max, lut_rgn_y_min,
						lut_rgn_hue_gain, lut_rgn_sat_gain, lut_rgn_y_gain,
						lut_rgn_en, COLORLUT_RGN_NUM, pLUTPivotTable, dwDataNew);

					//PQ_CheckLutCheckSum(dwDataNew,7936);

					DataNum = 0;
					for (i=0;i<8;i++)
					{
						PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,i<<10);
						for (iTableCnt=0;iTableCnt<ColorLUT531_Block_PointNum[i];iTableCnt++)//for (iTableCnt=0;iTableCnt<ColorLUT330C_Block_PointNum[i];iTableCnt++)
						{
							//PQ_RegisterWrite(VIP_reg_dpy_rgn_data, bCalcRegionOK? dwDataNew[DataNum]:pLUTPivotTable[DataNum]);

							*(volatile unsigned long*)(0xbe1cc184) = bCalcRegionOK? dwDataNew[DataNum]:pLUTPivotTable[DataNum];//+0x80);
							//printk(KERN_EMERG"[%d]:%08x",DataNum,dwDataNew[DataNum]);
							DataNum++;
							if(DataNum==640) DataNum=1024;
							if(DataNum==1664) DataNum=2048;
							if(DataNum==2816) DataNum=3072;
							if(DataNum==3840) DataNum=4096;
							if(DataNum==4736) DataNum=5120;
							if(DataNum==5760) DataNum=6144;
							if(DataNum==6912) DataNum=7168;

						}
					}
					//drv_vfree(dwDataNew, MODULEID_VIP);
					//dwDataNew = NULL;
				}

				PQ_RegisterWrite(VIP_reg_dpy_rgn_addr, 0x0);
				PQ_RegisterWrite(VIP_reg_dpy_yuv_lut_en,1);
			}
			up(&LutTableLock);
		}
		else
		{
			PQDebugPrint("Turn off LUT.");
			PQ_RegisterWrite(VIP_reg_dpy_yuv_lut_en,0);
		}

	}
	return TRUE;
}

BOOL PQ_CheckLastLutValue(void)
{
    static unsigned long LastCRC=0xff;
    static int LastSrcIndex=0xff;
    unsigned long dwCRCValue;
	UINT8 num = COLORLUT_RGN_NUM;

	dwCRCValue = CountCRC32((char*)lut_rgn_en,sizeof(UINT8)*num)+CountCRC32((char*)lut_rgn_hue_gain,sizeof(INT8)*num)+CountCRC32((char*)lut_rgn_sat_gain,sizeof(INT8)*num)+CountCRC32((char*)lut_rgn_y_gain,sizeof(INT8)*num)+
		CountCRC32((char*)lut_rgn_hue_min,sizeof(UINT8)*num)+CountCRC32((char*)lut_rgn_hue_max,sizeof(UINT8)*num)+CountCRC32((char*)lut_rgn_sat_min,sizeof(UINT8)*num)+CountCRC32((char*)lut_rgn_sat_max,sizeof(UINT8)*num)+
		CountCRC32((char*)lut_rgn_y_min,sizeof(UINT8)*num)+CountCRC32((char*)lut_rgn_y_max,sizeof(UINT8)*num)+CountCRC32((char*)lut_make,sizeof(UINT8)*num)+lut_smooth_level;

    if(LastSrcIndex==PQ_Get_Source_Grouped_Index() && LastCRC==dwCRCValue)
    {
        return FALSE;
    }
    else
    {
        LastSrcIndex=PQ_Get_Source_Grouped_Index();
        LastCRC = dwCRCValue;
        return TRUE;
    }
}

INT8 PQ_ColorLUT_GetRegionGain(UINT8 Type, UINT8 Index)
{
    if(Type == COLORLUT_HUE_GAIN)
    {
        return lut_rgn_hue_gain[Index];
    }
    else if(Type == COLORLUT_SAT_GAIN)
    {    
        return lut_rgn_sat_gain[Index];
    }

    return 0xff;
}

void PQ_ColorLUT_SetRegion(INT32 iRegionIdx, INT32 iSatGain, INT32 iYGain, INT32 iRotAngle, INT32 iRotGain, INT32 bEnable, BOOL bSet)
{
    if (iRegionIdx < 0 || iRegionIdx >= COLORLUT_RGN_NUM)
    {
        return;
    }

    lut_rgn_en[iRegionIdx] = bEnable;
    lut_rgn_hue_gain[iRegionIdx] = iRotGain;
    lut_rgn_sat_gain[iRegionIdx] = iSatGain;
    lut_rgn_y_gain[iRegionIdx] = iYGain;

    if(bSet)
    {
        if(PQ_CheckLastLutValue())
        {
            PQ_SetupLUTTable(ENABLE);
        }
    }
}

void PQ_ColorLUT_SetRange(UINT8 RegionIdx, UINT8 bMake, UINT8 HueMin, UINT8 HueMax, UINT8 SatMin, UINT8 SatMax, UINT8 YMin, UINT8 YMax, UINT8 SmoothLevel, BOOL bSet)
{
	if (RegionIdx >= COLORLUT_RGN_NUM)
	{
		return;
	}

	lut_make[RegionIdx] = bMake;
	lut_rgn_hue_min[RegionIdx] = HueMin;
	lut_rgn_hue_max[RegionIdx] = HueMax;
	lut_rgn_sat_min[RegionIdx] = SatMin;
	lut_rgn_sat_max[RegionIdx] = SatMax;
	lut_rgn_y_min[RegionIdx] = YMin;
	lut_rgn_y_max[RegionIdx] = YMax;
	lut_smooth_level = SmoothLevel;
	if (bSet)
	{
		PQ_SetupLUTTable(ENABLE);
	}
}

void PQ_SetupSaturationGainCurve(SatGainMethod opt)
{
    INT32 i;
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    UINT32 dwSatGainAddr;
    UINT8 ucTableIndex;
    SAT_GAIN_CURVE_V2I_DATA* pSatData;
    static UINT8 preOpt= 0xff;
    static BOOL SatGainInit = FALSE;
    static UINT8 PreTableIndex;
    
    dwSatGainAddr = VIP_reg_dpy_sat_g0b;
    ucTableIndex = pVtab->mSatGainCurve_V2.mGroupedIndex[ucCurrSrcIndex];
    pSatData = &pVtab->mSatGainCurve_V2.mSatGainCurve_V2_Data[ucTableIndex];
    
    if ((ucCurrSrcIndex >= SRC_INDEX_UNKNOWN))
    {
        PQDebugPrint("%s: SrcIndex (%d) unknown/invalid, pLUTTable->SrcCount (%d)!\n", __FUNCTION__, ucCurrSrcIndex,pLUTTable->SrcCount);
        return;
    }

    if(SatGainInit)
    {
        if((PreTableIndex == ucTableIndex) && (preOpt == opt))
        {
            return;
        }
    }
    
    switch(opt)
    {
        case SAT_GAIN_ATV_PAL_I_1280_PANEL_COLORBAR_PATCH: //#51690
            PQ_RegisterWrite(VIP_reg_dpy_sat_g0b, 0x0);
            PQ_RegisterWrite(VIP_reg_dpy_sat_g1b, 0x0);
            PQ_RegisterWrite(VIP_reg_dpy_sat_g2b, 0x40);
            break;
        case SAT_GAIN_NORMAL:
        case SAT_GAIN_ATV_PAL_M_GREY_SCALE_NR_PATCH:    
        case SAT_GAIN_ATV_SECAM_GREY_SCALE_NR_PATCH:
        case SAT_GAIN_ATV_GREY_SCALE_PATCH: //#52143    
        default:   
            //Set VIP_deg_dpy_sat_en
            PQ_RegisterWrite(DPY_DISX_CB58_DW_CB58,(((PQ_RegisterRead(DPY_DISX_CB58_DW_CB58))&0xfeffffff)|(pSatData->iDpySatEn<<24)));

            //Set VIP_reg_dpy_sat_opt
            PQ_RegisterWrite(DPY_DISX_CB58_DW_CB58,(((PQ_RegisterRead(DPY_DISX_CB58_DW_CB58))&0xfdffffff)|(pSatData->iDpySatOpt<<25)));

            //Set VIP_deg_dpy_sat_all
            if(opt == SAT_GAIN_ATV_PAL_M_GREY_SCALE_NR_PATCH)
            {
                PQ_RegisterWrite(DPY_DISX_CB54_DW_CB54,(((PQ_RegisterRead(DPY_DISX_CB54_DW_CB54))&0x00ffffff)|(0x40<<24)));
                
            }
            else if(opt == SAT_GAIN_ATV_SECAM_GREY_SCALE_NR_PATCH)
            {
                PQ_RegisterWrite(DPY_DISX_CB54_DW_CB54,(((PQ_RegisterRead(DPY_DISX_CB54_DW_CB54))&0x00ffffff)|(0x44<<24)));
            }
            else
            {
                PQ_RegisterWrite(DPY_DISX_CB54_DW_CB54,(((PQ_RegisterRead(DPY_DISX_CB54_DW_CB54))&0x00ffffff)|(pSatData->iDpySatAll<<24)));
            }
        		
            //Set VIP_deg_dpy_hue
            PQ_RegisterWrite(DPY_DISX_CB58_DW_CB58,(((PQ_RegisterRead(DPY_DISX_CB58_DW_CB58))&0xffff00ff)|(pSatData->iDpySatHue<<8)));

            for (i = 0; i < 17; i++)
            {
                PQ_RegisterWrite(dwSatGainAddr+i, pSatData->iSat_Gain[i]);
            }

            if(opt == SAT_GAIN_ATV_PAL_M_GREY_SCALE_NR_PATCH || opt == SAT_GAIN_ATV_SECAM_GREY_SCALE_NR_PATCH || opt == SAT_GAIN_ATV_GREY_SCALE_PATCH)
            {
                PQ_RegisterWrite(VIP_reg_dpy_sat_g0b, 0x20);
                PQ_RegisterWrite(VIP_reg_dpy_sat_g1b, 0x20);
                PQ_RegisterWrite(VIP_reg_dpy_sat_g2b, 0x20);
            }
            
            SatGainInit = TRUE;
            break;
    }

    PreTableIndex = ucTableIndex;
    preOpt = opt;
        
}


void PQ_GetRegInfo(PQ_RegInfo* pRegInfo)
{

	pRegInfo->NRRangeMax	=	3;	//0=OFF	1=WEAK	2=MEDIUM	3=STRONG
	pRegInfo->NRRangeMid	=	2;
	pRegInfo->NRRangeMin	=	0;

	pRegInfo->GammaRangeMax	=	2;	//cType : 0=SD Video, 1=HD Video, 2=RGB
	pRegInfo->GammaRangeMid	=	1;
	pRegInfo->GammaRangeMin	=	0;

	pRegInfo->BacklightRangeMax	=	3;	//0=OFF	1=WEAK	2=MEDIUM	3=STRONG
	pRegInfo->BacklightRangeMid	=	2;
	pRegInfo->BacklightRangeMin	=	0;

}

BOOL PQ_IsFadeEn(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;

	return pHwContext->bFadeEn;
}

void PQ_SetFadeValue(BOOL bFadeEn, UINT8 ucStartValue, UINT8 ucEndValue, UINT8 ucIncValue)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;

	pHwContext->bFadeEn = bFadeEn;
	pHwContext->ucFadeStartValue = ucStartValue;
	pHwContext->ucFadeEndValue = ucEndValue;
	pHwContext->ucFadeIncValue = ucIncValue;
}

void PQ_SetFadeInOut(void)
{
    UINT32 ulContrastValue;
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT8 ucStartValue = pHwContext->ucFadeStartValue;
	UINT8 ucEndValue = pHwContext->ucFadeEndValue;
	UINT8 ucIncValue = pHwContext->ucFadeIncValue;
	static UINT32 ulcurValue = 0;
	static UINT8 counter = 0;

    if (pHwContext->bFadeEn)
    {
		if (counter == 0)
			ulcurValue = ucStartValue;

		ulContrastValue = ulcurValue * PQ_GetCurrContrastValue() / 256;
        PQ_Contrast(TRUE, ulContrastValue);
	    if (ucEndValue > ucStartValue)
	    {
	        if (ulcurValue < ucEndValue)
	        {
		        ulcurValue += ucIncValue;
				counter++;
	        }
			else
			{
				PQ_Contrast(TRUE, (ucEndValue * PQ_GetCurrContrastValue() + 128) / 256);
				ulcurValue = 0;
				counter = 0;
				pHwContext->bFadeEn = 0;
			}
	    }
	    else
	    {
			if ((signed)ulcurValue > ucEndValue)
	        {
				ulcurValue -= ucIncValue;
				counter++;
	        }
			else
			{
				PQ_Contrast(TRUE, (ucEndValue * PQ_GetCurrContrastValue() + 128) / 256);
				ulcurValue = 0;
				counter = 0;
				pHwContext->bFadeEn = 0;
			}
    	}
    }
}

//#ifdef  VIP_SW_DC
#if 1

void PQ_GetSWDCParamCmd(ST_SWDC_Param *param)
{
	//if(DLC_Source <7)
	//{
	//	*param =PQ_SWDC_Param[DLC_Source];
	//}
	//else
	{
		*param = SWDC_Param[0];
	}

}

void PQ_SetSWDCParamCmd(ST_SWDC_Param *param)
{
	SWDC_Param[0]= *param;
	PQ_RegisterWrite(VIP_reg_dpy_hist_en,SWDC_Param[0].ucSWDC_En);
}

void PQ_GetSWDCSlopeCmd(ST_SWDC_Slope *pstSlope)
{
	//if(DLC_Source <7)
	//{
	//	*pstSlope =PQ_SWDC_HistSlop[DLC_Source];// Get Current Value
	//}
	//else
	{
		*pstSlope = SWDC_HistSlop[0];
	}
}

void PQ_SetSWDCSlopeCmd(ST_SWDC_Slope *pstSlope)
{
	SWDC_HistSlop[0]=*pstSlope;
}

void PQ_GetSWDCChromaCmd(ST_SWDC_Chroma *pstChroma)
{
	//if(DLC_Source <7)
	//{
	//	*pstChroma = PQ_SWDC_HistChroma[DLC_Source];// Get Current Value
	//}
	//else
	{
		*pstChroma = SWDC_HistChroma[0];
	}
}

void PQ_SetSWDCChromaCmd(ST_SWDC_Chroma *pstChroma)
{
	SWDC_HistChroma[0] = *pstChroma;
}
void PQ_GetSWDCInfoCmd(ST_SWDC_Info *info)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	info->ulHistCaseCur = pHwContext->ulHistCaseCur;
}
void PQ_SetSWDCSourceCmd(UINT8 *param)
{
	DLC_Source =param[0];
}
void PQ_GetSWDCSourceCmd(UINT8 *param)
{
	param[0] = DLC_Source;
}

void PQ_GetDrvCurrentSourceCmd(UINT8 *param)
{
    UINT8 ucUserSource;
    UINT8 ucSubSource;

    VIP_GetSource(&ucUserSource, &ucSubSource);

    switch(ucUserSource)
	{
		case SOURCE_CVD2:
			if (VIP_IsATVSource())
			{
				param[0] = PQTOOL_SOURCE_ATV;
			}
			else if (VIP_IsAVSource())
			{
			    param[0] = PQTOOL_SOURCE_AV;
			}
			else if (VIP_IsSVSource())
			{
				 param[0] = PQTOOL_SOURCE_SV;
			}
			break;

		case SOURCE_EXTS:
			if (VIP_IsPCSource())
			{
				param[0] = PQTOOL_SOURCE_PC;
			}
			else
			{
			   param[0] = PQTOOL_SOURCE_COMPONENT;
			}

			break;

		case SOURCE_HDMI:
			if (VIP_RunDVIMode())
			{
                param[0] = PQTOOL_SOURCE_DVI;
			}
			else
			{
				param[0] = PQTOOL_SOURCE_HDMI;
			}
			break;

		case SOURCE_MPEG:
			param[0] = PQTOOL_SOURCE_DTV;
			break;

		case SOURCE_JPEG:
		case SOURCE_PATTERN:
			param[0] = PQTOOL_SOURCE_JPEG;
			break;
        default:
            param[0] = 0xff;
            break;
	}

}


void PQ_SW_DynamicContrast_UserCurveAdjust(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	INT32 i,j, sum = 0;
	INT32 iSlop[4][15];

	for(i = 0; i<4;i++)
	{
		for(j = 0; j<15;j++)
		{
			iSlop[i][j] = (((INT32)(SWDC_HistSlop->SWDC_HistSlop[i+32][j])*2-256)*((INT32)SWDC_Param->wSWDC_Static_Alpha[i]-128)+64)/128;
		}
	}
	for(i = 0; i<15;i++)
	{
		pHwContext->ulCurveSlop[i]= (iSlop[0][i]+iSlop[1][i]+iSlop[2][i]+iSlop[3][i]);

		sum += (INT32)pHwContext->ulCurveSlop[i];
	}
	pHwContext->ulCurveSlop[15] = (-sum);

}
void PQ_SW_DynamicContrast_Param(UINT8 ucSource)
{
	//SWDC_HistSlop[0] = PQ_SWDC_HistSlop[ucSource];
	//SWDC_HistChroma[0] = PQ_SWDC_HistChroma[ucSource];
	//SWDC_Param[0] = PQ_SWDC_Param[ucSource];

	PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucTableIndex;
    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    DLC_SET_CURVE_PARAM *pDLC_SET_CURVE_PARAM;

    ucTableIndex = pVtab->mDynContrast.mGroupedIndex[ucCurrSrcIndex];
    pDLC_SET_CURVE_PARAM = &pVtab->mDynContrast.mDLC_Table[ucTableIndex];

	SWDC_HistSlop[0] = pDLC_SET_CURVE_PARAM->dlc_luma_slope;
	SWDC_HistChroma[0] = pDLC_SET_CURVE_PARAM->dlc_chroma_slope;


	SWDC_Param[0].ucSWDC_En = (UINT8)pDLC_SET_CURVE_PARAM->dlc_En;
	SWDC_Param[0].ucSWDC_Var_Cond_En = (UINT8)pDLC_SET_CURVE_PARAM->dlc_Var_Cond_En;
	SWDC_Param[0].wSWDC_Ratio[0] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Ratio[0];
	SWDC_Param[0].wSWDC_Ratio[1] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Ratio[1];
	SWDC_Param[0].wSWDC_Ratio[2] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Ratio[2];
	SWDC_Param[0].wSWDC_Ratio[3] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Ratio[3];
	SWDC_Param[0].wSWDC_Ratio[4] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Ratio[4];
	SWDC_Param[0].wSWDC_Ratio[5] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Ratio[5];
	SWDC_Param[0].wSWDC_Factor[0] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Factor[0];
	SWDC_Param[0].wSWDC_Factor[1] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Factor[1];
	SWDC_Param[0].wSWDC_Factor[2] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Factor[2];
	SWDC_Param[0].wSWDC_Factor[3] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Factor[3];
	SWDC_Param[0].wSWDC_Factor[4] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Factor[4];
	SWDC_Param[0].wSWDC_Alpha = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Alpha;
	SWDC_Param[0].wSWDC_Static_Alpha[0] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Static_Alpha[0];
	SWDC_Param[0].wSWDC_Static_Alpha[1] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Static_Alpha[1];
	SWDC_Param[0].wSWDC_Static_Alpha[2] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Static_Alpha[2];
	SWDC_Param[0].wSWDC_Static_Alpha[3] = (UINT16)pDLC_SET_CURVE_PARAM->dlc_Static_Alpha[3];
	SWDC_Param[0].wSWDC_YLevel = (UINT16)pDLC_SET_CURVE_PARAM->dlc_YLevel;
	SWDC_Param[0].wSWDC_CLevel = (UINT16)pDLC_SET_CURVE_PARAM->dlc_CLevel;
	PQ_RegisterWrite(VIP_reg_dpy_hist_en, SWDC_Param[0].ucSWDC_En);
}


void PQ_EnSWDCWorkQue_ISR(void)
{     
	PQ_SW_DynamicContrast_SceneChangeDetect_ISR();

    //queue_work(WQ_Struct_SWDC,&WQ_SWDC);
}

/**
 * @brief patch function for Dynamic Constract function(DCC)
 *
 * This function only for special DCC case. Set the slope value by array type, and auto calcaulate the start value
 *
 * Current patch pattern
 * 1. ATV and AV Colorbar
 * 2. ATV Secam with white xx% pattern
 * 3. ATV PAL M with white xx% pattern
 *
 * @param BarNoiseFlag, for specific pattern detect
 * @return 1 as patch applied, 0 for DCC regular rule
*/
BOOL _DCCPatch(BOOL BarNoiseFlag)
{
    BOOL PatchApplyFlag = PATCHNOTAPPLY;
#ifdef DRV_ENABLE_CVD2
    UINT8 ucNoiseStatus = 0;
    INT32 i, tmp;
    INT32 ATV_NTSC_COLORBAR_SLOPE[16] = {0xb8, 0xce, 0xf4, 0x12e, 0x152, 0x166, 0x158, 0x128, 0x116, 0x10c, 0x102, 0xec, 0xd6, 0x0c2, 0xb0, 0xb0};
    INT32 ATV_PAL_COLORBAR_SLOPE[16] = {0xd6, 0x125, 0x15e, 0x155, 0x143, 0x13f, 0x129, 0x101, 0xf3, 0xbd, 0xd0, 0xd6, 0xef, 0xe5, 0xea, 0x91};
    INT32 ATV_PAL_M_COLORBAR_SLOPE[16] = {0xab, 0xde, 0x11f, 0x153, 0x141, 0x14b, 0x11d, 0xf7, 0xe1, 0xb1, 0xd0, 0xd6, 0xf7, 0xfb, 0x10a, 0x111};
    INT32 ATV_SECAM_COLORBAR_SLOPE[16] = {0xd6, 0x115, 0x154, 0x151, 0x145, 0x13f, 0x129, 0x101, 0xeb, 0xb5, 0xd0, 0xd6, 0xef, 0xe5, 0xea, 0xbd};
    INT32 AV_NTSC_COLORBAR_SLOPE[16] = {0xb8, 0xce, 0xf4, 0x12e, 0x152, 0x166, 0x158, 0x128, 0x116, 0x10c, 0x102, 0xec, 0xd6, 0xc2, 0xb0, 0xb0};
    INT32 AV_PAL_COLORBAR_SLOPE[16] = {0xd6, 0x125, 0x15e, 0x155, 0x143, 0x13f, 0x129, 0x101, 0xf3, 0xbd, 0xd0, 0xd6, 0xef, 0xe5, 0xea, 0x91};
    INT32 AV_PAL_M_COLORBAR_SLOPE[16] = {0xe0, 0xea, 0x116, 0x136, 0x154, 0x168, 0x154, 0x13a, 0x120, 0x100, 0xf6, 0xd4, 0xc6, 0xb0, 0xa4, 0x9b};
    INT32 AV_SECAM_COLORBAR_SLOPE[16] = {0xd6, 0x115, 0x154, 0x151, 0x145, 0x13f, 0x129, 0x101, 0xeb, 0xb5, 0xd0, 0xd6, 0xef, 0xe5, 0xea, 0xbd};
    INT32 DCCSlope[16] = {0};

    CVD2_GetNoiseStatus(&ucNoiseStatus);

    // CVD2 Grey patten patch
    if(VIP_IsATVSource())
    {
        if ((VIP_GetStdColorSystem() == CVD2_STD_SECAM || VIP_GetStdColorSystem() == CVD2_STD_PAL_M) && BarNoiseFlag == 1) //#51594, #51661, #51662, #51659
        {
            PQ_RegisterWrite(VIP_reg_dpy_hist_slope2, 0xec);
            PQ_RegisterWrite(VIP_reg_dpy_hist_slope3, 0xec);

            PQ_RegisterWrite(VIP_reg_dpy_hist_start0 ,0);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start1 ,0x400);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start2 ,0x800);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start3 ,0xbb0);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start4 ,0xf60);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start5 ,0x1360);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start6 ,0x1760);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start7 ,0x1b60);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start8 ,0x1f60);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start9 ,0x2360);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start10 ,0x2760);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start11 ,0x2b60);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start12 ,0x2f60);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start13 ,0x3360);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start14 ,0x3760);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start15 ,0x3b60);  
            
            return PATCHAPPLIED;
        }
    }// ~CVD2 Grey patten patch
    
    // CVD2 ColorBar patch
    if(VIP_GetUserSource() == SOURCE_CVD2 && PQ_IsColorBar())
    {
        if(VIP_IsATVSource())
        {
            if (VIP_GetStdColorSystem() <= CVD2_STD_NTSC_443)
            {
                memcpy(&DCCSlope[0], &ATV_NTSC_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                PatchApplyFlag = PATCHAPPLIED;
            }
            else if(VIP_GetStdColorSystem() <= CVD2_STD_PAL_60 && VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK && ucNoiseStatus < 25)
            {
                if(VIP_GetStdColorSystem() != CVD2_STD_PAL_M)
                {
                    memcpy(&DCCSlope[0], &ATV_PAL_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                }
                else
                {
                    memcpy(&DCCSlope[0], &ATV_PAL_M_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                }
                
                PatchApplyFlag = PATCHAPPLIED;
            }
            else if(VIP_GetStdColorSystem() == CVD2_STD_SECAM && ucNoiseStatus < 25)
            {
                memcpy(&DCCSlope[0], &ATV_SECAM_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                PatchApplyFlag = PATCHAPPLIED;
            }
            
        }
        else // AV
        {
            if (VIP_GetStdColorSystem() <= CVD2_STD_NTSC_443)
            {
                memcpy(&DCCSlope[0], &AV_NTSC_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                PatchApplyFlag = PATCHAPPLIED;
            }
            else if(VIP_GetStdColorSystem() <= CVD2_STD_PAL_60 && VIP_GetStdColorSystem() >= CVD2_STD_PAL_IBGDK)
            {
                if(VIP_GetStdColorSystem() != CVD2_STD_PAL_M)
                { 
                    memcpy(&DCCSlope[0], &AV_PAL_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                    PatchApplyFlag = PATCHAPPLIED;
                }
                else
                {
                    memcpy(&DCCSlope[0], &AV_PAL_M_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                    PatchApplyFlag = PATCHAPPLIED;
                }
            }
            else if(VIP_GetStdColorSystem() == CVD2_STD_SECAM)
            {
                memcpy(&DCCSlope[0], &AV_SECAM_COLORBAR_SLOPE[0], sizeof(INT32)*16);
                PatchApplyFlag = PATCHAPPLIED;
            }
        }

        /*********  write data  *********/
        if  (PatchApplyFlag == PATCHAPPLIED) {
                for(i=0; i<16; i++)
                {
                    PQ_RegisterWrite(VIP_reg_dpy_hist_slope0+i*4, DCCSlope[i]);
                    PQ_RegisterWrite(VIP_reg_dpy_hist_chroma0+i*4, 256);
                }

                PQ_RegisterWrite(VIP_reg_dpy_hist_start0 , 0);
                tmp = 0;

                for(i=1; i<16; i++)
                {
                    tmp = tmp +(DCCSlope[i-1]<<2);
                    if (tmp < 1024 * (i-1)) tmp = 1024 * (i-1);				  
                    if (tmp>16367)
                    {
                        tmp = 16367;
                        DCCSlope[i] = 0;
                    }
                    PQ_RegisterWrite(VIP_reg_dpy_hist_start0+i*4 ,tmp);
                }
        }
        /*********  ~write data  *********/
    }//~if(VIP_GetUserSource() == SOURCE_CVD2 && PQ_IsColorBar())
#endif
    return PatchApplyFlag;
    
}

void _CheckHistBinDistribution(UINT32* pHistBin, UINT32 dwTotalPixel, UINT8 *pBinNull, UINT8 *pBinNormal)
{
    UINT32 ulHistBin[16];
    UINT8 i;
    memcpy(&ulHistBin[0], pHistBin, sizeof(UINT32)*16);

    for(i=0; i<16; i++)
    {        
        if(ulHistBin[i]<dwTotalPixel*50/1000)
        {
            if (ulHistBin[i]<dwTotalPixel*25/1000) // *10 to *20
                (*pBinNull) ++;
        }
        else
        {
            if ((i==0)&&(ulHistBin[1]<dwTotalPixel*50/1000))
                (*pBinNormal)++;
            else if ((i==15)&&(ulHistBin[14]<dwTotalPixel*50/1000))
                (*pBinNormal)++;
            else if ((i==14)&&(ulHistBin[13]<dwTotalPixel*50/1000)&&(ulHistBin[15]<dwTotalPixel*50/1000))
                (*pBinNormal)++;
            else if ((i==13)&&(ulHistBin[i-1]<dwTotalPixel*50/1000)&&((ulHistBin[i+1]<dwTotalPixel*50/1000)||(ulHistBin[i+2]<dwTotalPixel*50/1000)))
                (*pBinNormal)++;
            else if ((i==12)&&(ulHistBin[i-1]<dwTotalPixel*50/1000)&&((ulHistBin[i+1]<dwTotalPixel*50/1000)||(ulHistBin[i+2]<dwTotalPixel*50/1000)||(ulHistBin[i+3]<dwTotalPixel*50/1000)))
                (*pBinNormal)++;
            else if ((i< 12)&&(i>0)&&(ulHistBin[i-1]<dwTotalPixel*50/1000)&&((ulHistBin[i+1]<dwTotalPixel*50/1000)||
              (ulHistBin[i+2]<dwTotalPixel*50/1000)||(ulHistBin[i+3]<dwTotalPixel*50/1000)||(ulHistBin[i+4]<dwTotalPixel*50/1000)))
                (*pBinNormal)++;
        }
    }
    
}


/**
 * @brief apply different sharpness in specific scene 
 *
 * This function will detect specific pattern and apply different sharpness setting
 * purpose : to improve ring effect in AV source (monoscope)
 *
 * @param n/a
 * @return n/a
 * note : the PQ_GetMotionStatus condition is for exclude the scene in video book, video decoder, chapter #9
*/
void _SharpnessPatch(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    static UINT8 PatchApply = FALSE;
#ifdef CONFIG_AV_SUPPORT
    UINT8 cnt_init = 5 , cnt_th = 8, cnt_max = 16; //(th-init) = enable frm cnt; (max-th) = disable frm cnt
    static UINT8 sharpness_cnt = 0;
    UINT8 CVD2_Hist_Y_Bin[16] = {0}, CVD2_Hist_Cb_Bin[16] = {0}, CVD2_Hist_Cr_Bin[16] = {0};
    UINT32 ucvdi_field_diff_cnt = PQ_RegisterRead(VIP_field_diff_cnt);
    UINT32 ucvdi_field_diff_cnt_lp = PQ_RegisterRead(VIP_field_diff_cnt_lp); 
    UINT32 Sony_CH9 = 0 , PatGen_NoColor= 0;
    UINT8 mot_chk = 0, luma_chk = 0, mono_chk = 0, i, ucYBbin_255_Cnt = 0;
    UINT8 time_525 = 0, time_625 = 0;
    UINT32 other_cb_sum_0_6 = 0 , other_cb_sum_10_15 = 0 , other_cr_sum_0_6 = 0 , other_cr_sum_10_15 = 0, luma_sum = 0, mono_luma_sum_0_1 = 0, mono_luma_sum_7_13_14 = 0;
#endif
    pHwContext->PqPatch.PeakLtiPatch = PEAKLTI_NON_PATCH;
    pHwContext->PqPatch.DpyPeakingPatch = DPY_PEAKING_NON_PATCH;
    pHwContext->PqPatch.DsSharpnessPatch = DS_SHARPNESS_NON_PATCH;

#ifdef CONFIG_AV_SUPPORT
    if(VIP_IsAVSource())
    {	
        DRV_CVD2_GetLumaHist(CVD2_Hist_Y_Bin);
        DRV_CVD2_GetCbHist(CVD2_Hist_Cb_Bin);
        DRV_CVD2_GetCrHist(CVD2_Hist_Cr_Bin);

        time_525 = (VIP_GetStdColorSystem() == CVD2_STD_NTSC_M);
        time_625 = (VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK);

        if(sharpness_cnt==0)
        {
        	sharpness_cnt = cnt_init;
        }

        for(i = 0; i < 16; i++)
        {
            luma_sum += CVD2_Hist_Y_Bin[i];
            
            if(CVD2_Hist_Y_Bin[i] == 0xff)
            {
                ucYBbin_255_Cnt++;
            }
        }

        if((ucYBbin_255_Cnt == 1) && (luma_sum <= 0x220))
        {
            luma_chk = 1 ;
        }

        //monoscope
        mono_luma_sum_0_1 = CVD2_Hist_Y_Bin[0] + CVD2_Hist_Y_Bin[1];
        mono_luma_sum_7_13_14 = CVD2_Hist_Y_Bin[7] + CVD2_Hist_Y_Bin[13] + CVD2_Hist_Y_Bin[14];

        if(time_525)
        {
            mono_chk = (((mono_luma_sum_0_1 >= 0x70) && (mono_luma_sum_0_1 <= 0x98)) && ((mono_luma_sum_7_13_14 >= 0x138) && (mono_luma_sum_7_13_14 <= 0x150))) //mono 4:3
                || (((mono_luma_sum_0_1 >= 0x70) && (mono_luma_sum_0_1 <= 0x98)) && ((mono_luma_sum_7_13_14 >= 0x128) && (mono_luma_sum_7_13_14 <= 0x168))) ; //mono 16:9
        }
        else if (time_625)
        {
            mono_chk = (((mono_luma_sum_0_1 >= 0x90) && (mono_luma_sum_0_1 <= 0xb8)) && ((mono_luma_sum_7_13_14 >= 0xf0) && (mono_luma_sum_7_13_14 <= 0x138))) //mono 4:3
			       || (((mono_luma_sum_0_1 >= 0x90) && (mono_luma_sum_0_1 <= 0xb8)) && ((mono_luma_sum_7_13_14 >= 0x100) && (mono_luma_sum_7_13_14 <= 0x148))) ; //mono 16:9
        }
        else
        {
            mono_chk = 0;
        }
	
        for(i = 0; i < 16; i++)
        {
            if(i <= 6 )
            {
                other_cb_sum_0_6 += CVD2_Hist_Cb_Bin[i];
                other_cr_sum_0_6 += CVD2_Hist_Cr_Bin[i];
            }
            else
            {
                //exclude CVD2_Hist_Cb_Bin[7], CVD2_Hist_Cb_Bin[8] and CVD2_Hist_Cb_Bin[9]
                if((i != 7) && (i != 8) && (i != 9))
                {
                    other_cb_sum_10_15 += CVD2_Hist_Cb_Bin[i];
                    other_cr_sum_10_15 += CVD2_Hist_Cr_Bin[i];
                }
            }
        }

        if (time_525)
        {
            PatGen_NoColor = ( //(CVD2_Hist_Sat_Bin[0] == 0xff) && (other_sat_sum < 0x50) && //sat
                (CVD2_Hist_Cb_Bin[7] < 0xf0) && (CVD2_Hist_Cb_Bin[8] == 0xff) && (other_cb_sum_0_6 < 0x20) && (other_cb_sum_10_15 < 0x08) &&  //cb
                (CVD2_Hist_Cr_Bin[7] < 0xf0) && (CVD2_Hist_Cr_Bin[8] == 0xff) && (other_cr_sum_0_6 < 0x20) && (other_cr_sum_10_15 < 0x08));   //cr
        }
        else if (time_625)
        {
            PatGen_NoColor = ( //(CVD2_Hist_Sat_Bin[0] == 0xff) && (other_sat_sum < 0x50) && //sat
                (CVD2_Hist_Cb_Bin[7] < 0xf0) && (CVD2_Hist_Cb_Bin[8] == 0xff) && (other_cb_sum_0_6 < 0x30) && (other_cb_sum_10_15 < 0x08) &&  //cb
                (CVD2_Hist_Cr_Bin[7] < 0xf0) && (CVD2_Hist_Cr_Bin[8] == 0xff) && (other_cr_sum_0_6 < 0x20) && (other_cr_sum_10_15 < 0x14));   //cr
        }
        else
        {
            PatGen_NoColor = 0;
        }

        if((*((UINT8*)(0xbe1cd688))) == 0x22)
        {
            printk(KERN_EMERG"$$$$$  %x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x \n", 
                CVD2_Hist_Y_Bin[0], CVD2_Hist_Y_Bin[1], CVD2_Hist_Y_Bin[2], CVD2_Hist_Y_Bin[3]
                , CVD2_Hist_Y_Bin[4], CVD2_Hist_Y_Bin[5], CVD2_Hist_Y_Bin[6], CVD2_Hist_Y_Bin[7]
                , CVD2_Hist_Y_Bin[8], CVD2_Hist_Y_Bin[9], CVD2_Hist_Y_Bin[10], CVD2_Hist_Y_Bin[11]
                , CVD2_Hist_Y_Bin[12], CVD2_Hist_Y_Bin[13], CVD2_Hist_Y_Bin[14], CVD2_Hist_Y_Bin[15]);

            printk(KERN_EMERG"$$$$$  %x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x \n", 
                CVD2_Hist_Cb_Bin[0], CVD2_Hist_Cb_Bin[1], CVD2_Hist_Cb_Bin[2], CVD2_Hist_Cb_Bin[3]
                , CVD2_Hist_Cb_Bin[4], CVD2_Hist_Cb_Bin[5], CVD2_Hist_Cb_Bin[6], CVD2_Hist_Cb_Bin[7]
                , CVD2_Hist_Cb_Bin[8], CVD2_Hist_Cb_Bin[9], CVD2_Hist_Cb_Bin[10], CVD2_Hist_Cb_Bin[11]
                , CVD2_Hist_Cb_Bin[12], CVD2_Hist_Cb_Bin[13], CVD2_Hist_Cb_Bin[14], CVD2_Hist_Cb_Bin[15]);

            printk(KERN_EMERG"$$$$$  %x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x/%x \n", 
                CVD2_Hist_Cr_Bin[0], CVD2_Hist_Cr_Bin[1], CVD2_Hist_Cr_Bin[2], CVD2_Hist_Cr_Bin[3]
                , CVD2_Hist_Cr_Bin[4], CVD2_Hist_Cr_Bin[5], CVD2_Hist_Cr_Bin[6], CVD2_Hist_Cr_Bin[7]
                , CVD2_Hist_Cr_Bin[8], CVD2_Hist_Cr_Bin[9], CVD2_Hist_Cr_Bin[10], CVD2_Hist_Cr_Bin[11]
                , CVD2_Hist_Cr_Bin[12], CVD2_Hist_Cr_Bin[13], CVD2_Hist_Cr_Bin[14], CVD2_Hist_Cr_Bin[15]);

            printk(KERN_EMERG"$$$$v1 PGNC = [%d]/%x/%x/%x/%x\t luma_chk = [%d]/%x\t mono_chk = [%d]/%x/%x\t color sys = %d\n", 
				                               PatGen_NoColor, other_cb_sum_0_6, other_cb_sum_10_15, other_cr_sum_0_6, other_cr_sum_10_15, 
				                               luma_chk, luma_sum, 
				                               mono_chk, mono_luma_sum_0_1, mono_luma_sum_7_13_14, VIP_GetStdColorSystem());
        }
				
        if((*((UINT8*)(0xbe1cd688))) != 0x23)
        {
            mot_chk = ((luma_chk == 1) || (mono_chk == 1));
        }
        else 
        {
            mot_chk = (ucvdi_field_diff_cnt < 0x10) || (luma_chk == 1) || (mono_chk == 1);
        }

        // Detect  monoscope/white,exclude video book #ch17 and Sony #ch9  
        if(time_525 || time_625)
        {
            if((mot_chk == 1) && (PatGen_NoColor == 1))
            {
                if(++sharpness_cnt >= cnt_th) 
                {
                    sharpness_cnt = cnt_max;
                }		
                if((*((UINT8*)(0xbe1cd688))) == 0x22)
                {
                    printk(KERN_EMERG"$$$$$ cnt = %d\t Sony_CH9 = %d\t field_diff_cnt = %x\t ulHistCaseCur = %d\t \n", sharpness_cnt, Sony_CH9, ucvdi_field_diff_cnt_lp, pHwContext->ulHistCaseCur);
                }
            }
            else
            {
                if((--sharpness_cnt < cnt_th))
                {
                    sharpness_cnt = cnt_init;
                }
                if((*((UINT8*)(0xbe1cd688))) == 0x22)
                {
                    printk(KERN_EMERG"$$$$$ change pattern  cntr = %d\n\n", sharpness_cnt);
                }
            }
        }
      
        if((sharpness_cnt >= cnt_th) || ((*((UINT8*)(0xbe1cd688))) == 0x21) ||(VIP_GetStdColorSystem() == CVD2_STD_PAL_M) || (VIP_GetStdColorSystem() == CVD2_STD_PAL_CN)) 
        {
            if((*((UINT8*)(0xbe1cd688))) == 0x22)
            {
                printk(KERN_EMERG"$$$$$  cntrl = sharpness_cnt\n");
            }
            pHwContext->PqPatch.PeakLtiPatch = PEAKLTI_AV_IRE_PATCH;
            pHwContext->PqPatch.DpyPeakingPatch = DPY_PEAKING_AV_IRE_PATCH;
            pHwContext->PqPatch.DsSharpnessPatch = DS_SHARPNESS_AV_IRE_PATCH;
            PatchApply = TRUE;
            if((*((UINT8*)(0xbe1cd688))) == 0x22)
            {
                printk(KERN_EMERG"$$$$$ cnt = %d\t Sony_CH9 = %d\t field_diff_cnt = %x\t ulHistCaseCur = %d OK~~~ \n", sharpness_cnt, Sony_CH9, ucvdi_field_diff_cnt_lp, pHwContext->ulHistCaseCur);
            }
        }

        if(pHwContext->PqPatch.PeakLtiPatch != PEAKLTI_NON_PATCH)
        {
            if((*((UINT8*)(0xbe1cd688))) == 0x22)
                printk(KERN_EMERG"$$$$$ PEAKLTI_PATCH $$$$$\n" );
		PQ_Sharpness_Peaking_DLTI(TRUE, pMenuValue->iSharpness);
        }

        if(pHwContext->PqPatch.DpyPeakingPatch != DPY_PEAKING_NON_PATCH)
        {
            PQ_PeakingFilterSetup();
        }
    
        if(pHwContext->PqPatch.DsSharpnessPatch != DS_SHARPNESS_NON_PATCH)
        {	
            PQ_DSSharpness(TRUE, pMenuValue->iSharpness);
        }
    }
#endif

    if((pHwContext->PqPatch.PeakLtiPatch == PEAKLTI_NON_PATCH) && (PatchApply == TRUE))
    {
        if((*((UINT8*)(0xbe1cd688))) == 0x22)
        {
            printk(KERN_EMERG"$$$$$ PEAKLTI_NON_PATCH $$$$$\n" );
        }
        PatchApply = FALSE;
        PQ_Sharpness_Peaking_DLTI(TRUE, pMenuValue->iSharpness);
        PQ_PeakingFilterSetup();
        PQ_DSSharpness(TRUE, pMenuValue->iSharpness);      
    }
}


void PQ_SW_DynamicContrast_SceneChangeDetect_ISR(void)
{
    typedef struct _HIST_WEIGHT
    {
        UINT8 ucIndex;
        UINT32 ulWeight;
    } HIST_WEIGHT;
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    HIST_WEIGHT CurHistWeight[4];
    static HIST_WEIGHT PreHistWeight[4];
    UINT32 dwTotalPixel;
    UINT16 Var_ratio[6], Var_Factor[5];
    UINT32 ulHistBin[16];
    UINT32 ulCurAvgY;
    static UINT32 ulPreAvgY = 0;
    INT32 ulTargetSlop[16], ulTargetChroma[16];
    static INT32 ulPreTargetSlop[16] = {256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256};
    static INT32 ulPreTargetChroma[16]={256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256,	256};
    UINT8 ucSceneChangeEvent = 0, ChangeCondition[7], Var_cond_en[8], HistogramCase[32] , BinNormal=0,BinNull=0, ulcond1,ulcond2,ulcond3,ulcond4,ulcond5, ulcondS;
    INT32 i, j, tmp, alpha,iYLevel,iCLevel,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6, clr_ulcondS;
    static INT32 PreYLevel = 0, PreCLevel = 0, PreulcondS = 0, ulHistCasePre = 0, hit_flicker = 0, even_frame = 0, pre_nr = 0, flicker_cnt = 0;
    UINT8 HistCaseNum=0;
    UINT8 ucSWDC_En_Temp=0;
    BOOL ulChromaBin98=0, ulChromaBin99=0;
    BOOL GrayPatternFlag=0, BarNoiseFlag=0;
    UINT32 ulCurChromaBinPercentage,ulCurChromaBinPercentage7,ulCurChromaBinPercentage8;
    static UINT8 SsceneCNT = 0;

    if((*((UINT8*)(0xbe1cd688))) == 0x3) 
    {
        return;
    }

    if(PQ_GetColorProcessor() == FALSE)
    {
        ucSWDC_En_Temp = FALSE;
    }
    else
    {
        ucSWDC_En_Temp = SWDC_Param[0].ucSWDC_En;
    }

    ulCurChromaBinPercentage = PQ_ChromaBinPercentage(0);       
    if (VIP_IsATVSource() || VIP_IsAVSource())
    {
        if ( ulCurChromaBinPercentage > 998 )
            ulChromaBin99 = (ulCurChromaBinPercentage > 998)? 1:0;   // 1 : black/w
        else
            ulChromaBin98 = (ulCurChromaBinPercentage > 997)? 1:0;   // 1 : gray ; 0 : other
    }
    else
        ulChromaBin98 = (PQ_ChromaBinPercentage(0)>980)? 1:0;
	
    if (VIP_GetStdColorSystem() == CVD2_STD_SECAM)
    {
        ulChromaBin98 = (PQ_ChromaBinPercentage(0)>950)? 1:0;
    }

    //enable sw dc
    PQ_RegisterWrite(VIP_reg_dpy_bin_sel_hist, 1);
    PQ_RegisterWrite(VIP_reg_dpy_hist_int, 0);
    PQ_RegisterWrite(VIP_reg_dpy_hist_en, ucSWDC_En_Temp);

    Var_ratio[0] = SWDC_Param[0].wSWDC_Ratio[0];
    Var_ratio[1] = SWDC_Param[0].wSWDC_Ratio[1];
    Var_ratio[2] = SWDC_Param[0].wSWDC_Ratio[2];
    Var_ratio[3] = SWDC_Param[0].wSWDC_Ratio[3];
    Var_ratio[4] = SWDC_Param[0].wSWDC_Ratio[4];
    Var_ratio[5] = SWDC_Param[0].wSWDC_Ratio[5];

    for(i=0; i<8; i++)
        Var_cond_en[i] =  (SWDC_Param[0].ucSWDC_Var_Cond_En>>i)&0x01;
    Var_cond_en[1] = 0;

    Var_Factor[0] = SWDC_Param[0].wSWDC_Factor[0];
    Var_Factor[1] = SWDC_Param[0].wSWDC_Factor[1];
    Var_Factor[2] = SWDC_Param[0].wSWDC_Factor[2];
    Var_Factor[3] = SWDC_Param[0].wSWDC_Factor[3];
    Var_Factor[4] = SWDC_Param[0].wSWDC_Factor[4];

    alpha = SWDC_Param[0].wSWDC_Alpha;
    iYLevel = SWDC_Param[0].wSWDC_YLevel;
    iCLevel = SWDC_Param[0].wSWDC_CLevel;

    dwTotalPixel = 0;
    for(i = 0; i <16; i++)
    {
        ulHistBin[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
        dwTotalPixel += ulHistBin[i];
        pHwContext->LumaHist.ulLumaHistBin[i] = ulHistBin[i];
    }

    pHwContext->LumaHist.dwTotalPixel = dwTotalPixel;

    for(i = 0; i<4; i++)
        CurHistWeight[i].ucIndex= i;

    if(PreHistWeight[0].ucIndex == 0  && PreHistWeight[1].ucIndex == 0 && PreHistWeight[2].ucIndex == 0  && PreHistWeight[3].ucIndex == 0)
    {
        for(i = 0; i<4; i++)
            PreHistWeight[i].ucIndex= i;
    }

    if((PQ_RegisterRead(VIP_reg_dpy_en) == 0 ) || (dwTotalPixel ==0)) //DCR init value
    {
        for(i=0; i<16; i++)
        {
            PQ_RegisterWrite(VIP_reg_dpy_hist_slope0+i*4 ,256);
            PQ_RegisterWrite(VIP_reg_dpy_hist_start0+i*4 ,i*64*16);
            PQ_RegisterWrite(VIP_reg_dpy_hist_chroma0+i*4  ,256);
        }
        return;
    }

    if(dwTotalPixel > 0)
    {
    	ulCurAvgY = PQ_RegisterRead(VIP_reg_dpy_y_sum)*256 / dwTotalPixel;
    }

    CurHistWeight[0].ulWeight= (7*ulHistBin[0] +  9*ulHistBin[1]  + 9*ulHistBin[2]  + 4*ulHistBin[3]  + 2*ulHistBin[4]  +   ulHistBin[5])>>5;
    CurHistWeight[1].ulWeight= (  ulHistBin[2] +  2*ulHistBin[3]  + 4*ulHistBin[4]  + 9*ulHistBin[5]  + 9*ulHistBin[6]  + 4*ulHistBin[7]  + 2*ulHistBin[8] + ulHistBin[9])>>5;
    CurHistWeight[2].ulWeight= (  ulHistBin[6] +  2*ulHistBin[7]  + 4*ulHistBin[8]  + 9*ulHistBin[9]  + 9*ulHistBin[10] + 4*ulHistBin[11] + 2*ulHistBin[12] + ulHistBin[13])>>5;
    CurHistWeight[3].ulWeight= (  ulHistBin[10] +  2*ulHistBin[11] + 4*ulHistBin[12] + 9*ulHistBin[13] + 9*ulHistBin[14] + 7*ulHistBin[15])>>5;

    //sorting
    for(i = 0 ; i<4 ; i++)
        for(j=0; j<3-i; j++)
            if(CurHistWeight[j].ulWeight<CurHistWeight[j+1].ulWeight)
            {
                tmp = CurHistWeight[j].ulWeight;
                CurHistWeight[j].ulWeight= CurHistWeight[j+1].ulWeight;
                CurHistWeight[j+1].ulWeight= tmp;

                tmp = CurHistWeight[j].ucIndex;
                CurHistWeight[j].ucIndex= CurHistWeight[j+1].ucIndex;
                CurHistWeight[j+1].ucIndex= tmp;
            }

    ChangeCondition[0] = Var_cond_en[0] && ((ulCurAvgY<<8)>=(Var_ratio[0]*ulPreAvgY) || (ulPreAvgY<<8)>=(Var_ratio[0]*ulCurAvgY));
    ChangeCondition[1] = Var_cond_en[1] || (ulCurAvgY<<8)>=(Var_ratio[2]*ulPreAvgY) || (ulPreAvgY<<8)>=(Var_ratio[2]*ulCurAvgY);
    ChangeCondition[2] = ((CurHistWeight[0].ucIndex != PreHistWeight[0].ucIndex) && (CurHistWeight[0].ucIndex != PreHistWeight[1].ucIndex))  &&
                         ((CurHistWeight[1].ucIndex != PreHistWeight[0].ucIndex) && (CurHistWeight[1].ucIndex != PreHistWeight[1].ucIndex));
    ChangeCondition[3] = (CurHistWeight[0].ucIndex == PreHistWeight[1].ucIndex) &&
                         ((CurHistWeight[0].ulWeight<<8)>=Var_ratio[4]*CurHistWeight[1].ulWeight &&
                          (PreHistWeight[0].ulWeight<<8)>=Var_ratio[5]*PreHistWeight[1].ulWeight);

    ucSceneChangeEvent =   ChangeCondition[0] ||
                            ( ChangeCondition[1] && ((Var_cond_en[2]&&ChangeCondition[2])||(Var_cond_en[3]&&ChangeCondition[3])));

    if(PreYLevel != iYLevel || PreCLevel!=iCLevel)
        ucSceneChangeEvent = 1;

    if(ucSceneChangeEvent)
    {
        PQDebugPrint("%s: ChangeCondition = %d, %d, %d, %d ",__FUNCTION__,ChangeCondition[0],ChangeCondition[1],ChangeCondition[2],ChangeCondition[3]);
    }

    //for spacial case I
    BinNull = 0;
    BinNormal = 0;
    if (Var_cond_en[4]==1)
    {
        _CheckHistBinDistribution(&ulHistBin[0], dwTotalPixel, &BinNull, &BinNormal);
    }

    //ulcondS = (BinNull>14 || BinNormal>=4);
    ulcondS = (BinNull>16 || BinNormal>=4);
    clr_ulcondS = (BinNull<14 || BinNormal<4);

    if (ucSceneChangeEvent)
    {
        PreulcondS = ulcondS;
    }
    else if (clr_ulcondS)
    {
        PreulcondS = 0;
    }

    if (ucSceneChangeEvent==0 && even_frame)
    {
        even_frame = 0;
        return;
    }
    else
    {
        if (even_frame)
            even_frame = 0;
        else
            even_frame = 1;
    }

    tmp     = (CurHistWeight[0].ulWeight+CurHistWeight[1].ulWeight+CurHistWeight[2].ulWeight+CurHistWeight[3].ulWeight);

    ulcond1 = (CurHistWeight[0].ulWeight<<8)>=Var_Factor[0]*(UINT32)tmp;

    ulcond2 = (ulcond1==0) && ((CurHistWeight[0].ulWeight<<8)>=Var_Factor[3]*CurHistWeight[1].ulWeight) &&
              ((CurHistWeight[0].ulWeight<<8)+(CurHistWeight[1].ulWeight<<8))>=Var_Factor[1]*(UINT32)tmp;

    ulcond3 = (ulcond1==0) && ((CurHistWeight[0].ulWeight<<8)< Var_Factor[3]*CurHistWeight[1].ulWeight) &&
              ((CurHistWeight[0].ulWeight<<8)+(CurHistWeight[1].ulWeight<<8))>=Var_Factor[1]*(UINT32)tmp;

    ulcond4 = (ulcond1==0) && (ulcond2==0) && (ulcond3==0) && ((CurHistWeight[1].ulWeight<<8)>=Var_Factor[4]*CurHistWeight[2].ulWeight) &&
              ((CurHistWeight[0].ulWeight<<8)+(CurHistWeight[1].ulWeight<<8)+(CurHistWeight[2].ulWeight<<8))>=Var_Factor[2]*(UINT32)tmp;

    ulcond5 = (ulcond1==0) && (ulcond2==0) && (ulcond3==0) && ((CurHistWeight[1].ulWeight<<8)< Var_Factor[4]*CurHistWeight[2].ulWeight) &&
              ((CurHistWeight[0].ulWeight<<8)+(CurHistWeight[1].ulWeight<<8)+(CurHistWeight[2].ulWeight<<8))>=Var_Factor[2]*(UINT32)tmp;

    if(PreulcondS)
    {
        ulcond1 = ulcond2 = ulcond3 = ulcond4 = ulcond5 = 0;
        HistogramCase[31] =1;
    }
    else
        HistogramCase[31] =0;

    HistogramCase[0]  = (CurHistWeight[0].ucIndex==0) && ulcond1;
    HistogramCase[1]  = (CurHistWeight[0].ucIndex==0  && CurHistWeight[1].ucIndex==1)  && ulcond2;
    HistogramCase[2]  = ((CurHistWeight[0].ucIndex==0 || CurHistWeight[0].ucIndex==1)) && ((CurHistWeight[1].ucIndex==0 || CurHistWeight[1].ucIndex==1)) && ulcond3;
    HistogramCase[3]  = (CurHistWeight[0].ucIndex==1  && CurHistWeight[1].ucIndex==0)  && ulcond2;
    HistogramCase[4]  = (CurHistWeight[0].ucIndex==1) && ulcond1;
    HistogramCase[5]  = (CurHistWeight[0].ucIndex==1  && CurHistWeight[1].ucIndex==2)  && ulcond2;
    HistogramCase[6]  = ((CurHistWeight[0].ucIndex==1 || CurHistWeight[0].ucIndex==2)) && ((CurHistWeight[1].ucIndex==1 || CurHistWeight[1].ucIndex==2)) && ulcond3;
    HistogramCase[7]  = (CurHistWeight[0].ucIndex==2  && CurHistWeight[1].ucIndex==1)  && ulcond2;
    HistogramCase[8]  = (CurHistWeight[0].ucIndex==2) && ulcond1;
    HistogramCase[9]  = (CurHistWeight[0].ucIndex==2  && CurHistWeight[1].ucIndex==3)  && ulcond2;
    HistogramCase[10] = ((CurHistWeight[0].ucIndex==2 || CurHistWeight[0].ucIndex==3)) && ((CurHistWeight[1].ucIndex==2 || CurHistWeight[1].ucIndex==3)) && ulcond3;
    HistogramCase[11] = (CurHistWeight[0].ucIndex==3  && CurHistWeight[1].ucIndex==2)  && ulcond2;
    HistogramCase[12] = (CurHistWeight[0].ucIndex==3) && ulcond1;
    HistogramCase[13] = (CurHistWeight[0].ucIndex==0  && CurHistWeight[1].ucIndex==3)  && ulcond2;
    HistogramCase[14] = ((CurHistWeight[0].ucIndex==0 || CurHistWeight[0].ucIndex==3)) && ((CurHistWeight[1].ucIndex==0 || CurHistWeight[1].ucIndex==3)) && ulcond3;
    HistogramCase[15] = (CurHistWeight[0].ucIndex==3  && CurHistWeight[1].ucIndex==0)  && ulcond2;
    HistogramCase[16] = (CurHistWeight[0].ucIndex==0  && CurHistWeight[1].ucIndex==2)  && ulcond2;
    HistogramCase[17] = (CurHistWeight[0].ucIndex==2  && CurHistWeight[1].ucIndex==0)  && ulcond2;
    HistogramCase[18] = ((CurHistWeight[0].ucIndex==0 || CurHistWeight[0].ucIndex==2)) && ((CurHistWeight[1].ucIndex==0 || CurHistWeight[1].ucIndex==2)) && ulcond3;
    HistogramCase[19] = (CurHistWeight[0].ucIndex==1  && CurHistWeight[1].ucIndex==3)  && ulcond2;
    HistogramCase[20] = (CurHistWeight[0].ucIndex==3  && CurHistWeight[1].ucIndex==1)  && ulcond2;
    HistogramCase[21] = ((CurHistWeight[0].ucIndex==1 || CurHistWeight[0].ucIndex==3)) && ((CurHistWeight[1].ucIndex==1 || CurHistWeight[1].ucIndex==3)) && ulcond3;
    HistogramCase[22] = (CurHistWeight[3].ucIndex==3) && ulcond5;
    HistogramCase[23] = (CurHistWeight[3].ucIndex==3) && ulcond4;
    HistogramCase[24] = (CurHistWeight[3].ucIndex==0) && ulcond5;
    HistogramCase[25] = (CurHistWeight[3].ucIndex==0) && ulcond4;
    HistogramCase[26] = (CurHistWeight[3].ucIndex==2) && ulcond5;
    HistogramCase[27] = (CurHistWeight[3].ucIndex==2) && ulcond4;
    HistogramCase[28] = (CurHistWeight[3].ucIndex==1) && ulcond5;
    HistogramCase[29] = (CurHistWeight[3].ucIndex==1) && ulcond4;

    pHwContext->ulHistCaseCur = 0;
    for(i=0; i<30; i++)
    {
        if(HistogramCase[i] == 1)
            pHwContext->ulHistCaseCur = i+1;
    }

    if ( HistogramCase[6]==1 || HistogramCase[22]==1 || HistogramCase[23]==1 || HistogramCase[24]==1 || HistogramCase[25]==1)
        GrayPatternFlag = 1;
    else
        GrayPatternFlag = 0;
	
    if ( PreulcondS==1|| (GrayPatternFlag !=1 && ulChromaBin99==1) )
    {
			if ( (((ulHistBin[0]+ulHistBin[1]+ulHistBin[14]+ulHistBin[15])*100) / dwTotalPixel ) > 65 )
				pHwContext->ulHistCaseCur = 32; 	// black & white scene
			else
				pHwContext->ulHistCaseCur = 31; 	// gray scene
    }
    else if ( pHwContext->ulHistCaseCur==0 || (GrayPatternFlag ==1 && ulChromaBin98==1))
        pHwContext->ulHistCaseCur = 31;     // gray scene
    else if ( pHwContext->ulHistCaseCur==0 || (GrayPatternFlag ==1 && ulChromaBin99==1))
        pHwContext->ulHistCaseCur = 31;		// gray scene

    //avoid static scene unstable only 1-2 frame, then the DCC setting changed, ex. Video book/SONY/Chapter #9
    if(ulHistCasePre == 31 || ulHistCasePre ==32)
    {
        if(((pHwContext->ulHistCaseCur == 31) || (pHwContext->ulHistCaseCur == 32)) && (pHwContext->ulHistCaseCur == ulHistCasePre))
        {
            if(SsceneCNT< 3)
            {
                SsceneCNT++;
            }
        }
        else
        {
            if(SsceneCNT > 0)
            {
                SsceneCNT--;
            }
        }
    }

    if((SsceneCNT > 0) && pHwContext->ulHistCaseCur != ulHistCasePre)
    {
        //myrprintk("Scene unstable : ulHistCaseCur = %d, count = %d, return,", pHwContext->ulHistCaseCur, SsceneCNT);
        return;
    }
        
    ucTempDCCSceneID = pHwContext->ulHistCaseCur;
	
    // 	prevent flicker
    if (Var_cond_en[6]==1)
    {
        tmp1 = 0;
        for(i=0; i<4; i++)
        {
            if ((INT32)CurHistWeight[i].ulWeight>=(INT32)PreHistWeight[i].ulWeight)
            {
                tmp = ((INT32)CurHistWeight[i].ulWeight-(INT32)PreHistWeight[i].ulWeight);
                if ((flicker_cnt>0)&&(flicker_cnt<20))
                    flicker_cnt = flicker_cnt + 1;
                else if (flicker_cnt<20)
                    flicker_cnt = flicker_cnt + 2;                       
            } 
            else
            	{
                 tmp = ((INT32)PreHistWeight[i].ulWeight-(INT32)CurHistWeight[i].ulWeight);
                 if ((flicker_cnt<0)&&(flicker_cnt>-20))
                     flicker_cnt = flicker_cnt - 1;
                 else if (flicker_cnt>-20)
                     flicker_cnt = flicker_cnt - 2; 				 
            	}
            tmp1 += tmp;
        }

        tmp = (PreHistWeight[0].ulWeight+PreHistWeight[1].ulWeight+PreHistWeight[2].ulWeight+PreHistWeight[3].ulWeight)/18;

        if ((tmp1 < tmp)&&(flicker_cnt<10)&&(flicker_cnt>-10)&&
			(pHwContext->ulHistCaseCur!=ulHistCasePre)&&
			(ucSceneChangeEvent==0)&&
			(ulHistCasePre!=32 || pHwContext->ulHistCaseCur!= 32)&&
			(PQ_ChromaBinPercentage(0)<980)&&
			(((CurHistWeight[0].ucIndex == PreHistWeight[0].ucIndex)||(CurHistWeight[0].ucIndex == PreHistWeight[1].ucIndex))&&
		    ((CurHistWeight[1].ucIndex == PreHistWeight[0].ucIndex)||(CurHistWeight[1].ucIndex == PreHistWeight[1].ucIndex))))
	    {			
            pHwContext->ulHistCaseCur = ulHistCasePre; 
            hit_flicker = 1;
        }
        else
        {
            flicker_cnt = 0;
            hit_flicker = 0;  
        }
    }

    if(pHwContext->ulHistCaseCur != ulHistCasePre)
    {
        PQDebugPrint("ulHistCaseCur = %d, ulHistCasePre = %d", (pHwContext->ulHistCaseCur-1), (ulHistCasePre-1));
        PQDebugPrint("index =%d %d %d %d ", CurHistWeight[0].ucIndex, CurHistWeight[1].ucIndex, CurHistWeight[2].ucIndex, CurHistWeight[3].ucIndex);
        PQDebugPrint("weight=%d %d %d %d ", CurHistWeight[0].ulWeight, CurHistWeight[1].ulWeight, CurHistWeight[2].ulWeight, CurHistWeight[3].ulWeight);
    }

    HistCaseNum = pHwContext->ulHistCaseCur - 1;
    _SharpnessPatch();

    for(i=0; i<16; i++)
    {
        ulTargetSlop[i]= SWDC_HistSlop[0].SWDC_HistSlop[HistCaseNum][i]*2;
        ulTargetChroma[i]= SWDC_HistChroma[0].SWDC_HistChroma[HistCaseNum][i]*2;

    }

    // shrink black level  20140116
    if (Var_cond_en[3]==1 && PQ_GetAvgY_Value()>120 && pHwContext->ulHistCaseCur != 31 && pHwContext->ulHistCaseCur != 32)
    {
        if ((ulHistBin[0]+ulHistBin[1]+ulHistBin[2]+ulHistBin[3])>dwTotalPixel*200/1000)
        {
            tmp1 = 8*ulTargetSlop[0]/10;//8*ulTargetSlop[0]/10; //ulTargetSlop[0]/2;
            tmp2 = 4*ulTargetSlop[1]/10;//3*ulTargetSlop[1]/4; //3*ulTargetSlop[1]/4;
            tmp3 = 7*ulTargetSlop[2]/8;//7*ulTargetSlop[2]/8; //9*ulTargetSlop[2]/10;
        }
        else
        {
            tmp1 = ulTargetSlop[0]/2;
            tmp2 = 3*ulTargetSlop[1]/4;
            tmp3 = 9*ulTargetSlop[2]/10;
        }
        
        tmp  = (ulTargetSlop[0]-tmp1) + (ulTargetSlop[1]-tmp2) +  (ulTargetSlop[2]-tmp3);
        ulTargetSlop[0] = tmp1;
        ulTargetSlop[1] = tmp2;
        ulTargetSlop[2] = tmp3;
        tmp4 = tmp/13;
        tmp5 = tmp - 13*tmp4;

        for (i=3; i<15; i++)
        {
            ulTargetSlop[i] = ulTargetSlop[i] + tmp4;
        }
        ulTargetSlop[15] = ulTargetSlop[15] + tmp4 + tmp5;

    }

    //for spacial case II (reduce background noise effect)
    if (Var_cond_en[5]==1 || pHwContext->ulHistCaseCur == 32 )
    {
        tmp = 0;
        tmp1 = 0;
        for(i=2; i<14; i++)
        {
            if ((((ulHistBin[i]>dwTotalPixel*250/1000)&&(ulHistBin[i]>3*ulHistBin[i-1])&&(ulHistBin[i]>3*ulHistBin[i+1])) ||
                ((pre_nr==1)&&(ulHistBin[i]>dwTotalPixel*240/1000)&&(ulHistBin[i]>5*ulHistBin[i-1]/2)&&(ulHistBin[i]>5*ulHistBin[i+1]/2)))&&(ulTargetSlop[i]>64))
            {
                if (i<4)
                    tmp2 = 2*ulTargetSlop[i]/3;
                else
                    tmp2 = ulTargetSlop[i]/2;

                pre_nr = 1;

                tmp3 = ulTargetSlop[i]-tmp2;
                tmp += tmp3;
                ulTargetSlop[i] = tmp2;
            }
            else if (((((ulHistBin[i]+ulHistBin[i+1])>dwTotalPixel*500/1000)&&(ulHistBin[i]>dwTotalPixel*250/1000)&&
                      ((ulHistBin[i]+ulHistBin[i+1])>6*ulHistBin[i-1])&&((ulHistBin[i]+ulHistBin[i+1])>6*ulHistBin[i+2])) ||
                      ((pre_nr==1)&&((ulHistBin[i]+ulHistBin[i+1])>dwTotalPixel*450/1000)&&(ulHistBin[i]>dwTotalPixel*240/1000)&&
                      ((ulHistBin[i]+ulHistBin[i+1])>5*ulHistBin[i-1])&&((ulHistBin[i]+ulHistBin[i+1])>5*ulHistBin[i+2]))) &&(ulTargetSlop[i]>64))
            {
                if (ulHistBin[i]>5*ulHistBin[i+1]/3)
                {
                    if (i<4)
                        tmp2 = 2*ulTargetSlop[i]/3;
                    else
                        tmp2 = ulTargetSlop[i]/2;

                    tmp3 = ulTargetSlop[i]-tmp2;
                    tmp += tmp3;
                    ulTargetSlop[i] = tmp2;
                }
                else if (ulHistBin[i+1]>5*ulHistBin[i]/3)
                {
                    if (i<4)
                        tmp2 = 2*ulTargetSlop[i+1]/3;
                    else
                        tmp2 = ulTargetSlop[i+1]/2;

                    tmp3 = ulTargetSlop[i+1]-tmp2;
                    tmp += tmp3;
                    ulTargetSlop[i+1] = tmp2;
                }
                else
                {
                    tmp2 = 2*ulTargetSlop[i]/3;
                    tmp3 = ulTargetSlop[i]-tmp2;
                    tmp += tmp3;
                    ulTargetSlop[i] = tmp2;

                    tmp2 = 2*ulTargetSlop[i+1]/3;
                    tmp3 = ulTargetSlop[i+1]-tmp2;
                    tmp += tmp3;
                    ulTargetSlop[i+1] = tmp2;
                }

                pre_nr = 1;
            }
            else if ((((ulHistBin[i]>dwTotalPixel*350/1000)&&((ulHistBin[i]+ulHistBin[i-1])<=dwTotalPixel*500/1000)) ||
                      ((pre_nr==1)&&(ulHistBin[i]>dwTotalPixel*300/1000)&&((ulHistBin[i]+ulHistBin[i-1])<=dwTotalPixel*450/1000)))&&(ulTargetSlop[i]>64))
            {
                if (i<4)
                    tmp2 = 2*ulTargetSlop[i]/3;
                else
                    tmp2 = ulTargetSlop[i]/2;

                tmp3 = ulTargetSlop[i]-tmp2;
                tmp += tmp3;
                ulTargetSlop[i] = tmp2;

                pre_nr = 1;
            }
            else
            {
                pre_nr = 0;
            }

        }
        tmp3 = tmp>>4;
        tmp4 = tmp - 16*tmp3;

        for(i=0; i<15; i++)
        {
            tmp5 = (INT32)ulTargetSlop[i] + tmp3;
            if (tmp5>4095)
            {
                tmp4 += (tmp5 - 4095);
                ulTargetSlop[i] = 4095;
            }
            else
                ulTargetSlop[i] = tmp5;
        }

        tmp6  = (INT32)ulTargetSlop[15] + tmp3 + tmp4;
        if (tmp6>4095)
            ulTargetSlop[15] = 4095;
        else
            ulTargetSlop[15] = tmp6;
    }

    // static contrast
    PQ_SW_DynamicContrast_UserCurveAdjust();

    tmp1 = 0;
    tmp2 = 0;
    for(i=0; i<16; i++)
    {
        tmp =(INT32)ulTargetSlop[i] + (INT32)pHwContext->ulCurveSlop[i];

        if (tmp<0)
            tmp = 0;
        else if (tmp>4095)
            tmp = 4095;

        tmp1 += tmp;

        if ((tmp1>4095)&&(tmp2<=4095))
            ulTargetSlop[i] = 4095-tmp2;
        else if (tmp1>4095)
            ulTargetSlop[i] = 0;
        else
            ulTargetSlop[i] = tmp;

        tmp2 = tmp1;
    }

    tmp1 = 0;
    tmp2 = 0;
    for(i=0; i<16; i++)
    {
        tmp = (((INT32)ulTargetSlop[i]-256)*iYLevel+256*256+128)>>8;

	if (tmp<0)
		tmp = 0;
	else
        	tmp1 += tmp;

        if ((tmp1>4095)&&(tmp2<=4095))
            ulTargetSlop[i] = 4095-tmp2;
        else if (tmp1>4095)
            ulTargetSlop[i] = 0;
        else
            ulTargetSlop[i] = tmp;		//21

        tmp2 = tmp1;

        ulTargetChroma[i] = (((INT32)ulTargetChroma[i]-256)*iCLevel+256*256+128)>>8;
    }

    //for spacial case III ( expand white )
    if ((Var_cond_en[7]==1 || pHwContext->ulHistCaseCur == 31) && pHwContext->ulHistCaseCur != 32)
    {
        tmp1 = 0;
        tmp2 = 96;
        if ((ulHistBin[12]+ulHistBin[13]+ulHistBin[14]+ulHistBin[15])>dwTotalPixel*250/1000)
        {
            for (i=12; i<16; i++)
            {
                if ((INT32)ulTargetSlop[i]<(i-11)*tmp2)
                {
                    tmp = (i-11)*tmp2 - (INT32)ulTargetSlop[i];
                    tmp1 += tmp;
                    ulTargetSlop[i] = (i-11)*tmp2;
                }
            }

            tmp2 = tmp1>>4;
            tmp3 = tmp1-16*tmp2;

            for (i=0; i<16; i++)
            {
                tmp4 = ulTargetSlop[i];

                if (tmp4>tmp2)
                    ulTargetSlop[i] = tmp4-tmp2;
                else
                {
                    ulTargetSlop[i] = 0;
                    tmp3 = tmp3 + (tmp2-tmp4);
                }
            }

            tmp2 = tmp3>>2;
            tmp5 = tmp3-4*tmp2;

            for (i=12; i<16; i++)
            {
                tmp4 = ulTargetSlop[i];

                if (tmp4>tmp2)
                    ulTargetSlop[i] = tmp4-tmp2;
                else
                {
                    ulTargetSlop[i] = 0;
                    tmp5 = tmp5 + (tmp2-tmp4);
                }
            }

            tmp4 = ulTargetSlop[15];
            if (tmp4 > tmp5)
                ulTargetSlop[15] = tmp4 - tmp5;
            else
                ulTargetSlop[15] = 0;
        }
    }

    tmp1 =0;
    tmp2 = 0;
    for(i=0; i<16; i++)
    {
        if(!ucSceneChangeEvent)
        {
            tmp = (INT32)ulTargetSlop[i] + (((INT32)ulPreTargetSlop[i]-(INT32)ulTargetSlop[i])*alpha)/256;

            tmp1 += tmp;

            if ((tmp1>4095)&&(tmp2<=4095))
                ulTargetSlop[i] = 4095-tmp2;
            else if (tmp1>4095)
                ulTargetSlop[i] = 0;
            else
                ulTargetSlop[i] = tmp;	//21

            tmp2 = tmp1;
        }

        if(!ucSceneChangeEvent)
        {
            tmp = (INT32)ulTargetChroma[i] + (((INT32)ulPreTargetChroma[i]-(INT32)ulTargetChroma[i])*alpha)/256;
            ulTargetChroma[i] = tmp;
        }
    }

    // For special case IV - pure blue pattern : noise
    ulCurChromaBinPercentage7 = PQ_ChromaBinPercentage(7);       
    ulCurChromaBinPercentage8 = PQ_ChromaBinPercentage(8);       

    if ( (ulHistBin[1] == dwTotalPixel || ulHistBin[2] == dwTotalPixel) && (ulCurChromaBinPercentage7 > 998 || ulCurChromaBinPercentage8 > 998) )		BluePatternFlag = 1;
    else	BluePatternFlag = 0;

    // For special case V - white xx% pattern : bar noise
    if ((ulHistBin[2] == dwTotalPixel || ulHistBin[3] == dwTotalPixel) && pHwContext->ulHistCaseCur == 31) 	// gray white scene
        BarNoiseFlag = 1;
    else
        BarNoiseFlag = 0;

    //set register
    for(i=0; i<16; i++)
    {
        PQ_RegisterWrite(VIP_reg_dpy_hist_slope0+i*4 ,ulTargetSlop[i]);
        PQ_RegisterWrite(VIP_reg_dpy_hist_chroma0+i*4  ,ulTargetChroma[i]);
    }

    PQ_RegisterWrite(VIP_reg_dpy_hist_start0 , 0);
    tmp = 0;

    if(_DCCPatch(BarNoiseFlag) == PATCHNOTAPPLY)
    {
        for(i=1; i<16; i++)
        {
            tmp = tmp +(ulTargetSlop[i-1]<<2);

            if (tmp>16367)
            {
                tmp = 16367;
                ulTargetSlop[i] = 0;
                PQ_RegisterWrite(VIP_reg_dpy_hist_slope0+i*4 ,ulTargetSlop[i]);
            }

            PQ_RegisterWrite(VIP_reg_dpy_hist_start0+i*4 ,tmp);           
        }
    }

    ulPreAvgY = ulCurAvgY;
    if (hit_flicker==0) 	memcpy(PreHistWeight, CurHistWeight, sizeof(UINT32)*8);
    ulHistCasePre = pHwContext->ulHistCaseCur;
    PreYLevel = iYLevel;
    PreCLevel = iCLevel;
    memcpy(ulPreTargetSlop,ulTargetSlop,sizeof(INT32)*16);
    memcpy(ulPreTargetChroma, ulTargetChroma,sizeof(INT32)*16);

    //patch of #51943
#ifdef DRV_ENABLE_CVD2
    if(VIP_GetUserSource() == SOURCE_CVD2 && VIP_GetStdColorSystem() == CVD2_STD_PAL_IBGDK && pHwContext->bCVD2_NTSC_to_PAL_Patch)
    {
        DRV_CVD2_Enable_PAL_HighFrameDiff(FALSE);
        DRV_CVD2_AV_PAL_FinetuneHFDiff(TRUE);
    }
    else
    {
        DRV_CVD2_Enable_PAL_HighFrameDiff(TRUE);
        DRV_CVD2_AV_PAL_FinetuneHFDiff(FALSE);
    }
#endif
}

void PQ_SW_DynamicContrast_Enable(UINT8 wValue)
{
	if(wValue >1)
	{
		return;
	}
	SWDC_Param[0].ucSWDC_En = wValue;
}

UINT8 PQ_GetDynamicContrastEnable(void)
{
	return SWDC_Param[0].ucSWDC_En;
}

void PQ_SW_DynamicContrast_Y_Level(UINT16 wValue)
{
	if(wValue >512)
	{
		return;
	}
	SWDC_Param[0].wSWDC_YLevel= wValue;
}
void PQ_SW_DynamicContrast_C_Level(UINT16 wValue)
{
	if(wValue >512)
	{
		return;
	}
	SWDC_Param[0].wSWDC_CLevel= wValue;
}
void PQ_SW_DynamicContrast_Alpha_Mode(UINT8 bMode ,UINT8 bValue)
{
	if(bMode>3)
	{
		return;
	}

	SWDC_Param[0].wSWDC_Static_Alpha[bMode]= bValue;

}


#endif
UINT8 VIP_Get_PQ_Source(UINT8 ucSource, UINT8 ucSubSource)
{
	PQ_DLC_SRC bIndex=HDMI_IN;

	switch(ucSource)
	{
	case EXTS:
		if( ucSubSource==YPP1 || ucSubSource==YPP2)
		{
		    if(PQ_GetDefinitionIndex())
            {
                bIndex = COMP_HD_IN;
            }
            else
            {
                bIndex = COMP_IN;
            }

		    #if SEPERATE_YPBPR1_YPBPR2
            if(VIP_JudgeDVDSource()) //DVD have no HD resolution
            {
                bIndex = DVD_IN;
            }
            #endif
		}
        else if(ucSubSource==SCART_RGB1)
        {
            bIndex = SCART_IN;
        }
		else if( ucSubSource==DSUB )
		{
			bIndex = PC_IN;
		}

		break;
	case CVD2:
		if( ucSubSource==TV_INPUT_CHANNEL )
		{
			bIndex = ATV_IN;
		}
		else if( ucSubSource==AV1_INPUT_CHANNEL || ucSubSource==AV2_INPUT_CHANNEL || ucSubSource==AV3_INPUT_CHANNEL )
		{
			bIndex = AV_IN;
		}
		if( ucSubSource==S1_INPUT_CHANNEL || ucSubSource==S2_INPUT_CHANNEL || ucSubSource==S3_INPUT_CHANNEL )
		{
			bIndex = SV_IN;

		}
		break;
	case MPEG:
		{
            if(PQ_GetDefinitionIndex())
            {
                bIndex = DTV_HD_IN;
            }
            else
            {
			    bIndex = DTV_IN;
            }
		}
		break;
	case HDMI:
	default:
		if(VIP_RunDVIMode())
		{
			bIndex = PC_IN;
		}
		else
		{
		    if(PQ_GetDefinitionIndex())
            {
                bIndex = HDMI_HD_IN;
            }
            else
            {
			    bIndex = HDMI_IN;
            }
		}

		break;
	case JPEG:
	case PATN:
			bIndex = PC_IN;

		break;
	}

	return bIndex;

}

#ifdef DYNAMIC_BACKLIGHT



UINT8 PQ_GETAllBlackStatus(void)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	return pDBL->ucAllBlackStatus;
}

UINT32 PQ_GetBackLight(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT32 dwCur, dwBackLightAddr= REG_ADR2_PWM0_BACKLIGHT + PQ_GetPanelPWMNum() * 8;
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	dwCur= *((UINT32 *)(dwBackLightAddr));
	dwCur &= (~0x80000000);

	if(pDBL->ucOrder)
		dwCur = pDBL->dwTableMax - dwCur + pDBL->dwTableMin;
	if(pHwContext->ucLocationMode == HOMEMODE)
	{
		dwCur = pDBL->dwLightMin + ((dwCur - pDBL->dwLightMin)*100+32)/70;
	}

	return dwCur;
}

#ifdef CONFIG_EXTRA_PWM_CONTROL_FOR_FAN
void tv_Disable_ExtraPwm(UINT8 ucPwmNum, UINT32 uiFrequency, UINT32 uiDuty)
{
    *((UINT32 *)(REG_ADR2_PWM0_BACKLIGHT + (ucPwmNum*8))) = 0;
}
#endif

void PQ_SetDIM_REF_CTRL(UINT32 pwm_number, UINT32 status, UINT32 mmiovalue)
{
	UINT32 dwBackLightAddr, dwBackLightAddrPeroid;
	PBRVIP_FLASH brvip_flash_p = (PBRVIP_FLASH)SPI_PANELSET_SHADOWADDR;
	u32 BLBase = 0;
	u32 Pclk = 0;
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
	BootRomShareData_t *BootromShareData = (void *) KMFBR_ShareData_ShadowAddress;
#endif
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
	if(BootromShareData->PwmFreq == 0)
		BootromShareData->PwmFreq = brvip_flash_p->LCDBackLight_PWMFrq;
#endif

    if(brvip_flash_p->LCDBackLight_PWMSrc == 0)
	{
		if(brvip_flash_p->PanelParameter.LvdsParam_60.TxDiv > 0)
		{
			Pclk = REFCLK * 1000 * (brvip_flash_p->PanelParameter.LvdsParam_60.NDiv+1)/((brvip_flash_p->PanelParameter.LvdsParam_60.RefDiv+1)*(brvip_flash_p->PanelParameter.LvdsParam_60.TxDiv)*7);
		}
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
		if(BootromShareData->PwmFreq > 0)
		{
			BLBase = Pclk /BootromShareData->PwmFreq;
		}
#else
		if(brvip_flash_p->LCDBackLight_PWMFrq > 0)
		{
			BLBase = Pclk /brvip_flash_p->LCDBackLight_PWMFrq;
		}
#endif
	}
	else
	{
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
		if(BootromShareData->PwmFreq > 0)
		{
			BLBase = REFCLK*1000/BootromShareData->PwmFreq;
		}
#else
		if(brvip_flash_p->LCDBackLight_PWMFrq > 0)
		{
			BLBase = REFCLK*1000/brvip_flash_p->LCDBackLight_PWMFrq;
		}
#endif
	}

	if(BLBase == 0)
    {
	    BLBase = 1; //avoid overflowed constant
	}

	if ( pwm_number < 4 ) {
		dwBackLightAddrPeroid = REG_ADR1_PWM0_BACKLIGHT + (pwm_number * 8);
		dwBackLightAddr = REG_ADR2_PWM0_BACKLIGHT + (pwm_number * 8);
		*((UINT32 *)(dwBackLightAddr)) = 0;		// turn off PWM

        if ( status != 0 ) {					// turn on PWM
            
			#ifdef CONFIG_PANEL_BACKLIGHT_DIM_REF
			if ( (pwm_number==0) || (pwm_number==2) ) {			// REF 25KHz, Duty: 80%
				if(CONFIG_PANEL_PWM_REF_PERIOD > 0)
				{
					*((UINT32 *)(dwBackLightAddrPeroid)) = 0x16E3600 / CONFIG_PANEL_PWM_REF_PERIOD;
					*((UINT32 *)(dwBackLightAddr)) = ((0x16E3600 / CONFIG_PANEL_PWM_REF_PERIOD) * CONFIG_PANEL_PWM_DIM_DUTY/100) | 0x80000000;
				}
			}
			else if ( pwm_number == 3) {
				*((UINT32 *)(dwBackLightAddrPeroid)) = BLBase-1;
			    *((UINT32 *)(dwBackLightAddr)) = mmiovalue;
			}
			#else
			*((UINT32 *)(dwBackLightAddrPeroid)) = BLBase-1;
			*((UINT32 *)(dwBackLightAddr)) = mmiovalue;
			#endif
		}
		#ifdef CONFIG_PANEL_PWM_REF_INV
		if ( (0==status) && ((0==pwm_number) || (2==pwm_number)) ) {
			if(CONFIG_PANEL_PWM_REF_PERIOD > 0)
			{
				*((UINT32 *)(dwBackLightAddrPeroid)) = (0x16E3600 / CONFIG_PANEL_PWM_REF_PERIOD)-1;
				*((UINT32 *)(dwBackLightAddr)) = (0x16E3600 / CONFIG_PANEL_PWM_REF_PERIOD) | 0x80000000;
			}
			if ( 2==pwm_number ) {
				GPIOFunctionSelect(30, 0);
			}
		}
		#if 0
		#elif defined(CONFIG_PANEL_ADJ_INVERT)
		if ( (0==status) && (2==pwm_number) ) {
			GPIOFunctionSelect(30, 0);
		}
		#endif
		#endif
	}
}

void PQ_SetBackLight(UINT32 dwValue)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT32 dwBackLightAddr= REG_ADR2_PWM0_BACKLIGHT + PQ_GetPanelPWMNum() * 8;
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;

      
	if(pHwContext->ucLocationMode == HOMEMODE)
	{
		dwValue = pDBL->dwLightMin + ((dwValue - pDBL->dwLightMin)*70+50)/100;
	}
	if(pDBL->ucOrder)
	{
		dwValue = pDBL->dwTableMax - dwValue + pDBL->dwTableMin;

	}

    *((UINT32 *)(dwBackLightAddr))= dwValue|0x80000000;
}

UINT32 PQ_GetRealBackLight(void)
{
	UINT32 dwCur, dwBackLightAddr= REG_ADR2_PWM0_BACKLIGHT + PQ_GetPanelPWMNum() * 8;
	dwCur= *((UINT32 *)(dwBackLightAddr));
	dwCur &= (~0x80000000);

	return dwCur;
}

void PQ_SetRealBackLight(UINT32 dwValue)
{
	UINT32 dwBackLightAddr= REG_ADR2_PWM0_BACKLIGHT + PQ_GetPanelPWMNum() * 8;

	*((UINT32 *)(dwBackLightAddr))= dwValue|0x80000000;
}


UINT32 PQ_GetHomeModeValue(UINT32 *pValue)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT32 uiValue= *pValue;
	if(pHwContext->ucLocationMode == HOMEMODE)
	{
		uiValue = pDBL->dwLightMin + ((uiValue - pDBL->dwLightMin)*80+50)/100;
	}
	return uiValue;
}

void PQ_GetLightSensorInfo(UINT8 ucLSensorEn,UINT8 ucIndex, UINT32 dwLight)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	UINT32 ulCurBackLight, ulCurBLRate = 0;//, ulTargeBackLight
	static UINT8 ucLastLSensorEn = 0;
	UINT8 ucTmpLevel;
	dwLight &= ~(0x80000000);

	if(pDBL->ucOrder)
		dwLight = pDBL->dwTableMax - dwLight + pDBL->dwTableMin;

	PQDebugPrint("%s:ucLSensorEn = %d, udwLight = %ld(0x%lx)",__FUNCTION__, ucLSensorEn, dwLight, dwLight);
	if(pHwContext->ucLocationMode != STOREMODE)
	{
		pHwContext->ucLocationMode = STOREMODE;
		PQDebugPrint("&&&&&&&&&&close store mode&&&&&&&&&&&");
	}

	if( dwLight < pDBL->dwTableMin || dwLight>pDBL->dwTableMax )
	{
		PQDebugPrint("out of range:%ld~%ld(%ld)", pDBL->dwTableMin, pDBL->dwTableMax, dwLight);
		return;
	}

	pDBL->bLightSensor = ucLSensorEn;

	PQDebugPrint("pDBL->dwLightMax = %ld, pDBL->dwLightMin = %ld", pDBL->dwLightMax, pDBL->dwLightMin);
	if(pDBL->bLSChangeBacklight)
	{
		if((pDBL->dwLightMax-pDBL->dwLightMin) > 0)
		{
			ulCurBLRate = (pDBL->dwLSTarge-pDBL->dwLightMin)*100/(pDBL->dwLightMax-pDBL->dwLightMin);
		}
	}
	else
	{
		if((pDBL->dwLightMax-pDBL->dwLightMin) > 0)
		{
			ulCurBLRate = (PQ_GetBackLight()-pDBL->dwLightMin)*100/(pDBL->dwLightMax-pDBL->dwLightMin);
		}
	}

	ulCurBLRate = min((UINT32)100,ulCurBLRate);
	PQDebugPrint("pDBL->dwTableMin = %ld, pDBL->dwTableMax = %ld, ulCurBLRate = %ld", pDBL->dwTableMin, pDBL->dwTableMax, ulCurBLRate);
	if(ucLSensorEn)
	{
		if((pDBL->dwTableMax-pDBL->dwTableMin) > 0)
		{
			pDBL->dwBackLightRate = (dwLight-pDBL->dwTableMin)*100/(pDBL->dwTableMax-pDBL->dwTableMin);
		}

		if(pDBL->dwBackLightRate == 0)
			pDBL->dwBackLightRate = 100;
		pDBL->dwLightMin = pDBL->dwTableMin;
		pDBL->dwLightMid = pDBL->dwTableMin + (pDBL->dwTableMid-pDBL->dwTableMin)*pDBL->dwBackLightRate/100;
		pDBL->dwLightMax = pDBL->dwTableMin + (pDBL->dwTableMax-pDBL->dwTableMin)*pDBL->dwBackLightRate/100;
		pDBL->dwLightNormal = pDBL->dwTableMin + (pDBL->dwTableNormal-pDBL->dwTableMin)*pDBL->dwBackLightRate/100;

		if(pDBL->dwBackLightRate == 100)
		{
			pDBL->dwLightMin = pDBL->dwTableMin;
			pDBL->dwLightMid = pDBL->dwTableMid;
			pDBL->dwLightMax = pDBL->dwTableMax;
			pDBL->dwLightNormal = pDBL->dwTableNormal;
		}
	}
	else
	{
		pDBL->dwBackLightRate = 100;
		pDBL->dwLightMin = pDBL->dwTableMin;
		pDBL->dwLightMid = pDBL->dwTableMid;
		pDBL->dwLightMax = pDBL->dwTableMax;
		pDBL->dwLightNormal = pDBL->dwTableNormal;

	}

	PQDebugPrint("pDBL->dwBackLightRate = %ld, ucLSensorEn = %d, ucLastLSensorEn = %d", pDBL->dwBackLightRate, ucLSensorEn, ucLastLSensorEn);

	if(pDBL->ucLevel==OFF && pDBL->bLSChangeBacklight==0)
		return;

	if(pDBL->ucAllBlackStatus)
	{
		PQDebugPrint("ignore lightsensor change");
		return;
	}

	//slow change back light when light sensor disable<->enable
	ulCurBackLight = PQ_GetBackLight();

	if(pDBL->dwBackLightRate != 100)
		pDBL->dwLSTarge = pDBL->dwLightMin + (pDBL->dwLightMax-pDBL->dwLightMin)*ulCurBLRate/100;
	else
		pDBL->dwLSTarge = ulCurBackLight;
	pDBL->iLSADD = max((INT32)(pDBL->dwLSTarge - ulCurBackLight)/50, 30);
	pDBL->bLSChangeBacklight = 1;
	PQDebugPrint("rate0:%ld(0x%lx) -> %ld(0x%lx), idiff = %d",ulCurBackLight, ulCurBackLight, pDBL->dwLSTarge, pDBL->dwLSTarge, pDBL->iLSADD);
	ucTmpLevel = pDBL->ucLevel;
	pDBL->ucLevel = OFF;

	if(pDBL->iLSADD == 0 || ucLastLSensorEn == ucLSensorEn)
		PQ_SetBackLight(pDBL->dwLSTarge);
	else
	{
		if(pDBL->bLSChangeBacklight)
		{

			while(pDBL->dwLSTarge != ulCurBackLight)
			{

				if( (signed)((signed)ulCurBackLight+pDBL->iLSADD)<0 )
					ulCurBackLight = 0;
				else
					ulCurBackLight += pDBL->iLSADD;

				if(abs((signed)ulCurBackLight - pDBL->dwLSTarge) < abs(pDBL->iLSADD))
				{
					ulCurBackLight = pDBL->dwLSTarge;

				}
				PQ_SetBackLight(ulCurBackLight);
				PQ_DelayMS(10);
			}

		}
	}

	PQDebugPrint("turn on dynamic backlight:pDBL->ucLevel = %d\n\n", pDBL->ucLevel);
	pDBL->bLSChangeBacklight = 0;

	pDBL->ucLevel = ucTmpLevel;
	ucLastLSensorEn = ucLSensorEn;
}

void PQ_SetBacklightParameter(UINT8 ucTop,UINT8 ucBot,UINT8 ucTh_low,UINT8 ucTh_High)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;

	pDBL->ucTop = ucTop;
	pDBL->ucBot = ucBot ;
	pDBL->ucTh_low=ucTh_low ;
	pDBL->ucTh_High=ucTh_High;
	PQDebugPrint("ucTop = %d, ucBot = %d, ucTh_High = %d, ucTh_low = %d",
			pDBL->ucTop, pDBL->ucBot, pDBL->ucTh_High, pDBL->ucTh_low);
}

void PQ_LightSensorChange(void)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	UINT32 ulCurBackLight = PQ_GetBackLight();
	static UINT8 ucTmpLevel=0xff;
	static UINT32 ucLastBL = 0;
	if(pDBL->bLSChangeBacklight)
	{
		if( pDBL->ucLevel!=0)
		{
			ucTmpLevel = pDBL->ucLevel;
			pDBL->ucLevel = OFF;
			PQDebugPrint("turn off dynamic backlight");
		}
		if(pDBL->dwLSTarge != ulCurBackLight)
		{



			if( (signed)((signed)ulCurBackLight+pDBL->iLSADD)<0 )
				ulCurBackLight = 0;
			else
				ulCurBackLight += pDBL->iLSADD;
			if(abs((signed)ulCurBackLight - pDBL->dwLSTarge) < abs(pDBL->iLSADD))
			{
				//PQDebugPrint("abs(%d-%d)<%d",ulCurBackLight, pDBL->dwLSTarge, pDBL->iLSADD );
				ulCurBackLight = pDBL->dwLSTarge;

			}
			PQ_SetBackLight(ulCurBackLight);

			if(ucLastBL == ulCurBackLight)
			{
				PQDebugPrint("ERR:ulCurBackLight = %ld, pDBL->iLSADD = %d, pDBL->dwLSTarge = %ld", ulCurBackLight, pDBL->iLSADD, pDBL->dwLSTarge);
				ulCurBackLight = pDBL->dwLSTarge;
				PQ_SetBackLight(ulCurBackLight);
				return;
			}
			ucLastBL = ulCurBackLight;

			//PQDebugPrint("%s:rate0:backlight = %ld(0x%lx)",__FUNCTION__, ulCurBackLight, ulCurBackLight);
		}
		else
		{
			ucLastBL = 0;
			pDBL->bLSChangeBacklight = 0;
			pDBL->ucLevel = ucTmpLevel;
			PQDebugPrint("turn on dynamic backlight:pDBL->ucLevel = %d", pDBL->ucLevel);
		}
	}
}


void PQ_InitDynamicBackLight(void)
{
	PBRVIP_FLASH brvip_flash_p = (PBRVIP_FLASH)SPI_PANELSET_SHADOWADDR;
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
	BootRomShareData_t *BootromShareData = (void *) KMFBR_ShareData_ShadowAddress;
#endif
	INT32 i;
	UINT32 BLBase = 0, Pclk = 0;
    UINT16 uwMaxduty, uwMinduty;
	#ifdef DYNAMICBL_ADJUST
	UINT8 bindex;
	#endif
	sema_init(&pDBL->sem, 1);
	pDBL->ucLevel= OFF;
	pDBL->ucLevelTarget= OFF;
	pDBL->nBound1= 45; //boundary for black ~=10%
	pDBL->nBound2= 65; //boundary for keeping black ~=20%
	pDBL->nBound3= 203; //boundary for keeping white ~=80%
	pDBL->nBound4= 203; //boundary for white ~=90%
	pDBL->wDetectFrameCount= 176; //16x
//#ifdef CONFIG_PANEL_ADJ_INVERT
//	pDBL->ucOrder = 1;
//#else
	pDBL->ucOrder = brvip_flash_p->LCDBackLight_Order;
//#endif
	pDBL->ucDynamicBLType = DYNAMIC_BL_FORMAL;

#ifdef DYNAMICBL_ADJUST
  DynamicBL_OSD_MAX = brvip_flash_p->DynamicBacklightOSDMax;
  DynamicBL_OSD_Min = brvip_flash_p->DynamicBacklightOSDMin;
  DynamicBL_normal = brvip_flash_p->DynamicBacklightOSDNormal;
//  printk("\n\n init MAX = %d Min = %d normal = %d \n\n\n\n",DynamicBL_OSD_MAX,DynamicBL_OSD_Min,DynamicBL_normal);
  #endif
  
    GetCustomerData("gElectricity_PWM_table", (void *)&(pDBL->pElectricity_PWM_table), &(pDBL->Electricity_PWM_table_Size));
    pDBL->Electricity_PWM_table_Size = pDBL->Electricity_PWM_table_Size/sizeof(Electity_PWM_Mapping_Table);
    PQ_get_PWM_Duty(&uwMaxduty, &uwMinduty);    
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
		if(BootromShareData->PwmFreq == 0)
			BootromShareData->PwmFreq = brvip_flash_p->LCDBackLight_PWMFrq;
#endif


    //LCDBackLightMap[] has possibly not yet initialized here, so vip get value by itself.
	if(brvip_flash_p->LCDBackLight_PWMSrc == 0)
	{
		if((brvip_flash_p->PanelParameter.LvdsParam_60.TxDiv) > 0)
		{
			Pclk = REFCLK * 1000 * (brvip_flash_p->PanelParameter.LvdsParam_60.NDiv+1)/((brvip_flash_p->PanelParameter.LvdsParam_60.RefDiv+1)*(brvip_flash_p->PanelParameter.LvdsParam_60.TxDiv)*7);
		}
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
		if(BootromShareData->PwmFreq > 0)
		{
			BLBase = Pclk /BootromShareData->PwmFreq;
		}

#else
		if(brvip_flash_p->LCDBackLight_PWMFrq > 0)
		{
			BLBase = Pclk /brvip_flash_p->LCDBackLight_PWMFrq;
		}
#endif
	}
	else
	{
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
		if(BootromShareData->PwmFreq > 0)
		{
			BLBase = REFCLK*1000/BootromShareData->PwmFreq;
		}
#else
		if(brvip_flash_p->LCDBackLight_PWMFrq > 0)
		{
			BLBase = REFCLK*1000/brvip_flash_p->LCDBackLight_PWMFrq;
		}
#endif
	}

	//LCDBackLightMap[] has possibly not yet initialized here, so vip get value by itself.
	for(i = 0; i <15; i++)
	{
	    #ifdef CONFIG_SUPPORT_PWM_DUTY_IN_DECIMAL
        pDBL->BacklightTab[i] = round(BLBase*uwMinduty, 1000) + round((BLBase*(uwMaxduty - uwMinduty) * i), 14*1000);        
        #else
		pDBL->BacklightTab[i] = round(BLBase*uwMinduty, 100) + round((BLBase*(uwMaxduty - uwMinduty) * i), 14*100);
        #endif
	}

    
	pDBL->dwTableMin= pDBL->BacklightTab[0];
	pDBL->dwTableMax= pDBL->BacklightTab[14];
	pDBL->dwTableMid= pDBL->BacklightTab[7];
	#ifdef DYNAMICBL_ADJUST
	bindex = 14 * DynamicBL_normal / 100 ;
	pDBL->dwTableNormal= pDBL->BacklightTab[bindex];
	#else
	pDBL->dwTableNormal= pDBL->BacklightTab[12];
	#endif

	// to avoid the PWM is wrong order(smaller->larger is right) in panelset.ini
	if( pDBL->dwTableMin>pDBL->dwTableMax )
	{
		pDBL->dwTableNormal= pDBL->dwTableMin;
		pDBL->dwTableMin= pDBL->dwTableMax;
		pDBL->dwTableMax= pDBL->dwTableNormal;
		#ifdef DYNAMICBL_ADJUST
		bindex = 14 - 14 * DynamicBL_normal / 100 ;
		pDBL->dwTableNormal= pDBL->BacklightTab[bindex];	 //14-12
		#else
		pDBL->dwTableNormal= pDBL->BacklightTab[2];	 //14-12
		#endif
	}

	pDBL->dwLightMax = pDBL->dwTableMax;
	pDBL->dwLightMid = pDBL->dwTableMid;
	pDBL->dwLightMin = pDBL->dwTableMin;
	pDBL->dwLightNormal= pDBL->dwTableNormal;
	pDBL->dwLightMid =pDBL->dwTableMid;
	pDBL->dwLightQuot= (pDBL->dwTableMax-pDBL->dwTableMin)/VIP_DBL_LEVEL_DEGREE;
	pDBL->bLSChangeBacklight = 0;
	pDBL->bLightSensor = 0;
	pDBL->dwBackLightRate = 100;
	pDBL->ucHistMinPercentage = 40;
	
	pDBL->nBound0_more = 60;
	
	pDBL->nBound0 = 100;

	pDBL->nBound1= 130; //16+219*12%
	pDBL->nBound2= 150; //16+219*20%
	pDBL->nBound3= 180; //16+219*80%
	pDBL->nBound4= 190; //16+219*88%
	
	pDBL->nBound5 = 200; //16+219*88%
	pDBL->wDetectFrameCount= 288;

	PQDebugPrint("%s: Bound={0x%x 0x%x 0x%x 0x%x} nDetectFrameCount=0x%x", __FUNCTION__, pDBL->nBound1, pDBL->nBound2, pDBL->nBound3, pDBL->nBound4, pDBL->wDetectFrameCount);
	PQDebugPrint("%s: dwLightMin=0x%lx dwLightMax=0x%lx dwLightNormal=0x%lx dwLightQuot=0x%lx", __FUNCTION__, pDBL->dwLightMin, pDBL->dwLightMax, pDBL->dwLightNormal, pDBL->dwLightQuot);
	PQDebugPrint("%s: dwTableMin=0x%lx dwTableMax=0x%lx dwTableNormal=0x%lx dwLightQuot=0x%lx", __FUNCTION__, pDBL->dwTableMin, pDBL->dwTableMax, pDBL->dwTableNormal, pDBL->dwLightQuot);

}

void PQ_DynamicBackLightAP(UINT8 ucLevel, UINT32 dwMap)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	if(dwMap <=14)
		PQ_EnableDynamicBackLight(ucLevel, pDBL->BacklightTab[dwMap]);
}

UINT8 PQ_specialpatterndetect(void)
{
	UINT8 ucStaticFlag = STATIC_FRAME;
	UINT32 dwTotalPixel;
	UINT8 i;
    UINT32 ulHistBin[16];
	//UINT8 bIsSpecialHist = 0;
	
    PQHW_CONTEXT* pHwContext= &PQHwContext;
	
	if(ucVDI_Static_Cnt_2 > 10)
	{
		ucStaticFlag = MOTION_FRAME;
	}
	else
	{
		ucStaticFlag = STATIC_FRAME;
	}


    dwTotalPixel = 0;
    for(i = 0; i <16; i++)
    {
        ulHistBin[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
        dwTotalPixel += ulHistBin[i];
    }

	/*if(((((ulHistBin[1] > (dwTotalPixel * 70/100))?1:0) ||((ulHistBin[0] > (dwTotalPixel * 70/100))?1:0)) &&
		((((ulHistBin[2] > (dwTotalPixel * 9/1000))?1:0)&&
		((ulHistBin[3] > (dwTotalPixel * 1/1000))?1:0) )|| 
		(((ulHistBin[1] > (dwTotalPixel * 11/1000))?1:0)&&
		((ulHistBin[2] > (dwTotalPixel * 11/1000))?1:0)))&&
		((((ulHistBin[12] > (dwTotalPixel * 8/1000))?1:0)&&
		((ulHistBin[13] > (dwTotalPixel * 8/1000))?1:0)&&
		((ulHistBin[14] > (dwTotalPixel * 6/100))?1:0))||	
		(((ulHistBin[11] > (dwTotalPixel * 8/1000))?1:0)&&
			((ulHistBin[12] > (dwTotalPixel * 9/100))?1:0)&&
			((ulHistBin[13] > (dwTotalPixel * 5/1000))?1:0)) ||	
		(((ulHistBin[11] > (dwTotalPixel * 8/1000))?1:0)&&
			((ulHistBin[12] > (dwTotalPixel * 14/1000))?1:0)&&
			((ulHistBin[13] > (dwTotalPixel * 12/100))?1:0))  || 
	(((ulHistBin[13] > (dwTotalPixel * 10/1000))?1:0)&&
			((ulHistBin[14] > (dwTotalPixel * 10/1000))?1:0)&&
			((ulHistBin[15] > (dwTotalPixel * 8/100))?1:0)))) || //�Ź���	
		((ulHistBin[13] >= (dwTotalPixel * 950/1000))?1:0))//white level
	{
		bIsSpecialHist = 1;
	}
	else
	{
			bIsSpecialHist = 0;
	}*/

	//if(( bIsSpecialHist == 1) && (ucStaticFlag ==STATIC_FRAME) && ((pHwContext->ulHistCaseCur == 32) || (pHwContext->ulHistCaseCur == 31)))
	if((ucStaticFlag ==STATIC_FRAME) && ((pHwContext->ulHistCaseCur == 32) || (pHwContext->ulHistCaseCur == 31)))
	{
		//printk("\n\n TRUE  ucStaticFlag = %d pHwContext->ulHistCaseCur = %d\n\n\n",ucStaticFlag,pHwContext->ulHistCaseCur);
		return TRUE;
	}

	else
	{
		//printk("\n\n False \n\n\n");
		return FALSE;
	}

}
void PQ_EnableDynamicBackLight(UINT8 ucLevel, UINT32 dwLightUser)
{
#ifdef DynamicBacklight_EnergyEfficiency
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
      BOOL bEnable = (ucLevel>=WEAK && ucLevel<=STRONG);
#endif
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	//UINT32 dwCur,dwTarget;
	UINT32 dwTarget;
	//INT32 iLoop,iAdd;//,iStep= 8;
	UINT8 ucTmpLS;
    PBRVIP_FLASH brvip_flash_p = (PBRVIP_FLASH)SPI_PANELSET_SHADOWADDR;
	UINT32 maxBLValue = 0, minBLValue = 0;
	
#if 0//def DYNAMICBL_ADJUST
	ptv_base_t ptv = getptvdev();
	UINT32 mmiovalue;
#endif

    if(PQ_GetColorProcessor() == FALSE)
        return;

	dwLightUser &= ~(0x80000000); //clear the setting bit
	if(pDBL->ucOrder)
	{
		PQDebugPrint("%s: dwLightUser=%ld(%#lx)", __FUNCTION__, dwLightUser, dwLightUser);
		dwLightUser = pDBL->dwTableMax- dwLightUser + pDBL->dwTableMin;
	}

	PQ_ADVANCE_HWPrint("%s: ucLevel=%d dwLightUser=0x%x pDBL->ucOrder = %d", __FUNCTION__, ucLevel, dwLightUser, pDBL->ucOrder);

	down(&pDBL->sem);

	pDBL->ucLevel= OFF;
	ucTmpLS = pDBL->bLightSensor;
	pDBL->bLightSensor = OFF; //turn off to prevent action at the same time

	if( dwLightUser<pDBL->dwTableMin || dwLightUser>pDBL->dwTableMax ||  dwLightUser == 0)
		dwLightUser= pDBL->dwTableNormal;

	//no centering adjustment if enable
	//dwTarget= pDBL->dwTableNormal= dwLightUser;
	dwTarget= pDBL->dwTableNormal;

#ifdef DynamicBacklight_EnergyEfficiency
	if(PQ_GetDynamicBLType() == DYNAMIC_BL_ENERGY_EFFICIENCY)
	{
		pDBL->dwTableNormal= pDBL->BacklightTab[12];
		if( pDBL->dwTableMin>pDBL->dwTableMax )
			pDBL->dwTableNormal= pDBL->BacklightTab[2];	 //14-12
	}
#endif

	if( dwTarget>=pDBL->dwTableMin && dwTarget<=pDBL->dwTableMax )
	{
		PQDebugPrint("default = %ld(0x%lx)",dwTarget,dwTarget);

		if(ucTmpLS)
			dwTarget = pDBL->dwTableMin + ((dwTarget - pDBL->dwTableMin)*pDBL->dwBackLightRate+50)/100;

	}
	

	maxBLValue = (LCDBackLightMap[0] > LCDBackLightMap[14]) ? LCDBackLightMap[0] : LCDBackLightMap[14];
	minBLValue = (LCDBackLightMap[0] > LCDBackLightMap[14]) ? LCDBackLightMap[14] : LCDBackLightMap[0];

    if(brvip_flash_p->LCDBackLight_Order)
    {
       dwTarget = maxBLValue - (dwTarget-minBLValue);
    }

	//init for BL variables
	pDBL->bLightSensor = ucTmpLS;
	pDBL->bLSChangeBacklight = 0;
	PQ_BackLightDetect(TRUE);
	pDBL->dwWhiteLevel= VIP_DBL_INVALID_WHITE_LEVEL;
	pDBL->dwLightTarget= pDBL->dwLightNormal;
	pDBL->iAdd= 0;
	pDBL->ucLevelTarget= ucLevel;
#ifdef DynamicBacklight_EnergyEfficiency
	if(PQ_GetDynamicBLType()==DYNAMIC_BL_ENERGY_EFFICIENCY)
	{
		if(!bEnable)
		{
			PQ_PresetBackLight(TRUE, dwTarget, BL_QUICK);
			PQ_PresetContrast(TRUE, pMenuValue->iContrast, 1);
		}
		else
		{
			PQ_EEBackLightDetect(FALSE);
			PQ_PresetBackLight(TRUE, pDBL->dwLightTarget, BL_QUICK);
		}
	}
	else
#endif
	{
	
	printk("\n dwLightTarget = 0x%0x\n",dwTarget);
	#if 0//def DYNAMICBL_ADJUST
	
		mmiovalue = tv_GetLCDBackLightValue(ptv->pBootRomShareData->LcdBacklightValue);
		
		PQ_ChangeBackLight(mmiovalue, 1);
	#else	
		PQ_PresetBackLight(TRUE, dwTarget, PQ_GetHomeModeValue(&dwTarget) > PQ_GetRealBackLight() ? BL_QUICK : BL_SLOW);	
	#endif
	}
	pDBL->ucAllBlackStatus = 0;
	up(&pDBL->sem);

}


void PQ_PresetBackLight(BOOL bReset, UINT32 dwLightTarget, INT32 nSpeed)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	static UINT8 nPollingIndex= 0;
	static INT32 iAdd = 0;
	static UINT32 dwCur = 0;
	static UINT32 dwTarget = 0;
	static UINT32 dwNext = 0;
	static UINT8 nStep = 1;
	static BOOL bStart = FALSE;
	if(bReset)
	{
		pDBL->ucLevel= OFF;
		dwCur = PQ_GetRealBackLight();
		dwTarget = PQ_GetHomeModeValue(&dwLightTarget);
		if(nSpeed == BL_SLOW)
			nStep = 5;
		else
			nStep = 12;
		iAdd = pDBL->dwLightQuot * nStep;
		if( dwTarget<dwCur )
			iAdd= -(iAdd);

		nPollingIndex = 0;
		bStart = TRUE;
		PQDebugPrint("%s:dwCur = %d(%x), dwTarget = %d(%x), nStep = %d, iAdd = %d",__FUNCTION__,dwCur, dwCur, dwTarget, dwTarget, nStep , iAdd);
	}
	if(bStart == TRUE)
	{
		nPollingIndex++;
		if(nPollingIndex<3)
			return;
		nPollingIndex = 0;

		dwCur = PQ_GetRealBackLight();
		dwNext= dwCur+iAdd;

		if( abs(dwCur - dwTarget) <= abs(dwCur - dwNext))
		{
			dwNext= dwTarget;
		}
		if((iAdd > 0 && dwCur > dwTarget) || (iAdd < 0 && dwCur < dwTarget) || iAdd == 0)//prevent other driver set backlight traversing our target value.
		{
			PQ_SetRealBackLight(dwTarget);
			dwNext = dwCur = dwTarget;
		}
		if( dwNext!=dwCur )
		{
			PQ_SetRealBackLight(dwNext);
			//PQDebugPrint("%s: dwNext=0x%lx dwCur=0x%lx dwTarget=0x%lx pDBL->dwLightMin=0x%lx\n", __FUNCTION__, dwNext, dwCur, dwTarget, pDBL->dwLightMin);
		}
		else
		{
			PQDebugPrint("%s: DONE!!! dwCur=%#lx(%ld)\n", __FUNCTION__, dwCur, dwCur);
			bStart = FALSE;
			pDBL->ucLevel= pDBL->ucLevelTarget;
		}

	}

}

void PQ_BackLightDetect(BOOL bReset)
{
	PQ_PresetBackLight(FALSE, 0, 0);
#if 0

#else
	#if 0
	VIP_LEDBackLightDetect(bReset);
	#else
		#ifdef DynamicBacklight_EnergyEfficiency
			if(PQ_GetDynamicBLType() == DYNAMIC_BL_ENERGY_EFFICIENCY)
			{
				PQ_EEBackLightDetect(bReset);
				PQ_PresetContrast(FALSE, 0, 0);
			}
			else
		#endif

		#if 0

		#else
			PQ_FormalBackLightDetect(bReset);
		#endif
	#endif
#endif


}

UINT32 PQ_BackLightTarget(UINT8 nDBLStatus, UINT8 nWhiteCondition, UINT32 dwCur)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	UINT32 dwLightTarget;
	#ifdef DYNAMICBL_ADJUST
	UINT32 bMaxBL,bMinBL,bOSDNormal;
	//ptv_base_t ptv = getptvdev();
//	UINT32 maxBLValue,minBLValue;
	#endif
//    PBRVIP_FLASH brvip_flash_p = (PBRVIP_FLASH)SPI_PANELSET_SHADOWADDR;
#if 0
	INT32 nStep,nSlowStep,nQuickStep;
	nSlowStep= 1;
	nQuickStep= 3;
	if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
	{
		dwLightTarget= (nWhiteCondition==1) ? pDBL->dwLightMin : pDBL->dwLightMax;
		nStep= (nWhiteCondition==1) ? nSlowStep : nQuickStep; //white color want to increase the steps
	}
	else
	{
		dwLightTarget= pDBL->dwLightNormal;
		nStep= nQuickStep;
	}
	pDBL->dwLightTarget= dwLightTarget;
	pDBL->iAdd= pDBL->dwLightQuot*nStep;
	if( dwLightTarget<dwCur )
		pDBL->iAdd= -(pDBL->iAdd);
#else
	UINT32 dwFrameCount =0,dwDiff;

	#ifdef DYNAMICBL_ADJUST
	if(VIP_IsATVSource())
	{
		bMaxBL = tv_GetLCDBackLightValueexceptinvert(DynamicBL_OSD_MAX + DynamicBL_OSD_MAX_FineTune);
		bMinBL = tv_GetLCDBackLightValueexceptinvert(DynamicBL_OSD_Min + DynamicBL_OSD_Min_FineTune);
		bOSDNormal = tv_GetLCDBackLightValueexceptinvert(DynamicBL_normal + DynamicBL_OSD_Normal_FineTune);
	}
	else
	{
		bMaxBL = tv_GetLCDBackLightValueexceptinvert(DynamicBL_OSD_MAX);
		bMinBL = tv_GetLCDBackLightValueexceptinvert(DynamicBL_OSD_Min);
		bOSDNormal = tv_GetLCDBackLightValueexceptinvert(DynamicBL_normal);
	}
		
		//bOSDBL = tv_GetLCDBackLightValueexceptinvert(ptv->pBootRomShareData->LcdBacklightValue.OSD_backlight_index);
	#endif

	if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
	{
		if((nWhiteCondition==1 )||( nWhiteCondition==2 )||( nWhiteCondition==3 ))
		{
			#ifdef DYNAMICBL_ADJUST
			
			dwLightTarget= bMinBL;//pDBL->dwLightMin;
			dwDiff= pDBL->dwLightMax-bMinBL;//pDBL->dwLightMin;

			if( pDBL->ucLevel==WEAK)
				{
				dwLightTarget= bOSDNormal - (dwDiff * 11 / 64);
				//printk("\n\n an weak  target = 0x%0x \n\n",dwLightTarget);
				}
			else if( pDBL->ucLevel==MEDIUM )
				{
				dwLightTarget= bOSDNormal - (dwDiff * 22 / 64);
				//printk("\n\n an middle  target = 0x%0x \n\n",dwLightTarget);
				}
			else if( pDBL->ucLevel==STRONG)
				{
				dwLightTarget= bOSDNormal - (dwDiff * 32 / 64);;// bMinBL;//bOSDBL - (dwDiff>>1);
			//	printk("\n\n an strong  target = 0x%0x \n\n",dwLightTarget);
				}
			
							
		//	printk("\n\n\n whitecondition 111 dwLightTarget = 0x%0x  bOSDBL = 0x%0x    \n\n\n",dwLightTarget,bOSDBL);
			#else
				dwLightTarget= pDBL->dwLightMin;
				dwDiff= pDBL->dwLightNormal-pDBL->dwLightMin;
				if( pDBL->ucLevel==MEDIUM )
					dwLightTarget= pDBL->dwLightNormal - (dwDiff>>1);
				else if( pDBL->ucLevel==WEAK )
					dwLightTarget= pDBL->dwLightNormal - (dwDiff>>2);

			#endif
		}
		else
		{
			#ifdef DYNAMICBL_ADJUST
			
			dwLightTarget= pDBL->dwLightMax;
			dwDiff= pDBL->dwLightMax- bMaxBL;
			if( pDBL->ucLevel==WEAK )
				{
				dwLightTarget= bOSDNormal + (dwDiff>>3);
				
			//	printk("\n\n liang weak  target = 0x%0x \n\n",dwLightTarget);
				}
			else if( pDBL->ucLevel==MEDIUM )
				{
			//	printk("\n\n liang middle  target = 0x%0x \n\n",dwLightTarget);
				dwLightTarget= bOSDNormal + (dwDiff>>2);
				}
			else if( pDBL->ucLevel==STRONG)
				{
			//	printk("\n\n liang strong  target = 0x%0x \n\n",dwLightTarget);
				dwLightTarget= bOSDNormal + (dwDiff>>1);
				}
		
					//	printk("\n\n\n whitecondition 55555 dwLightTarget = 0x%0x  bOSDBL = 0x%0x    \n\n\n",dwLightTarget,bOSDBL);
			#else
				dwLightTarget= pDBL->dwLightMax;
				dwDiff= pDBL->dwLightMax-pDBL->dwLightNormal;
				if( pDBL->ucLevel==MEDIUM )
					dwLightTarget= pDBL->dwLightNormal + (dwDiff>>1);
				else if( pDBL->ucLevel==WEAK )
					dwLightTarget= pDBL->dwLightNormal + (dwDiff>>2);
			#endif
		}
	}
	else
	{
#ifdef DYNAMICBL_ADJUST
	
//	printk("\n\n   *******************************************  \n\n");
	
	dwLightTarget = bOSDNormal;//bMaxBL;//bOSDBL;//bMaxBL;//bOSDBL;//tv_GetLCDBackLightValueexceptinvert(ptv->pBootRomShareData->LcdBacklightValue);
	
	//printk("\n normal dwLightTarget = 0x%0x\n",dwLightTarget);
#else
	dwLightTarget = pDBL->dwLightNormal;//bMaxBL;//bOSDBL;//tv_GetLCDBackLightValueexceptinvert(ptv->pBootRomShareData->LcdBacklightValue);

#endif

	}

	if(dwLightTarget <pDBL->dwLightMin)
		dwLightTarget = pDBL->dwLightMin;
	else if(dwLightTarget > pDBL->dwLightMax)	  
		dwLightTarget = pDBL->dwLightMax; 
		

//printk("\n final dwLightTarget = 0x%0x\n",dwLightTarget);


		
	//dwCur must be pDBL->dwLightNormal here
    if(pDBL->dwLightQuot==0)
		pDBL->dwLightQuot =1;

	if(pDBL->dwLightQuot > 0)
	{
		dwFrameCount= abs(dwLightTarget-dwCur) / pDBL->dwLightQuot;
	}


	if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
		dwFrameCount= 3 * dwFrameCount;

	if( dwFrameCount==0 )
		dwFrameCount= 1;

	pDBL->dwLightTarget= dwLightTarget;
	pDBL->iAdd= 2*((signed)pDBL->dwLightTarget-(signed)dwCur)/(signed)dwFrameCount;

    if(dwFrameCount<3)
		dwFrameCount = 3;

	if(pDBL->iAdd == 0)
	{
		if((dwFrameCount/3) > 0)
		{
			pDBL->iAdd= 2*((signed)pDBL->dwLightTarget-(signed)dwCur)/(signed)(dwFrameCount/3);
		}
	}
#endif

	//PQDebugPrint("%s: dwLightTarget=0x%lx dwCur=0x%lx iAdd=%x", __FUNCTION__, dwLightTarget, dwCur, pDBL->iAdd);
	return dwLightTarget;
}

BOOL PQ_ColorSearchAutoDet(UINT8 ucPath, UINT8 ucColorType ,UINT32 *pulMaxValue, UINT32*pulMinValue)
{
	BOOL bResault = TRUE;
	static UINT8 ucErrorCnt=ERR_CNT, ucStage = 0;
	static UINT32 MaxValue = 0xffffff, MinValue = 0xffffff;

	if(ucStage == 0)
	{
		PQ_RegisterWrite(VIP_reg_adix_sch_csel, ucColorType);	//0-Green/Y, 1-Blue/Pb, 2-Red/Pr
		PQ_RegisterWrite(VIP_reg_adix_sch_en, ENABLE);
		ucErrorCnt=ERR_CNT;
		ucStage =1;
	}else
	{
		ucErrorCnt --;
		if(PQ_RegisterRead(VIP_reg_adix_sch_en)==0)
		{
			MaxValue=PQ_RegisterRead(VIP_sta_xp_color_max);
			MinValue=PQ_RegisterRead(VIP_sta_xp_color_min);
			ucStage =0;
		}
		if(ucErrorCnt == 0)
		{
			ucStage =0;
			bResault = FALSE;
		}


	}

	*pulMaxValue = MaxValue;
	*pulMinValue = MinValue;

	return bResault;
}

UINT8 PQ_AllBlackDetect(void)
{
	UINT32 ulThreshold = (VIP_GetInputDataFormat()==RGB)?10:16;
	UINT32 ulMaxValue, ulMinValue;
	PQ_ColorSearchAutoDet(1, 0 ,&ulMaxValue, &ulMinValue);
	ulMaxValue = ulMaxValue >>2;
	ulMinValue = ulMinValue >>2;
	if(ulMaxValue <= ulThreshold  && ulMinValue <= ulThreshold)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

void PQ_LEDBackLightDetect(BOOL bReset)
{
	//static UINT8 nPollingIndex= 0;
	static UINT16 wDetectCount= 0, dwLast;
	//static UINT8 nEnteringWhiteCondition= 0;
	static UINT8 nPrevWhiteCondition= 0xff;
	static UINT8 nDBLStatus= VIP_DBL_STATUS_DETECTING, TurnOffBL = 0;
	//BOOL bNeedDown=0;
	UINT8 i,nWhiteCondition;
	UINT32 nGrayLevelCount[16]; // 21 bit at max
	UINT32 dwTotalPixel,dwTotalWhite,dwWhiteLevel;
	UINT32 dwCur,dwTarget=0,dwNext;
	//UINT32 dwGrayLevelAddr= 0xbe1cc6dc;
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	static UINT8 LastLSChang = 0xff;
	if( bReset )
	{
		//nPollingIndex= 0;
		wDetectCount= 0;
		//nEnteringWhiteCondition= 0;
		nPrevWhiteCondition= 0xff;
		nDBLStatus= VIP_DBL_STATUS_DETECTING;
		LastLSChang = 0xff;
		return;
	}

	if( pDBL->ucLevel==OFF && pDBL->bLSChangeBacklight==0)
	{
		nPrevWhiteCondition = 0xfd;
		LastLSChang = 0xff;
		return;
	}


	for(i=0;i<16;i++)
		nGrayLevelCount[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);

	dwTotalPixel= 0;
	dwTotalWhite= 0;

	for(i=0; i<16; i++)
	{
		dwTotalWhite+= nGrayLevelCount[i] * (i*16+8);
		dwTotalPixel+= nGrayLevelCount[i];
	}
	if( dwTotalPixel==0 )
		return;
	dwWhiteLevel = dwTotalWhite / dwTotalPixel;

	//White Condition has 5 scopes which is divided by dbl_bound1~4.
	if(PQ_AllBlackDetect())
		nWhiteCondition= 0;
	else if( dwWhiteLevel<=pDBL->nBound1 )
		nWhiteCondition= 1;
	else if( dwWhiteLevel<=pDBL->nBound2 )
		nWhiteCondition= 2;
	else if( dwWhiteLevel<=pDBL->nBound3 )
		nWhiteCondition= 3;
	else
		nWhiteCondition= 5;

 	//PQDebugPrint("%s:dwWhiteLevel = %ld, nWhiteCondition = %d",__FUNCTION__, dwWhiteLevel, nWhiteCondition);
 	//if(nPrevWhiteCondition!=nWhiteCondition)
	//	PQDebugPrint("dwWhiteLevel = %ld, nPrevWhiteCondition = %d, nWhiteCondition = %d", dwWhiteLevel, nPrevWhiteCondition, nWhiteCondition);
	//smooth change in white condition
	if(nPrevWhiteCondition!=nWhiteCondition)
	{
		if(	nDBLStatus!=VIP_DBL_STATUS_DETECTING)
			nWhiteCondition = nPrevWhiteCondition;
		else
		{

			if((nPrevWhiteCondition == 0 && pDBL->ucAllBlackStatus)&& nWhiteCondition >=1)
				nWhiteCondition = 1;
			else if(nPrevWhiteCondition == 1&& nWhiteCondition >=3)
				nWhiteCondition = 3;

			if(nPrevWhiteCondition == 5 && nWhiteCondition <=3)
				nWhiteCondition = 3;
			else if(nPrevWhiteCondition == 3 && nWhiteCondition <=1)
				nWhiteCondition = 1;
		}
	}


	//notice kmf if enter/leave all black status
	dwCur=PQ_GetBackLight();
	if(dwCur == pDBL->dwTableMin && dwLast != pDBL->dwTableMin)
	{
		pDBL->ucAllBlackStatus = 1;
		GPIOSetValueByPinFunc(GPIO_PIN_LEDBL_DETECT, GPIO_FUNC_OFFLEVEL);
		PQDebugPrint("noticekmf:enter all black status");
		//noticekmf(NOTICEMSG_BL_ON_OFF, &pDBL->ucAllBlackStatus); weichih mark due to KMF doesn't handle this message
	}
	else
	{
		if(nPrevWhiteCondition == 0 && nWhiteCondition!=0 && TurnOffBL ==1)
		{

			pDBL->ucAllBlackStatus = 0;
			TurnOffBL = 0;
			GPIOSetValueByPinFunc(GPIO_PIN_LEDBL_DETECT, GPIO_FUNC_ONLEVEL);
			PQDebugPrint("noticekmf:leave all black status");
			//noticekmf(NOTICEMSG_BL_ON_OFF, &pDBL->ucAllBlackStatus); weichih mark due to KMF doesn't handle this message

		}
	}

	if(nPrevWhiteCondition != nWhiteCondition)
	{
		PQDebugPrint("%s:change to WhiteCondition = %d\n",__FUNCTION__, nWhiteCondition);
	}

	//cancel dynamic backlight when light sensor change
	if(LastLSChang==0 && pDBL->bLSChangeBacklight==1)
	{
		nDBLStatus=VIP_DBL_STATUS_DETECTING;
		pDBL->iAdd = 0;
	}

	//do dynamic backlight again
	if(LastLSChang==1 && pDBL->bLSChangeBacklight==0)
		nPrevWhiteCondition = nWhiteCondition+1;


	switch(nWhiteCondition)
	{
		case 0:
			if(nPrevWhiteCondition!=nWhiteCondition)
				wDetectCount = 0;
			else
			{
				if(wDetectCount == 6000)
				{
					pDBL->dwLightTarget = pDBL->dwTableMin;
					dwCur=PQ_GetBackLight();
					pDBL->iAdd = (INT32)(pDBL->dwLightTarget - dwCur)/(300);
					PQDebugPrint("&&&&&in 60s(set min backlight), pDBL->dwLightTarget = %ld, pDBL->iAdd = %d, dwCur = %ld", pDBL->dwLightTarget, pDBL->iAdd, dwCur);
					nDBLStatus=VIP_DBL_STATUS_ENTERING;
					TurnOffBL = 1;
				}
			}
			if(pDBL->ucAllBlackStatus && PQ_GetBackLight()!=pDBL->dwTableMin)
			{
				PQDebugPrint("redetect black status");
				pDBL->ucAllBlackStatus = 0;
				wDetectCount = 0;

			}
			if(wDetectCount < 50000)
				wDetectCount++;
			break;

		case 1:

			if(nPrevWhiteCondition!=nWhiteCondition)
			{
				//static UINT8 ucIncreaseStep = 0;
				wDetectCount = 0;
				if(nPrevWhiteCondition==0)
				{
					pDBL->dwLightTarget = pDBL->dwLightMid;
					dwCur=PQ_GetBackLight();
					//if(pDBL->dwLightTarget < dwCur)
					{
						pDBL->iAdd = (INT32)(pDBL->dwLightTarget - dwCur)/(300);
						PQDebugPrint("&&&&&(increase)in 5s(50 percent backlight) pDBL->dwLightTarget = %ld, pDBL->iAdd = %d, dwCur = %ld", pDBL->dwLightTarget, pDBL->iAdd, dwCur);
						nDBLStatus=VIP_DBL_STATUS_ENTERING;
						//ucIncreaseStep = 1;
					}
				}
			}
			else
			{

				if( wDetectCount == 500)
				{
					pDBL->dwLightTarget = pDBL->dwLightMid;
					dwCur=PQ_GetBackLight();
					//if(pDBL->dwLightTarget < dwCur)
					{
						pDBL->iAdd = (INT32)(pDBL->dwLightTarget - dwCur)/(300);
						PQDebugPrint("&&&&&(decrease)in 5s(50 percent backlight) pDBL->dwLightTarget = %ld, pDBL->iAdd = %d, dwCur = %ld", pDBL->dwLightTarget, pDBL->iAdd, dwCur);
						nDBLStatus=VIP_DBL_STATUS_ENTERING;
					}
				}


				/*
				else if(wDetectCount == 6800)
				{
					pDBL->dwLightTarget = pDBL->dwLightMin;
					dwCur=PQ_GetBackLight();
					pDBL->iAdd = (INT32)(pDBL->dwLightTarget - dwCur)/300;
					PQDebugPrint("&&&&&in 60s(set min backlight), pDBL->dwLightTarget = %ld, pDBL->iAdd = %d, dwCur = %ld", pDBL->dwLightTarget, pDBL->iAdd, dwCur);
					nDBLStatus=VIP_DBL_STATUS_ENTERING;
				}
				*/
			}

			if(wDetectCount < 50000)
				wDetectCount++;
			break;
		case 2:/*
			if(nPrevWhiteCondition!=nWhiteCondition)
			{
				wDetectCount = 0;
				dwCur=PQ_GetBackLight();
				if(dwCur <= pDBL->dwLightMid)
				{
					pDBL->dwLightTarget = pDBL->dwLightMid;
					dwCur=PQ_GetBackLight();
					pDBL->iAdd = (INT32)(pDBL->dwLightTarget - dwCur)/(200/4);
					PQDebugPrint("&&&&&set to 50 percent backlight");//, pDBL->dwLightTarget = %ld, pDBL->iAdd = %d, dwCur = %ld", pDBL->dwLightTarget, pDBL->iAdd, dwCur);
					nDBLStatus=VIP_DBL_STATUS_ENTERING;

				}
				else
				{
					nDBLStatus=VIP_DBL_STATUS_KEEPING;
					PQDebugPrint("&&&&&keep current backlight");
				}
			}
			break;*/
		case 3:
			if(nPrevWhiteCondition!=nWhiteCondition)
			{
				wDetectCount = 0;
				pDBL->dwLightTarget = pDBL->dwLightNormal;
				dwCur=PQ_GetBackLight();
				pDBL->iAdd = (INT32)(pDBL->dwLightTarget - dwCur)/(200);
				nDBLStatus=VIP_DBL_STATUS_LEAVING ;
				PQDebugPrint("&&&&&return to default backlight: %ld -> %ld", dwCur, pDBL->dwLightTarget);
			}
			break;
		case 5:
			if(nPrevWhiteCondition!=nWhiteCondition)
				wDetectCount = 0;
			else
			{
				if(wDetectCount == (300))
				{
					pDBL->dwLightTarget = pDBL->dwLightMax;
					dwCur=PQ_GetBackLight();
					pDBL->iAdd = (INT32)(pDBL->dwLightTarget - dwCur)/(200);
					nDBLStatus=VIP_DBL_STATUS_ENTERING;
					PQDebugPrint("&&&&&in 3(set max backlight), pDBL->dwLightTarget = %ld, pDBL->iAdd = %d, dwCur = %ld", pDBL->dwLightTarget, pDBL->iAdd, dwCur);
				}
			}

			if(wDetectCount < 50000)
				wDetectCount++;
			break;


	}

	if( (nDBLStatus==VIP_DBL_STATUS_ENTERING || nDBLStatus==VIP_DBL_STATUS_LEAVING))
	{
		if(pDBL->iAdd==0)
			nDBLStatus = VIP_DBL_STATUS_DETECTING;
		dwCur=PQ_GetBackLight();
		dwTarget= pDBL->dwLightTarget;
		dwNext= dwCur+pDBL->iAdd;
		if( (signed)((signed)dwCur+pDBL->iAdd)<0)
			dwNext= 0;


		if( abs(dwCur - dwTarget) <= abs(dwCur - dwNext))
		{
			dwNext= dwTarget;
		}

		//PQDebugPrint("%s:  dwCur=0x%lx dwNext=0x%lx, dwTarget=0x%lx", __FUNCTION__,  dwCur, dwNext, dwTarget);
		if( dwNext!=dwCur )
		{
			PQ_SetBackLight(dwNext);
		}
		else
			nDBLStatus = VIP_DBL_STATUS_DETECTING;
	}
	nPrevWhiteCondition= nWhiteCondition;
	LastLSChang = pDBL->bLSChangeBacklight;

	dwLast = dwCur;
}


BOOL bATVstatus = FALSE;

void PQ_SetATVStatus(BOOL bstatus)
{
	bATVstatus = bstatus;
	return;
}

//Frame rate is 60Hz(60 frame/sec) if handle on vsync, or 50 frame/sec if handle on 20ms timer.
//DBL is detected every 16 frames, this period is about 1/4 sec.
void PQ_FormalBackLightDetect(BOOL bReset)
{
	static UINT8 nPollingIndex= 0;
	static UINT16 wDetectFrameCount= 0;
	static UINT8 nEnteringWhiteCondition= 0;
	static UINT8 nPrevWhiteCondition= 0;
	static UINT8 nDBLStatus= VIP_DBL_STATUS_DETECTING;
	static UINT8 nCounter = 0,nCounter1 = 0;
	BOOL bNeedDown=0;
	UINT8 i,nWhiteCondition;
	UINT32 nGrayLevelCount[16]; // 21 bit at max
	UINT32 dwTotalPixel,dwTotalWeight,dwWhiteLevel;
	UINT32 dwCur,dwTarget=0,dwNext;
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	ptv_base_t ptv = getptvdev();
	UINT32 mmiovalue;
	UINT8 bNosignal;
	UINT8 bUserSource,ucSubSource;

#ifdef DYNAMICBL_ADJUST
//	UINT32 bMaxBL,bMinBL;
#endif
	UINT32 maxBLValue = 0, minBLValue = 0;
#ifndef CONFIG_PANEL_ADJ_INVERT
	PBRVIP_FLASH brvip_flash_p = (PBRVIP_FLASH)SPI_PANELSET_SHADOWADDR;
#endif		

	if( bReset )
	{
		nPollingIndex= 0;
		wDetectFrameCount= 0;
		nEnteringWhiteCondition= 0;
		nPrevWhiteCondition= 0;
		nDBLStatus= VIP_DBL_STATUS_DETECTING;
		return;
	}

	if( pDBL->ucLevel==OFF )
	{
		return;
	}

	nPollingIndex++;
	if( (nDBLStatus==VIP_DBL_STATUS_ENTERING) || (nDBLStatus==VIP_DBL_STATUS_LEAVING) )
	{
		if( nPollingIndex<3 ) //=25/8
			return;
	}
	else
	{
		if( nPollingIndex<25 ) //16ms x 16 Frame / 10ms = 25.6
		{
			return;
		}
	}
	nPollingIndex= 0;

	dwTotalPixel= 0;
	dwTotalWeight= 0;
	for(i=0; i<16; i++)
	{
		nGrayLevelCount[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
		dwTotalPixel+= nGrayLevelCount[i];
		dwTotalWeight+= nGrayLevelCount[i]*i+(nGrayLevelCount[i]>>1); //count*i.5
	}
    VIP_GetSource(&bUserSource, &ucSubSource);	
	
if(((bUserSource == SOURCE_CVD2) && (VIP_IsATVSource())&& (!bATVstatus)) || (((bUserSource != SOURCE_CVD2) || ((bUserSource == SOURCE_CVD2) &&(!VIP_IsATVSource())))&& (gfTVFEMuteFlg.fTVFEMuteFlag)))
	{
		bNosignal = 1;
	}
	else
	{
		bNosignal = 0;
	}

	if((PQ_specialpatterndetect() == TRUE)|| (bNosignal == 1))
	{
		//printk("\n\n\n\n\n	   enter special pattern	\n\n\n\n\n\n");
		//if((nCounter <= 251) || (nCounter1 <=251))
		{
			if((PQ_specialpatterndetect() == TRUE) && (bNosignal == 0))
			{
		//	printk("\n\n 111111  \n\n");
				maxBLValue = (LCDBackLightMap[0] > LCDBackLightMap[14]) ? LCDBackLightMap[0] : LCDBackLightMap[14];
				minBLValue = (LCDBackLightMap[0] > LCDBackLightMap[14]) ? LCDBackLightMap[14] : LCDBackLightMap[0];
						
				#ifdef CONFIG_PANEL_ADJ_INVERT
				{
					maxBLValue = minBLValue;
				}
				#else
				if(brvip_flash_p->LCDBackLight_Order)
				{
					maxBLValue = minBLValue;
				}
				#endif
			
				if( nCounter1 == 5)
				{
					maxBLValue = maxBLValue | 0x80000000;
					PQ_ChangeBackLight(maxBLValue, 0);
				}
				nCounter1 ++;
				if(nCounter != 0)
					nCounter = 0;
				if(nCounter1 > 250)
					nCounter1 = 250;
			}
			else if(bNosignal == 1)
			{
			//	printk("\n\n 222222222  \n\n");
				//printk("\n\n\n\n\n     enter here 22      \n\n\n\n\n\n");
				if( nCounter== 8)
				{
				mmiovalue = tv_GetLCDBackLightValue(ptv->pBootRomShareData->LcdBacklightValue);
				
				PQ_ChangeBackLight(mmiovalue, 0);
				}
				nCounter ++;
				
				if(nCounter1 != 0)
					nCounter1 = 0;
				if(nCounter > 250)
					nCounter = 250;
			}
		}
		return;
	}
	else
	{
		//printk("\n\n\n\n\n	   enter here test	 nCounter = %d \n\n\n\n\n\n",nCounter);
		if((nCounter != 0) ||(nCounter1 != 0))
		{
			nCounter = 0;
			nCounter1 = 0;
			
			nPollingIndex= 0;
			wDetectFrameCount= 0;
			nEnteringWhiteCondition= 0;
			nPrevWhiteCondition= 0;
			nDBLStatus= VIP_DBL_STATUS_DETECTING;
			return;
		}
	}
	dwCur=PQ_GetBackLight();
	//Rule1: Calc rate of white pixel
	//dwWhiteLevel= (dwTotalWhite<<8)/dwTotalPixel;  // n x 256 to expand to VIP_DBL_LEVEL_DEGREE

	//Rule2: Calc weighted average
	dwWhiteLevel= (dwTotalWeight<<4)/dwTotalPixel;  // n x 16 to expand to VIP_DBL_LEVEL_DEGREE

#if 1
	if( pDBL->dwWhiteLevel!=VIP_DBL_INVALID_WHITE_LEVEL )
	{
		if( pDBL->dwWhiteLevel<128 )
		{
			if( dwWhiteLevel<pDBL->dwWhiteLevel )
				dwWhiteLevel= (3*pDBL->dwWhiteLevel + dwWhiteLevel)>>2; //0.75*pDBL->dwWhiteLevel + 0.25*dwWhiteLevel;
			else
				dwWhiteLevel= (pDBL->dwWhiteLevel + 3*dwWhiteLevel)>>2; //0.25*pDBL->dwWhiteLevel + 0.75*dwWhiteLevel
		}
		else
		{
			if( dwWhiteLevel<pDBL->dwWhiteLevel )
				dwWhiteLevel= (pDBL->dwWhiteLevel + 3*dwWhiteLevel)>>2;
			else
				dwWhiteLevel= (3*pDBL->dwWhiteLevel + dwWhiteLevel)>>2;
		}
	}
	pDBL->dwWhiteLevel= dwWhiteLevel;
#endif

	//White Condition has 5 scopes which is divided by dbl_bound1~4.
	if( dwWhiteLevel<=pDBL->nBound1 )
	{
		nWhiteCondition= 1;
		#ifdef DYNAMICBL_ADJUST
		if( dwWhiteLevel > pDBL->nBound0 )
		{
			pDBL->ucLevel=WEAK;
			nWhiteCondition= 3;
		}
		else if( dwWhiteLevel > pDBL->nBound0_more)
		{
			nWhiteCondition= 2;
			pDBL->ucLevel=MEDIUM;
		}
		else
		{
			nWhiteCondition= 1;
			pDBL->ucLevel=STRONG;
		}
		#endif
		//	printk("\n\ndwWhiteLevel = %d pDBL->ucLevel = %d\n\n",dwWhiteLevel,pDBL->ucLevel);
			
	}
	else if( dwWhiteLevel<=pDBL->nBound2 )
		{
			nWhiteCondition= 2;
			#ifdef DYNAMICBL_ADJUST
			nWhiteCondition= 4;
			pDBL->ucLevel=MEDIUM;
			#endif
		}
#ifdef VIP_DBL_WHITE_PATTERN_BRIGHTING
	else if( dwWhiteLevel<=pDBL->nBound3 )
		{
			nWhiteCondition= 3;
			#ifdef DYNAMICBL_ADJUST
			nWhiteCondition= 5;
			pDBL->ucLevel=MEDIUM;
			#endif
		}
	else if( dwWhiteLevel<=pDBL->nBound4 )
		{
			nWhiteCondition= 4;
			#ifdef DYNAMICBL_ADJUST
			nWhiteCondition= 6;
			pDBL->ucLevel=MEDIUM;
			#endif
		}
	else
		{
			nWhiteCondition= 5;
			#ifdef DYNAMICBL_ADJUST
			if(dwWhiteLevel <= pDBL->nBound5)
			{
				nWhiteCondition= 7;
				pDBL->ucLevel=MEDIUM;
			}
			else
			{
				nWhiteCondition= 8;
				pDBL->ucLevel=STRONG;
			}
			#endif
		}
#else
	else
		{
			nWhiteCondition= 3;
			#ifdef DYNAMICBL_ADJUST
			pDBL->ucLevel=MEDIUM;
			#endif
		}
#endif
//printk("\n\n   dwWhiteLevel = %d nWhiteCondition =   %d nDBLStatus = %d\n\n",dwWhiteLevel,nWhiteCondition,nDBLStatus);


	switch(nDBLStatus)
	{
	case VIP_DBL_STATUS_DETECTING:
	case VIP_DBL_STATUS_DETECTING_WHITE_ENTERING:
		if( nPrevWhiteCondition!=nWhiteCondition )
		{
			wDetectFrameCount= 0;
			if( nDBLStatus==VIP_DBL_STATUS_DETECTING_WHITE_ENTERING )
			{
				if( (nPrevWhiteCondition<5 && nWhiteCondition>=5) || (nPrevWhiteCondition>5 && nWhiteCondition<=5) )
				{
					nDBLStatus= VIP_DBL_STATUS_LEAVING;
				}
			}
		}
		else if( nWhiteCondition==1 || nWhiteCondition==2 || nWhiteCondition==3|| nWhiteCondition==7 || nWhiteCondition==8)
		{
			wDetectFrameCount+= VIP_DBL_FRAME_INTERVAL;
			if( wDetectFrameCount>=pDBL->wDetectFrameCount ) //50 frams x 3 sec if 144
			{
				dwTarget= PQ_BackLightTarget(VIP_DBL_STATUS_ENTERING, nWhiteCondition, dwCur);//nWhiteCondition==1 ? pDBL->dwLightMin : pDBL->dwLightMax;
				
//#ifdef CONFIG_PANEL_ADJ_INVERT
	//			if( ((nWhiteCondition==1 || nWhiteCondition==0 ) && dwCur<dwTarget) || (nWhiteCondition==5 && dwCur>dwTarget) )
//#else
				if(( ((nWhiteCondition==1 || nWhiteCondition==2 || nWhiteCondition==3) && dwCur>dwTarget)) || ((nWhiteCondition==7 || nWhiteCondition==8 )&& dwCur<dwTarget) )

//#endif
				{
					nDBLStatus= VIP_DBL_STATUS_ENTERING;
					nEnteringWhiteCondition= nWhiteCondition;
				}
				else
				{
					wDetectFrameCount= 0;
				}
			}
		}

		if( nDBLStatus==VIP_DBL_STATUS_LEAVING )
		{
			PQ_BackLightTarget(nDBLStatus, nWhiteCondition, dwCur);
			PQDebugPrint("%s: Leaving while detection and entering , dwTarget=normal", __FUNCTION__);
		}

		if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
		{
			//PQ_BackLightTarget(nDBLStatus, nWhiteCondition, dwCur);
			PQDebugPrint("%s: Entering %s , dwTarget=0x%lx", __FUNCTION__, nWhiteCondition==1?"Black":"White", dwTarget);
		}

		break;
	case VIP_DBL_STATUS_KEEPING: //nPrevWhiteCondition must be 1, 5, 2 or 4
	case VIP_DBL_STATUS_ENTERING: //nPrevWhiteCondition must be 1 or 5
		if( nPrevWhiteCondition!=nWhiteCondition )
		{
			if(( nPrevWhiteCondition==1 ) || ( nPrevWhiteCondition==2 ) || nPrevWhiteCondition==3)
				nDBLStatus= nWhiteCondition>=4 ?VIP_DBL_STATUS_LEAVING:VIP_DBL_STATUS_DETECTING_WHITE_ENTERING;
			else if( nPrevWhiteCondition==7 || nPrevWhiteCondition==8 )
				nDBLStatus= nWhiteCondition<=6?VIP_DBL_STATUS_LEAVING:VIP_DBL_STATUS_DETECTING_WHITE_ENTERING;
			wDetectFrameCount= 0;

			if( nDBLStatus==VIP_DBL_STATUS_LEAVING )
			{
				PQ_BackLightTarget(nDBLStatus, nWhiteCondition, dwCur);
				PQDebugPrint("%s: Leaving while entering , dwTarget=normal", __FUNCTION__);
			}
		}
		break;
		#if 0
	
	case VIP_DBL_STATUS_KEEPING: //nPrevWhiteCondition must be 1, 5, 2 or 4

	printk("\n\n\n\n    KEEPING \n\n\n\n");
		if( nPrevWhiteCondition!=nWhiteCondition )
		{
			if( nPrevWhiteCondition<5 )
			{
				if( nWhiteCondition>=5)
					nDBLStatus= VIP_DBL_STATUS_LEAVING;
			}
			else if( nPrevWhiteCondition>5 )
			{
				if( nWhiteCondition<=5 )
					nDBLStatus= VIP_DBL_STATUS_LEAVING;
			}
			wDetectFrameCount= 0;

			if( nDBLStatus==VIP_DBL_STATUS_LEAVING )
			{
				PQ_BackLightTarget(nDBLStatus, nWhiteCondition, dwCur);
				PQDebugPrint("%s: Leaving while keeping , dwTarget=normal", __FUNCTION__);
			}
		}
		break;
	#endif
	case VIP_DBL_STATUS_LEAVING:
		break;
	}

	if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
	{
		bNeedDown= (nEnteringWhiteCondition==1  || nEnteringWhiteCondition==3 || nEnteringWhiteCondition==2 )? TRUE : FALSE;
	}
	else if( nDBLStatus==VIP_DBL_STATUS_LEAVING )
	{
		bNeedDown= (nEnteringWhiteCondition==1  || nEnteringWhiteCondition==3 || nEnteringWhiteCondition==2 )? FALSE : TRUE;
	}

	if( nDBLStatus==VIP_DBL_STATUS_ENTERING || nDBLStatus==VIP_DBL_STATUS_LEAVING )
	{
		dwTarget= pDBL->dwLightTarget;
		dwNext= dwCur+pDBL->iAdd;
		if( (signed)((signed)dwCur+pDBL->iAdd)<0 )
			dwNext= 0;
		//PQDebugPrint("%s: bNeedDown=%d dwCur=0x%lx dwNext=0x%lx", __FUNCTION__, bNeedDown, dwCur, dwNext);
		if( (bNeedDown && dwNext<=dwTarget) || ( !bNeedDown && dwNext>=dwTarget ) )
		{
			dwNext= dwTarget;
			nDBLStatus= (nDBLStatus==VIP_DBL_STATUS_ENTERING)?VIP_DBL_STATUS_KEEPING:VIP_DBL_STATUS_DETECTING;
		//	PQDebugPrint("%s: dwNext=0x%lx Reach end", __FUNCTION__, dwNext);
		}

		if( dwNext!=dwCur )
		{
			PQ_SetBackLight(dwNext);
		}
	}
	nPrevWhiteCondition= nWhiteCondition;
}


UINT32 PQ_EEBackLightTarget(UINT8 nDBLStatus, UINT32 dwWhiteLevel, UINT32 dwCur)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	//UINT32 dwLightTarget;
	INT32 nStep,nSlowStep,nQuickStep;
	//UINT32 ActiveMinBackLight = pDBL->dwTableMin;
	//UINT32 dwBacklight40Percent;

	nSlowStep= 1;//5;
	nQuickStep= 3;//12;
	if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
	{
		nStep= nQuickStep; //white color want to increase the steps
	}
	else if( nDBLStatus==VIP_DBL_STATUS_KEEPING )
	{
		//dwLightTarget = PQ_GetHomeModeValue(&dwLightTarget);
		nStep= nSlowStep;
	}
	else if( nDBLStatus==VIP_DBL_STATUS_LEAVING )
	{
		//dwLightTarget = PQ_GetHomeModeValue(&dwLightTarget);
		nStep= nQuickStep;
	}
	else
	{
		nStep= nQuickStep;
	}
	//pDBL->dwLightTarget= dwLightTarget;
	//PQDebugPrint("%s:dwLightTarget=%#lx(%ld) OSD max=%#lx(%ld) pDBL->dwTableNormal=%#lx(%ld)",__FUNCTION__, dwLightTarget, dwLightTarget, pDBL->dwTableNormal, pDBL->dwTableNormal, pDBL->dwTableNormal, pDBL->dwTableNormal);
	if((pDBL->dwLightQuot+1)/2 == 0)
		pDBL->iAdd= nStep;
	else
		pDBL->iAdd= ((pDBL->dwLightQuot+1)/2)*nStep;
	if( pDBL->dwLightTarget<dwCur )
		pDBL->iAdd= -(pDBL->iAdd);

	return pDBL->dwLightTarget;
}


void PQ_EEBackLightDetect(BOOL bReset)
{
	PQHW_CONTEXT * pHwContext= &PQHwContext;
	PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
	//VIP_SOURCE_INFO* pSourceInfo = VIP_GetSourceInfo();
	static UINT8 nPollingIndex= 0;
	//static UINT16 dwLast;
	//static UINT8 nEnteringWhiteCondition= 0;
	static UINT8 nPrevWhiteCondition= 0xff;
	static UINT8 nDBLStatus= VIP_DBL_STATUS_DETECTING;
	static UINT8 nHistGrayLevel= 0;
	//BOOL bNeedDown=0;
	UINT8 nWhiteCondition;
	UINT32 nGrayLevelCount[16]; // 21 bit at max
	UINT32 dwTotalPixel,dwWhiteLevel, dwPixelCount;
	UINT32 dwCur,dwTarget=0,dwNext;//, dwHistPWM, dwHistPWMMin;
	INT32 nContrast;
	UINT32 nPercentage1 = 1000;
	UINT32 nPercentage2;
	INT32 i;
	//UINT32 dwGrayLevelAddr= 0xbe1cc6dc;
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	if( bReset )
	{
		nPollingIndex= 0;
		//nEnteringWhiteCondition= 0;
		nPrevWhiteCondition= 0;
		nDBLStatus= VIP_DBL_STATUS_DETECTING;
		return;
	}

	if( pDBL->ucLevel==OFF )
	{
		nPrevWhiteCondition = 0xfd;
		return;
	}

    if(pHwContext->bPWMOff) // if Set baclight off, notset PWM anymore
	{
	    return;
	}

	nPollingIndex++;

	if( (nDBLStatus==VIP_DBL_STATUS_ENTERING) || (nDBLStatus==VIP_DBL_STATUS_LEAVING) || (nDBLStatus==VIP_DBL_STATUS_KEEPING) )
	{
		if( nPollingIndex<3 ) //=25/8
			return;
	}
	else
	{
		if( nPollingIndex<3 ) //16ms x 16 Frame / 10ms = 25.6
		{
			return;
		}
	}
	nPollingIndex= 0;

	dwTotalPixel= 0;

	for(i=0; i<16; i++)
	{
		nGrayLevelCount[i] = PQ_RegisterRead(VIP_reg_dpy_hist_bin0+i*4);
		dwTotalPixel+= nGrayLevelCount[i];
	}
	if( dwTotalPixel==0 )
		return;
	dwWhiteLevel = PQ_RegisterRead(VIP_reg_dpy_y_sum)*256 / dwTotalPixel; //y_sum = (reg(c8c8))*256 //y_sum = real_y_sum/2, dwTotalPixel = real_total/2
	//if(pSourceInfo->ucUserSource == CVD2)
		//dwWhiteLevel +=16;
	//PQDebugPrint("%s:dwWhiteLevel = %ld\n",__FUNCTION__, dwWhiteLevel);

	dwCur=PQ_GetRealBackLight();

	//White Condition has 3 scopes.
	if( dwWhiteLevel<=60)//pDBL->nBound1 )
		nWhiteCondition= 1;
	else if(dwWhiteLevel<=104)//pDBL->nBound3)
		nWhiteCondition= 2;
	else
		nWhiteCondition= 3;

	if(nPrevWhiteCondition != nWhiteCondition)
	{
		PQDebugPrint("%s:change to WhiteCondition = %d\n",__FUNCTION__, nWhiteCondition);
	}

	switch(nWhiteCondition)
	{
		case 1:
			if(nPrevWhiteCondition!=nWhiteCondition)
			{
				//==============================================histogram 1% counting and algorithm2
				dwPixelCount = 0;
				for(i=15; i>=0; i--)
				{
					//PQDebugPrint("%s:nGrayLevelCount[%d] = %ld",__FUNCTION__, i, nGrayLevelCount[i]);
					dwPixelCount += nGrayLevelCount[i];
					if(dwPixelCount > (dwTotalPixel + 50)/100)//find 1% hist position from nGrayLevelCount[15] to nGrayLevelCount[0]
						break;
				}
				PQDebugPrint("%s:%%1 gray level position[0~15] : i=%d dwPixelCount=%ld dwTotalPixel=%ld",__FUNCTION__, i, dwPixelCount, dwTotalPixel);
				if(abs((INT32)nHistGrayLevel - (INT32)i)>1)
					nHistGrayLevel = i;
				nPercentage1 = 1000;
				nPercentage2 = pDBL->ucHistMinPercentage * 10 + (nHistGrayLevel * (100 - pDBL->ucHistMinPercentage) * 10 + 8)/15;
				if(pHwContext->ucDynamicBacklightMode == 1)
				{
					if(pDBL->ucOrder)
						pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * nPercentage1  / 1000;
					else
						pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * nPercentage1  / 1000;
				}
				else if(pHwContext->ucDynamicBacklightMode == 2)
				{
					if(pDBL->ucOrder)
						pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * nPercentage2 / 1000;
					else
						pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * nPercentage2 / 1000;
				}
				else
				{
					if(pDBL->ucOrder)
						pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * (nPercentage1 * nPercentage2/1000) / 1000;
					else
						pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * (nPercentage1 * nPercentage2/1000) / 1000;
				}
				PQDebugPrint("%s:pDBL->dwLightMax=%ld pDBL->dwTableNormal=%ld",__FUNCTION__, pDBL->dwLightMax, pDBL->dwTableNormal);
				PQDebugPrint("%s:ucDynamicBacklightMode=%d nPercentage1=%ld nPercentage2=%ld final Percentage=%ld",__FUNCTION__, pHwContext->ucDynamicBacklightMode, nPercentage1, nPercentage2, (nPercentage1 * nPercentage2+500) / 1000);

				//==============================================

				nContrast = pMenuValue->iContrast + 30 - (30 * nHistGrayLevel / 15);

				nDBLStatus=VIP_DBL_STATUS_ENTERING;
				PQ_EEBackLightTarget(VIP_DBL_STATUS_ENTERING, dwWhiteLevel, dwCur);
				PQDebugPrint("%s:pDBL->dwLightTarget=%ld(%#lx)", __FUNCTION__, pDBL->dwLightTarget, pDBL->dwLightTarget);
				PQ_PresetContrast(TRUE, nContrast, 1);
			}
			break;
		case 2:

			//==============================================histogram 1% counting and algorithm2
			dwPixelCount = 0;
			for(i=15; i>=0; i--)
			{
				dwPixelCount += nGrayLevelCount[i];
				if(dwPixelCount > (dwTotalPixel + 50)/100)//find 1% hist position from nGrayLevelCount[15] to nGrayLevelCount[0]
					break;
			}
			PQDebugPrint("%s:%%1 gray level position[0~15] : i=%d dwPixelCount=%ld dwTotalPixel=%ld",__FUNCTION__, i, dwPixelCount, dwTotalPixel);
			if(abs((INT32)nHistGrayLevel - (INT32)i)>1)
				nHistGrayLevel = i;
			nPercentage1 = 1000 - (1000-400)*(dwWhiteLevel-60)/(104-60);
			nPercentage2 = pDBL->ucHistMinPercentage * 10 + (nHistGrayLevel * (100 - pDBL->ucHistMinPercentage) * 10 + 8)/15;
			if(pHwContext->ucDynamicBacklightMode == 1)
			{
				if(pDBL->ucOrder)
					pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * nPercentage1  / 1000;
				else
					pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * nPercentage1  / 1000;
			}
			else if(pHwContext->ucDynamicBacklightMode == 2)
			{
				if(pDBL->ucOrder)
					pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * nPercentage2 / 1000;
				else
					pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * nPercentage2 / 1000;
			}
			else
			{
				if(pDBL->ucOrder)
						pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * (nPercentage1 * nPercentage2/1000) / 1000;
					else
						pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * (nPercentage1 * nPercentage2/1000) / 1000;
			}
			PQDebugPrint("%s:pDBL->dwLightMax=%ld pDBL->dwTableNormal=%ld",__FUNCTION__, pDBL->dwLightMax, pDBL->dwTableNormal);
			PQDebugPrint("%s:ucDynamicBacklightMode=%d nPercentage1=%ld nPercentage2=%ld final Percentage=%ld",__FUNCTION__, pHwContext->ucDynamicBacklightMode, nPercentage1, nPercentage2, (nPercentage1 * nPercentage2+500) / 1000);

			//==============================================

			nContrast = pMenuValue->iContrast + 30 - (30 * nHistGrayLevel / 15);

			nDBLStatus=VIP_DBL_STATUS_KEEPING;
			PQ_EEBackLightTarget(VIP_DBL_STATUS_KEEPING, dwWhiteLevel, dwCur);
			PQ_PresetContrast(TRUE, nContrast, 1);
			break;
		case 3:
			if(nPrevWhiteCondition!=nWhiteCondition)
			{

				//==============================================histogram 1% counting and algorithm2
				dwPixelCount = 0;
				for(i=15; i>=0; i--)
				{
					dwPixelCount += nGrayLevelCount[i];
					if(dwPixelCount > (dwTotalPixel + 50)/100)//find 1% hist position from nGrayLevelCount[15] to nGrayLevelCount[0]
						break;
				}
				PQDebugPrint("%s:%%1 gray level position[0~15] : i=%d dwPixelCount=%ld dwTotalPixel=%ld",__FUNCTION__, i, dwPixelCount, dwTotalPixel);
				if(abs((INT32)nHistGrayLevel - (INT32)i)>1)
					nHistGrayLevel = i;
				nPercentage1 = 400;
				nPercentage2 = pDBL->ucHistMinPercentage * 10 + (nHistGrayLevel * (100 - pDBL->ucHistMinPercentage) * 10 + 8)/15;
				if(pHwContext->ucDynamicBacklightMode == 1)
				{
					if(pDBL->ucOrder)
						pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * nPercentage1  / 1000;
					else
						pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * nPercentage1  / 1000;
				}
				else if(pHwContext->ucDynamicBacklightMode == 2)
				{
					if(pDBL->ucOrder)
						pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * nPercentage2 / 1000;
					else
						pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * nPercentage2 / 1000;
				}
				else
				{
					if(pDBL->ucOrder)
						pDBL->dwLightTarget = pDBL->dwLightMax - (pDBL->dwLightMax - pDBL->dwTableNormal) * (nPercentage1 * nPercentage2/1000) / 1000;
					else
						pDBL->dwLightTarget = pDBL->dwTableMin + (pDBL->dwTableNormal - pDBL->dwTableMin) * (nPercentage1 * nPercentage2/1000) / 1000;
				}
				PQDebugPrint("%s:pDBL->dwLightMax=%ld pDBL->dwTableNormal=%ld",__FUNCTION__, pDBL->dwLightMax, pDBL->dwTableNormal);
				PQDebugPrint("%s:ucDynamicBacklightMode=%d nPercentage1=%ld nPercentage2=%ld final Percentage=%ld",__FUNCTION__, pHwContext->ucDynamicBacklightMode, nPercentage1, nPercentage2, (nPercentage1 * nPercentage2+500) / 1000);

				//==============================================

				nContrast = pMenuValue->iContrast + 30 - (30 * nHistGrayLevel / 15);

				nDBLStatus=VIP_DBL_STATUS_LEAVING;
				PQ_EEBackLightTarget(VIP_DBL_STATUS_LEAVING, dwWhiteLevel, dwCur);
				PQDebugPrint("%s:pDBL->dwLightTarget=%ld(%#lx)", __FUNCTION__, pDBL->dwLightTarget, pDBL->dwLightTarget);
				PQ_PresetContrast(TRUE, nContrast, 1);
			}
			break;

	}

	if( nDBLStatus==VIP_DBL_STATUS_ENTERING || nDBLStatus==VIP_DBL_STATUS_KEEPING || nDBLStatus==VIP_DBL_STATUS_LEAVING )
	{
		dwCur=PQ_GetRealBackLight();
		dwTarget= pDBL->dwLightTarget;//(pDBL->dwTableNormal==0) ? pDBL->dwLightTarget : pDBL->dwLightTarget * dwHistPWM / pDBL->dwTableNormal;
		dwNext= dwCur+pDBL->iAdd;

		if( abs(dwCur - dwTarget) <= abs(dwCur - dwNext))
		{
			dwNext= dwTarget;
		}
		if((pDBL->iAdd > 0 && dwCur > dwTarget) || (pDBL->iAdd < 0 && dwCur < dwTarget))//prevent other driver set backlight traversing our target value.
		{
			PQ_SetRealBackLight(dwTarget);
			dwNext = dwCur = dwTarget;
		}

		if( dwNext!=dwCur )
		{
			PQ_SetRealBackLight(dwNext);

		}
		else
		{
			nDBLStatus = VIP_DBL_STATUS_DETECTING;
		}
	}

	nPrevWhiteCondition= nWhiteCondition;
}



void PQ_PresetContrast(BOOL bReset, INT32 iValue, INT32 nSpeed)
{
	PQHW_CONTEXT * pHwContext= &PQHwContext;
	static UINT32 nPollingIndex= 0;
	static INT32 iAdd = 0;
	static INT32 dwCur = 0;
	static INT32 dwTarget = 0;
	static INT32 dwNext = 0;
	static BOOL bStart = FALSE;
	if(bReset)
	{
		if(iValue == 0)
		{
			if(nSpeed == 0)
			{
				bStart = FALSE;
				PQDebugPrint("%s:stop!!!",__FUNCTION__);
			}
			else
			{
				PQDebugPrint("%s:iValue = %d, menu value error!!!",__FUNCTION__,iValue);
			}
			return;
		}
		if(iValue == dwTarget)
			return;
		spin_lock(&pHwContext->Spin_PresetContrast);
		iAdd = nSpeed;
		dwCur = pHwContext->iContrast>>COLOR_MATRIX_GAIN_OSD_DIFFBIT;
		dwTarget = iValue;
		if( dwTarget<dwCur )
			iAdd= -(iAdd);

		nPollingIndex = 0;
		bStart = TRUE;
		spin_unlock(&pHwContext->Spin_PresetContrast);
		PQDebugPrint("%s:dwCur = %ld(%#lx), dwTarget = %ld(%#lx), iAdd = %d",__FUNCTION__,dwCur, dwCur, dwTarget, dwTarget, iAdd);
	}
	if(bStart == TRUE)
	{
		nPollingIndex++;
		if(nPollingIndex<75)
			return;
		nPollingIndex = 0;

		dwCur = (pHwContext->iContrast>>COLOR_MATRIX_GAIN_OSD_DIFFBIT);
		dwNext= dwCur+iAdd;

		if( abs(dwCur - dwTarget) <= abs(dwCur - dwNext))
		{
			dwNext= dwTarget;
		}
		if((iAdd > 0 && dwCur > dwTarget) || (iAdd < 0 && dwCur < dwTarget))//prevent other driver set backlight traversing our target value.
		{
			PQ_Contrast(TRUE, dwTarget);
			dwNext = dwCur = dwTarget;
		}
		if( dwNext!=dwCur )
		{
			PQ_Contrast(TRUE, dwNext);
			//PQDebugPrint("%s: dwNext=0x%lx dwCur=0x%lx dwTarget=0x%lx pDBL->dwLightMin=0x%lx\n", __FUNCTION__, dwNext, dwCur, dwTarget, pDBL->dwLightMin);
		}
		else
		{
			PQDebugPrint("%s: DONE!!! dwCur=%#lx(%ld)\n", __FUNCTION__, dwCur, dwCur);
			bStart = FALSE;
		}

	}

}

void PQ_SISPresetContrast(UINT8 ucValue, INT32 nSpeed)
{
	PQHW_CONTEXT * pHwContext= &PQHwContext;
	static UINT32 nPollingIndex= 0;
	static INT32 iAdd = 0;
	static UINT32 dwCur = 0;
	static UINT32 dwTarget = 0;
	static UINT32 dwNext = 0;
	if(ucValue == 0)
	{
		PQDebugPrint("%s:ucValue = %d, menu value error!!!",__FUNCTION__,ucValue);
		return;
	}
	dwCur = pHwContext->iContrast>>COLOR_MATRIX_GAIN_OSD_DIFFBIT;
	if(ucValue == dwCur)
		return;
	iAdd = nSpeed;
	dwTarget = ucValue;
	if( dwTarget<dwCur )
		iAdd= -(iAdd);
	//PQDebugPrint("%s:dwCur = %ld(%#lx), dwTarget = %ld(%#lx), iAdd = %d",__FUNCTION__,dwCur, dwCur, dwTarget, dwTarget, iAdd);

	nPollingIndex++;
	if(nPollingIndex<75)
		return;
	nPollingIndex = 0;
	PQDebugPrint("[Robert]%s:in\n\n",__FUNCTION__);
	dwNext= dwCur+iAdd;

	if( abs(dwCur - dwTarget) <= abs(dwCur - dwNext))
	{
		dwNext= dwTarget;
	}
	if((iAdd > 0 && dwCur > dwTarget) || (iAdd < 0 && dwCur < dwTarget))//prevent other driver set backlight traversing our target value.
	{
		PQ_Contrast(TRUE, dwTarget);
		dwNext = dwCur = dwTarget;
	}
	if( dwNext!=dwCur )
	{
		PQ_Contrast(TRUE, dwNext);
		//PQDebugPrint("%s: dwNext=0x%lx dwCur=0x%lx dwTarget=0x%lx pDBL->dwLightMin=0x%lx\n", __FUNCTION__, dwNext, dwCur, dwTarget, pDBL->dwLightMin);
	}

}

void PQ_SetDynamicBacklightMode(UINT8 ucMode)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	pHwContext->ucDynamicBacklightMode = ucMode;
	PQ_BackLightDetect(TRUE);
}

void PQ_SetBackLightLevel(UINT8 ucLevel)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	UINT32 dwValue;
	dwValue = pDBL->BacklightTab[ucLevel];
	PQ_EnableDynamicBackLight(STRONG, dwValue);

}

void PQ_SetBacklightHistMin(UINT8 ucValue)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	if(ucValue <=100)
	{
		pDBL->ucHistMinPercentage = ucValue;
		PQDebugPrint("%s: HistMinPercentage=%d\n", __FUNCTION__, pDBL->ucHistMinPercentage);
	}
	else
	{
		PQDebugPrint("%s: unqualified value(%d)!!!\n", __FUNCTION__, ucValue);
		return;
	}
	PQ_BackLightDetect(TRUE);
}

void PQ_SetDynamicBLType(UINT8 ucType)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
	PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;

	PQDebugPrint("%s: ucType=%d\n", __FUNCTION__, ucType);
	pDBL->ucDynamicBLType = ucType;
	if(ucType!=DYNAMIC_BL_ENERGY_EFFICIENCY || pDBL->ucLevel==OFF)
	{
		PQ_PresetContrast(TRUE, pMenuValue->iContrast, 1);
	}
#ifdef DynamicBacklight_EnergyEfficiency
	if(ucType == DYNAMIC_BL_ENERGY_EFFICIENCY)
	{
		pDBL->dwTableNormal= pDBL->BacklightTab[12];
		if( pDBL->dwTableMin>pDBL->dwTableMax )
			pDBL->dwTableNormal= pDBL->BacklightTab[2];	 //14-12
	}
#endif
	PQ_BackLightDetect(TRUE);
}

UINT8 PQ_GetDynamicBLType(void)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	return pDBL->ucDynamicBLType;
}

UINT8 PQ_GetOrderedBackLight(UINT32 *pLight)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	if(pDBL->ucOrder)
		*pLight = pDBL->dwTableMax - *pLight + pDBL->dwTableMin;
	return TRUE;
}


void PQ_SetMaxPWM(UINT32 ucValue)
{
	DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
	ucValue = (~0x80000000) & ucValue;
	PQDebugPrint("%s: %ld(%#lx)", __FUNCTION__, ucValue, ucValue);
	if(pDBL->dwTableMin>pDBL->dwTableMax)
	{
		if(ucValue > pDBL->dwTableMin)
		{
			PQDebugPrint("%s: out of range!! >= dwTableMin", __FUNCTION__);
			return;
		}
	}
	else
	{
		if(ucValue < pDBL->dwTableMin)
		{
			PQDebugPrint("%s: out of range!! <= dwTableMin", __FUNCTION__);
			return;
		}
	}
	if(pDBL->ucOrder)
		ucValue = pDBL->dwTableMax- ucValue + pDBL->dwTableMin;
	pDBL->dwLightMax = ucValue;
	PQ_BackLightDetect(TRUE);
	PQ_PresetContrast(TRUE, 0, 0);
}

void PQ_FlDetLevel(UINT8 ucLevel)
{
	UINT32 WindowH = PQ_RegisterRead(VIP_reg_pnl_hde) - PQ_RegisterRead(VIP_reg_pnl_hds);
	UINT32 WindowV = PQ_RegisterRead(VIP_reg_pnl_vde) - PQ_RegisterRead(VIP_reg_pnl_vds);

	PQ_RegisterWrite(VIP_reg_dpy_fl_blk_hnum, ceil(WindowH*2,48));
	PQ_RegisterWrite(VIP_reg_dpy_fl_blk_vnum, ceil(WindowV,36));

	if(VIP_GetPanelHeight()==1200)
	{
		/*1920x1200 panel must cause video twinkle in flashtone part like #35997*/
		ucLevel = 0;
	}
	
	PQ_RegisterWrite(VIP_reg_dpy_fl_det_en, ucLevel?1:0);

	PQDebugPrint("%s: ucLevel = %d",__FUNCTION__, ucLevel);

	switch(ucLevel)
	{
		case STRONG:
			PQ_RegisterWrite(VIP_reg_dpy_fl_det_factor, 15);
			PQ_RegisterWrite(VIP_reg_dpy_fl_max, 63);
			break;
		case MEDIUM:
			PQ_RegisterWrite(VIP_reg_dpy_fl_det_factor, 9);
			PQ_RegisterWrite(VIP_reg_dpy_fl_max, 40);
			break;
		case WEAK:
			PQ_RegisterWrite(VIP_reg_dpy_fl_det_factor, 3);
			PQ_RegisterWrite(VIP_reg_dpy_fl_max, 16);
			break;
	}
}

void PQ_Set_UV_Coring(void)
{

    PQHW_CONTEXT* pHwContext= &PQHwContext;
	VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucTableIndex;

    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    UV_Coring_BY_Group_Idx *pUV_Coring_Setting;
    UV_Coring_ext *pUV_Coring_ext;
	
    if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
    if (pVtab->mUV_Coring.mUV_CoringGroupedIndex[ucCurrSrcIndex] >= 8) return;

    ucTableIndex = pVtab->mUV_Coring.mUV_CoringGroupedIndex[ucCurrSrcIndex];
    pUV_Coring_Setting = &pVtab->mUV_Coring.UV_Coring_BY_Group_Idx[ucTableIndex];
    pUV_Coring_ext = &pVtab->mUV_Coring_ext[ucTableIndex];

    PQ_RegisterWrite(VIP_reg_uv_coring_en, pUV_Coring_Setting->iUVCoring_en);
    PQ_RegisterWrite(VIP_reg_uv_coring_opt, pUV_Coring_ext->UVCoringOpt);	
    PQ_RegisterWrite(VIP_reg_uv_coring, pUV_Coring_Setting->iUVCoring);
    PQ_RegisterWrite(VIP_reg_uv_coring_1, pUV_Coring_ext->iUVCoring_2);
    PQ_RegisterWrite(VIP_reg_uv_coring_2, pUV_Coring_ext->iUVCoring_3);
    PQ_RegisterWrite(VIP_reg_uv_coring_lu_th_lo, pUV_Coring_ext->bluma_th_lo[0]);
    PQ_RegisterWrite(VIP_reg_uv_coring_lu_th_hi, pUV_Coring_ext->bluma_th_hi[0]);
    PQ_RegisterWrite(VIP_reg_uv_coring_lu_th_lo1, pUV_Coring_ext->bluma_th_lo[1]);
    PQ_RegisterWrite(VIP_reg_uv_coring_lu_th_hi1, pUV_Coring_ext->bluma_th_hi[1]);
    PQ_RegisterWrite(VIP_reg_uv_coring_blend_slope, pUV_Coring_ext->bBlend_slope[0]);
    PQ_RegisterWrite(VIP_reg_uv_coring_blend_slope1, pUV_Coring_ext->bBlend_slope[1]);
	
}


/*******************************************************************
//	function name		: PQ_Set_UV_Offset
//	input parameter	: n/a
//	output parameter	: n/a
//	purpose			: HW DPY new function since chip 8506 compare with uv coring function
//   return			: none
//   ToDo                   : check the pre bound function 
*******************************************************************/
void PQ_Set_UV_Offset(void)
{

    PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
    UINT8 ucTableIndex;

    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    UV_Offset_Data *pUVOffsetData;
    int UVOffCbTemp, UVOffCrTemp;
	
    if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;
    if (pVtab->mUV_Coring.mUV_CoringGroupedIndex[ucCurrSrcIndex] >= 8) return;

    ucTableIndex = pVtab->mUV_Coring.mUV_CoringGroupedIndex[ucCurrSrcIndex];
    pUVOffsetData = &pVtab->mUVOffset.UVOffset[ucTableIndex];

    PQ_RegisterWrite(VIP_REG_DPY_UV_OFFSET_EN, pUVOffsetData->UVOffsetEn);
    PQ_RegisterWrite(VIP_REG_DPY_UVOFFSET_METHOD_SELECT, pUVOffsetData->UVOffsetMethodSelect);
    
    if(pUVOffsetData->UVOffsetMethodSelect == 2) // value 2 = method 3, //patch for HW request in 8506
    {
        PQ_RegisterWrite(VIP_REG_DPY_OFF_LUMI_LOW, 0);
        PQ_RegisterWrite(VIP_REG_DPY_OFF_LUMI_HIGH, 0);
    }
    else //method 1 and method 2
    {
        PQ_RegisterWrite(VIP_REG_DPY_OFF_LUMI_LOW, pUVOffsetData->DPYOffLumiLow);
        PQ_RegisterWrite(VIP_REG_DPY_OFF_LUMI_HIGH, pUVOffsetData->DPYOffLumiHigh);

        if(pUVOffsetData->UVOffsetMethodSelect == 0)
        {
            UVOffCbTemp = pUVOffsetData->DPYUVOffCbMethod1;
            UVOffCrTemp = pUVOffsetData->DPYUVOffCrMethod1;
        }
        else
        {
            UVOffCbTemp = pUVOffsetData->DPYUVOffCbMethod2;
            UVOffCrTemp = pUVOffsetData->DPYUVOffCrMethod2; 
        }

        PQ_RegisterWrite(VIP_REG_DPY_UV_OFF_CB, UVOffCbTemp);
        PQ_RegisterWrite(VIP_REG_DPY_UV_OFF_CR, UVOffCrTemp);   
    }

    
    
    PQ_RegisterWrite(VIP_REG_DPY_SLOPE_MAXRGB_CB, pUVOffsetData->DPYSlopeMaxRGBCb);
    PQ_RegisterWrite(VIP_REG_DPY_SLOPE_MAXRGB_CR, pUVOffsetData->DPYSlopeMaxRGBCr);
    PQ_RegisterWrite(VIP_REG_DPY_OFF_SAT_LOW_LOW2, pUVOffsetData->DPYOffSatLowLow2);

    PQ_RegisterWrite(VIP_REG_DPY_OFF_SAT_LOW_LOW, pUVOffsetData->DPYOffSatLowLow);
    PQ_RegisterWrite(VIP_REG_DPY_OFF_SAT_LOW, pUVOffsetData->DPYOffSatLow);
    PQ_RegisterWrite(VIP_REG_DPY_OFF_SAT_HIGH, pUVOffsetData->DPYOffSatHigh);
    PQ_RegisterWrite(VIP_REG_DPY_UV_SAT_OFFSET_CB, pUVOffsetData->DPYUVSatOffsetCb);

    PQ_RegisterWrite(VIP_REG_DPY_UV_OFFSET_CB, pUVOffsetData->UVOffsetCb);
    PQ_RegisterWrite(VIP_REG_DPY_SLOPE_SAT_CB2, pUVOffsetData->DPYSlopeSatCb2);
    PQ_RegisterWrite(VIP_REG_DPY_SLOPE_SAT_CB, pUVOffsetData->DPYSlopeSatCb);
    PQ_RegisterWrite(VIP_REG_DPY_UV_SAT_OFFSET_CR, pUVOffsetData->DPYUVSatOffsetCr);

    PQ_RegisterWrite(VIP_REG_DPY_UV_OFFSET_CR, pUVOffsetData->UVOffsetCr);
    PQ_RegisterWrite(VIP_REG_DPY_SLOPE_SAT_CR2, pUVOffsetData->DPYSlopeSatCr2);
    PQ_RegisterWrite(VIP_REG_DPY_SLOPE_SAT_CR, pUVOffsetData->DPYSlopeSatCr);

}


#endif //#ifdef DYNAMIC_BACKLIGHT

void PQ_set_PWM_Duty(UINT16 uwMaxDuty, UINT16 uwMinDuty)
{
    DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
    pDBL->PWMDutyMax = uwMaxDuty;
    pDBL->PWMDutyMin = uwMinDuty;
}


void PQ_get_PWM_Duty(UINT16* uwMaxDuty, UINT16* uwMinDuty)
{
    DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
    *uwMaxDuty = pDBL->PWMDutyMax;
    *uwMinDuty = pDBL->PWMDutyMin;
}

UINT8 PQ_GetDefinitionIndex(void)
{
    UINT8 PQ_Definition = PQ_STANDARD_DEFINITION;

    if(VIP_GetInputVSize()>576+24) /* safer boundary */
    {
        PQ_Definition = PQ_HIGH_DEFINITION;
    }

    return PQ_Definition;
}



void PQ_HW_Initial(void)
{

    PQ_RegisterWrite(VIP_reg_slr_mix_hdiff_th, 64);
    PQ_RegisterWrite(VIP_reg_slr_mix_vdiff_th, 64);

    //post 2d sharpness overshoot fac
    PQ_RegisterWrite(VIP_reg_slr_2d_c_ovsht_fac, 0);
    PQ_RegisterWrite(VIP_reg_slr_2d_c_unsht_fac, 0);
    PQ_RegisterWrite(VIP_reg_slr_2d_c_ovsht_clip, 0);
    PQ_RegisterWrite(VIP_reg_slr_2d_c_unsht_clip, 0);
       
    PQ_RegisterWrite(VIP_reg_slr_dcti_smooth_gain, 64);
    
    PQ_RegisterWrite(VIP_reg_gfx_dbk_max_1_3_ratio_en, 1);

    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_th_dyn_adj, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_snr_demo_inv, 0);
    PQ_RegisterWrite(VIP_reg_vdi_snr_hc_lp_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_map_s_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_blk_diff_lp_en, 0);
    
    PQ_RegisterWrite(VIP_reg_vdi_snr_hc_fact0, 0x08);   
    PQ_RegisterWrite(VIP_reg_vdi_snr_hc_fact1, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_snr_hc_fact2, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_snr_hc_lp_gain, 0x2B);
    
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_chroma_tap_sel, 0x00);
    if (PQ_GET_YUV_Datat_Formal()== 0 || PQ_GET_YUV_Datat_Formal()==1)
    {
       
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_tulow_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_tnulow_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tulow_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tnulow_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_demo_inv, 0);
        PQ_RegisterWrite(VIP_reg_vdi_lb_double_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_std_5row, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_en, 0);

        PQ_RegisterWrite(VIP_reg_vdi_mad_loa_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_selcurframe2dpy, 0);
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_tulow_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_tnulow_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tulow_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_tnulow_en, 0);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnrz_demo_inv, 0);
        PQ_RegisterWrite(VIP_reg_vdi_lb_double_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_std_5row, 1);
        PQ_RegisterWrite(VIP_reg_vdi_tnr_c_en, 1);

        PQ_RegisterWrite(VIP_reg_vdi_mad_loa_en, 1);
        PQ_RegisterWrite(VIP_reg_vdi_selcurframe2dpy, 0);
    }
    
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ul_low_stb_th, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_adj_max, 0x30);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_v_ref, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_inc_fact, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_dec_fact, 0x02);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_u_ref, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_adj_fact, 0x28);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_adj_min, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_adj_max, 0x22);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_u_ref, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_th1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_th1_adj_fact, 0x28);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_th1_adj_min, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_th1_adj_max, 0x22);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_fac1, 0x02);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_clamp_fac1, 0x02);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_init, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_adj_min_dith, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_adj_min, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_alpha, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_s, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_th1_s, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_snr_slope_s, 0x03);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_th1, 0x24);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_th2, 0x02);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_th3, 0x800);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_th4, 0x00);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_color_th1, 0x24);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_color_th2, 0x03);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_color_th4, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_color_th3, 0x850);

    PQ_RegisterWrite(VIP_reg_vdi_tnr_mbw1_alpha_adj, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_mbw2_alpha_adj, 0x0C);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_mbw3_alpha_adj, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_mbwm_alpha_adj, 0x18);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_mbw1_alpha_adj, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_mbw2_alpha_adj, 0x0C);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_mbw3_alpha_adj, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_mbwm_alpha_adj, 0x18);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_ulow_mbw1_alpha_adj, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_ulow_mbw2_alpha_adj, 0x18);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_ulow_mbw3_alpha_adj, 0x20);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_ulow_mbwm_alpha_adj, 0x28);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ulow_mbw1_alpha_adj, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ulow_mbw2_alpha_adj, 0x18);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ulow_mbw3_alpha_adj, 0x20);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ulow_mbwm_alpha_adj, 0x28);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_chroma, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_th1_s, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_slope_s, 0x00);

    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add2, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add3, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add4, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add5, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add6, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_add7, 0x00);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_add1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_add2, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_add3, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_add4, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_add5, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_add6, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_add7, 0x00);
    
    PQ_RegisterWrite(VIP_reg_vdi_ne_fd_chg_mbw_thd, 0x680);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_y_lb_1, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_y_rb_1, 0x40);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha1_inc, 0x3c);
    
    PQ_RegisterWrite(VIP_reg_vdi_alpha_sel, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_alpha1_tulow_en, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_alpha1_tnulow_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_alpha2_tulow_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_alpha2_tnulow_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_alpha1_sulow_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_alpha1_snulow_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_alpha2_sulow_en, 0);
    PQ_RegisterWrite(VIP_reg_vdi_alpha2_snulow_en, 0);
    
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha1_inc, 0x23);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha2_inc, 0x23);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha1_dec, 0x0A);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha2_dec, 0x0A);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_sel, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_inc, 0x23);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha1_dec, 0x23);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_inc, 0x0A);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha2_dec, 0x0A);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_init, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_adj_min_dith, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_adj_min, 0x04);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_ultra_low_alpha, 0x04);
    
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_en, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_edgemode0, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_edgemode1, 0);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_filter_sel, 0x01);

    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_clamp_sel, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_en, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_sel, 0);
    
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_mode1fac, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_length, 0x03);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_cls_max, 0x40);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_cls_min, 0x20);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_cls_slp, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_cls_thr, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_clamp_thr, 0x2f);
    PQ_RegisterWrite(VIP_reg_vdi_snr_dering_clamp_max, 0x10);
    
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_fac, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_cls_thr, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_cls_slp, 0x20);
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_cls_min, 0x30);
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_cls_max, 0x40);
    PQ_RegisterWrite(VIP_reg_vdi_snr_2df_edge_fil_sel, 0x01);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_typ0, 0x1);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_typ1, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_typ2, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_typ3, 0x0);

    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_clamp_typ0, 0x1);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_clamp_typ1, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_clamp_typ2, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_clamp_typ3, 0x1);
    
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_fac, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_fac, 0x18);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_u_ref_s, 0x0);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_adj_fact_s, 0x0);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_adj_min_s, 0x0);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_th1_adj_max_s, 0x0);
    PQ_RegisterWrite(VIP_reg_vdi_snr_fun_debug, 0x0);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_fac1, 0x02);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_clamp_fac, 0x30);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_typ3, 0);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_clamp_fac, 0x30);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_tap0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_clamp_tap1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_clamp_tap0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_clamp_tap1, 0x00);

    PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_tap0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_clamp_tap1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_clamp_tap0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_clamp_tap1, 0x00);
    
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_lp, 0x25);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_div0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_alpha_div1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_alpha_div0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_alpha_div1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_8bit0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_8bit1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_8bit0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_8bit1, 0x00);
    
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_div0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_alpha_div1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_alpha_div0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_alpha_div0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_8bit0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_8bit1, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_8bit0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_8bit1, 0x00);
    
    PQ_RegisterWrite(VIP_reg_vdi_debug_fix_val0, 0);
    PQ_RegisterWrite(VIP_reg_vdi_debug_fix_val1, 128);
    PQ_RegisterWrite(VIP_reg_vdi_debug_fix_val2, 255);

        
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_0, 0);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_1, 0x08);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_2, 0x10);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_3, 24);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_4, 32);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_5, 40);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_6, 48);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_7, 56);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_8, 64);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_9, 72);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_a, 80);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_b, 88);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_c, 96);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_d, 104);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_e, 112);
    PQ_RegisterWrite(VIP_reg_vdi_ne_asd_thr_f, 120);
    
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_0, 0);
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_1, 8  );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_2, 16 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_3, 24 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_4, 32 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_5, 40 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_6, 48 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_7, 56 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_8, 64 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_9, 72 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_a, 80 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_b, 88 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_c, 96 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_d, 104);
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_e, 112);
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_thr_f, 120);
    
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_0, 0);
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_1, 8  );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_2, 16 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_3, 24 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_4, 32 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_5, 40 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_6, 48 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_7, 56 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_8, 64 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_9, 72 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_a, 80 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_b, 88 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_c, 96 );
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_d, 104);
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_e, 112);
    PQ_RegisterWrite(VIP_reg_vdi_ne_sad_asd_thr_f, 120);

    PQ_RegisterWrite(VIP_reg_dpy_flcom0_magmax, 0x37);
    PQ_RegisterWrite(VIP_reg_dpy_fl_blk_hnum, 40);
    PQ_RegisterWrite(VIP_reg_dpy_fl_blk_vnum, 30);

    //#debug mode
    PQ_RegisterWrite(VIP_reg_dpy_fl_det_dbg_en, 0);

    //#medium
    PQ_RegisterWrite(VIP_reg_dpy_fl_det_factor, 9);

    //PIP deal with the data that read from memory with 0-255 nominal range(JPEG case)
    DRV_PICX_SetRGB2YCbCrRange(ePICX_YCBCR_255);

    DRV_PICX_SetRGB2YCbCrMatrixOpt(FALSE);
    DRV_GFX_SetRGB2YCbCrMatrixOpt(FALSE);
    DRV_GFX_MemRequestOpt(ENABLE);
    DRV_VDI_SetSNR();

    PQ_RegisterWrite(VIP_reg_slr_auto_colorbar	,0x0); 
    PQ_RegisterWrite(VIP_reg_slr_detail_en		,0x0); 
    PQ_RegisterWrite(VIP_reg_slr_sat_th	        ,0x100);

    PQ_RegisterWrite(VIP_reg_dpy_gm_cfg12bit, 0);

}


#ifdef NEW_COEFFICIENT
void load_coeff_table_nodelay(UINT8 index,UINT8 table)
{
	INT32 i;
	UINT32* COEFF=(UINT32*)&V_SCALING_UP;
	UINT8 flag_noscaling_H=0;

	switch(table)
	{
	    case HCOEFF_NoScaling:
			flag_noscaling_H=1;
			break;
		case VCOEFF_ScalingUP:
			COEFF=(UINT32*)&V_SCALING_UP;
			break;
		case VCOEFF_Scaling_100_110:
			COEFF=(UINT32*)&V_SCALING_100_110;
			break;
		case VCOEFF_Scaling_110_120:
			COEFF=(UINT32*)&V_SCALING_110_120;
			break;
		case VCOEFF_Scaling_120_130:
			COEFF=(UINT32*)&V_SCALING_120_130;
			break;
		case VCOEFF_Scaling_130_140:
			COEFF=(UINT32*)&V_SCALING_130_140;
			break;
		case VCOEFF_Scaling_140_150:
			COEFF=(UINT32*)&V_SCALING_140_150;
			break;
		case VCOEFF_Scaling_150_160:
			COEFF=(UINT32*)&V_SCALING_150_160;
			break;
		case VCOEFF_Scaling_160_170:
			COEFF=(UINT32*)&V_SCALING_160_170;
			break;
		case VCOEFF_Scaling_170_180:
			COEFF=(UINT32*)&V_SCALING_170_180;
			break;
        case VCOEFF_Scaling_180_190:
			COEFF=(UINT32*)&V_SCALING_180_190;
			break;
        case VCOEFF_Scaling_190_200:
			COEFF=(UINT32*)&V_SCALING_190_200;
			break;
        case VCOEFF_Scaling_200_250:
			COEFF=(UINT32*)&V_SCALING_200_250;
			break;
        case VCOEFF_Scaling_250_300:
			COEFF=(UINT32*)&V_SCALING_250_300;
			break;
        case VCOEFF_Scaling_300_350:
			COEFF=(UINT32*)&V_SCALING_300_350;
			break;
        case VCOEFF_Scaling_350_400:
			COEFF=(UINT32*)&V_SCALING_350_400;
			break;
		case COEFF_Scaling_1:
			COEFF=(UINT32*)&SCALING_1;
			break;
		default:
			break;
	}


	PQ_RegisterWrite( VIP_reg_slr_coeff_sel, index);

	//if((flag_noscaling_V==0)&&(flag_noscaling_H==0))
	if(flag_noscaling_H==0)
	{
		for(i=0;i<=32;i++)
			mips1_word_coeff_group_nodelay( i, COEFF[3*i+0], COEFF[3*i+1], COEFF[3*i+2]);
		//  printk(KERN_EMERG"load_coeff_table_nodelay<==\n");
	}
	else
	{
		mips1_word_coeff_group_nodelay( 0, 0, 0x10000000, 0);
		//mips1_word_coeff_group_nodelay( 0, 0, 0, 0);
	}

	//if(index==2)
	//	PQ_RegisterWrite( VIP_reg_slr_coeff_sel, 0);
}//load_coeff_table~

void _PQ_FillNewCoefficient(UINT8 PRE_H_COEFF_TYPE,UINT8 POST_H_COEFF_TYPE,UINT8 V_COEFF_TYPE)
{
    load_coeff_table_nodelay((UINT8)0,PRE_H_COEFF_TYPE);
    load_coeff_table_nodelay((UINT8)2,V_COEFF_TYPE);
}

//================================================================================
//	function name		: PQ_Decide_Coefficient_Table
//	input parameter	:
//	output parameter	: none
//	purpose			: setup coefficient table in each scaler type
//   return			: none
//   modify note 		:  #34050, revision 53627, cross talk pattern unsmooth in 1280x760 or 1280x1024 pattern
//					      [how] if H size = 1280, set PRE_H_COEFF_TYPE = VCOEFF_Scaling_130_140
//                                   #35850, revision 56413, cross talk pattern unsmooth inVG858, timing:982, Patten:923, p.size/4:3
//						[how]  if H size = 1280, add V_COEFF_TYPE = VCOEFF_Scaling_250_300; 
//					    revision 59244, fonts unclear in PC, 1280x1024 panel
//                                       [how] 1. revert 2 modification above (revision 53627, revision 56413)
//                                                2. set PRE_H_COEFF_TYPE = HCOEFF_NoScaling in specific input pattern
//                                  #35850, revision 60738, cross talk pattern unsmooth inVG858, timing:982, Patten:923, p.size/4:3
//                                       [how] 1. cancel the revert in revision 59244, and modify the coefficient table setting to PRE_H_COEFF_TYPE = VCOEFF_ScalingUP;
//================================================================================
void PQ_Decide_Coefficient_Table(UINT8 ucUserSource, DRV_SLR_CONFIG eSlrConfig, UINT32 PreHfactor, UINT32 PostHfactor, UINT32 Vfactor)
{
    //the range of PreHfactor or Vfactor is 2048 * 1.1 = 2253, 2048 * 1.2 = 2458, etc...

    UINT8 PRE_H_COEFF_TYPE=0,POST_H_COEFF_TYPE=0,V_COEFF_TYPE=0;
    PRE_H_COEFF_TYPE=HCOEFF_NoScaling;
    POST_H_COEFF_TYPE=HCOEFF_NoScaling;
    V_COEFF_TYPE=VCOEFF_ScalingUP;

    // Decide PRE_H_COEFF_TYPE by PreHfactor
    //chienjen:using the same  PRE_H_COEFF table as V_COEFF table
    if(PreHfactor<2048) 			      	PRE_H_COEFF_TYPE=VCOEFF_ScalingUP;
    else if(PreHfactor==2048) 		      	PRE_H_COEFF_TYPE=HCOEFF_NoScaling;
    else if((PreHfactor>2048)&&(PreHfactor<=2253))	PRE_H_COEFF_TYPE=VCOEFF_Scaling_100_110;
    else if((PreHfactor>2253)&&(PreHfactor<=2458))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_110_120;
    else if((PreHfactor>2458)&&(PreHfactor<=2662))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_120_130;
    else if((PreHfactor>2662)&&(PreHfactor<=2867))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_130_140;
    else if((PreHfactor>2867)&&(PreHfactor<=3072))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_140_150;
    else if((PreHfactor>3072)&&(PreHfactor<=3277))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_150_160;
    else if((PreHfactor>3277)&&(PreHfactor<=3482))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_160_170;
    else if((PreHfactor>3482)&&(PreHfactor<=3686))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_170_180;
    else if((PreHfactor>3686)&&(PreHfactor<=3891))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_180_190;
    else if((PreHfactor>3891)&&(PreHfactor<=4096))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_190_200;
    else if((PreHfactor>4096)&&(PreHfactor<=5120))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_200_250;
    else if((PreHfactor>5120)&&(PreHfactor<=6144))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_250_300;
    else if((PreHfactor>6144)&&(PreHfactor<=7168))  PRE_H_COEFF_TYPE=VCOEFF_Scaling_300_350;
    else if(PreHfactor>7168)  PRE_H_COEFF_TYPE=VCOEFF_Scaling_350_400;

    if(PostHfactor == 2048 && Vfactor == 2048)
        Vfactor=2048;
    else if(PostHfactor > 2048 || Vfactor> 2048)
        Vfactor = max(PostHfactor, Vfactor);

    // Decide V_COEFF_TYPE by Vfactor
    if(Vfactor<2048 || PostHfactor<=2048)		V_COEFF_TYPE=VCOEFF_ScalingUP;
    else if((Vfactor>2048)&&(Vfactor<=2253))	V_COEFF_TYPE=VCOEFF_Scaling_100_110;
    else if((Vfactor>2253)&&(Vfactor<=2458))	V_COEFF_TYPE=VCOEFF_Scaling_110_120;
    else if((Vfactor>2458)&&(Vfactor<=2662))	V_COEFF_TYPE=VCOEFF_Scaling_120_130;
    else if((Vfactor>2662)&&(Vfactor<=2867))	V_COEFF_TYPE=VCOEFF_Scaling_130_140;
    else if((Vfactor>2867)&&(Vfactor<=3072))	V_COEFF_TYPE=VCOEFF_Scaling_140_150;
    else if((Vfactor>3072)&&(Vfactor<=3277))	V_COEFF_TYPE=VCOEFF_Scaling_150_160;
    else if((Vfactor>3277)&&(Vfactor<=3482))	V_COEFF_TYPE=VCOEFF_Scaling_160_170;
    else if((Vfactor>3482)&&(Vfactor<=3686))	V_COEFF_TYPE=VCOEFF_Scaling_170_180;
    else if((Vfactor>3686)&&(Vfactor<=3891))	V_COEFF_TYPE=VCOEFF_Scaling_180_190;
    else if((Vfactor>3891)&&(Vfactor<=4096))	V_COEFF_TYPE=VCOEFF_Scaling_190_200;
    else if((Vfactor>4096)&&(Vfactor<=5120))	V_COEFF_TYPE=VCOEFF_Scaling_200_250;
    else if((Vfactor>5120)&&(Vfactor<=6144))	V_COEFF_TYPE=VCOEFF_Scaling_250_300;
    else if((Vfactor>6144)&&(Vfactor<=7168))    V_COEFF_TYPE=VCOEFF_Scaling_300_350;
    else if(Vfactor>7168)	V_COEFF_TYPE=VCOEFF_Scaling_350_400;

    if(eSlrConfig == eSLR_CONFIG_PRE_NON_POST_NON)
    {
        PRE_H_COEFF_TYPE = HCOEFF_NoScaling;
        POST_H_COEFF_TYPE = HCOEFF_NoScaling;
        V_COEFF_TYPE = VCOEFF_ScalingUP;
    }

	if( VIP_GetInputVSize() <= 600 ) //SD
	{
		if(VIP_IsATVSource())
			V_COEFF_TYPE = VCOEFF_Scaling_110_120;
		if(VIP_IsSourceDTV())
			V_COEFF_TYPE = VCOEFF_Scaling_200_250;
	}

	if( _VIP_InputWidthEnlargeRate() > 0)
	{
	    	if(VIP_IsPCSource() &&  (PreHfactor / _VIP_InputWidthEnlargeRate())== 2048)
	    	{
	      	  PRE_H_COEFF_TYPE = HCOEFF_NoScaling;
	    	}
    	}

    if(VIP_IsPCSource() && (VIP_GetInputHSize()/_VIP_InputWidthEnlargeRate()) == 1280) // #34050
    {
        //PRE_H_COEFF_TYPE = VCOEFF_Scaling_130_140;
        //V_COEFF_TYPE = VCOEFF_Scaling_250_300; //#mantis 35850
		PRE_H_COEFF_TYPE = VCOEFF_ScalingUP;
    }

    #ifdef CONFIG_USE_TCON_OUTPUT
    if((VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource()) || (VIP_GetUserSource() == SOURCE_HDMI)) 
    {
        if(PreHfactor == 0x81b && Vfactor == 0x7cb)//#49208
        {
            if((VIP_GetAspect()==ASPECT_ZOOM2) && (VIP_GetUserSource() == SOURCE_HDMI)) //#51737
            {
                PRE_H_COEFF_TYPE = COEFF_Scaling_1;
            }
            else
            {
                PRE_H_COEFF_TYPE = VCOEFF_Scaling_190_200;    
            }
             
             V_COEFF_TYPE = VCOEFF_Scaling_170_180;
        }
        else if(PreHfactor == 2306 && Vfactor == 2310)
        {
            if((VIP_GetAspect()==ASPECT_ZOOM1) && (VIP_GetUserSource() == SOURCE_HDMI)) 
            {
                PRE_H_COEFF_TYPE = COEFF_Scaling_1;
            }
        }
    }
    #endif

	if(VIP_GetUserSource() == SOURCE_MPEG && V_COEFF_TYPE>=VCOEFF_Scaling_180_190)
		V_COEFF_TYPE = COEFF_Scaling_1;

    //==============Fill Coefficient===============
    _PQ_FillNewCoefficient(PRE_H_COEFF_TYPE,POST_H_COEFF_TYPE,V_COEFF_TYPE);
    //======================================================================
}

#endif

void mips1_word_coeff_group(UINT8 ucAddr, UINT32 dw64, UINT32 dw68, UINT32 dw6c)
{
	PQ_RegisterWrite(VIP_reg_slr_coeff_addr, ucAddr);
	PQ_RegisterWrite(VIP_reg_slr_coeff_data2, dw64);
	PQ_RegisterWrite(VIP_reg_slr_coeff_data1, dw68);
	PQ_RegisterWrite(VIP_reg_slr_coeff_data0, dw6c);

}

#ifdef NEW_COEFFICIENT
void mips1_word_coeff_group_nodelay(UINT8 ucAddr, UINT32 dw64, UINT32 dw68, UINT32 dw6c)
{
	//PQ_RegisterWrite(VIP_reg_slr_coeff_addr, ucAddr);
	//PQ_RegisterWrite(VIP_reg_slr_coeff_data2, dw64);
	//PQ_RegisterWrite(VIP_reg_slr_coeff_data1, dw68);
	//PQ_RegisterWrite(VIP_reg_slr_coeff_data0, dw6c);
    *(volatile UINT8*)(0xbe1cd060)=ucAddr;
	*(volatile unsigned long*)(0xbe1cd064)=dw64;
	*(volatile unsigned long*)(0xbe1cd068)=dw68;
	*(volatile unsigned long*)(0xbe1cd06c)=dw6c;
    //printk(KERN_EMERG"ucAddr=%d,dw64=0x%x,dw68=0x%x,dw6c=0x%x\n",ucAddr,dw64,dw68,dw6c);
}
#endif

void load_coeff_table(void)
{
	INT32 i;
	// printk(KERN_EMERG"load_coeff_table===>\n");
	for(i=0;i<3;i++)
	{
		  //2009-05-08 CJ fix HW bug
		  //SLR coeff. setting sequence :   0  ��  4  ��  5  ��  1 ��  5 �� 7  ��  6  ��  2   ��   0
		  //0, 1, 2  :  Set  oxbe1cd062 and  write/read  coeff.
		  //4, 5, 6, 7 :  Olny set  oxbe1cd062
		if(i==1)
		{
			PQ_RegisterWrite( VIP_reg_slr_coeff_sel, 4);
			PQ_RegisterWrite( VIP_reg_slr_coeff_sel, 5);
		}
		if(i==2)
		{
			PQ_RegisterWrite( VIP_reg_slr_coeff_sel, 5);
			PQ_RegisterWrite( VIP_reg_slr_coeff_sel, 7);
			PQ_RegisterWrite( VIP_reg_slr_coeff_sel, 6);
		}

		PQ_RegisterWrite( VIP_reg_slr_coeff_sel, i);
		switch(i)
		{
			//prev_h/_h
			case 0:
			case 1:
				//Because C.J's coeff. had line bugs, so use 328's h coeff
				mips1_word_coeff_group( 0, 0x00000000, 0x10000000, 0x00000000);
				mips1_word_coeff_group( 1, 0x0008FFCC, 0x10020037, 0xFFF8FFFC);
				mips1_word_coeff_group( 2, 0x000EFF99, 0x10020071, 0xFFEFFFF8);
				mips1_word_coeff_group( 3, 0x0014FF69, 0x0FFE00AE, 0xFFE5FFF4);
				mips1_word_coeff_group( 4, 0x0019FF3B, 0x0FF700EC, 0xFFDAFFF0);
				mips1_word_coeff_group( 5, 0x001EFF10, 0x0FED012E, 0xFFCEFFEC);
				mips1_word_coeff_group( 6, 0x0021FEE7, 0x0FDF0171, 0xFFC1FFE8);
				mips1_word_coeff_group( 7, 0x0024FEC0, 0x0FCE01B7, 0xFFB4FFE4);
				mips1_word_coeff_group( 8, 0x0027FE9C, 0x0FBA01FF, 0xFFA5FFE1);
				mips1_word_coeff_group( 9, 0x0028FE7B, 0x0FA20249, 0xFF96FFDD);
				mips1_word_coeff_group(10, 0x0029FE5C, 0x0F880296, 0xFF86FFDA);
				mips1_word_coeff_group(11, 0x0029FE3F, 0x0F6A02E4, 0xFF76FFD6);
				mips1_word_coeff_group(12, 0x0028FE25, 0x0F480334, 0xFF64FFD4);
				mips1_word_coeff_group(13, 0x0027FE0D, 0x0F230386, 0xFF52FFD1);
				mips1_word_coeff_group(14, 0x0026FDF8, 0x0EFB03DA, 0xFF40FFCE);
				mips1_word_coeff_group(15, 0x0024FDE5, 0x0ED00430, 0xFF2DFFCC);
				mips1_word_coeff_group(16, 0x0021FDD5, 0x0EA10486, 0xFF1AFFCA);
				mips1_word_coeff_group(17, 0x001EFDC7, 0x0E7004DF, 0xFF06FFC9);
				mips1_word_coeff_group(18, 0x001BFDBB, 0x0E3B0538, 0xFEF2FFC8);
				mips1_word_coeff_group(19, 0x0017FDB1, 0x0E030592, 0xFEDDFFC7);
				mips1_word_coeff_group(20, 0x0013FDAA, 0x0DC805ED, 0xFEC9FFC7);
				mips1_word_coeff_group(21, 0x000FFDA5, 0x0D8A0649, 0xFEB4FFC7);
				mips1_word_coeff_group(22, 0x000BFDA2, 0x0D4906A6, 0xFE9FFFC7);
				mips1_word_coeff_group(23, 0x0006FDA1, 0x0D050703, 0xFE8BFFC8);
				mips1_word_coeff_group(24, 0x0002FDA2, 0x0CBF0760, 0xFE76FFC9);
				mips1_word_coeff_group(25, 0xFFFDFDA5, 0x0C7607BD, 0xFE62FFCA);
				mips1_word_coeff_group(26, 0xFFF9FDAA, 0x0C2A081A, 0xFE4FFFCC);
				mips1_word_coeff_group(27, 0xFFF4FDB0, 0x0BDD0877, 0xFE3CFFCE);
				mips1_word_coeff_group(28, 0xFFEFFDB8, 0x0B8D08D3, 0xFE29FFD1);
				mips1_word_coeff_group(29, 0xFFEBFDC2, 0x0B3B092E, 0xFE17FFD4);
				mips1_word_coeff_group(30, 0xFFE7FDCD, 0x0AE70989, 0xFE07FFD7);
				mips1_word_coeff_group(31, 0xFFE2FDDA, 0x0A9209E3, 0xFDF7FFDB);
				mips1_word_coeff_group(32, 0xFFDEFDE8, 0x0A3B0A3B, 0xFDE8FFDE);

				break;
			//_v
			case 2:
				mips1_word_coeff_group( 0, 0x00000000, 0x10000000, 0x00000000);
				mips1_word_coeff_group( 1, 0x0000FFDC, 0x0FF70028, 0x00060000);
				mips1_word_coeff_group( 2, 0x0000FFBB, 0x0FE80052, 0x000C0000);
				mips1_word_coeff_group( 3, 0x0000FF9D, 0x0FD2007F, 0x00120000);
				mips1_word_coeff_group( 4, 0x0000FF82, 0x0FB800AF, 0x00180000);
				mips1_word_coeff_group( 5, 0x0000FF6A, 0x0F9700E1, 0x001E0000);
				mips1_word_coeff_group( 6, 0x0000FF55, 0x0F720116, 0x00230000);
				mips1_word_coeff_group( 7, 0x0000FF44, 0x0F48014D, 0x00280000);
				mips1_word_coeff_group( 8, 0x0000FF35, 0x0F190186, 0x002C0000);
				mips1_word_coeff_group( 9, 0x0000FF29, 0x0EE501C2, 0x00300000);
				mips1_word_coeff_group(10, 0x0000FF20, 0x0EAE01FE, 0x00340000);
				mips1_word_coeff_group(11, 0x0000FF19, 0x0E74023D, 0x00360000);
				mips1_word_coeff_group(12, 0x0000FF15, 0x0E36027D, 0x00390000);
				mips1_word_coeff_group(13, 0x0000FF13, 0x0DF502BF, 0x003A0000);
				mips1_word_coeff_group(14, 0x0000FF13, 0x0DB10302, 0x003A0000);
				mips1_word_coeff_group(15, 0x0000FF14, 0x0D6C0346, 0x003A0000);
				mips1_word_coeff_group(16, 0x0000FF18, 0x0D24038B, 0x00390000);
				mips1_word_coeff_group(17, 0x0000FF1D, 0x0CDA03D2, 0x00380000);
				mips1_word_coeff_group(18, 0x0000FF24, 0x0C8F0419, 0x00350000);
				mips1_word_coeff_group(19, 0x0000FF2B, 0x0C430461, 0x00320000);
				mips1_word_coeff_group(20, 0x0000FF34, 0x0BF604A9, 0x002D0000);
				mips1_word_coeff_group(21, 0x0000FF3E, 0x0BA704F3, 0x00280000);
				mips1_word_coeff_group(22, 0x0000FF49, 0x0B59053D, 0x00230000);
				mips1_word_coeff_group(23, 0x0000FF54, 0x0B090587, 0x001C0000);
				mips1_word_coeff_group(24, 0x0000FF60, 0x0ABA05D2, 0x00150000);
				mips1_word_coeff_group(25, 0x0000FF6C, 0x0A6A061E, 0x000D0000);
				mips1_word_coeff_group(26, 0x0000FF78, 0x0A1A066A, 0x00040000);
				mips1_word_coeff_group(27, 0x0000FF85, 0x09CA06B7, 0xFFFB0000);
				mips1_word_coeff_group(28, 0x0000FF92, 0x097A0704, 0xFFF10000);
				mips1_word_coeff_group(29, 0x0000FF9F, 0x092A0751, 0xFFE70000);
				mips1_word_coeff_group(30, 0x0000FFAB, 0x08DB079F, 0xFFDC0000);
				mips1_word_coeff_group(31, 0x0000FFB8, 0x088B07EE, 0xFFD00000);
				mips1_word_coeff_group(32, 0x0000FFC4, 0x083C083C, 0xFFC40000);

				break;
		}//switch~
		if(i==2)
			PQ_RegisterWrite( VIP_reg_slr_coeff_sel, 0);
	}//for~
// 	printk(KERN_EMERG"load_coeff_tabl<e===\n");
}//load_coeff_table~


void sp_w_table(void)
{
//	printk(KERN_EMERG"sp_w_table==========================>\n");
	////dclk = 240mhz/8 = 30mhz
	//mips1_byte( 0xbe1c0009,	0x8);//d clock dclk==>mclk*12/27.576 ex:19.45*12/27.576=8.46
	//mips1_byte( 0xbe1c0009,	0x4);
	//msleep(1000);

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//// MBW Config
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	//

	PQ_RegisterWrite(VIP_reg_slr_mbw_en, 0x1);
	PQ_RegisterWrite(VIP_reg_slr_mix_mbw_min, 0x0);
	PQ_RegisterWrite(VIP_reg_slr_mix_mbw_max, 0x0);
	PQ_RegisterWrite(VIP_reg_slr_mix_mbw_min_th, 0x0);
	PQ_RegisterWrite(VIP_reg_slr_mix_mbw_max_th, 0x0);
	PQ_RegisterWrite(VIP_reg_slr_mix_mbw_shift, 0x0);
	PQ_RegisterWrite(VIP_reg_slr_spw_max, 0x20);
	PQ_RegisterWrite(VIP_reg_slr_spw_min, 0x8);
	PQ_RegisterWrite(VIP_reg_slr_spw_offset, 0x6);
	PQ_RegisterWrite(VIP_reg_slr_spw_slope1, 0x40);
	PQ_RegisterWrite(VIP_reg_slr_spw_slope2, 0x20);


	//20100302 for �إ� 168c0 (avoid words blur) setting
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_hmot_th1 , 0x1);
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_hmot_th2, 8);
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_mmot_th1, 0x2);
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_mmot_th2, 8);
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_lmot_th1, 0x0);
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_lmot_th2, 0);
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_mot_th1, 0x3);
	PQ_RegisterWrite(VIP_reg_slr_mix_mb_mot_th2, 0);
	PQ_RegisterWrite(VIP_reg_slr_mix_max, 0x4);
	PQ_RegisterWrite(VIP_reg_slr_mix_min, 5);
	PQ_RegisterWrite(VIP_reg_slr_mesh_dec_th,0);
	PQ_RegisterWrite(VIP_reg_slr_mix_mbw_limit, 4);
	PQ_RegisterWrite(VIP_reg_slr_spw_th, 0x8);

}

void PQ_AffectInPanelVSync_ISR(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    
    PQ_SW_DynamicContrast_SceneChangeDetect_ISR();
    PQ_Sharpness_POST_2D(FALSE, pMenuValue->iSharpness);
    PQ_Brightness(FALSE, pMenuValue->iBrightness);
    PQ_Sharpness(FALSE, pMenuValue->iSharpness);
    PQ_DSSharpness(FALSE, pMenuValue->iSharpness);
    PQ_DPYSharpness(FALSE, pMenuValue->iSharpness);
    PQ_HorSharpness(FALSE, pMenuValue->iSharpness);
    PQ_Sharpness_POSTDCTI(FALSE,pMenuValue->iSharpness);
    PQ_Sharpness_POSTDLTI(FALSE, pMenuValue->iSharpness);
    PQ_Sharpness_Peaking_DLTI(FALSE, pMenuValue->iSharpness);
    
    if(!PQ_IsFadeEn())
    {
	    PQ_Contrast(FALSE, pMenuValue->iContrast);
    }
    
    PQ_ColorMatrixSetup(FALSE, 0);
    PQ_ColorMatrixComp(FALSE);
    PQ_CheckMotionStatusMethod2(FALSE);
    
}

void PQ_AffectInInputVSync_ISR(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    INT32 ucvdi_mot_cnt = PQ_RegisterRead(VIP_vdi_mot_cnt);
    static int ResetCount;
    static BOOL ResetFlag;

    PQ_SWDTColorBar();
    PQ_PureColorPatternDetect(20);
    PQ_DigitalScanADC2Detect();
    if((VIP_GetScalerPreScaleV() <= 576 && VIP_GetInterlaceMode() ) && PQ_GetColorProcessor() && VIP_GetColorCrossEnable())
    {
        if(ucvdi_mot_cnt >  (VIP_GetInputHSize() * (VIP_GetInputVSize()>>VIP_GetInterlaceMode()) * 20 / 100)) 
        {
           PQ_ResetColorCrossMemData(TRUE);
           PQ_SetColorCross(DISABLE);
           PQ_RegisterWrite(VIP_reg_vdi_tnr_en, 0);
           ResetCount = 2;
           ResetFlag = TRUE;
        }

        if(ResetCount > 0)
        {
            ResetCount--;
        }

        if((ResetCount == 0) && (ResetFlag == TRUE))
        {
            PQ_ResetColorCrossMemData(FALSE);
            PQ_SetColorCross(ENABLE);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_en, 1);
            ResetFlag = FALSE;
        }
    }

    PQ_Sharpness_PREDCTI(FALSE, pMenuValue->iSharpness);
    PQ_Sharpness_PREDLTI(FALSE, pMenuValue->iSharpness);	
    PQ_HmeControl();
    PQ_ChromaMotionDetectControl();
    PQ_TpwControl();	
    #ifdef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION			
    PQ_SigmaNR(FALSE, 0xff, 0xff, 0xff);
    #else
    PQ_SigmaNR(FALSE, pMenuValue->ucNRLevel, 0xff, 0xff);		
    #endif
    
}


#ifdef CONFIG_ENABLE_MIR
void mips1_MIR_word_coeff_group_nodelay(UINT8 ucAddr, UINT32 dw64, UINT32 dw68, UINT32 dw6c)
{
	mips1_byte_nodelay( 0xbe1ce060, ucAddr);
	mips1_word_nodelay(0xbe1ce064, dw64);
	mips1_word_nodelay(0xbe1ce068, dw68);
	mips1_word_nodelay(0xbe1ce06c, dw6c);
}

void load_MIR_coeff_table_nodelay(UINT8 index, UINT8 table)
{
	INT32 i;
	UINT32* COEFF=(UINT32*)&V_SCALING_UP;
	UINT8 flag_noscaling_V=0;

	switch(table)
	{
	    case HCOEFF_NoScaling:
			flag_noscaling_V=1;
			break;
		case VCOEFF_ScalingUP:
			COEFF=(UINT32*)&V_SCALING_UP;
			break;
		case VCOEFF_Scaling_100_110:
			COEFF=(UINT32*)&V_SCALING_100_110;
			break;
		case VCOEFF_Scaling_110_120:
			COEFF=(UINT32*)&V_SCALING_110_120;
			break;
		case VCOEFF_Scaling_120_130:
			COEFF=(UINT32*)&V_SCALING_120_130;
			break;
		case VCOEFF_Scaling_130_140:
			COEFF=(UINT32*)&V_SCALING_130_140;
			break;
		case VCOEFF_Scaling_140_150:
			COEFF=(UINT32*)&V_SCALING_140_150;
			break;
		case VCOEFF_Scaling_150_160:
			COEFF=(UINT32*)&V_SCALING_150_160;
			break;
		case VCOEFF_Scaling_160_170:
			COEFF=(UINT32*)&V_SCALING_160_170;
			break;
        case VCOEFF_Scaling_170_180:
			COEFF=(UINT32*)&V_SCALING_170_180;
			break;
        case VCOEFF_Scaling_180_190:
			COEFF=(UINT32*)&V_SCALING_180_190;
			break;
        case VCOEFF_Scaling_190_200:
			COEFF=(UINT32*)&V_SCALING_190_200;
			break;
        case VCOEFF_Scaling_200_250:
			COEFF=(UINT32*)&V_SCALING_200_250;
			break;
        case VCOEFF_Scaling_250_300:
			COEFF=(UINT32*)&V_SCALING_250_300;
			break;
        case VCOEFF_Scaling_300_350:
			COEFF=(UINT32*)&V_SCALING_300_350;
			break;
        case VCOEFF_Scaling_350_400:
			COEFF=(UINT32*)&V_SCALING_350_400;
			break;
		default: //case VCOEFF_Scaling_195_250 COEFF=(DWORD*)&V_SCALING_UP;
			break;
	}


	if(flag_noscaling_V==0)
	{
		for(i=0;i<=32;i++)
			mips1_MIR_word_coeff_group_nodelay( i, COEFF[3*i+0], COEFF[3*i+1], COEFF[3*i+2]);
	}
	else
	{
		mips1_MIR_word_coeff_group_nodelay( 0, 0, 0x10000000, 0);	//??
	}

}//load_coeff_table~


void PQ_MIR_FillNewCoefficient(UINT8 V_COEFF_TYPE)
{
	load_MIR_coeff_table_nodelay((UINT8)0,V_COEFF_TYPE);

}


void PQ_MIR_Decide_Coefficient_Table(UINT32 Hfactor)
{

	UINT8 V_COEFF_TYPE=0;

	V_COEFF_TYPE=HCOEFF_NoScaling;

   if(Hfactor<2048)                     V_COEFF_TYPE=VCOEFF_ScalingUP;
   else if(Hfactor==2048)               V_COEFF_TYPE=HCOEFF_NoScaling;
   else if((Hfactor>2048)&&(Hfactor<=2253))  V_COEFF_TYPE=VCOEFF_Scaling_100_110;
   else if((Hfactor>2253)&&(Hfactor<=2458))  V_COEFF_TYPE=VCOEFF_Scaling_110_120;
   else if((Hfactor>2458)&&(Hfactor<=2662))  V_COEFF_TYPE=VCOEFF_Scaling_120_130;
   else if((Hfactor>2662)&&(Hfactor<=2867))  V_COEFF_TYPE=VCOEFF_Scaling_130_140;
   else if((Hfactor>2867)&&(Hfactor<=3072))  V_COEFF_TYPE=VCOEFF_Scaling_140_150;
   else if((Hfactor>3072)&&(Hfactor<=3277))  V_COEFF_TYPE=VCOEFF_Scaling_150_160;
   else if((Hfactor>3277)&&(Hfactor<=3482))  V_COEFF_TYPE=VCOEFF_Scaling_160_170;
   else if((Hfactor>3482)&&(Hfactor<=3686))  V_COEFF_TYPE=VCOEFF_Scaling_170_180;
   else if((Hfactor>3686)&&(Hfactor<=3891))  V_COEFF_TYPE=VCOEFF_Scaling_180_190;
   else if((Hfactor>3891)&&(Hfactor<=4096))  V_COEFF_TYPE=VCOEFF_Scaling_190_200;
   else if((Hfactor>4096)&&(Hfactor<=5120))  V_COEFF_TYPE=VCOEFF_Scaling_200_250;
   else if((Hfactor>5120)&&(Hfactor<=6144))  V_COEFF_TYPE=VCOEFF_Scaling_250_300;
   else if((Hfactor>6144)&&(Hfactor<=7168))  V_COEFF_TYPE=VCOEFF_Scaling_300_350;
   else if(Hfactor>7168)  V_COEFF_TYPE=VCOEFF_Scaling_350_400;


	VIPDebugPrint("%s:Hfactor = %d, V_COEFF_TYPE = %d",__FUNCTION__, Hfactor, V_COEFF_TYPE);

	//==============Fill Coefficient===============
	PQ_MIR_FillNewCoefficient(V_COEFF_TYPE);
	//======================================================================


}
#endif


// (1) re caculate PWM period by PWM freq (2) re caculate LCDBackLightMap
void PQ_SETPWMFreq(UINT32 PWMFreq)
{
//#ifndef CONFIG_PANEL_ADJ_INVERT
	PBRVIP_FLASH brvip_flash_p = (PBRVIP_FLASH)SPI_PANELSET_SHADOWADDR;
//#endif
	UINT32 nBLBase;
	UINT32 dwBackLightAddrPeroid;
	UINT32 dwBackLightAddr= 0;
    UINT32 nPeroidmmiVale, nBackLightmmiVale;
	UINT8 i;
	UINT32 mapValue = 0;
    UINT16 uwMaxduty, uwMinduty;
		//get duty
#ifdef CONFIG_SUPPORT_PWMFrequency_SaveIn_FactoryMode
	ptv_base_t ptvdev = getptvdev();
	ptvdev->pBootRomShareData->PwmFreq = PWMFreq;
	ptvdev->bflashsetting = TRUE;
#endif
	dwBackLightAddrPeroid = REG_ADR1_PWM0_BACKLIGHT + (PQ_GetPanelPWMNum() * 8);
    nPeroidmmiVale = *((UINT32 *)(dwBackLightAddrPeroid));
	dwBackLightAddr= REG_ADR2_PWM0_BACKLIGHT + PQ_GetPanelPWMNum() * 8;
    nBackLightmmiVale = *((UINT32 *)(dwBackLightAddr)) & 0xfffffff;
	//nDutyValue = nBackLightmmiVale*100/nPeroidmmiVale;

	if(PWMFreq <= 0)//check PWMFreq vaild
		PWMFreq = 1;

	//1.duty first 0
	//*((UINT32 *)(dwBackLightAddr))= 0;

	//2.set freq
	nBLBase = REFCLK*1000/PWMFreq;
	*((UINT32 *)(dwBackLightAddrPeroid)) = nBLBase-1;

	//3.set duty
	*((UINT32 *)(dwBackLightAddr)) = 0;		// reset PWM
	if((nPeroidmmiVale*PWMFreq) > 0)
	{
		mapValue = REFCLK*1000*nBackLightmmiVale/(nPeroidmmiVale*PWMFreq) | 0x80000000;
	}
	//*((UINT32 *)(dwBackLightAddr)) = mapValue | 0x80000000;
	PQ_ChangeBackLight(mapValue, 1);

    PQ_get_PWM_Duty(&uwMaxduty, &uwMinduty);
	
#if 0//def CONFIG_PANEL_ADJ_INVERT
	#ifdef CONFIG_SUPPORT_PWM_DUTY_IN_DECIMAL
	LCDBackLightMap[0] = nBLBase*uwMaxduty/1000;
	LCDBackLightMap[14] = nBLBase*uwMinduty/1000;
	#else
	LCDBackLightMap[0] = nBLBase*uwMaxduty/100;
	LCDBackLightMap[14] = nBLBase*uwMinduty/100;
	#endif

	for (i = 0; i< 15; i++)
	{
		LCDBackLightMap[i] = LCDBackLightMap[0]-(LCDBackLightMap[0]-LCDBackLightMap[14])*i/14;
	}

#else
	if(brvip_flash_p->LCDBackLight_Order)
	{
	    #ifdef CONFIG_SUPPORT_PWM_DUTY_IN_DECIMAL
        LCDBackLightMap[0] = nBLBase*uwMaxduty/1000;
		LCDBackLightMap[14] = nBLBase*uwMinduty/1000;
        #else
		LCDBackLightMap[0] = nBLBase*uwMaxduty/100;
		LCDBackLightMap[14] = nBLBase*uwMinduty/100;
        #endif

		for (i = 0; i< 15; i++)
    	{
    		LCDBackLightMap[i] = LCDBackLightMap[0]-(LCDBackLightMap[0]-LCDBackLightMap[14])*i/14;
    	}
	}
	else
	{
	    #ifdef CONFIG_SUPPORT_PWM_DUTY_IN_DECIMAL
        LCDBackLightMap[14] = nBLBase*uwMaxduty/1000;
		LCDBackLightMap[0] = nBLBase*uwMinduty/1000;
        #else
		LCDBackLightMap[14] = nBLBase*uwMaxduty/100;
		LCDBackLightMap[0] = nBLBase*uwMinduty/100;
        #endif


		for (i = 0; i< 15; i++)
	    	{
	    		LCDBackLightMap[i] = LCDBackLightMap[0]+(LCDBackLightMap[14]-LCDBackLightMap[0])*i/14;
	             //myprintk("after LCDBackLightMap[%d] = 0x%x", i, LCDBackLightMap[i]);
	    	}
	}
#endif

#ifdef DYNAMIC_BACKLIGHT
	PQ_InitDynamicBackLight();
#endif

}

UINT32 PQ_GETCurrPWMFreq(void)
{
    UINT32 dwBackLightAddrPeroid;
    UINT32 nBLBase, uiPWMFreq;

    dwBackLightAddrPeroid = REG_ADR1_PWM0_BACKLIGHT + (PQ_GetPanelPWMNum() * 8);
    nBLBase = *((UINT32 *)(dwBackLightAddrPeroid));

	if(nBLBase == 0)
		nBLBase = 1;
	
    uiPWMFreq = REFCLK*1000/nBLBase;
    return uiPWMFreq;
}

UINT32 PQ_GETCurrPWM(void)
{
    UINT32 dwBackLightAddr;
    UINT32 nBLBase;

    dwBackLightAddr= REG_ADR2_PWM0_BACKLIGHT + PQ_GetPanelPWMNum() * 8;
    nBLBase = *((UINT32 *)(dwBackLightAddr)) & 0xfffffff;

    if(nBLBase == 0)
        nBLBase = 1;
    return nBLBase;
}


void PQ_SetPWMOff(BOOL bStatus)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

	pHwContext->bPWMOff = bStatus;
}

UINT32 PQ_GETCurrDutyPWM(void)
{
    UINT32 dwBackLightAddrPeroid;
	UINT32 dwBackLightAddr= 0;
    UINT32 nPeroidmmiVale, nBackLightmmiVale,nDutyValue = 0;

    dwBackLightAddrPeroid = REG_ADR1_PWM0_BACKLIGHT + (PQ_GetPanelPWMNum() * 8);
    nPeroidmmiVale = *((UINT32 *)(dwBackLightAddrPeroid));

	dwBackLightAddr= REG_ADR2_PWM0_BACKLIGHT + PQ_GetPanelPWMNum() * 8;
    nBackLightmmiVale = *((UINT32 *)(dwBackLightAddr)) & 0xfffffff;

	if(nPeroidmmiVale > 0)
	{
#ifdef CONFIG_SUPPORT_PWM_DUTY_IN_DECIMAL
		nDutyValue = nBackLightmmiVale*1000/nPeroidmmiVale;
#else
		nDutyValue = nBackLightmmiVale*100/nPeroidmmiVale;
#endif
	}
    return nDutyValue;
}

void PQ_SETCurrDutyPWM(UINT16 uwDuty)
{
    UINT32 dwBackLightAddrPeroid;
    UINT32 nPeroidmmiVale, nPWMValue;

    dwBackLightAddrPeroid = REG_ADR1_PWM0_BACKLIGHT + (PQ_GetPanelPWMNum() * 8);
    nPeroidmmiVale = *((UINT32 *)(dwBackLightAddrPeroid));

#ifdef CONFIG_SUPPORT_PWM_DUTY_IN_DECIMAL
    nPWMValue = nPeroidmmiVale*uwDuty/1000;
    if(uwDuty != 0 && nPWMValue == 0)
    {
        nPWMValue = 0x1;
    }
#else
    nPWMValue = nPeroidmmiVale*uwDuty/100;
#endif
    PQ_SetRealBackLight(nPWMValue);

}



UINT32 PQ_GETCurrPolarity(void)
{
    UINT32 uiPolarity;
//#ifndef CONFIG_PANEL_ADJ_INVERT
	PBRVIP_FLASH brvip_flash_p = (PBRVIP_FLASH)SPI_PANELSET_SHADOWADDR;
//#endif
#if 0//def CONFIG_PANEL_ADJ_INVERT
	uiPolarity = 1;
#else
	uiPolarity = brvip_flash_p->LCDBackLight_Order;
#endif
	return uiPolarity;
}


/****************************************************************************
  * Function  : PQ_GETCurrElectricity
  * Params    : n/a
  * Description: get the PWM value and mapping to electricity table
  * Returns    :  return the mapping electricity value
****************************************************************************/
UINT32 PQ_GETCurrElectricity(void)
{
    DYNAMIC_BACKLIGHT_PARAM* pDBL= &g_DynamicBackLight;
    UINT32 i;
    UINT32 dwcurrentDuty;
    
    dwcurrentDuty = PQ_GETCurrDutyPWM();

    for(i = 0; i < pDBL->Electricity_PWM_table_Size; i++)
    {
        if(pDBL->pElectricity_PWM_table[i].PWM_Value == dwcurrentDuty)
        {
            return pDBL->pElectricity_PWM_table[i].Electity_Value;
        }
    }

    return 0;
}


UINT8 PQ_GetPanelPWMNum(void)
{
    CUSTIMIZATION_TABLEPTR pCustimizationBase= (CUSTIMIZATION_TABLEPTR) SPI_OPTIONDATA_SHADOWADDR;
    #ifdef CONFIG_PANEL_ADJ_AS_GPIO
    return pCustimizationBase->PanelBackLightGPIONum;
    #else
    return pCustimizationBase->PanelPWMNum;
    #endif
    
}


//****************************************************************************
//
//   Function   : PQ_SetFilmMode
//   Params    :
//   Description: Enable/Disable 2:2 pulldown or 2:3 pulldown detection
//   Returns    : void
//****************************************************************************

void PQ_SetFilmMode(UINT8 ucEnable)
{
    UINT32 vdi_hsize_i,vdi_vsize,vdi_total;

    vdi_hsize_i= VIP_GetScalerPreScaleH(); //= (reg_adix_che-reg_adix_chs) * 2048 / reg_slr_hfactor
    vdi_vsize= PQ_Get_VDI_VSize(); //= reg_adix_cve-reg_adix_cvs
    vdi_total= vdi_hsize_i*vdi_vsize;

    if( ucEnable)
    {
        PQ_RegisterWrite(VIP_reg_vdi_32qual_22result, 0);

        if(VIP_GetUserSource() == SOURCE_CVD2 && VIP_IsAVSource())//KW request 2012/11/06
        {
            PQ_RegisterWrite(VIP_reg_vdi_combcnt_fm_same_thd, 0x450);
            PQ_RegisterWrite(VIP_reg_vdi_combcnt_hm_fs_thd, 0x450);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_vdi_combcnt_fm_same_thd, vdi_total/115);
            PQ_RegisterWrite(VIP_reg_vdi_combcnt_hm_fs_thd, vdi_total/58);
        }
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_vdi_32qual_22result, 1);
        PQ_RegisterWrite(VIP_reg_vdi_combcnt_fm_same_thd, 0x5);
        PQ_RegisterWrite(VIP_reg_vdi_combcnt_hm_fs_thd, 0x5);
    }
}

/*******************************************************************
//	function name		: PQ_SetNotFullScreenPatchStatus & PQ_GetNotFullScreenPatchStatus
//	input parameter	: bStatus : if not full screen, set true
//	output parameter	: none
//	purpose			: patch for 131 sharpness bug, HW will fix it next chip
//   return			: none
*******************************************************************/
void PQ_SetNotFullScreenPatchStatus(BOOL bStatus)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;

	pHwContext->bNotFullScreen = bStatus;
       PQ_RegisterWrite(VIP_reg_dpy_filter_chroma, bStatus);
	PQ_PeakingFilterSetup();  

}

UINT8 PQ_GetNotFullScreenPatchStatus(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;

	return pHwContext->bNotFullScreen;
}

UINT32 PQ_Get_VDI_VSize(void)
{
    UINT8 ucInterlaceMode;
    UINT32 vdi_vsize;

    ucInterlaceMode = VIP_GetInterlaceMode();
    if(ucInterlaceMode < 2)
    {
        vdi_vsize = VIP_GetlInputCaptureVSize()>>ucInterlaceMode;
        return vdi_vsize;
    }
    else
    {
        return 0;
    }
}


void PQ_SetColorCross(BOOL ucEnable)
{
    if(ucEnable == DISABLE)
    {
        PQ_RegisterWrite(VIP_REG_H602F_CROSS, 0);
        return;
    }

    if(VIP_GetInputVSize()==576 && VIP_GetInterlaceMode()==TRUE)
    {
        PQ_RegisterWrite(VIP_REG_H602F_CROSS, 0xf);
    }
    else
    {
        PQ_RegisterWrite(VIP_REG_H602F_CROSS, 0x3);
    }
    
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_VCOMB_Y, 0x20);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TOGGLE_MAX, 0x48);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TOGGLE_MIN, 0x4);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TOGGLE_GAIN, 0x40);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TOGGLE_GAIN_C, 0x80);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TOGGLE_DIV_C, 0x8);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_MAX, 0xc0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_INC, 0x3);

    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_DEC0, 0x1);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_DEC1, 0x2);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_DEC2, 0x8);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_DEC3, 0x10);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_DEC4, 0x14);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_DEC5, 0x18);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_DEC6, 0x20);
    

    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_ALPHA_SUB, 0x5);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_ALPHA_MUL, 0x8);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_ALPHA_DIV, 0x5);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_ALPHA_MAX, 0x20);

    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TOGGLE_MAX, 210);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TOGGLE_MIN, 0x10);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_MAX, 192);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_INC0, 0x3);

    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_INC1, 0x2);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_INC2, 0x1);
    mips1_byte_nodelay( 0xbe1c6095, 0x1);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_DEC0, 0x1);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_DEC1, 0x2);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_DEC2, 0x8);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_DEC3, 0x10);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_DEC4, 0x14);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_DEC5, 0x18);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_DEC6, 0x20);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_ALPHA_SUB, 0x5);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_ALPHA_MUL, 0x8);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_ALPHA_DIV, 0x5);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_ALPHA_MAX, 0x20);

    mips1_byte_nodelay( 0xbe1c60bf, 0x11); //no used any more

    PQ_RegisterWrite(VIP_REG_VDI_CROSSYC_FD_CHG_THD_CUR, 0x1ffff);
    PQ_RegisterWrite(VIP_REG_VDI_CROSSYC_FD_CHG_MBW_THD, 0xffff);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_HPY_THR, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_HPY_DEC, 0x4);	
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_STDY_THR, 0x21f);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_STDC_THR, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_STDY_THR1, 0xff);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_STDC_THR1, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_OPTION, 0xe);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_INC3, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_INC4, 0x1);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_CHROMA_DIF, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_CHROMA_SLP, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_HPC_THR, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_HPC_DEC, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_HPY_THR, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_HPY_DEC, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_STDY_THR, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_STDC_THR, 0x21f);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_STDY_THR1, 0);
    PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_STDC_THR1, 0x1);
    PQ_RegisterWrite(VIP_REG_VDI_Y2C_CTL, 0x1);
    PQ_RegisterWrite(VIP_REG_VDI_C2Y_CTL, 0x1);
    PQ_RegisterWrite(VIP_REG_VDI_Y2C_FC_TH, 0x68);
    PQ_RegisterWrite(VIP_REG_VDI_Y2C_CMOT_DEC, 0x6);
    PQ_RegisterWrite(VIP_REG_VDI_Y2C_CMOT_TH, 0x60);
    PQ_RegisterWrite(VIP_REG_VDI_Y2C_SAT_TH, 0xa);
    PQ_RegisterWrite(VIP_REG_VDI_C2Y_SAT_TH, 0x10);
    PQ_RegisterWrite(VIP_REG_VDI_C2Y_LSAT_DEC, 0);

}

void PQ_GetRGBGainAdjustModuleCmd(UINT8 *param)
{
      #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
	param[0] = 0;
      #else
      param[0] = 1;
      #endif
}

void PQ_GetRGBGainParamCmd(RGB_GAIN *param)
{
      #ifdef CONFIG_WHITE_BALANCE_ADJUST_IN_DPY_MATRIX 
      RGBGain_Param[0].RGBGain[0] = 1024;
      RGBGain_Param[0].RGBGain[1] = 1024;
      RGBGain_Param[0].RGBGain[2] = 1024;
      #else
      PQHW_CONTEXT* pHwContext= &PQHwContext;
      RGBGain_Param[0].RGBGain[0] = pHwContext->iRGain;
      RGBGain_Param[0].RGBGain[1] = pHwContext->iGGain;
      RGBGain_Param[0].RGBGain[2] = pHwContext->iBGain;
      #endif
      *param = RGBGain_Param[0];
      //*param = SWDC_Param[0];
}

/**
 * @brief reset the memory data for cross luma/chroma
 *
 * This function reset cross luma\chroma related data in memory, to resolved function 
 * delay 1-2 sec after scene change. resume the function after 3 frame 
 *
 * @param bReset, 1 for reset memory data, 0 for recover setting
 * @return n/a
*/
void PQ_ResetColorCrossMemData(BOOL bReset)
{
    if(bReset)
    {
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_MAX, 0);
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_MAX, 0);
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_ALPHA_MAX, 0);
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_ALPHA_MAX, 0);

    }
    else
    {
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_TC_MAX, 0xc0);
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_TC_MAX, 192);
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2Y_ALPHA_MAX, 0x20);
        PQ_RegisterWrite(VIP_REG_VDI_CROSS2C_ALPHA_MAX, 0x20);

    }
    
}


BOOL PQ_CheckCvd2NonSTDStatus(void)
{
#ifdef DRV_ENABLE_CVD2
    UINT8 CVD2LockStatus = 0;
    cvd2_TypeSigSTD CVD2_Non_standard;
    UINT8 ucUserSource, ucSubSource;

    VIP_GetSource(&ucUserSource, &ucSubSource);
    if(ucUserSource != SOURCE_CVD2)
    {
        return FALSE;
    }

    DRV_CVD2_Get_LockStatus(&CVD2LockStatus); 
    if((CVD2LockStatus & (hlock|vlock) )== (hlock|vlock))
    {
        DRV_CVD2_CheckNonSTDStatus(&CVD2_Non_standard);	//0x1
        if(CVD2_Non_standard.horizontal_nSTD || CVD2_Non_standard.vertical_nSTD)
        {
            return TRUE;
        }
    }
#endif
    return FALSE;
}


void PQ_SetJPEGDisplayModePatch(UINT8 ucDisplayMode)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;
    
    if(ucDisplayMode == VIP_THUMBNAIL)
    {
        pHwContext->PqPatch.Post2DPatch = POST_2D_SHARPNESS_JPEG_THUMBNAIL_PATCH;
        pHwContext->PqPatch.PostDLTIPatch = POST_DLTI_JPEG_THUMBNAIL_PATCH;
        pHwContext->PqPatch.DPYSharpnessPatch = DPY_SHARPNESS_JPEG_THUMBNAIL_PATCH;
    }
    else
    {
        pHwContext->PqPatch.Post2DPatch = POST_2D_SHARPNESS_DEFAULT;
        pHwContext->PqPatch.PostDLTIPatch = POST_DLTI_DEFAULT;
        pHwContext->PqPatch.DPYSharpnessPatch = DPY_SHARPNESS_DEFAULT;
    }

    PQ_Sharpness_POST_2D(TRUE, pMenuValue->iSharpness);
    PQ_Sharpness_POSTDLTI(TRUE, pMenuValue->iSharpness);
    PQ_DPYSharpness(TRUE, pMenuValue->iSharpness);

}