UTS6710/drivers/pq/533/pq_hw.c

#include "osdef.h" //joshua check
#include <linux/delay.h>
#include <linux/types.h>
#include "pq_hw.h"
#include "../../vip/533/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"

#define VIP_DBL_INVALID_WHITE_LEVEL	0xffffffff

PQHW_CONTEXT	PQHwContext;

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

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

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


//#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[];

//===================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);


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]));
		}

		 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 ;
	BOOL bEnableEnhancedColor;
	UINT32 tmp = 0;
	INT32 i;
    UINT8 ucTableIndex;

    UINT8 ucCurrSrcIndex = PQ_Get_Source_Grouped_Index();
    COLOR_MATRIX_DATA *pCOLOR_MATRIX_DATA;

    ucTableIndex = pVtab->mColorMatrix.mGroupedIndex[ucCurrSrcIndex];
    pCOLOR_MATRIX_DATA = &pVtab->mColorMatrix.mSrcColorMatrix[ucTableIndex];
	i = 0;

	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() == 0 )
		{
			p601ColorSpaceTable = ColorSpaceTableYCC_Limit601;
			p709ColorSpaceTable = ColorSpaceTableYCC_Limit709;
		}
		else if( VIP_GetRGB2YCbCrRange() == 1 )
		{
			p601ColorSpaceTable = ColorSpaceTableYCC_Full601;
			p709ColorSpaceTable = ColorSpaceTableYCC_Full709;
		}
		else
		{
			p601ColorSpaceTable = ColorSpaceTableYCC_Limit601;
			p709ColorSpaceTable = ColorSpaceTableYCC_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( 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];
	}
	else //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;
				}
				else
				{
					pColorSpaceTable = p601ColorSpaceTable;
				}
			}
		}
		else	//ypp format
		{

			switch(VIP_GetInputColorStandard())
			{
				case YCC_709:
					pColorSpaceTable=p709ColorSpaceTable;
					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;
					else
						pColorSpaceTable=p601ColorSpaceTable;
					break;
			}
		}
	}

	if(VIP_IsJPEGSource())
	{
		if(VIP_GetInputDataFormat() == RGB)
		{
			pColorSpaceTable =ColorSpaceBMP;
			PQ_RegisterWrite(VIP_reg_dpy_ypp, 0);
		}
		else
		{
			pColorSpaceTable =ColorSpaceJPEG;
  			PQ_RegisterWrite(VIP_reg_dpy_ypp, 1);
		}
	}
	else if(VIP_GetInputDataFormat() != RGB)
	{
		PQ_RegisterWrite(VIP_reg_dpy_ypp, 1);
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_dpy_ypp, 0);
	}

	pHwContext->CurColorMatrix = (CSC_SETTING*)pColorSpaceTable;

//	PQ_RegisterWrite(VIP_reg_dpy_hsy_bypass, DISABLE);
	//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);
		PQ_RegisterWrite(VIP_reg_picx_rgb2ycbcr_235, 0);
		if((VIP_IsInputDataFormatBGR()==TRUE) && (VIP_IsJPEGSource() ==TRUE))
		{
			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_rgb2ycbcr_235, 0);
		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_ypp, DISABLE);  //request by VIP HW

/*
	//add clip setting
	if(pColorSpaceTable==ColorSpaceTableJPEGRGB)
	{
		PQ_RegisterWrite(VIP_reg_dpy_mtx_min_yuv, 0);
		PQ_RegisterWrite(VIP_reg_dpy_mtx_max_uv, 1023);
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_dpy_mtx_min_yuv, 64);
		PQ_RegisterWrite(VIP_reg_dpy_mtx_max_uv, 963);

	}

*/
	PQ_RegisterWrite(VIP_reg_dpy_mtx_min_yuv, 	0);
	PQ_RegisterWrite(VIP_reg_dpy_mtx_max_y,		1023);
	PQ_RegisterWrite(VIP_reg_dpy_mtx_max_uv, 	1023);

	//#if prevent_DPY_from_clamping_input_YCC_16_235
	//	if(pHwContext->bEnableColorProcess)
	//	PQ_RegisterWrite(VIP_reg_dpy_ypp, ENABLE);//2009-03-10 CC==> To prevent DPY from clamping input YCC to 16-235.
	//else
	//	PQ_RegisterWrite(VIP_reg_dpy_ypp, DISABLE);
	//#else
	//PQ_RegisterWrite(VIP_reg_dpy_ypp, DISABLE);
	//#endif
	//PQ_RegisterWrite(VIP_reg_dpy_yuv_int, ENABLE);
	//PQ_RegisterWrite(VIP_reg_dpy_rgn_int, pHwContext->bSetupCRLuma?DISABLE:ENABLE);
	if(VIP_GetScreenOnSt() )
		PQ_SetColorMatrix(DISABLE);
		//PQ_RegisterWrite(VIP_reg_dpy_matrix_bypass, DISABLE);

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

	//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]);
	//pHwContext->iColorMatrixC1=pColorSpaceTable[9];
	//pHwContext->iColorMatrixC2= pColorSpaceTable[10];
	//pHwContext->iColorMatrixC3= pColorSpaceTable[11];

	//matrix_aXX are set only when rgb_int= 0
	/*
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a11, pColorSpaceTable[0]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a12, pColorSpaceTable[1]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a13, pColorSpaceTable[2]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a21, pColorSpaceTable[3]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a22, pColorSpaceTable[4]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a23, pColorSpaceTable[5]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a31, pColorSpaceTable[6]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a32, pColorSpaceTable[7]);
	PQ_RegisterWrite(VIP_reg_dpy_matrix_a33, pColorSpaceTable[8]);
	*/

	PQ_RegisterWrite(VIP_reg_dpy_u_reset,DISABLE);

	bEnableEnhancedColor= pHwContext->bEnableColorProcess;

#if 0
	//always open brightness, contrast and hue function
	bEnableColor= TRUE;
#endif


	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_uv,	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_uv,	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_uv,	1023);
      	}
	else
	{
		ucYUVOffset=8;
 
		PQ_RegisterWrite(VIP_reg_dpy_mtx_max_y, 	1023-ucYUVOffset);
		PQ_RegisterWrite(VIP_reg_dpy_mtx_max_uv,	1023-ucYUVOffset);
	}
}


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

	//set color standard when jpeg to avoid it set the same as last source
	if(ucInputSource == SOURCE_JPEG)
		VIP_SetInputColorStandard(PQ_COLOR_SPACE_NORMAL);

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

		pHwContext->nColorSpaceMode= ucMode;
		//setup color space
		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);

}

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

//****************************************************************************
//   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_Init(void)
{
    //685e 0xbb
    PQ_NR_TnrzEnable();
    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,    1);     //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);
}


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;
	//PQDebugPrint("ucItemID=%d ucDegree=%d\n",ucItemID, ucDegree);
	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:
		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);
		//PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_gain_inc, VIP_IsATVSource()?0x7f:0x20);


		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);
		PQ_RegisterWrite(VIP_reg_vdi_snr_hl_trans, 0x10);
		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:
		PQ_RegisterWrite(VIP_reg_vdi_snr_vl_smooth, 0x22);
		PQ_RegisterWrite(VIP_reg_vdi_snr_vl_trans, 16);
		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);
		}
		PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring, 0xc);
		PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring_th1, 0x4);
		PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring_th2,0x6);
		PQ_RegisterWrite(VIP_reg_vdi_snr_hc_coring_th3, 0x11);
		break;
	case PQ_ITEM_CHROMA_SNR_STRENGTH:
		PQ_RegisterWrite(VIP_reg_vdi_snr_hc_trans, 0x2c);
        PQ_RegisterWrite(VIP_reg_vdi_snr_hc_smooth, CSNRStrength[ucDegree].vdi_snr_hc_smooth);
		break;
	case PQ_ITEM_SNR1_ULTRA_LOW:
			PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_hl_coring, 0x30);
			PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th3, 0x800);
		break;
	case PQ_ITEM_SNR2_ULTRA_LOW:
		PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_vl_coring, 0x30);


		PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_th3, 0x800);
		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);
	#if 0
		//2009-07-31 JY and bonnine request...............
		//mnr filter in vertical direction:for all path except for ATV and DTV tuner be1c613a=0x1c
		if((!(VIP_IsATVSource()))&&(VIP_GetUserSource()!=SOURCE_MPEG))
			PQ_RegisterWrite(VIP_reg_vdi_mnr_v_coring_inc,0x1c);
		else
			PQ_RegisterWrite(VIP_reg_vdi_mnr_v_coring_inc, pMosquitoNrCoring->vdi_mnr_v_coring_inc);
	#else
		PQ_RegisterWrite(VIP_reg_vdi_mnr_v_coring_inc, pMosquitoNrCoring->vdi_mnr_v_coring_inc);
	#endif
		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;
    }

    //VIPDebugPrint("%s %d, ucCurrSrcIndex = %d\n",__FUNCTION__, __LINE__, ucCurrSrcIndex);
    ucTableIndex = pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex];
    //VIPDebugPrint("%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;
	
    //VIPDebugPrint("%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;
        }
    }
}




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;   
                
    }
}

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);	
}

BOOL PQ_SWDTColorBar(void)
{
#if 1
	UINT8 i=0,dis_th=0, act_th=2;
	UINT8 c_bin_cnt=0;
//  UINT32 cb00,cb01,cb02,cb03,cb04,cb05,cb06,cb07,cb08,cb09,cb10,cb11,cb12,cb13,cb14,cb15,cb16,cb17;
	UINT32 ulHunBinNum[18];
	UINT32 CaptureWindowSize=0;

	PQ_RegisterWrite(VIP_reg_slr_auto_colorbar	,0x0); 
	PQ_RegisterWrite(VIP_reg_slr_detail_en		,0x0); 
	PQ_RegisterWrite(VIP_reg_slr_detail_cnt_en	,0x0);
	PQ_RegisterWrite(VIP_reg_slr_sat_th	        ,0x100);

	ulHunBinNum[0]=PQ_RegisterRead(VIP_c_bin00_pre);
	ulHunBinNum[1]=PQ_RegisterRead(VIP_c_bin01_pre);
	ulHunBinNum[2]=PQ_RegisterRead(VIP_c_bin02_pre);
	ulHunBinNum[3]=PQ_RegisterRead(VIP_c_bin03_pre);
	ulHunBinNum[4]=PQ_RegisterRead(VIP_c_bin04_pre);
	ulHunBinNum[5]=PQ_RegisterRead(VIP_c_bin05_pre);
	ulHunBinNum[6]=PQ_RegisterRead(VIP_c_bin06_pre);
	ulHunBinNum[7]=PQ_RegisterRead(VIP_c_bin07_pre);
	ulHunBinNum[8]=PQ_RegisterRead(VIP_c_bin08_pre);
	ulHunBinNum[9]=PQ_RegisterRead(VIP_c_bin09_pre);
	ulHunBinNum[10]=PQ_RegisterRead(VIP_c_bin10_pre);
	ulHunBinNum[11]=PQ_RegisterRead(VIP_c_bin11_pre);
	ulHunBinNum[12]=PQ_RegisterRead(VIP_c_bin12_pre);
	ulHunBinNum[13]=PQ_RegisterRead(VIP_c_bin13_pre);
	ulHunBinNum[14]=PQ_RegisterRead(VIP_c_bin14_pre);
	ulHunBinNum[15]=PQ_RegisterRead(VIP_c_bin15_pre);
	ulHunBinNum[16]=PQ_RegisterRead(VIP_c_bin16_pre);
	ulHunBinNum[17]=PQ_RegisterRead(VIP_c_bin17_pre);
	
	
	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++)
	{
		if(CaptureWindowSize > 0)	
		ulHunBinNum[i] = (100*ulHunBinNum[i])/CaptureWindowSize;
	}	
	
	c_bin_cnt=0;

	for(i=0;i<18;i++)
	{
		if ((i==0)&&((ulHunBinNum[0]>act_th)&&
			         (((ulHunBinNum[17]<=dis_th)&&((ulHunBinNum[1]<=dis_th)||(ulHunBinNum[2]<=dis_th)))||
			          ((ulHunBinNum[1]<=dis_th)&&((ulHunBinNum[17]<=dis_th)||(ulHunBinNum[16]<=dis_th))))))    
			c_bin_cnt = c_bin_cnt + 1;	
		else if ((i==1)&&((ulHunBinNum[1]>act_th)&&
			              (((ulHunBinNum[0]<=dis_th)&&((ulHunBinNum[2]<=dis_th)||(ulHunBinNum[3]<=dis_th)))||
			               ((ulHunBinNum[2]<=dis_th)&&((ulHunBinNum[0]<=dis_th)||(ulHunBinNum[17]<=dis_th))))))    
			c_bin_cnt = c_bin_cnt + 1;	
		else if ((i==2)&&((ulHunBinNum[2]>act_th)&&
			              (((ulHunBinNum[1]<=dis_th)&&((ulHunBinNum[3]<=dis_th)||(ulHunBinNum[4]<=dis_th)))||
			               ((ulHunBinNum[3]<=dis_th)&&((ulHunBinNum[1]<=dis_th)||(ulHunBinNum[0]<=dis_th))))))    
			c_bin_cnt = c_bin_cnt + 1;			
		else if ((i>2)&&(ulHunBinNum[i]>act_th)&&
			     (((ulHunBinNum[(i-1)%18]<=dis_th)&&((ulHunBinNum[(i+1)%18]<=dis_th)||(ulHunBinNum[(i+2)%18]<=dis_th)))||
			      ((ulHunBinNum[(i+1)%18]<=dis_th)&&((ulHunBinNum[(i-1)%18]<=dis_th)||(ulHunBinNum[(i-2)%18]<=dis_th)))))    
			c_bin_cnt = c_bin_cnt + 1;	
	}
		
	if((*((UINT8*)(0xbe1cd688))) == 0x1) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s:c_bin_cnt=%d \n\033[0m\n ",__LINE__,__FUNCTION__,c_bin_cnt);

    if (c_bin_cnt>=6)
		return 1;
	else 
		return 0;
#else
	return PQ_RegisterRead(VIP_reg_slr_auto_colorbar);
#endif	
}

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

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

void PQ_ColorBarDetect(void) //sharlene
{
    UINT8 ucSD, cnt_th=5, colorbar;
    UINT32 vdi_vsize;
    UINT8 ucUserSource;
    UINT8 ucSubSource;
    static UINT8  stable_cnt = 0;

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

	if((*((UINT8*)(0xbe1cd688))) == 0x2)  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_RegisterWrite(VIP_reg_slr_icp_alpha, 0x200);
        
        return;
    }
        
    vdi_vsize= PQ_Get_VDI_VSize();

    ucSD = (vdi_vsize<=576)?1:0;

    VIP_GetSource(&ucUserSource, &ucSubSource);

    colorbar = PQ_SWDTColorBar();
  
    if  (colorbar==0 && stable_cnt != 0)
    {
        stable_cnt = stable_cnt - 1;   
    }  
    else if  (colorbar!=0 && stable_cnt != cnt_th)
    {
        stable_cnt = stable_cnt + 1;   
    }  
    //PQ_RegisterWrite(VIP_deg_dpy_sat_all, ucTempColorBarSaturation+(6*stable_cnt));  
    
    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)    
    {
         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,    ucUserSource == SOURCE_CVD2?2:3);
            PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, ucUserSource == SOURCE_CVD2?2:5);
            PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post, 0);

            if(ucUserSource == SOURCE_CVD2){
                if(VIP_IsATVSource()){
                    PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,    0x2);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x2);
                    PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x0);  

                    if(VIP_GetStdColorSystem() > CVD2_STD_NTSC_443 && VIP_GetStdColorSystem() < CVD2_STD_SECAM)
                    {
                        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);
                    }
                }
                else{
                    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_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);   }
            }
            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,   0x0);   }
				        else { 
                       PQ_RegisterWrite(VIP_reg_slr_dcti_scale_pre,    1);	//#40391
			                 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);
            PQ_RegisterWrite(VIP_reg_slr_dcti_shoot_tap_post,0x0);          
        }
        
        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);
    }
    else if(colorbar==0 && utempCheckColorbarDTFunctionEN ==1 && stable_cnt == 0)
    {       
        PQ_SetColorBarFnFlag(DISABLE);
        PQ_Sharpness_PREDCTI(TRUE, utempSharpnesscValue);
        PQ_Sharpness_POSTDCTI(TRUE,utempSharpnesscValue);
        PQ_Sharpness_POST_2D(TRUE, utempSharpnesscValue);
        PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0x200);
        
       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);
	}
}


UINT32 ucVDI_MotionFlag = 0;
UINT32 ucTempM=0;
UINT32 ucVDI_Static_Cnt = 0;
UINT32 ucVDI_Static_Cnt_2 = 0;

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, ucAdjustTNRC = 0;
    UINT8 ucResetTNRC = 0;
	UINT32 ucSwapTNRLevel =0;
	UINT32 ulHsize=0, ulVsize=0;
	UINT32 dwTotalPixel =0;
//	UINT32 ucVdiMotionCut=0;
//	UINT8 ucCVD2_MotionFlag=0;// = (*((UINT8 *)(0xbe170195))&0x02);
	UINT8 ucNRLevel = 0;
	BOOL DPYGrayFlag=0;
	UINT32 NRGain[5] = {SDNR_Gain_normal,SDNR_Gain_Low,SDNR_Gain_Mid,SDNR_Gain_High,600};
	UINT8 ucNoiseStatus = 0;// =CVD2_GetNoiseStatus(&ucNoiseStatus);
	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);
	UINT32 ucvdi_field_diff_cnt_lp = PQ_RegisterRead(VIP_field_diff_cnt_lp);
	UINT8 CVD2NoiseLevel;
	UINT8 CVD2LockStatus = 0;
	BOOL ucCVD2_NSTD_Flag=0;
	cvd2_TypeSigSTD CVD2_Non_standard;
	BOOL ucVDI_static_flag = 0;
	UINT32 ucCTNRLevel = NRGain[4];
	static UINT8 ucStaticFlag = STATIC_FRAME, ucLastStaticFlag = 0xff; //#mantis 40034
	NR_Setting_BY_Group_Idx *pNR_Setting_BY_Group_Idx;
      #ifdef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION
      BOOL SpecialFlag=0;
      #endif
    
	if (ucCurrSrcIndex >= min(SRC_INDEX_UNKNOWN, 20)) return;

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

    if(PQ_GetColorProcessor() == FALSE || VIP_GetVDIPause())
        return;
    
	if (pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex] >= 8) return;
    ucTableIndex = pVtab->mNRSetting.mNRSourceGroupedIndex[ucCurrSrcIndex];
    pNR_Setting_BY_Group_Idx = &pVtab->mNRSetting.mNRSetting_byGroupIdx[ucTableIndex];

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

//==Gray Pattern========
	if( ((PQ_RegisterRead(VIP_c_gray_bin_pre)*100)/dwTotalPixel) >= 98 )
		DPYGrayFlag = 1;
	else
		DPYGrayFlag = 0;
//==MotionCut============
	if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s:63a4=%d,624c=%d,6238=%d \n\033[0m\n ",__LINE__,__FUNCTION__,ucfield_diff_cnt,ucvdi_mot_cnt,ucvdi_vdbk_sts);

	ucVDI_MotionFlag = PQ_GetMotionStatus(); //#40034
	if( VIP_IsATVSource() && (VIP_GetStdColorSystem() < CVD2_STD_SECAM))
	{
		if(ucvdi_mot_cnt > 300)
		{
			PQ_RegisterWrite(VIP_reg_slr_snr_sel, 3);
		}
		else
		{
			PQ_RegisterWrite(VIP_reg_slr_snr_sel, 0);
		}
	}
	else
	{
		PQ_Set_NR_SLR_SNR(NR_SNR_BEFORE_SCALER);
	}
//=======================
	if (ucvdi_field_diff_cnt_lp <= 40 && ucVDI_Static_Cnt < 200)
	{
		ucVDI_Static_Cnt ++;
	}
	else if (ucvdi_field_diff_cnt_lp > 40 && ucVDI_Static_Cnt != 0)
	{
		ucVDI_Static_Cnt --;
	}

	if ( ucVDI_Static_Cnt >= 10 )
	{
		ucVDI_static_flag = 1;
	}
	else
	{
		ucVDI_static_flag = 0;
	}

	if( VIP_IsATVSource())
	{
		if(ucvdi_field_diff_cnt_lp >= 0x4fff && ucVDI_Static_Cnt_2 <30)
		{
			ucVDI_Static_Cnt_2++;
		}
		else if(ucvdi_field_diff_cnt_lp < 0x4fff && ucVDI_Static_Cnt_2 > 0)
		{
			ucVDI_Static_Cnt_2--;
		}
	}
	else if(VIP_IsSourceDTV() || VIP_IsAVSource())
	{
		if(ucvdi_field_diff_cnt_lp >= 0x1ff && ucVDI_Static_Cnt_2 <30)
		{
			ucVDI_Static_Cnt_2++;
		}
		else if(ucvdi_field_diff_cnt_lp < 0x1ff && ucVDI_Static_Cnt_2 > 0)
		{
			ucVDI_Static_Cnt_2--;
		}
	}
	else
	{
		if(ucvdi_field_diff_cnt_lp >= 0xff && ucVDI_Static_Cnt_2 <30)
		{
			ucVDI_Static_Cnt_2++;
		}
		else if(ucvdi_field_diff_cnt_lp < 0xff && ucVDI_Static_Cnt_2 > 0)
		{
			ucVDI_Static_Cnt_2--;
		}
	}
	

	if(ucVDI_Static_Cnt_2 > 10)
	{
		ucStaticFlag = MOTION_FRAME;
	}
	else
	{
		ucStaticFlag = STATIC_FRAME;
	}
	
//==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;
//==CVD2NoiseLV==================
	CVD2_GetNoiseStatus(&ucNoiseStatus);
	if( (ucNoiseStatus > (ucTempM+2)) || (ucNoiseStatus < (ucTempM-2)))
		ucTempM = 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) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: CVD2_Noise=%d \n\033[0m\n ",__LINE__,__FUNCTION__,ucTempM);
//	ucCVD2_MotionFlag = (*((UINT8 *)(0xbe170195))&0x02);
//==CVD2_NonSTDStatus========================================================================
	DRV_CVD2_Get_LockStatus(&CVD2LockStatus); //0x6	

	if((CVD2LockStatus & (hlock|vlock) )== (hlock|vlock))
	{
		DRV_CVD2_CheckNonSTDStatus(&CVD2_Non_standard);	//0x1
		if(CVD2_Non_standard.horizontal_nSTD)
			ucCVD2_NSTD_Flag = 1;
		else
			ucCVD2_NSTD_Flag = 0;
	}
//==Color Bar================================================================
	if ( (PQ_SWDTColorBar() && ucStaticFlag == 0) || 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);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en	,0);

        if(VIP_IsATVSource() && (VIP_GetStdColorSystem() > CVD2_STD_NTSC_443 && VIP_GetStdColorSystem() < CVD2_STD_SECAM))
        {
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_en  ,0);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_en  ,0);
        }
        if(VIP_IsATVSource() && (VIP_GetStdColorSystem()== CVD2_STD_NTSC_M))
        {
            ucAdjustTNRC = TRUE;
            //TNR C
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_en  ,1);
            // thr 0 ~ 4
		    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr0, 45);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr1, 82);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr2, 138);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr3, 185);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_thr4, 213);         
            // slp 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp0, 7);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp1, 3);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp2, 5);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp3, 4);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp4, 9);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_slp5, 3);
            // fac 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac0, 0);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac1, 5);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac2, 7);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac3, 12);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac4, 15);
            PQ_RegisterWrite(VIP_reg_vdi_tnr_c_map_fac5, 19);

            //TNRZ C
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_en  ,1);
            // thr 0 ~ 4
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr0, 49);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr1, 84);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr2, 123);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr3, 165);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_thr4, 208);


            // slp 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp0, 9);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp1, 9);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp2, 6);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp3, 3);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp4, 2);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_slp5, 4);


            // fac 0 ~ 5
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac0, 2);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac1, 9);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac2, 14);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac3, 18);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac4, 20);
            PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_map_fac5, 22);
        }
        else
        {
            if(ucAdjustTNRC)
            {
                ucAdjustTNRC = FALSE;
                ucResetTNRC = TRUE;
            }
        }
        
		if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ColorBar \n\033[0m\n ",__LINE__,__FUNCTION__);
	}
	else if(VIP_GetUserSource() == SOURCE_CVD2 && (VIP_IsATVSource() || VIP_GetStdColorSystem() == CVD2_STD_SECAM))
	{
	    #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION
	    if(pHwContext->nNRLevel != OFF)
          #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);
    			
    			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: ATV_NR-0 \n\033[0m\n ",__LINE__,__FUNCTION__);
    		}
    		else if (CVD2NoiseLevel == 1)
    		{
    			ucSwapTNRLevel = NRGain[2];
    			PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
    			PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
    			
    			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_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: ATV_NR-1 \n\033[0m\n ",__LINE__,__FUNCTION__);
    		}
    		else if (CVD2NoiseLevel == 2)
    		{
    			ucSwapTNRLevel = NRGain[3];
    			PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
    			//PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
    			PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en	,0);
    			
    			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_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);
    			
    			if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ATV_NR-2 \n\033[0m\n ",__LINE__,__FUNCTION__);
    		}
    		else
    		{
    			if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ATV_NR-3 \n\033[0m\n ",__LINE__,__FUNCTION__);
    			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);

    			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);
    				PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en 	,0);
    				if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ATV_NR-3GY \n\033[0m\n ",__LINE__,__FUNCTION__);
    			}
    			else
    			{
    				if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: ATV_NR-3NGY \n\033[0m\n ",__LINE__,__FUNCTION__);
    				PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
    				//PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
    				PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en	,0);
    				
    				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);
    			}
    		}

    		/*if (VIP_GetStdColorSystem() == CVD2_STD_SECAM)
    		{
    		    ucSwapTNRLevel = NRGain[4];
    			PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
    			PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en	,0);
                SpecialFlag = 1;
    		}*/
    		
    		if( ( ((ucTempDCCSceneID == 31 || ucTempDCCSceneID == 32) && ulChromaBin98) || PQ_ChromaBinPercentage(13)>980 ) && !ucVDI_MotionFlag )		
    		{
    			ucSwapTNRLevel = NRGain[4];
    			PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
    			PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en	,0);
    		
    			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);
                   #ifdef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION 
    			SpecialFlag = 1;
                   #endif
    			
    			if((*((UINT8*)(0xbe1cd688))) == 0x8) printk(KERN_EMERG"\033[1m\033[40;35m [%d]%s: 31/32 \n\033[0m\n ",__LINE__,__FUNCTION__);
    		}

	    }
        #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION
		else
		{
			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_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,1);
			PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_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: ATV_NR-0 \n\033[0m\n ",__LINE__,__FUNCTION__);
		}
        #endif

        if(ucAdjustTNRC)
        {
            ucAdjustTNRC = FALSE;
            ucResetTNRC = TRUE;
        }
        
	}
	else if( VIP_GetUserSource() == SOURCE_CVD2 && (!VIP_IsATVSource() && VIP_GetStdColorSystem() != CVD2_STD_SECAM))
	{
		if( ucNoiseStatus <= 1 )
		{
			ucSwapTNRLevel =  NRGain[0];
            PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
			PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
		}
		else if(ucNoiseStatus <=0x5)
		{
		    PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
			PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
			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 && ulChromaBin98 == 1 && ucVDI_MotionFlag == 0)
			{
				PQ_RegisterWrite(VIP_reg_vdi_tnr_map_en 	,0);
				PQ_RegisterWrite(VIP_reg_vdi_tnrz_map_en 	,0);			
				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_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR);
				PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNRZ);
				
				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);
			}
		}
		

        if(ucAdjustTNRC)
        {
            ucAdjustTNRC = FALSE;
            ucResetTNRC = TRUE;
        }
	}
	else
	{
		ucSwapTNRLevel = NRGain[0];
	}
	

    if(ucResetTNRC)
    {
        PQ_Set_NR_BlockAlpha(NR_BLOCK_ALPHA_TNR_C);
    }

	if((VIP_GetUserSource() == SOURCE_CVD2 || ((VIP_GetUserSource() == SOURCE_HDMI || VIP_IsSourceDTV() || (VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource()))&& VIP_GetInputHSize()<=720 )) && (ucLastStaticFlag != ucStaticFlag))
	{
		if(ucStaticFlag == MOTION_FRAME)
		{
			PQ_SetFuzzyEliminate(ENABLE);
		}
		else
		{
			PQ_SetFuzzyEliminate(DISABLE);
		}
	}
	ucLastStaticFlag = ucStaticFlag;
	
     if((ucSwapTNRLevel == ucLastSwapNRLevel && ucLastNRLevel == pHwContext->nNRLevel) && !pHwContext->bNR_Reset_by_changeSrc) 
     {
        return;
	}

	if(VIP_GetUserSource() != SOURCE_CVD2)
	{
		PQ_NR_Init();
		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_slr_mbw_en			,1);
		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__);
	}
	else
		PQ_NR_TnrzEnable();
	
	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;
    }
  
    if((pHwContext->nNRLevel == OFF) && //NR 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);
    }
    else if((pHwContext->nNRLevel == OFF) && ((VIP_GetUserSource() == SOURCE_CVD2) ||(VIP_GetUserSource() == SOURCE_EXTS && !VIP_IsPCSource())))
    {
        #ifndef CONFIG_FORCE_NR_EFFECT_ENHANCED_IN_OFF_OPTION
        if(VIP_IsATVSource())
        {
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, 3);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH, 3);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_CORING, 3);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, 3);
            PQ_SetupStrength(PQ_ITEM_TNR_ULTRA_LOW, 0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_CORING,  2);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR1_STRENGTH,		  0);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_CORING,  2);
            PQ_SetupStrength(PQ_ITEM_LUMA_SNR2_STRENGTH,		  2);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_CORING, 2);
            PQ_SetupStrength(PQ_ITEM_CHROMA_SNR_STRENGTH,   1);
        }        
        #else
        if(SpecialFlag)
        {
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaTnrCoring.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_STRENGTH,(UINT32) pNR_Setting_BY_Group_Idx->LumaTnrStrength.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.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_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
        {
            PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaTnrCoring.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_CORING, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[0] * 100 / 100);
            PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.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);
        }  
     }
     else
     {
    	  PQ_SetupStrength(PQ_ITEM_LUMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->LumaTnrCoring.Degree[ucNRLevel] * ucSwapTNRLevel / 100);
    	  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_CORING, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[ucNRLevel] * ucCTNRLevel);
    		  PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_STRENGTH, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.Degree[ucNRLevel] * ucCTNRLevel);
    	  }
    	  else
    	  {
    		  PQ_SetupStrength(PQ_ITEM_CHROMA_TNR_CORING, (UINT32)pNR_Setting_BY_Group_Idx->ChromaTnrStrength.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_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);
    	  
     }

    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 >= 0xffd)
				//printk("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;
	}
}

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++)
    {
        printk("[%s-%d]=======>!!! Initial Peaking\n", __FUNCTION__, __LINE__);
		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;
    memset(&pHwContext->mSharp_PREDCTI_Reserve, 0, sizeof(SHARP_PREDCTI_RESERVE));    
    memset(&pHwContext->mSharp_POSTDCTI_Reserve, 0, sizeof(SHARP_POSTDCTI_RESERVE));    
    memset(&pHwContext->mSharp_POSTDLTI_Reserve, 0, sizeof(SHARP_POSTDLTI_RESERVE));    
    memset(&pHwContext->mSharp_POST2D_Reserve, 0, sizeof(SHARP_POST2D_RESERVE));
    pHwContext->PqPatch.Post2DPatch = POST_2D_SHARPNESS_DEFAULT;

	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);

    //OSD & GAMMA swap enable in 531
    PQ_RegisterWrite(DPY_COMM_C08C_DW_C08C, 1);

	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);

	WQ_Struct_NRAdjust = create_singlethread_workqueue("NR_Adjust_Workqueue");
	INIT_WORK(&WQ_NRAdjust,(work_func_t)PQ_AdjustNr);

    WQ_Struct_SWDC = create_singlethread_workqueue("SWDC_Workqueue");	
    INIT_WORK(&WQ_SWDC,(work_func_t)PQ_SW_DynamicContrast_SceneChangeDetect_ISR);    

    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 *piGain = &pHwContext->iRGain;
	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;


	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);

				lliTmpValue = pHwContext->iContrast * (LONG LONG INT32)piGain[ucNum/3];
				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];

        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;

    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;

    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;
        }
        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->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_SWDTColorBar())
        {
            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_post_icp_en_pre, pSHARP_PREDCTI_DATA->iPostChromaFilterEnable);
        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]);
        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);

        utempCheckColorbarDTFunctionEN = 0;
}

}

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;
            pSharp_POSTDCTI_Reserve->iTargetScale = pPostDCTIData->iScale[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iScale[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iScale[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTargetGainTap = pPostDCTIData->iGainTap[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iGainTap[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iGainTap[PQ_SHARPNESS_0PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTargetShootTap = pPostDCTIData->iShootTap[PQ_SHARPNESS_0PERCENT]+ (pPostDCTIData->iShootTap[PQ_SHARPNESS_50PERCENT] - pPostDCTIData->iShootTap[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]+ (pPostDCTIData->iScale[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iScale[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTargetGainTap = pPostDCTIData->iGainTap[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iGainTap[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iGainTap[PQ_SHARPNESS_50PERCENT]) * ucValue / 63;
            pSharp_POSTDCTI_Reserve->iTargetShootTap = pPostDCTIData->iShootTap[PQ_SHARPNESS_50PERCENT]+ (pPostDCTIData->iShootTap[PQ_SHARPNESS_100PERCENT] - pPostDCTIData->iShootTap[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;
        }

	#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_dcti_en_post, pPostDCTIData->iPostDCTIEnable);
        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]);

        if(VIP_IsSourceDTV() || !PQ_SWDTColorBar())
        {
            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))
		{
			 PQ_RegisterWrite(VIP_reg_slr_dcti_scale_post,	 0x3);	  //#40362
			 PQ_RegisterWrite(VIP_reg_slr_dcti_gain_tap_post, 0x5);
			 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); 
		}

        utempCheckColorbarDTFunctionEN = 0;
    }
}

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;
        }
    #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 another sharpness setting in regular panel here */}
	#else
		 /* Check different setting status and remove same setting item to here */
	#endif
        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_dclip_sel_post, pSharp_POSTDLTI_Reserve->iTargetDCMode);
        PQ_RegisterWrite(VIP_reg_slr_dlti_ovsht_dclip_post, pSharp_POSTDLTI_Reserve->iTargetDCOverShoot);
        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_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_th1_post, pSharp_POSTDLTI_Reserve->iTagetTh1);
        PQ_RegisterWrite(VIP_reg_slr_dlti_gain_slope0_post, pSharp_POSTDLTI_Reserve->iTagetSlp0);
        PQ_RegisterWrite(VIP_reg_slr_dlti_gain_slope1_post, pSharp_POSTDLTI_Reserve->iTagetSlp1);
        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);

    }
}


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;
        }

    #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(_en_post, pPostDLTIData->iPostDLTIEnable);
        
        if(_VIP_GetPreviewWndowStatus() || pHwContext->PqPatch.Post2DPatch == POST_2D_SHARPNESS_JPEG_THUMBNAIL_PATCH)
        {
            PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en,0);
			//printk("\n\n  THUMBNAIL   \n\n");
        }
        else
        {
        	PQ_RegisterWrite(VIP_reg_slr_2d_sharp_en, pPost2DSharpData->iPost2DSharpEnable);
			//printk("\n\n  NORMAL   \n\n");
        }
        //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);

        if(VIP_IsSourceDTV() || !PQ_SWDTColorBar())
        {
            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_CVD2) || (!VIP_IsPCSource() && (VIP_GetUserSource() == SOURCE_EXTS) && (VIP_GetInputVSize() < 600))||((VIP_GetUserSource() == SOURCE_MPEG)&& (VIP_GetInputVSize() < 600))) //mmantis 35657
        {
            PQ_RegisterWrite(VIP_reg_slr_ds_cond1_sel3, 1);
            PQ_RegisterWrite(VIP_reg_slr_ds_sad_lr_max, 0);
        }
        else
        {
            PQ_RegisterWrite(VIP_reg_slr_ds_cond1_sel3, 0);
            PQ_RegisterWrite(VIP_reg_slr_ds_sad_lr_max, 0x18);
        }

		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_PAL_60)
				{
					 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
			}

    }
}



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]);
      }
}



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;

	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( 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
		/* Check different setting status and remove same setting item to here */	
	#endif
	
    	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);
	
    	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);
		if(!utempCheckColorbarDTFunctionEN || VIP_IsSourceDTV())
		 	{
				PQ_Sharpness_PREDCTI(TRUE, ucValue);
       	 		PQ_Sharpness_POSTDCTI(TRUE,ucValue);
				PQ_Sharpness_POST_2D(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);

}

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);				
	}

}


//****************************************************************************
//
//   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);
			PQ_ColorMatrixSetup(TRUE, 0);
			PQ_ColorMatrixSetup(TRUE, 1);
			PQ_ColorMatrixSetup(TRUE, 2);
			break;
		case PQ_CT_GAIN_G:
			pHwContext->iGGain=iValue<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
			PQ_ColorMatrixSetup(TRUE, 3);
			PQ_ColorMatrixSetup(TRUE, 4);
			PQ_ColorMatrixSetup(TRUE, 5);
			break;
		case PQ_CT_GAIN_B:
			pHwContext->iBGain=iValue<<(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM);
			PQ_ColorMatrixSetup(TRUE, 6);
			PQ_ColorMatrixSetup(TRUE, 7);
			PQ_ColorMatrixSetup(TRUE, 8);
			break;
	}
	PQ_ColorMatrixComp(TRUE);
}

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_th3, 0x800);
		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_snr_ulow_hl_coring, 0x30);
		PQ_RegisterWrite(VIP_reg_vdi_snr_ulow_vl_coring, 0x30);
		//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(CONFIG_DRAMSIZE == 64)
    if(VIP_IsPCSource()|| VIP_RunDVIMode())
	{
        bNrEnable=DISABLE;
    }
//#endif


	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_SetGammaTable
//   Params    : *pulAddr
//   Description: set gamma table to VIP
//   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_512;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_SetupGammaTable(UINT8 ucEnable, UINT8 ucTableIndex)
{
	volatile UINT32 *pGammaTable = NULL;
	UINT8 pGammaTableID[15];
	UINT32 ulCounter;
	BOOL b12BitGammaTable= FALSE;
	PQHW_CONTEXT* pHwContext= &PQHwContext;

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

	if(pHwContext->GammaIndex != ucTableIndex || pHwContext->GammaEnable != ucEnable)//prevent blanking from duplicate setting
	{
		if(ucEnable == ENABLE)
		{
			if(ucTableIndex>2) // gamma table index is out of range
			{
				PQDebugPrint("%s: [ERROR!!] ucTableIndex is illegal(out of range: 0~2)", __FUNCTION__);
				return;
			}
			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_RegisterWrite(VIP_reg_dpy_no_gamma, ENABLE);	//disable gamma function
				return;
			}

			// start to setup gamma table as following if ucTableIndex and GammaTableID are correct

			pHwContext->GammaIndex=ucTableIndex;
			pHwContext->GammaEnable = ENABLE;

			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

			//write gamma table
			PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr,0);		//initial index for gamma table write
			for (ulCounter=0;ulCounter<GAMMA_RGB_MAXINDEX;ulCounter=ulCounter+2)	//input data 10/12 bits
			{
	#ifdef CONFIG_PANEL_LM201WE3_TLF5_1680X1050__S2TEK_IS_DEFAULT
				UINT16 TempR,TempB,TempG;
				TempR = 1023 - ((pGammaTable[ulCounter] & 0x3ff00000) >> 20);
				TempG = 1023 - ((pGammaTable[ulCounter] & 0xFFD00) >> 10);
				TempB = 1023 - (pGammaTable[ulCounter] & 0x3FF);
				pGammaTable[ulCounter] = (TempR << 20) + (TempG << 10) + TempB;
				if(!b12BitGammaTable)
				{
					PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,pGammaTable[ulCounter]);
				}
				else
				{
					PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,pGammaTable[ulCounter]);
					PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,pGammaTable[ulCounter+1]);
				}

	#else				//short setting time to avoid setting error
				if(!b12BitGammaTable)
				{
					PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,pGammaTable[ulCounter]);
				}
				else
				{
					PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,pGammaTable[ulCounter]);
					PQ_RegisterWrite(VIP_reg_dpy_gmlut_data,pGammaTable[ulCounter+1]);
				}
	#endif
			}

			PQ_RegisterWrite(VIP_reg_dpy_no_gamma, DISABLE);	//enable gamma function

			PQ_RegisterWrite(VIP_reg_dpy_gmlut_addr,0);
			PQ_RegisterWrite(VIP_reg_dpy_gm_cfg12bit, b12BitGammaTable);
		}
		else
		{
			pHwContext->GammaEnable = DISABLE;
			PQDebugPrint("Without Gamma Table.......Turn off Gamma correction.");
			PQ_RegisterWrite(VIP_reg_dpy_no_gamma, ENABLE);	//disable gamma function
		}
	}
}



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);
#if 0
		PQ_Hue(16);
#else
		PQ_Hue(50);
#endif

		//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);

		//Disable dynamic contrast


		//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);

		//Disable LUT
        PQ_SetupLUTTable(DISABLE);
	}
	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);

		//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);

		//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_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;
	}
}

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 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_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;
	default:
		return FALSE;
	}
    return FALSE;
}

void PQ_PeakingFilterSetup(void)
{
	PQHW_CONTEXT* pHwContext= &PQHwContext;
    VTAB_CMN_VALUE_DEFINE* pVtab= &pHwContext->VtabCmnValue;
	PEAKING_SETTING *pPeaking;
    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];

	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_smooth, 64); //menu adjust
//	PQ_RegisterWrite(VIP_reg_dpy_filter_hl_sharp, 64); //menu adjust
//	PQ_RegisterWrite(VIP_reg_dpy_filter_hc_smooth, 64); //menu adjust
//	PQ_RegisterWrite(VIP_reg_dpy_filter_hc_sharp, 64); //menu adjust

	//for sharpness
	//if( pHwContext->ulInputHSize>=1900 ) //1920x1080 i/p==>1900/1920*2048=0x7EA

	if((((DRV_SLR_GetFactor_HFactor())*(DRV_SLR_GetFactor_HFactor_6HV())*100)/(2048*2048))>90)
		pPeaking= &pVtab->mPeaking.mPeaking_Data[ucTableIndex].Peaking[2];
	else if(VIP_GetInputVSize() >= 1000)	//1080
		pPeaking= &pVtab->mPeaking.mPeaking_Data[ucTableIndex].Peaking[2];
	else if(VIP_GetInputVSize() >= 700) 	//720
		pPeaking= &pVtab->mPeaking.mPeaking_Data[ucTableIndex].Peaking[1];
	else
		pPeaking= &pVtab->mPeaking.mPeaking_Data[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);

	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_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_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);


}

//================================================================================
//	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);

		PQ_RegisterWrite(VIP_reg_slr_icp_alpha, 0x200); //ATV LOGO ICP

		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);

	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
	{
		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_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;
}


void PQ_ConditionSetting(UINT8 ucMode)
{

	if (ucMode == MODE_DeinterlaceFilter)
	{
		///////////////////////////////////////////////////////////
		// From MAD Setup on 7 Places
		///////////////////////////////////////////////////////////
		if( (VIP_GetUserSource()==SOURCE_MPEG && VIP_GetInputHSize()<800 && VIP_GetInterlaceMode()) || VIP_IsAVSource() || VIP_IsATVSource() )
		{
			// for eric request to improve the sd quality like mantis  43324
			PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 0);

				// NTSC building horizontal line flicker issue  #45589
    		if((VIP_IsAVSource() || VIP_IsATVSource()) && (VIP_GetStdColorSystem() <= CVD2_STD_NTSC_443))
    		{
				PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 5);
				PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 13);
    		}
			else
			{			
				PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 0);
				PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 8);
			}
		}
		else
		{
			PQ_RegisterWrite(VIP_reg_vdi_mad_hlp_en, 1);
			PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff1, 5);
			PQ_RegisterWrite(VIP_reg_vdi_mad_tpw_xoff2, 13);
		}

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

}


void PQ_VDeblockFilterEnable(void)
{
    if(VIP_IsATVSource())
       	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#################################################################################
	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"
	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,0x30);//                		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,0x0);//             		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_scale_post	,0x00); //0x0080DF74
		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
	}
	else
	{
		PQ_RegisterWrite(VIP_reg_slr_dlti_scale_post	,0x01); //0x0080DF74
		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
	}

}


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_detail_en			,0x0); //Sony PQ(NTSC) ColorBar
	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);

	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
		}
		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_dbk_vdiff_th3, 0x2);

	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, 2);
	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;
		//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())
		{
			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;
#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 = 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

			}
#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, 180);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_he, vdi_hsize_i-180);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_vs, vdi_vsize-hme_height+1);
			PQ_RegisterWrite(VIP_reg_vdi_mad_hme_det_ve, vdi_vsize-1);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_det_vs, vdi_vsize-hme_height);
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_det_ve, vdi_vsize-2);
			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);
		}
		else
		{
			PQ_RegisterWrite(VIP_reg_vdi_mad_gmv_en, 0);
			PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 0);

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

	}


}

void PQ_HmeControl(void)
{
	static int counter=256;
	//for JunYun suggest, 22 & 32 need close hme for «Ø¿vª«±ÛÂà·|¤À§Ãissue
	if(VIP_IsATVSource() &&(VIP_GetStdColorSystem()<=CVD2_STD_NTSC_443))
	{
		if((PQ_RegisterRead(VIP_vdi_32det_sts)& 0x1000)>>12)
		{
			counter--;
			if(counter==0)
				PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 0);
			else if(counter<0)
				counter=0;
		}
		else
		{
			counter++;
			if(counter==255)
				PQ_RegisterWrite(VIP_reg_slr_hme_rgn_en, 1);
			else if(counter>255)
				counter=255;
		}
	}
}

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_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
//           
//****************************************************************************

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, 0x375); //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 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);


	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 bTNRForChroma= TRUE;
	BOOL bDeblockEnable;

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

	PQ_RegisterWrite(VIP_reg_vdi_reset, 1);

	//deinterlace setup
	if(VIP_GetInterlaceMode())
	{
		PQ_RegisterWrite(VIP_reg_vdi_interlace, 1);    
	}
	else
	{
	    PQ_RegisterWrite(VIP_reg_vdi_interlace, 0);  
	}

	PQ_RegisterWrite(VIP_reg_vdi_bypass, bFunctionEnable ? 0 : 1);	//always open in 9561
	//if(pHwContext->cInterlaceMode==0){PQ_RegisterWrite(VIP_reg_gfx_buf_bypass,1);}
	PQ_RegisterWrite(VIP_reg_gfx_buf_bypass,0);
	if( bFunctionEnable )
	{
		bATVSource= (ucSource==CVD2) && (ucSubSource==TV_INPUT_CHANNEL);
		bPCSource= (ucSource==EXTS) && (ucSubSource==DSUB);
		//2008.12.11, Emily: 1080i/p is disabled, either.
		//bMrd_4prev1= (VIP_GetInterlaceMode() && VIP_GetInputVSize()<1080) ? ENABLE : DISABLE;
		//disable TNRForChroma if v prescalling down is used or pixelclock is too large.
//2008-12-15 Add condiction-PC/DVI close TNR
/*
#if 0
		bTNRForChroma= TRUE;
#else
		bTNRForChroma= (DRV_SLR_GetConfig() == eSLR_CONFIG_PRE_6HV_POST_H) &&
						(VIP_GetSourcePixelClock()<110000000) &&
						(VIP_GetInputDataFormat()!=RGB)
						? ENABLE : DISABLE;
#endif
		if((ucSource==MPEG)&&(VIP_GetInputVSize()>576))
			bTNRForChroma=DISABLE;
		if((VIP_GetCHIP_ID() & 0xff)>0x30 && VIP_GetUserSource() == SOURCE_MPEG)
			bTNRForChroma=DISABLE;

		if((VIP_GetCHIP_ID() & 0xff)==0x30 && VIP_GetInputVSize()>720)//  for insufficient bandwidth
			bTNRForChroma=DISABLE;
		else if(VIP_IsAVSource())
			bTNRForChroma=DISABLE;
*/
		//Chroma TNR always Enable (DTV 1080i Disable)
		if( (ucSource==MPEG) && (VIP_GetInputVSize()>720) && VIP_GetInterlaceMode())
			bTNRForChroma=DISABLE;
		else
			bTNRForChroma=ENABLE;


		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;

		//0x6000
		//PQ_RegisterWrite(VIP_reg_vdi_reset, 0);
		PQ_RegisterWrite(VIP_reg_vdi_mrd_en, 1);
		PQ_RegisterWrite(VIP_reg_vdi_nomrd_4prev1, VIP_GetInterlaceMode()?0:1);
		//PQ_RegisterWrite(VIP_reg_vdi_interlace, pHwContext->cInterlaceMode);
		PQ_RegisterWrite(VIP_reg_vdi_take_m32, 0);
		PQ_RegisterWrite(VIP_reg_vdi_take_m22, 0);
		//PQ_RegisterWrite(VIP_reg_vdi_pause_en, 0); //VIP_InputFreeze() setup this

		//0x6001
		//Rule 1:
		//If NR is off, disable all except MAD.
		//If NR is on, enable all for Interlace mode.
		//Disable MAD, but keep deblock and mosquito detection active for progressive mode.
		//So 0x6001[2] = vdi_interlace, Others = nr_on
		//Rule 2:
		//Noise Reduction On/Off : 6001[0], 6001[3,4], 6002[3]
		//MPEG Noise Reduction On/Off : 6001[1], 6001[6]


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

//#if(CONFIG_DRAMSIZE == 64)
		if(VIP_IsPCSource() || VIP_RunDVIMode())
			bNrEnable=DISABLE;
//#endif
		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);

		//2008-12-15 PC/DVI close MBW
#if 0
		if(pHwContext->cInputDataFormat==RGB && !bPCSource )
#else
		if((VIP_GetInputDataFormat()==RGB) || bPCSource )
#endif
		PQ_RegisterWrite(VIP_reg_vdi_mnr_fil_en, 0);
		else
		PQ_RegisterWrite(VIP_reg_vdi_mnr_fil_en, bMpegNrEnable);
		//0x6002
		if ((ucSource==SOURCE_EXTS) && PQ_GET_YUV_Datat_Formal()<3)
		{
			PQ_RegisterWrite(VIP_reg_vdi_tnr_c_en, DISABLE);
			PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_en, DISABLE);
		}
		else
		{
			PQ_RegisterWrite(VIP_reg_vdi_tnr_c_en, bTNRForChroma); //disable this can save memory bandwidth
			PQ_RegisterWrite(VIP_reg_vdi_tnrz_c_en, bTNRForChroma);
		}

		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_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_mbw_en, 0);
		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);

		//6100=0x17
#if 0
		if(VIP_IsPCSource())
		{
			PQ_RegisterWrite(VIP_reg_vdi_snr_adj_en,1);
			PQ_RegisterWrite(VIP_reg_vdi_snr_ultra_low_en, 1);
			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_snr_hor_mix_en, 1);
		}
		else
#endif
		{
		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_ultra_low_bmax_sel, 0);
		PQ_RegisterWrite(VIP_reg_vdi_snr_hor_mix_en, 1);
		}

		PQ_RegisterWrite(VIP_reg_vdi_tnr_th1_s, 9);

		//0x6032, 0x6035, 0x6026,
		PQ_RegisterWrite(VIP_reg_vdi_tnr_slope_s, 1);
		PQ_RegisterWrite(VIP_reg_vdi_tnrz_slope_s, 1);

		//0x6036~0x603a //x
		PQ_RegisterWrite(VIP_reg_vdi_tnr_c_th1_s, 10);

		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);

		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);
		PQ_RegisterWrite(VIP_reg_vdi_snr_strong_edge_th, VIP_GetInputVSize()<720?0x60:0);


		//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_reset, 0);

	PQ_RegisterWrite(VIP_reg_vdi_sigmanr_factor,2);//2009-07-14 yuling adjust the factor to pass some ADC pattern shake issue.

#if CONFIG_CHIPID == 0x533
/*20160706 for JunYun request to add reg control tnr en*/
	//if(((PQ_RegisterRead(VIP_reg_picx_dummyf)&0xff)>>4)==3)

	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);
		PQ_RegisterWrite(VIP_reg_vdi_mad_tpc_en, DISABLE);
		//PQ_RegisterWrite(VIP_reg_gfx_dummy2,0x2);  // 533 A1  if bypass and tnrc disable,  reduce chroma bandwidth setting
	}
#endif


}


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
	//PQ_DLC_SRC bPq_Index;
    pHwContext->PqPatch.Post2DPatch = POST_2D_SHARPNESS_DEFAULT;

	//printk(KERN_EMERG"ucSource=%d ucSubSource=%d\n",ucSource, ucSubSource);
	//VIP_IsAVSource()= (ucSource==CVD2) && ((ucSubSource==AV1_INPUT_CHANNEL)|(ucSubSource==AV2_INPUT_CHANNEL));
	pHwContext->pCurVtabSrcValue= pVtab;
	//printk(KERN_EMERG"VIP_IsAVSource()=%d\n",VIP_IsAVSource());
#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_RegisterWrite(VIP_reg_dpy_no_gamma, ENABLE);	//disable gamma function
		}
		else
		{
		    	PQ_RegisterWrite(VIP_reg_dpy_no_gamma, pMenuValue->bNoGamma);
		}
	}
	//bPq_Index = VIP_Get_PQ_Source(ucSource,ucSubSource);
	//printk("SOURCE=%d \n",bPq_Index);
//#ifdef  VIP_SW_DC
#if 1
 	PQ_SW_DynamicContrast_Param(0);
#endif

    PQ_Set_UV_Coring();
    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(ENABLE);

	//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;
}

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;
			}
			break;

		case SOURCE_MPEG:
			if(VIP_GetInputVSize()>576+24) /* safer boundary */
			{
				ucCurrSrcIndex = SRC_INDEX_DTV_HD;
			}
			else
			{
				ucCurrSrcIndex = SRC_INDEX_DTV_SD;
			}
			break;

		case SOURCE_JPEG:
		case SOURCE_PATTERN:
			ucCurrSrcIndex = SRC_INDEX_JPEG;
			break;
	}


	return ucCurrSrcIndex;

}


#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};

void PQ_Default_Color_Lut_Setting(void)
{
    INT32 i;
	volatile UINT8 * pLUT = (volatile UINT8*) SPI_COLORLUTTABLE_SHADOWADDR;
	PLUTTable pLUTTable = (PLUTTable) pLUT;
	if (*(UINT8*)0xbe000005>=0x30) //chip ver.
		return;

    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.
	for(i=0; i< 7936; i++)
	{
		PQ_RegisterWrite(VIP_reg_dpy_rgn_data, 0);//COLOR_LUTABLE[i]);
	}
}


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) + (96*YValue);
		if(Addr>767)
			Addr = 767;
	}
	else if(type==2)
	{
		Addr = HValue + (SValue<<4) + (80*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;

	if(LumaValue>1023)
		LumaValue=1023;
	
	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);
				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-
				ptLUTout[z][y][x].Hoffset = HValue;
				ptLUTout[z][y][x].Soffset = SValue;
				ptLUTout[z][y][x].Yoffset = YValue;
			}
		}
	}
	//	AfxMessageBox("exit here............2");

}


void _PQ_ColorLUTSortOffsetToPt(UINT32 *dwOffsetSort, LUT_OFFSET *ptLUTout,int HueIndex,int SatIndex,int LumaIndex)
{
	int HValue=0,SValue=0,YValue=0;
	UINT32 dwAddr;
	UINT32 dwOffset;

	dwAddr = GetLutHwAddress(HueIndex,SatIndex,LumaIndex);
	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-
	ptLUTout->Hoffset = HValue;
	ptLUTout->Soffset = SValue;
	ptLUTout->Yoffset = YValue;
}



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 > 15)
				{
					iHdiff = 15;
				}
				if(iHdiff < -16)
				{
					iHdiff = -16;
				}
				if (iSdiff > 31)
				{
					iSdiff = 31;
				}
				if(iSdiff < 0)
				{
					iSdiff = 0;
				}
				if (iYdiff > 31)
				{
					iYdiff = 31;
				}
				if(iYdiff < -32)
				{
					iYdiff = -32;
				}

				dwOffset = ((iHdiff&0x1f)<<11) | ((iSdiff&0x1f)<<6) |(iYdiff&0x3f);


				dwAddr = GetLutHwAddress(x, y, z);
				//dwOffsetSort[dwAddr] = dwOffset;
				PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,dwAddr);
				PQ_RegisterWrite(VIP_reg_dpy_rgn_data,dwOffset);

			}
		}
	}

}

void _PQ_ColorLUTSortLUTV3(LUT_OFFSET ptLUTout,int HueIndex,int SatIndex,int LumaIndex)//, UINT32 *dwOffsetSort)
{
	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));

	iHdiff=ptLUTout.Hoffset;
	iSdiff=ptLUTout.Soffset+m_Global_S_offset;
	iYdiff=ptLUTout.Yoffset;


	if (iHdiff > 15)
	{
		iHdiff = 15;
	}
	if(iHdiff < -16)
	{
		iHdiff = -16;
	}
	if (iSdiff > 31)
	{
		iSdiff = 31;
	}
	if(iSdiff < 0)
	{
		iSdiff = 0;
	}
	if (iYdiff > 31)
	{
		iYdiff = 31;
	}
	if(iYdiff < -32)
	{
		iYdiff = -32;
	}

	dwOffset = ((iHdiff&0x1f)<<11) | ((iSdiff&0x1f)<<6) |(iYdiff&0x3f);


	dwAddr = GetLutHwAddress(HueIndex,SatIndex,LumaIndex);
	//dwOffsetSort[dwAddr] = dwOffset;
	PQ_RegisterWrite(VIP_reg_dpy_rgn_addr,dwAddr);
	PQ_RegisterWrite(VIP_reg_dpy_rgn_data,dwOffset);

}



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;
	//LUT_OFFSET ptLut;
	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};

	if (NULL == pbuf)
		pbuf = (COLORLUT_BUF*)drv_vmalloc(sizeof(COLORLUT_BUF),MODULEID_VIP);
	if (NULL == pbuf) 
		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);

									//_PQ_ColorLUTSortOffsetToPt(dwDataAddr,&ptLut,y,s,h);
									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(ptLut,y,s,h);
								}
							}
						}
					}
				}
			}
		}
	}

	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;
        
}


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;

	printk(KERN_EMERG"%s: ucEnable=%d pLUT=%p", __FUNCTION__, ucEnable, pLUT);
	*(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;
	}

	/*
	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) 
				//{
					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);

					if(bCalcRegionOK==FALSE)
					{
						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) = 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;
    }
}


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(BOOL bEnable)
{
	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;
    dwSatGainAddr = VIP_reg_dpy_sat_g0b;

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

    ucTableIndex = pVtab->mSatGainCurve_V2.mGroupedIndex[ucCurrSrcIndex];
    pSatData = &pVtab->mSatGainCurve_V2.mSatGainCurve_V2_Data[ucTableIndex];

    //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
    PQ_RegisterWrite(DPY_DISX_CB54_DW_CB54,(((PQ_RegisterRead(DPY_DISX_CB54_DW_CB54))&0x00ffffff)|(pSatData->iDpySatAll<<24)));
	ucTempColorBarSaturation = PQ_RegisterRead(VIP_deg_dpy_sat_all);
		
    //Set VIP_deg_dpy_hue
    PQ_RegisterWrite(DPY_DISX_CB58_DW_CB58,(((PQ_RegisterRead(DPY_DISX_CB58_DW_CB58))&0xffff00ff)|(pSatData->iDpySatHue<<8)));

    #if CONFIG_CHIPID==0x531
    for (i = 0; i < 17; i++)
    {
        PQ_RegisterWrite(dwSatGainAddr+i*4, pSatData->iSat_Gain[i]);
    }
    #else
    for (i = 0; i < 17; i++)
    {
        PQ_RegisterWrite(dwSatGainAddr+i, pSatData->iSat_Gain[i]);
    }
    #endif

}


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);
}


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;
//	UINT32 ulHsize,ulVsize;
//	UINT32 /*dwInputCW_TotalPixel,*/ dwChromaHistTotal=0;
	BOOL /*DPYGrayFlag=0,*/ ulChromaBin98=0, ulChromaBin99=0;
	BOOL GrayPatternFlag=0;
	UINT32 ulCurChromaBinPercentage,ulCurChromaBinPercentage7,ulCurChromaBinPercentage8;

/*	//==Total Pixel=========
	ulHsize = PQ_RegisterRead(VIP_reg_slr_out_width);
	ulVsize = VIP_GetlInputCaptureVSize()>>VIP_GetInterlaceMode();
	dwInputCW_TotalPixel = ulHsize*ulVsize ;
*/	//==Chroma==================
	UINT8 ucSWDC_En_Temp=0; 

	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;
	}
	//==========================


    //UINT8 CustUC_DbgEn;
    //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, SWDC_Param[0].ucSWDC_En);
	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];
    }

    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) || (ulCurAvgY<<8)<=(Var_ratio[1]*ulPreAvgY));
    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) || (ulCurAvgY<<8)<=(Var_ratio[3]*ulPreAvgY);
    ChangeCondition[1] = Var_cond_en[1] || (ulCurAvgY<<8)>=(Var_ratio[2]*ulPreAvgY) || (ulPreAvgY<<8)>=(Var_ratio[2]*ulCurAvgY);

   ///ChangeCondition[1] = 0;

    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)
    {
        for(i=0; i<16; i++)
        {
            if(ulHistBin[i]<dwTotalPixel*50/1000)
            {
                if (ulHistBin[i]<dwTotalPixel*25/1000) // *10 to *20
                    BinNull ++;
            }
            else
            {
                if ((i==0)&&(ulHistBin[1]<dwTotalPixel*50/1000))
                    BinNormal ++;
                else if ((i==15)&&(ulHistBin[14]<dwTotalPixel*50/1000))
                    BinNormal ++;
                else if ((i==14)&&(ulHistBin[13]<dwTotalPixel*50/1000)&&(ulHistBin[15]<dwTotalPixel*50/1000))
                    BinNormal ++;
                else if ((i==13)&&(ulHistBin[i-1]<dwTotalPixel*50/1000)&&((ulHistBin[i+1]<dwTotalPixel*50/1000)||
                         (ulHistBin[i+2]<dwTotalPixel*50/1000)))
                    BinNormal ++;
                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)))
                    BinNormal ++;
                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)))
                    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( (((PQ_RegisterRead(VIP_c_gray_bin_pre)*100)/dwInputCW_TotalPixel) >= 98) && ulChromaBin98 )
		DPYGrayFlag = 1;
	else
		DPYGrayFlag = 0;
*/
	if ( HistogramCase[6]==1 || HistogramCase[22]==1 || HistogramCase[23]==1 || HistogramCase[24]==1)
		GrayPatternFlag = 1;
	else
		GrayPatternFlag = 0;
	

/*
    if ((PreulcondS==1)||(((HistogramCase[22]==1)||(HistogramCase[24]==1)||(HistogramCase[6]==1))&&(DPYGrayFlag==1)))
        pHwContext->ulHistCaseCur = 32;
    else if (pHwContext->ulHistCaseCur==0)
        pHwContext->ulHistCaseCur = 31;
*/

    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

    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("tmp1 = %d", tmp1);
        PQDebugPrint("ulHistCaseCur = %d, ulHistCasePre = %d", (pHwContext->ulHistCaseCur-1), (ulHistCasePre-1));
        PQDebugPrint("index =%9d%9d%9d%9d ", CurHistWeight[0].ucIndex, CurHistWeight[1].ucIndex, CurHistWeight[2].ucIndex, CurHistWeight[3].ucIndex);
        PQDebugPrint("weight=%9ld%9ld%9ld%9ld ", CurHistWeight[0].ulWeight, CurHistWeight[1].ulWeight, CurHistWeight[2].ulWeight, CurHistWeight[3].ulWeight);
    }

    HistCaseNum = pHwContext->ulHistCaseCur - 1;


    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 (((HistCaseNum==0)&&(((ulHistBin[0]+ulHistBin[1])>dwTotalPixel*600/1000)&&((ulHistBin[2]+ulHistBin[3])<dwTotalPixel*75/1000))) ||
//							   ((ulHistBin[0]>dwTotalPixel*150/1000)&&((ulHistBin[0]+ulHistBin[1])>dwTotalPixel*600/1000)&&((ulHistBin[2]+ulHistBin[3])<dwTotalPixel*150/1000)))

		//(((ulHistBin[1]+ulHistBin[2])>dwTotalPixel*600/1000)&&(ulHistBin[3]<dwTotalPixel*150/1000)) ||
		//					   (((ulHistBin[0]+ulHistBin[1]+ulHistBin[2])>dwTotalPixel*900/1000)&&(ulHistBin[3]<dwTotalPixel*50/1000)) ||
		//					   ((ulHistBin[2]>dwTotalPixel*900/1000)&&(ulHistBin[3]<dwTotalPixel*50/1000)))
//		{
		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)
	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 )
    //tmp = ulHistBin[12]+ulHistBin[13]+ulHistBin[14]+ulHistBin[15];

    //if (Var_cond_en[7]==1)// && (tmp > dwTotalPixel*10/1000))
	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;

    //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_start0 , 0);
    tmp = 0;
    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);

    }

    for(i=0; i<16; i++)
    {
        PQ_RegisterWrite(VIP_reg_dpy_hist_chroma0+i*4  ,ulTargetChroma[i]);
    }


    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);

//    *(UINT8 *)0xbe1cd688=0x0; //sharlene

}

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;
}

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)) = 0x1770000 / CONFIG_PANEL_PWM_REF_PERIOD;
					*((UINT32 *)(dwBackLightAddr)) = ((0x1770000 / 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)) = (0x1770000 / CONFIG_PANEL_PWM_REF_PERIOD)-1;
				*((UINT32 *)(dwBackLightAddr)) = (0x1770000 / CONFIG_PANEL_PWM_REF_PERIOD) | 0x80000000;
			}
			#if (CONFIG_CHIPID == 0x331 || CONFIG_CHIPID == 0x533)
			if ( 2==pwm_number ) {
				GPIOFunctionSelect(30, 0);
			}
			#endif
		}
		#if 0
		#elif defined(CONFIG_PANEL_ADJ_INVERT)
		if ( (0==status) && (2==pwm_number) ) {
			#if (CONFIG_CHIPID == 0x331 || CONFIG_CHIPID == 0x533)
			GPIOFunctionSelect(30, 0);
			#endif
		}
		#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;

	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
#if 0//def CONFIG_PANEL_ADJ_INVERT
	pDBL->ucOrder = 1;
#else
	pDBL->ucOrder = brvip_flash_p->LCDBackLight_Order;
#endif
	pDBL->ucDynamicBLType = DYNAMIC_BL_FORMAL;
  
    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];
	pDBL->dwTableNormal= pDBL->BacklightTab[12];

	// 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;
		pDBL->dwTableNormal= pDBL->BacklightTab[2];	 //14-12
	}

	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->nBound1= 42; //16+219*12%
	pDBL->nBound2= 60; //16+219*20%
	pDBL->nBound3= 191; //16+219*80%
	pDBL->nBound4= 209; //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]);
}


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;

    if(PQ_GetColorProcessor() == FALSE)
        return;

	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
	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;

	}

	//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
	{
	PQ_PresetBackLight(TRUE, dwTarget, PQ_GetHomeModeValue(&dwTarget) > PQ_GetRealBackLight() ? BL_QUICK : BL_SLOW);
	}
	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 = %ld(%#lx), dwTarget = %ld(%#lx), 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;

#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;

	if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
	{
		if( nWhiteCondition==1 )
		{
			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);
		}
		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);
		}
	}
	else
	{
		dwLightTarget= pDBL->dwLightNormal;
	}

	//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;
}



//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;
	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;

	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
	}

	if( dwTotalPixel==0 )
		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;
	else if( dwWhiteLevel<=pDBL->nBound2 )
		nWhiteCondition= 2;
#ifdef VIP_DBL_WHITE_PATTERN_BRIGHTING
	else if( dwWhiteLevel<=pDBL->nBound3 )
		nWhiteCondition= 3;
	else if( dwWhiteLevel<=pDBL->nBound4 )
		nWhiteCondition= 4;
	else
		nWhiteCondition= 5;
#else
	else
		nWhiteCondition= 3;
#endif

	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<3 && nWhiteCondition>=3) || (nPrevWhiteCondition>3 && nWhiteCondition<=3) )
				{
					nDBLStatus= VIP_DBL_STATUS_LEAVING;
				}
			}
		}
		else if( nWhiteCondition==1 || nWhiteCondition==5 )
		{
			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;
				if( (nWhiteCondition==1 && dwCur>dwTarget) || (nWhiteCondition==5 && dwCur<dwTarget) )
				{
					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_ENTERING: //nPrevWhiteCondition must be 1 or 5
		if( nPrevWhiteCondition!=nWhiteCondition )
		{
			if( nPrevWhiteCondition==1 )
				nDBLStatus= nWhiteCondition>=3?VIP_DBL_STATUS_LEAVING:VIP_DBL_STATUS_DETECTING_WHITE_ENTERING;
			else if( nPrevWhiteCondition==5 )
				nDBLStatus= nWhiteCondition<=3?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;
	case VIP_DBL_STATUS_KEEPING: //nPrevWhiteCondition must be 1, 5, 2 or 4
		if( nPrevWhiteCondition!=nWhiteCondition )
		{
			if( nPrevWhiteCondition<3 )
			{
				if( nWhiteCondition>=3 )
					nDBLStatus= VIP_DBL_STATUS_LEAVING;
			}
			else if( nPrevWhiteCondition>3 )
			{
				if( nWhiteCondition<=3 )
					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;
	case VIP_DBL_STATUS_LEAVING:
		break;
	}

	if( nDBLStatus==VIP_DBL_STATUS_ENTERING )
	{
		bNeedDown= nEnteringWhiteCondition==1 ? TRUE : FALSE;
	}
	else if( nDBLStatus==VIP_DBL_STATUS_LEAVING )
	{
		bNeedDown= nEnteringWhiteCondition==1 ? 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;

    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];

    if(pUV_Coring_Setting->iUVCoring_en)
    {
        PQ_RegisterWrite(VIP_reg_uv_coring_en, ENABLE);
        PQ_RegisterWrite(VIP_reg_uv_coring, pUV_Coring_Setting->iUVCoring);
    }
    else
    {
        PQ_RegisterWrite(VIP_reg_uv_coring_en, OFF);
    }


}




#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, 0x1);

    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_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);

	//20170320 Modify default value because of mantis 0042440 
    PQ_RegisterWrite(VIP_reg_vdi_tnr_8bit0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_8bit1, 0x01);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_8bit0, 0x00);
    PQ_RegisterWrite(VIP_reg_vdi_tnr_c_8bit1, 0x01);
    
    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);
}


#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;
		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;
    }


    //==============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_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);
    
    if(!PQ_IsFadeEn())
    {
	    PQ_Contrast(FALSE, pMenuValue->iContrast);
    }
	PQ_ColorMatrixSetup(FALSE, 0);
	PQ_ColorMatrixComp(FALSE);
}

void PQ_AffectInInputVSync_ISR(void)
{
    PQHW_CONTEXT* pHwContext= &PQHwContext;
    PQ_MENU_VALUE* pMenuValue= &pHwContext->MenuValue;

    PQ_Sharpness_PREDCTI(FALSE, pMenuValue->iSharpness);
	
	PQ_HmeControl();
}


#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;
}

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);
    }
}

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_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;
		PQ_RegisterWrite(VIP_reg_slr_dlti_dclip_en_post, 1);
    }
    else
    {
        pHwContext->PqPatch.Post2DPatch = POST_2D_SHARPNESS_DEFAULT;
    }
    PQ_Sharpness_POST_2D(TRUE, pMenuValue->iSharpness);
}