UTS6710/drivers/pq/533/pq_hw.h

#ifndef _PQ_HW_H
#define _PQ_HW_H

/*******************************************************************************
* Header include
******************************************************************************/
#include <linux/spinlock_types.h>
#include <drv_pq_internal.h>
#include <drv_pq.h>
#include "pq_tab.h"
#include <project.h>


#define PQ_GetRegisterEndBit(ulRegisterName)	((ulRegisterName >> 22) & 0x00000003F)
#define GET_VALUE_BITS(ulRegisterName, ulValue) ((UINT32)(ulValue << (32 - PQ_GetRegisterEndBit(ulRegisterName)))) >> ((32 - PQ_GetRegisterEndBit(ulRegisterName)))
#define PQ_GetStartAndEndBits(ulRegisterName)    (ulRegisterName & 0x0FFF0000)
#define PQ_GetRegisterStartBit(ulRegisterName)	((ulRegisterName >> 16) & 0x00000003F)

#define ALL_BITS    0x08000000
#define WIDTH_BIT_8		0x02000000
#define REGISTER_ADDRESS_MASK		0x0000FFFF
#define REGISTER_TYPE_MASK			0xF0000000

#define REGISTER_ADDRESS_LVDS_MAPPING	0x0800C1B4 //0x0800C1B4[13:12] : lvds bit-per-pixel type

#define COLOR_MATRIX_GAIN_BIT_SYSTEM			10

#define REFCLK 24576
#define NewTNRVer 0xabcdabcd



/*330
#if 0
#define COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM		7
#else
#define COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM		6
#endif
*/

#define COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM		10 //531

#define BRIGHTNESS_OFFSET  (2<<(COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM-1))

#define COLOR_MATRIX_GAIN_OSD_DIFFBIT			(COLOR_MATRIX_GAIN_BIT_SYSTEM-COLOR_MATRIX_GAIN_OSD_BIT_SYSTEM)
#define COLOR_MATRIX_BIAS_BIT_SYSTEM			8
#define COLOR_MATRIX_BIAS_OSD_BIT_SYSTEM		8
//#define COLOR_MATRIX_YPP_COMP_OFFSET			(16<<(COLOR_MATRIX_BIAS_BIT_SYSTEM-8))
#define COLOR_MATRIX_YPP_COMP_OFFSET			64*4

#define 	OFF			0
#define	WEAK		1
#define	MEDIUM		2
#define   STRONG		3
#define   AUTO		4

#define ERR_CNT 	20

#define PQ_DebugMsg_CustUserCurveInit 0x4
#define PQ_DebugMsg_CustUserCurvePolling 0x8

#define CSC_RGB		0
#define CSC_601		1
#define CSC_709		2

#define PQ_CMDSET_GET_RGN_LUT		0
#define PQ_CMDSET_SET_RGN_LUT		1
#define PQ_CMDSET_GET_RGN_LUT_STR	2
#define PQ_CMDSET_SET_RGN_LUT_STR	3
#define PQ_CMDSET_GET_RGN_LUT_330C	4
#define PQ_CMDSET_SET_RGN_LUT_330C	5
#define PQ_CMDSET_GET_RGN_LUT_V3	6
#define PQ_CMDSET_SET_RGN_LUT_V3	7
#define PQ_CMDSET_GET_COLOR_MATRIX	10
#define PQ_CMDSET_SET_COLOR_MATRIX	11
#define PQ_CMDSET_GET_SW_DC_SCENE_DET_SLOPE		20
#define PQ_CMDSET_SET_SW_DC_SCENE_DET_SLOPE		21
#define PQ_CMDSET_GET_SW_DC_SCENE_DET_CHROMA	22
#define PQ_CMDSET_SET_SW_DC_SCENE_DET_CHROMA	23
#define PQ_CMDSET_GET_SW_DC_SCENE_DET_PARAM		24
#define PQ_CMDSET_SET_SW_DC_SCENE_DET_PARAM		25
#define PQ_CMDSET_GET_SW_DC_SCENE_DET_INFO		26
#define PQ_CMDSET_GET_SW_DC_SCENE_DET_SOURCE	27
#define PQ_CMDSET_SET_SW_DC_SCENE_DET_SOURCE	28
#define PQ_CMDSET_GET_DRV_CURRENT_SOURCE	29
#define PQ_CMDSET_SET_NR_ADJUST_STATUS	30



#define PQ_CMDSET_GET_VIP_FLASH_INFO	60

#define 	UNLOCK 				0
#define 	LOCK				1

#define PQ_SAT_NO_OPERATION	0
#define PQ_SAT_SET_VALUE		1
#define PQ_SAT_INIT_VALUE		2
#define PQ_SAT_WAIT_5SEC		3
#define PQ_SAT_DETECT_SCENE	4
#define PQ_SAT_RE_SET_VALUE	5

#define SDNR_Gain_normal 100
#define SDNR_Gain_Low 130
#define SDNR_Gain_Mid 160
#define SDNR_Gain_High 200

#define 	DPY_EOF_EVENT		0x25

#define MODE_DeinterlaceFilter 0
#define VIP_TABLE_GROUPED_NUMBER 8 //for number of VIP table grouped setting
#define SNR_MAP_GAIN_NUM 2


/*******************************************************************************
* Enum
******************************************************************************/

//dynamic backlight change speed
enum
{
	BL_SLOW,
	BL_QUICK,
};



enum{
	USERCURVE_DETECT,
	USERCURVE_ENTERING,
};

enum{
	USERCURVE_OFF,
	USERCURVE_PQ,
	USERCURVE_HW,
	USERCURVE_HW_AUTO_TH,
};

enum {
	PQ_EVENT_NONWAITE,
	PQ_EVENT_WAITE
};
/*
    @ note : need sync with LUT source define in tool(ColorLUTvxDlg.h)
*/

typedef enum
{
	SRC_INDEX_ATV_NTSC=0,
	SRC_INDEX_ATV_PAL,
	SRC_INDEX_AV_NTSC,
	SRC_INDEX_AV_PAL,
	SRC_INDEX_SVideo_NTSC,
	SRC_INDEX_SVideo_PAL,
	SRC_INDEX_Component_SD,
	SRC_INDEX_Component_HD,
	SRC_INDEX_HDMI_SD,
	SRC_INDEX_HDMI_HD,
	SRC_INDEX_DTV_SD,
	SRC_INDEX_DTV_HD,
	SRC_INDEX_JPEG ,
	SRC_INDEX_PC,
	SRC_INDEX_DVI,
	SRC_INDEX_SCART_RGB,
	SRC_INDEX_DVD,
	SRC_INDEX_UNKNOWN
} PQ_LUT_SRC;


typedef enum
{
        ATV_IN,
        DTV_IN,
        DTV_HD_IN,
        AV_IN,
        SV_IN,
        COMP_IN,
        COMP_HD_IN,
        SCART_IN,
        HDMI_IN,
        HDMI_HD_IN,
        PC_IN,
        DVD_IN,
        DVD_HD_IN,
        END_IN,
        END_IN_EXT
}PQ_DLC_SRC;

typedef enum {
	PQ_ITEM_LUMA_TNR_CORING,
	PQ_ITEM_LUMA_TNR_STRENGTH,
	PQ_ITEM_CHROMA_TNR_CORING,
	PQ_ITEM_CHROMA_TNR_STRENGTH,
	PQ_ITEM_LUMA_SNR1_CORING,
	PQ_ITEM_LUMA_SNR1_STRENGTH,
	PQ_ITEM_LUMA_SNR2_CORING,
	PQ_ITEM_LUMA_SNR2_STRENGTH,
	PQ_ITEM_CHROMA_SNR_CORING,
	PQ_ITEM_CHROMA_SNR_STRENGTH,
	PQ_ITEM_BLOCK_NR_CORING,
	PQ_ITEM_BLOCK_NR_STRENGTH,
	PQ_ITEM_MOSQUITO_NR_CORING,
	PQ_ITEM_MOSQUITO_NR_STRENGTH,
	PQ_ITEM_TNR_ULTRA_LOW,
	PQ_ITEM_SNR1_ULTRA_LOW,
	PQ_ITEM_SNR2_ULTRA_LOW,
} PQ_ITEM;

typedef enum
{
    PQ_STANDARD_DEFINITION,
    PQ_HIGH_DEFINITION,
} PQ_Definition;

typedef enum
{
        NR_BLOCK_ALPHA_TNR,
        NR_BLOCK_ALPHA_TNR_SNR,
        NR_BLOCK_ALPHA_TNR_C,
        NR_BLOCK_ALPHA_TNRZ,
        NR_BLOCK_ALPHA_TNRZ_C,
        NR_BLOCK_ALPHA_END // 5
}PQ_NR_BLOCKALPHA_TYPE;

enum{
	PQ_SHARPNESS_0PERCENT,
	PQ_SHARPNESS_50PERCENT,
	PQ_SHARPNESS_100PERCENT,
	PQ_SHARPNESS_PERCENT_END
};


/*******************************************************************************
* Structure
******************************************************************************/
typedef struct _ST_PQ_CMDSET_CLR_MATRIX
{
	CSC_SETTING curMatrix; // before contrast, brightness, ColorTemp, Hue, Sat, Ypp_en compensation
	INT32 iMatrixC[3];
	INT32 iContrast;
	INT32 iBrightness;
	INT32 iCTRGBGain[3]; // R:0, G:1, B:2
	INT32 iCTRGBBias[3]; // R:0, G:1, B:2
	INT32 iHue;
	INT32 iSaturation;
} ST_PQ_CMDSET_CLR_MATRIX;

typedef struct _ST_PQ_CMDSET_CLR_MATRIX_EX
{
	CSC_SETTING curMatrix; // before contrast, brightness, ColorTemp, Hue, Sat, Ypp_en compensation
	INT32 iMatrixC[3];
	INT32 iContrast;
	INT32 iBrightness;
	INT32 iCTRGBGain[3]; // R:0, G:1, B:2
	INT32 iCTRGBBias[3]; // R:0, G:1, B:2
	INT32 iHue;
	INT32 iSaturation;
	INT32 iOSDGainBit;
	INT32 iOSDBiasBit;
} ST_PQ_CMDSET_CLR_MATRIX_EX;

typedef struct _SAT_INFO //saturation
{
	UINT8 ucOperation; //0: none 1:wait 5 sec to enter detecting 2:scene detect every 1 sec
	UINT8 ucSat;
	UINT8 ucDiff;
	UINT8 ucDiff_min;
	UINT8 ucDiff_max;
	BOOL bCeneChange;
	UINT16 nTimeout;
	spinlock_t SpinLock;
} SAT_INFO;

typedef struct _COLOR_MATRIX_COMP_INT
{
    INT32 iValue:12;
}COLOR_MATRIX_COMP_INT;



typedef struct _FL_SETTING
{
	INT32 detect_en;
	INT32 angle_max;
	INT32 angle_min;
	INT32 rot_angle;
	INT32 sin;
	INT32 cos;
	INT32 lrange;
	INT32 hrange;
	INT32 sat;
	INT32 sat_max;
	INT32 calc_bypass;
	INT32 q_left;
	INT32 q_right;
	INT32 q1;
} FL_SETTING;

typedef struct _RG_SETTING
{
	INT32 detect_en;
	INT32 angle_max;
	INT32 angle_min;
	INT32 rot_angle;
	INT32 sin;
	INT32 cos;
	INT32 lrange;
	INT32 hrange;
	INT32 mult;
	INT32 mult_max;
	INT32 calc_bypass;
	INT32 q;
	INT32 q1;
} RG_SETTING;

typedef struct _GAMMA_OPT
{
	INT32 pc_no_gamma;
} GAMMA_OPT;

typedef struct CR_MSETTING
{
	INT32 fl_mrange;
	INT32 reg0_mrange;
	INT32 reg1_mrange;
	INT32 reg2_mrange;
	INT32 reg3_mrange;
	INT32 reg4_mrange;
	INT32 reg5_mrange;
}CR_MSETTING;

typedef struct _DS_SHARP_RATIO
{
	INT32 ratio[6];

} DS_SHARP_RATIO;

typedef struct _SAT_GAIN_CURVE
{
	UINT8 mSatGainCurveSource[20];
	UINT8 sat_gb[8][16];
} SAT_GAIN_CURVE;



typedef struct _PQ_PATCH
{
    UINT8 Post2DPatch;
}PQ_PATCH;

typedef struct _PQ_MENU_VALUE
{
    INT32 iBrightness,iContrast,iSharpness,iSaturation,iHue;
    INT32 iColorTemp[3];
    INT32 iColorBias[3];
    UINT8 ucDCLevel;
    UINT8 ucCWLevel;
    INT8 cSGOffset;
    UINT8 ucNRLevel;
    UINT8 ucMPEGNRLevel;
    BOOL bNoGamma;
    UINT8 ucColorStyle;
    UINT8 ucColorProcess;

} PQ_MENU_VALUE;

typedef struct _SHARP_INFO
{
	//INT32 x1,m1,x2,m2,smooth,sharp;
	INT32 m1,m2,smooth,sharp;
	union {
		INT32 ilimit; // for initial fake
		UINT8 limit[4]; //0:sd or all(before V34) 1:md 2:hd 3:enable_flag
	};
	INT32 pivotx,pivoty;
} SHARP_INFO;

typedef struct _STRENGTH_DEFINE
{
	INT32 Degree[3]; //weak, medium, strong
} STRENGTH_DEFINE;

typedef struct _PEAKING_SETTING
{
	INT32 filter_y_h1;
	INT32 filter_y_h2;
	INT32 filter_y_h3;
	INT32 filter_y_h4;
} PEAKING_SETTING;

typedef struct _REG_RANGE
{
	INT32 min;
	INT32 max;
	INT32 middle;
} REG_RANGE;


typedef struct _DS_SHARP_INFO
{
	INT32 fac0,fac1,fac2,th0,th1,slope0,slope1;
	union {
		INT32 ioversht; // for initial fake
		UINT8 oversht[4]; //0:sd or all(before V34) 1:md 2:hd 3:enable_flag
	};
	union {
		INT32 iundersht; // for initial fake
		UINT8 undersht[4]; //0:sd or all(before V34) 1:md 2:hd 3:enable_flag
	};
} DS_SHARP_INFO;


typedef struct _DC_STRENGTH_DEFINE//dynamic contrast for v25
{
	UINT32 Degree[3]; //weak, medium, strong
} DC_STRENGTH_DEFINE;

typedef struct _DARK_SHARP_INFO
{
	UINT16 th[4];
	UINT16 fac[4];
	UINT8 slope[5];
	UINT8 reserve[2];
	UINT8 enable;
} DARK_SHARP_INFO;

typedef struct _REG_RANGE_EXT
{
	INT32 midleft;
	INT32 midright;
} REG_RANGE_EXT;

typedef struct _USER_CURVE_INFO
{
	const USER_BIN_SET*  pStaticGamma;
	const USER_BIN_SET*  pBlackLevelExtension;
	const USER_BIN_SET*  pWhiteLevelExtension;
} USER_CURVE_INFO;

typedef struct
{
	UINT32 TableOffset;
	UINT32 TableSize;
	UINT32 XorCRC;
	UINT32 TableFlag;
} LUTTableInfo;

typedef struct HeadStruct
{
    UINT8 LUTID[3];
    UINT8 Version;
    UINT32 FileSize;
    UINT16 IndexOffset;
    UINT16 HeadLength;
    UINT8 TableCount;
    UINT8 SrcCount;
	UINT8 HueScale;
    UINT8 Empty;
    UINT8 SrcIndex[32];
    UINT8 Reserved1[16];
    UINT8 Tag[32];
    LUTTableInfo TblInfo[8];
}LUTHead;


typedef struct LUTStruct
{
	UINT8 LUTID[3];
	UINT8 Version;
	UINT32 FileSize;
	UINT16 IndexOffset;
	UINT16 HeadLength;
	UINT8 TableCount;
	UINT8 SrcCount;
	UINT8 HueScale;
	UINT8 SatScale;
	UINT8 SrcIndex[32];
	UINT8 Reserved1[16];
	UINT8 Tag[32];
	LUTTableInfo TblInfo[8];
	UINT32 Pivot0[512];
	UINT16  PivotStrength0[512];
	UINT32 Pivot1[512];
	UINT16  PivotStrength1[512];
	UINT32 Pivot2[512];
	UINT16  PivotStrength2[512];
	UINT32 Pivot3[512];
	UINT16  PivotStrength3[512];
	UINT32 Pivot4[512];
	UINT16  PivotStrength4[512];
	UINT32 Pivot5[512];
	UINT16  PivotStrength5[512];
	UINT32 Pivot6[512];
	UINT16  PivotStrength6[512];
	UINT32 Pivot7[512];
	UINT16  PivotStrength7[512];
	UINT8 Reserved2[12];
	UINT16 FileXorCRC;
} LUTTable, *PLUTTable;

typedef struct _COLOR_LUT_330C_6BIT_INT
{
	INT32 iCb:6;
	INT32 iCr:6;
	INT32 iY:6;
}COLOR_LUT_330C_6BIT_INT;

typedef struct _NR_BLOCKALPHA_DEFINE
{
    UINT32 mmap_en;
	STRENGTH_DEFINE mthr[5];
    STRENGTH_DEFINE mslp[6];
    STRENGTH_DEFINE mfac[6];
} NR_BLOCKALPHA_DEFINE;

typedef struct NR_Setting_BY_Group_Idx
{
    STRENGTH_DEFINE LumaTnrCoring;
	STRENGTH_DEFINE LumaTnrStrength;
	STRENGTH_DEFINE ChromaTnrCoring;
	STRENGTH_DEFINE ChromaTnrStrength;
	STRENGTH_DEFINE LumaSnr1Coring;
	STRENGTH_DEFINE LumaSnr1Strength;
    STRENGTH_DEFINE LumaSnr2Coring;
	STRENGTH_DEFINE LumaSnr2Strength;
	STRENGTH_DEFINE ChromaSnrCoring;
	STRENGTH_DEFINE ChromaSnrStrength;
	STRENGTH_DEFINE BlockNrCoring;
	STRENGTH_DEFINE BlockNrStrength;
	STRENGTH_DEFINE MosquitoNrCoring;
	STRENGTH_DEFINE MosquitoNrStrength;
    INT32 			TnrUltraLowCtl;			   //v23	//bit[0]:weak bit[1]:medium bit[2]:strong
	INT32	 		SnrUltraLowCtl;
    NR_BLOCKALPHA_DEFINE NRBlockAlpha[NR_BLOCK_ALPHA_END];

}NR_Setting_BY_Group_Idx;

typedef struct _NR_Setting
{
    UINT8 mNRSourceGroupedIndex[20];
    NR_Setting_BY_Group_Idx mNRSetting_byGroupIdx[VIP_TABLE_GROUPED_NUMBER];

}NR_Setting;

typedef struct _UV_Coring_BY_Group_Idx
{
    INT32 iUVCoring_en;
    INT32 iUVCoring;
}UV_Coring_BY_Group_Idx;

typedef struct _UV_Coring
{
    UINT8 mUV_CoringGroupedIndex[20];
    UV_Coring_BY_Group_Idx UV_Coring_BY_Group_Idx[VIP_TABLE_GROUPED_NUMBER];
}UV_Coring;

//=== new sharpness PREDCTI
typedef struct _SHARP_PREDCTI_DATA
{
    INT32 iPreDCTIEnable;
    INT32 iPreChromaFilterEnable;
    INT32 iPostChromaFilterEnable;
    INT32 iPreChromaFilterLevel;
    INT32 icoef[3];
    INT32 iScale[PQ_SHARPNESS_PERCENT_END];
    INT32 iGainTap[PQ_SHARPNESS_PERCENT_END];
    INT32 iShootTap[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain0[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain1[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain2[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh0[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh1[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope0[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope1[PQ_SHARPNESS_PERCENT_END];
}SHARP_PREDCTI_DATA;

typedef struct _SHARP_PREDCTI
{
    UINT8 mGroupedIndex[20];
    SHARP_PREDCTI_DATA mPreDCTIData[VIP_TABLE_GROUPED_NUMBER];

}SHARP_PREDCTI;


//=== new sharpness POSTDCTI
typedef struct _SHARP_POSTDCTI_DATA
{
    INT32 iPostDCTIEnable;
    INT32 iPostChromaFilterEnable;
    INT32 iPreChromaFilterEnable;
    INT32 iPostChromaFilterLevel;
    INT32 icoef[6];
    INT32 iScale[PQ_SHARPNESS_PERCENT_END];
    INT32 iGainTap[PQ_SHARPNESS_PERCENT_END];
    INT32 iShootTap[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain0[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain1[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain2[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh0[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh1[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope0[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope1[PQ_SHARPNESS_PERCENT_END];
}SHARP_POSTDCTI_DATA;

typedef struct _SHARP_POSTDCTI
{
    UINT8 mGroupedIndex[20];
    SHARP_POSTDCTI_DATA mPostDCTIData[VIP_TABLE_GROUPED_NUMBER];
}SHARP_POSTDCTI;

//=== new sharpness POSTDLTI
typedef struct _SHARP_POSTDLTI_DATA
{
    INT32 iPostDLTIEnable;
    INT32 iDynamicClipEnable;
    INT32 icoef[6];
    INT32 iDnamicClipMode[PQ_SHARPNESS_PERCENT_END];
    INT32 iDnamicClipOverShoot[PQ_SHARPNESS_PERCENT_END];
    INT32 iDnamicClipUnderShoot[PQ_SHARPNESS_PERCENT_END];
    INT32 iDnamicClipOverShootfac[PQ_SHARPNESS_PERCENT_END];
    INT32 iDnamicClipUnderShootfac[PQ_SHARPNESS_PERCENT_END];
    INT32 iScale[PQ_SHARPNESS_PERCENT_END];
    INT32 iGainTap[PQ_SHARPNESS_PERCENT_END];
    INT32 iShootTap[PQ_SHARPNESS_PERCENT_END];
    INT32 iNormalOverShoot[PQ_SHARPNESS_PERCENT_END];
    INT32 iNormalUnderShoot[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain0[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain1[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain2[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh0[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh1[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope0[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope1[PQ_SHARPNESS_PERCENT_END];
}SHARP_POSTDLTI_DATA;

typedef struct _SHARP_POSTDLTI
{
    UINT8 mGroupedIndex[20];
    SHARP_POSTDLTI_DATA mPostDLTIData[VIP_TABLE_GROUPED_NUMBER];
}SHARP_POSTDLTI;

//=== new sharpness POST2DSHARPNESS
typedef struct _SHARP_POST2DSHARPNESS_DATA
{
    INT32 iPost2DSharpEnable;
    INT32 iGain0_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain1_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain2_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh0_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh1_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope0_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope1_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iFilterMode_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iScale_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iGainTap_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iShootTap_Luma[PQ_SHARPNESS_PERCENT_END];
    INT32 iNormalOverShoot[PQ_SHARPNESS_PERCENT_END];
    INT32 iNormalUnderShoot[PQ_SHARPNESS_PERCENT_END];
    INT32 iOverShootFactor[PQ_SHARPNESS_PERCENT_END];
    INT32 iUnderShootFactor[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain0_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain1_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iGain2_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh0_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iTh1_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope0_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iSlope1_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iFilterMode_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iScale_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iGainTap_Chroma[PQ_SHARPNESS_PERCENT_END];
    INT32 iShootTap_Chroma[PQ_SHARPNESS_PERCENT_END];
}SHARP_POST2DSHARPNESS_DATA;

typedef struct _SHARP_POST2DSHARPNESS
{
    UINT8 mGroupedIndex[20];
    SHARP_POST2DSHARPNESS_DATA mPost2DSharpData[VIP_TABLE_GROUPED_NUMBER];
}SHARP_POST2DSHARPNESS;

typedef struct _SAT_GAIN_CURVE_V2_DATA
{
    INT32 iDpySatEn;
    INT32 iDpySatOpt;
    INT32 iDpySatAll;
    INT32 iDpySatHue;
    INT32 iSat_Gain[17];
}SAT_GAIN_CURVE_V2I_DATA;


typedef struct _SAT_GAIN_CURVE_V2
{
    UINT8 mGroupedIndex[20];
    SAT_GAIN_CURVE_V2I_DATA mSatGainCurve_V2_Data[VIP_TABLE_GROUPED_NUMBER];
}SAT_GAIN_CURVE_V2;


//=== DS Sharpness 
typedef struct _DS_SHARPNESS_DATA
{
    STRENGTH_DEFINE	SlrSharpRatio;
    DS_SHARP_INFO DSSharpWeak[2];			// y/c
	DS_SHARP_INFO DSSharpNormal[2];
	DS_SHARP_INFO DSSharpStrong[2];
    UINT32		DS_Sharp_Angle;		//bit[0~1]:SD	bit[2~3]angle	bit[8~9]:MD	bit[10~11]:angle	bit[16~17]:HD	bit[18~19]:angle
    DARK_SHARP_INFO DSSharpDark;
}DS_SHARPNESS_DATA;


typedef struct _DS_SHARPNESS
{
    UINT8 mGroupedIndex[20];
    DS_SHARPNESS_DATA mDS_Sharpness_Data[VIP_TABLE_GROUPED_NUMBER];
}DS_SHARPNESS;

//=== HOR Sharpness
typedef struct _HOR_SHARPNESS_DATA
{
    DS_SHARP_INFO HorSharpWeak[2];			//v32 y/c
	DS_SHARP_INFO HorSharpNormal[2];
	DS_SHARP_INFO HorSharpStrong[2];
	DARK_SHARP_INFO HorSharpDark;
}HOR_SHARPNESS_DATA;


typedef struct _HOR_SHARPNESS
{
    UINT8 mGroupedIndex[20];
    HOR_SHARPNESS_DATA mHOR_Sharpness_Data[VIP_TABLE_GROUPED_NUMBER];
}HOR_SHARPNESS;

//=== Sharpness
typedef struct _SHARPNESS_DATA
{
    SHARP_INFO sharp_strong[4];
	SHARP_INFO sharp_normal[4];
	SHARP_INFO sharp_weak[4];
}SHARPNESS_DATA;


typedef struct _SHARPNESS
{
    UINT8 mGroupedIndex[20];
    SHARPNESS_DATA mSharpness_Data[VIP_TABLE_GROUPED_NUMBER];
}SHARPNESS;

//=== Peaking
typedef struct _PEAKING_DATA
{
 	PEAKING_SETTING Peaking[3]; //sd,md,hd
}PEAKING_DATA;


typedef struct _PEAKING
{
    UINT8 mGroupedIndex[20];
    PEAKING_DATA mPeaking_Data[VIP_TABLE_GROUPED_NUMBER];
}PEAKING;

//=== Range
typedef struct _RANGE_DATA
{
 	REG_RANGE		BrightnessRange;
	REG_RANGE		ContrastRange;
	REG_RANGE		ColorTempGainRange;
	REG_RANGE		ColorTempOffsetRange;
	REG_RANGE		SaturationRange;
	REG_RANGE		HueRange;
    REG_RANGE_EXT	BrightnessRangeExt;
	REG_RANGE_EXT	ContrastRangeExt;
	REG_RANGE_EXT	SaturationRangeExt;
}RANGE_DATA;


typedef struct _RANGE
{
    UINT8 mGroupedIndex[20];
    RANGE_DATA mRange_Data[VIP_TABLE_GROUPED_NUMBER];
}RANGE;

//=== DINTERLACE FILTER

typedef struct _DEIN_FILTER_DATA
{
	INT32 sd_vdi_mad_hlp_en;
	INT32 sd_slr_mix_ach;
	INT32 sd_slr_mix_bch;
	INT32 md_vdi_mad_hlp_en;
	INT32 md_slr_mix_ach;
	INT32 md_slr_mix_bch;
	INT32 hd_vdi_mad_hlp_en;
	INT32 hd_slr_mix_ach;
	INT32 hd_slr_mix_bch;
} DEIN_FILTER_DATA;


typedef struct _DEIN_FILTER
{
    UINT8 mGroupedIndex[20];
    DEIN_FILTER_DATA mDeIN_Fil_Data[VIP_TABLE_GROUPED_NUMBER];
}DEIN_FILTER;


//=== COLOR MATRIX

typedef struct _COLOR_MATRIX_DATA
{
	CSC_SETTING mSrcColorMatrix[2]; 
} COLOR_MATRIX_DATA;


typedef struct _COLOR_MATRIX
{
    UINT8 mGroupedIndex[20];
    COLOR_MATRIX_DATA mSrcColorMatrix[VIP_TABLE_GROUPED_NUMBER];
}COLOR_MATRIX;

//=== Dynamic Contrast

typedef struct _DLC_SET_CURVE_PARAM
{
	ST_SWDC_Slope dlc_luma_slope;
	ST_SWDC_Chroma dlc_chroma_slope;
	INT32  dlc_En;
	INT32  dlc_Var_Cond_En;
	INT32  dlc_Ratio[6];
	INT32  dlc_Factor[5];
	INT32  dlc_Alpha;
	INT32  dlc_Static_Alpha[4];
	INT32  dlc_YLevel;
	INT32  dlc_CLevel;
} DLC_SET_CURVE_PARAM;


typedef struct _DynamicContrast
{
    UINT8 mGroupedIndex[20];
    DLC_SET_CURVE_PARAM mDLC_Table[VIP_TABLE_GROUPED_NUMBER];
}DynamicContrast;

typedef enum
{
        NR_SNR_BEFORE_SCALER,
        NR_SNR_AFTER_SCALER,
        NR_SNR_END ,
}PQ_NR_SNR_TYPE;


typedef struct _SNR_DATA
{
   STRENGTH_DEFINE SNR_Sel;
   STRENGTH_DEFINE SNR_Chk_Middle_Pxl;
   STRENGTH_DEFINE SNR_th;
   STRENGTH_DEFINE SNR_Gain[SNR_MAP_GAIN_NUM];
   STRENGTH_DEFINE SNR_Slope;
}SNR_DATA;

typedef struct _SNR_Setting
{
    int SNR_MapByPass;
    SNR_DATA SNR_Luma;
    SNR_DATA SNR_Chroma;
}SNR_Setting;





//becareful! never change order or data type.
typedef struct _VTAB_CMN_VALUE_DEFINE
{
    int MagicNumber1;
	CSC_SETTING mColorSpaceConversionTable[3]; 	//v17// only 601 709  RGB
	int MagicNumber2;
	GAMMA_OPT mGmaOpt; 							//v18
	int MagicNumber3;
	INT32 ucLoadScartRGBTab;						//v21
	int MagicNumber4;
	DS_SHARP_RATIO mSharpRatio[2];				//v22 //y/c
	int MagicNumber5;
	INT32	iSharpRatio6;							//v27
	int MagicNumber6;
	INT32	iSharpRatio6_c;							//v27
	int MagicNumber7;
	SAT_GAIN_CURVE mSatGainCurve;		//v33
	int MagicNumber8;
    DynamicContrast mDynContrast;
    UINT32 MagicNumber9;
    NR_Setting mNRSetting;
    int MagicNumber10;
    UV_Coring mUV_Coring;
    int MagicNumber11;
    SHARP_PREDCTI mSharpness_PreDCTI;
    int MagicNumber12;
    SHARP_POSTDCTI mSharpness_PostDCTI;
    int MagicNumber13;
    SHARP_POSTDLTI mSharpness_PostDLTI;
    int MagicNumber14;
    SHARP_POST2DSHARPNESS mSharpness_Post2DSharpness;
    int MagicNumber15;
    SAT_GAIN_CURVE_V2 mSatGainCurve_V2;
    int MagicNumber16;
    DS_SHARPNESS mDS_Sharpenss;
    int MagicNumber17;
    HOR_SHARPNESS mHOR_Sharpenss;
    int MagicNumber18;
    PEAKING mPeaking;
    int MagicNumber19;
    RANGE mRange;
    int MagicNumber20;
    DEIN_FILTER mDeinterlaceFilter;
    int MagicNumber21;
    COLOR_MATRIX mColorMatrix;
    int MagicNumber22;
    SHARPNESS mSharpenss;  
    int MagicNumber23;
    UINT32 SlrLowAngleOrMBWDisable;
    int MagicNumber24;
    SNR_Setting mSNR1Setting[VIP_TABLE_GROUPED_NUMBER]; // only work at 331 chip
    SNR_Setting mSNR2Setting[VIP_TABLE_GROUPED_NUMBER]; // only work at 331 chip
    int MagicNumber25;
} VTAB_CMN_VALUE_DEFINE;

typedef struct _VTAB_SRC_VALUE_DEFINE
{
	INT32 iReserve1,iReserve2;
	  //v18
	INT32 			ColorRegionSrcCtl[4];	   //v19  //bit[0~5]:region[0~5] bit[6]:flesh tone bit[7]:source control enable
											//[0]:601 ctl, [1]:709 ctl, [2]:pal ctl, [3]:xvYcc
			   //v20   // only 601 709
	 //v28	//bit[0]:slr_low_dis_rgn1_en	bit[1]:slr_low_dis_rgn2_en		bit[2]:slr_low_dis_rgn3_en		bit[3]:slr_mbw_dis_rgn1_en		bit[4]:slr_mbw_dis_rgn2_en		bit[5]:slr_mbw_dis_rgn3_en
} VTAB_SRC_VALUE_DEFINE;


#ifdef DYNAMIC_BACKLIGHT
typedef struct _DYNAMIC_BACKLIGHT_PARAM
{
	UINT32 dwTableMin;	//min and max of baclight in panel set table
	UINT32 dwTableMid;
	UINT32 dwTableMax;
	UINT32 dwTableNormal;
	UINT32 dwLightMin;	//min and max of baclight in certain rate(cause by light sensor or energy saving)
	UINT32 dwLightMid;
	UINT32 dwLightMax;
	UINT32 dwLightQuot;
	UINT32 dwLightNormal;
	UINT32 dwLightTarget;
	INT32 iAdd;
	UINT32 dwWhiteLevel;
	UINT8 nBound1,nBound2,nBound3,nBound4; //boundaries in gray level: 0~255
	UINT16 wDetectFrameCount;
	UINT8 ucLevel;
	UINT8 ucLevelTarget;
	UINT8 ucOrder;			//1: much setting value has less backlight
	UINT8 bLightSensor:1;
	UINT8 bLSChangeBacklight;
	INT32 iLSADD;
	UINT32 dwLSTarge;
	UINT32 dwBackLightRate;
	UINT8 ucAllBlackStatus;
	struct semaphore sem;
	UINT32 BacklightTab[15];
	UINT8 ucTop, ucBot, ucTh_low, ucTh_High, ucbase;  //0~100%
	UINT8 ucHistMinPercentage;
	UINT8 ucDynamicBLType;
	UINT8 ucDBLContrastHi;
	UINT8 ucDBLContrastLow;
    UINT16 PWMDutyMax;
    UINT16 PWMDutyMin;
    Electity_PWM_Mapping_Table* pElectricity_PWM_table;
    UINT32 Electricity_PWM_table_Size;
} DYNAMIC_BACKLIGHT_PARAM;
#endif //#ifdef DYNAMIC_BACKLIGHT

typedef struct _SHARP_PREDCTI_RESERVE
{
    INT32 iTagetFac0; 
    INT32 iTagetFac1;
    INT32 iTagetFac2; 
    INT32 iTagetTh0; 
    INT32 iTagetTh1; 
    INT32 iTagetSlp0;
    INT32 iTagetSlp1; 
    INT32 iTargetScale; 
    INT32 iTargetGainTap; 
    INT32 iTargetShootTap;
}SHARP_PREDCTI_RESERVE;

typedef struct _SHARP_POSTDCTI_RESERVE
{
    INT32 iTagetFac0; 
    INT32 iTagetFac1; 
    INT32 iTagetFac2; 
    INT32 iTagetTh0; 
    INT32 iTagetTh1; 
    INT32 iTagetSlp0;
    INT32 iTagetSlp1; 
    INT32 iTargetScale; 
    INT32 iTargetGainTap; 
    INT32 iTargetShootTap;   
}SHARP_POSTDCTI_RESERVE;

typedef struct _SHARP_POSTDLTI_RESERVE
{
    INT32 iTagetFac0; 
    INT32 iTagetFac1; 
    INT32 iTagetFac2; 
    INT32 iTagetTh0; 
    INT32 iTagetTh1;
    INT32 iTagetSlp0;
    INT32 iTagetSlp1;
    INT32 iTargetScale;
    INT32 iTargetGainTap;
    INT32 iTargetShootTap; 
    INT32 iTargetDCMode;
    INT32 iTargetDCOverShoot;
    INT32 iTargetDCUnderShoot;
    INT32 iTargetDCOverShootfac;
    INT32 iTargetDCUnderShootfac;
    INT32 iTargetNorOverShoot; 
    INT32 iTargetNorlUnderShoot;
}SHARP_POSTDLTI_RESERVE;

typedef struct _SHARP_POST2D_RESERVE
{
    INT32 iTagetFac0_L; 
    INT32 iTagetFac1_L; 
    INT32 iTagetFac2_L; 
    INT32 iTagetTh0_L; 
    INT32 iTagetTh1_L; 
    INT32 iTagetSlp0_L;
    INT32 iTagetSlp1_L; 
    INT32 iTargetFM_L;
    INT32 iTargetScale_L;
    INT32 iTargetGainTap_L;
    INT32 iTargetShootTap_L;
    INT32 iTargetNorOverShoot;
    INT32 iTargetNorlUnderShoot;
    INT32 iTargetOverShootfac;
    INT32 iTargetUnderShootfac;
    INT32 iTagetFac0_C;
    INT32 iTagetFac1_C; 
    INT32 iTagetFac2_C;
    INT32 iTagetTh0_C;
    INT32 iTagetTh1_C;
    INT32 iTagetSlp0_C;
    INT32 iTagetSlp1_C;
    INT32 iTargetFM_C;
    INT32 iTargetScale_C;
    INT32 iTargetGainTap_C;
    INT32 iTargetShootTap_C;
}SHARP_POST2D_RESERVE;


typedef struct _PQHW_CONTEXT
{
	PQ_MENU_VALUE MenuValue;
	UINT8 ucLocationMode;	//0:home mode 1:sotre mode

	UINT8 GammaIndex;
	UINT8 GammaEnable;
	UINT8 GammaCount;
	UINT32 wGamaTable[1024];
	UINT8 ucNRUserMax;
	UINT8 ucNRUserMin;
	INT32 iColorMatrixC1;
	INT32 iColorMatrixC2;
	INT32 iColorMatrixC3;
	UINT8 ucMPEGNRUserMax;
	UINT8 CVD2_store_nr_setting;
	CSC_SETTING* CurColorMatrix;
	//SAT_INFO SatInfo; //joshua: nobody use
	VTAB_CMN_VALUE_DEFINE VtabCmnValue;
	VTAB_SRC_VALUE_DEFINE* pCurVtabSrcValue;
	INT32 iCurrContrastValue; //backup current contrast value for fade in/out

	SAT_INFO SatInfo;
	USER_CURVE_INFO UserCurveInfo;
	VTAB_SRC_VALUE_DEFINE VtabSrcValue[VTAB_MAX_SOURCE];
	unsigned nNRLevel;//:2; //Noise Reduction Level: {Off, Weak, Medium, Strong}
	unsigned nMPEGNRLevel;//:2; //Noise Reduction Level of MPEG format: {Off, Weak, Medium, Strong}
	unsigned nColorSpaceMode:2; // {Off, Auto, Normal, Wide}
	unsigned bDynamicSaturation:2; //{Off, On}
	unsigned bEnableColorProcess:1;
	UINT8 ucMPEGNRUserMin;
	UINT8 Degree;
	INT8 hl_sharp;
	INT8 hc_sharp;
	INT8 hl_smooth;
	INT8 hc_smooth;
	UINT8 hl_menu_sharp;
	UINT8 hc_menu_sharp;
	BOOL bSceneChg;
	INT32 store_hl_limit;
	INT32 store_vl_limit;
	UINT8  UserCurveInit;
	UINT8 LoadPQTable;
	UINT8 ucDynamicBacklightMode;
	UINT8 ucDynamicContrastLevel;
	spinlock_t Spin_PresetContrast;
	UINT8  UserCurveSetup;
	// SOFTWARE_COLOR_MATRIX
	INT32 iBrightness;
	INT32 iRBias;
	INT32 iGBias;
	INT32 iBBias;
	INT32 iContrast;
	INT32 iRGain;
	INT32 iGGain;
	INT32 iBGain;
	INT32 iHue;
	INT32 iSaturation;
	UINT8 menu_sharpness;
	UINT8 ucMatrixbypassCtl;
	INT32 iAdjustNRCounter;
	BOOL bFadeEn;
	UINT8 ucFadeStartValue;
	UINT8 ucFadeEndValue;
	UINT8 ucFadeIncValue;
	UINT8 ucYuvDataFormat;

//#ifdef  VIP_SW_DC
#if 1
	INT32  ulCurveSlop[16];
	UINT16 ulHistCaseCur;
#endif
	BOOL bPWMOff; // for tunr off PWM, not set PWM any more
	SHARP_PREDCTI_RESERVE mSharp_PREDCTI_Reserve;    
    SHARP_POSTDCTI_RESERVE mSharp_POSTDCTI_Reserve;    
    SHARP_POSTDLTI_RESERVE mSharp_POSTDLTI_Reserve;    
    SHARP_POST2D_RESERVE mSharp_POST2D_Reserve;
    BOOL bNR_Reset_by_changeSrc;
    PQ_PATCH PqPatch;
}PQHW_CONTEXT;

enum{
    POST_2D_SHARPNESS_JPEG_THUMBNAIL_PATCH,     
    POST_2D_SHARPNESS_DEFAULT,  //default
};

typedef struct _COLORLUT_VALUE_INT6
{
	INT32 x:6;
	INT32 y:6;
	INT32 z:6;
}COLORLUT_VALUE_INT6;

typedef struct _COLOR_MATRIX_INT
{
	INT32 iValue:14;
}COLOR_MATRIX_INT;

typedef struct _LUT_OFFSET
{
	int Hoffset;
	int Soffset;
	int Yoffset;
} LUT_OFFSET;


typedef struct _COLORLUT_BUF
{
	LUT_OFFSET lutOffset[16][11][32];
}COLORLUT_BUF;

void PQ_ColorLUT_SetRegion(INT32 iRegionIdx, INT32 iSatGain, INT32 iYGain, INT32 iRotAngle, INT32 iRotGain, INT32 bEnable, BOOL bSet);

/*******************************************************************************
* Program
******************************************************************************/
//========================register read/write function========================
UINT32 PQ_GetRegisterType(UINT32 ulRegisterType);
void PQ_RegisterWrite(UINT32 ulRegisterName, UINT32 ulValue);
UINT32 PQ_RegisterRead(UINT32 ulRegisterName );
UINT8 PQ_CheckSpecialRegister(UINT32 ulReg);
//========================pq main flow setting function========================

//============================local func.=================================
void PQ_ColorMatrixComp(UINT8 bReset);
void PQ_ColorMatrixSetup(UINT8 bReset, UINT8 ucNum);
void PQ_FleshTone_Init(void);
void PQ_NR_Init(void);
void PQ_SetupStrength(PQ_ITEM ucItemID, UINT8 ucDegree);
UINT32 PQ_ChromaBinPercentage(UINT8 ucBin);
BOOL PQ_SWDTColorBar(void);
void PQ_PCColorBar_SharpnessPatch(void); //eric
void PQ_ColorBarDetect(void); //sharlene
void PQ_AdjustNr(void);
void PQ_LoadSettingValue(UINT8*, UINT8 ucTableIndex);
void PQ_ColorSpaceMode(UINT8 ucMode, UINT8 ucInputSource);
void PQ_InitVtabValue(void);
void PQ_Sharpness_PREDCTI(BOOL bReset,UINT8 ucValue);
void PQ_Sharpness_POSTDCTI(BOOL bReset,UINT8 ucValue);
void PQ_Sharpness_POSTDLTI(BOOL bReset,UINT8 ucValue);
void PQ_Sharpness_POST_2D(BOOL bReset,UINT8 ucValue);
void PQ_HorSharpness(BOOL bReset,UINT8 ucValue);
void PQ_DSSharpness(BOOL bReset,UINT8 ucValue);
void PQ_DPYSharpness(BOOL bReset,UINT8 ucValue);
void PQ_CalcPivotxy(SHARP_INFO* sharp_info);
void PQ_NRLevel(UINT32 nr_level, UINT32 vdi_total);
void PQ_MPEGNRLevel(UINT32 nr_level, UINT32 vdi_total);
BOOL PQ_AccessColorMatrix(UINT32 *pulData, INT32 AccessMode, UINT32 dwDataSize);
BOOL PQ_AccessColorLUT(UINT32 *pulAddr, INT32 AcessMode, BOOL bNew, INT32 LUTBlockIndex);
BOOL PQ_SetColorLUTStr(UINT16 *pwAddr);
BOOL PQ_GetColorLUTStr(UINT16 *pwAddr);
void PQ_ConditionSetting(UINT8 ucMode);
void PQ_VDeblockFilterEnable(void);
BOOL PQ_NtscPalDetect(void);
void PQ_DS_Init(void);
void PQ_DSSetting(void);
void PQ_SLR_ColorBarDetailSet(void);
void PQ_DeinterlaceFilter(void);
VTAB_SRC_VALUE_DEFINE* PQ_GetSourceVTab(UINT8 ucSource, UINT8 ucSubSource);
void PQ_DeblockFilterAndDetect(BOOL bDemoMode, UINT32 vdi_hsize_i, UINT32 vdi_vsize);
void PQ_HmeSetup(UINT32 vdi_hsize_i, UINT32 vdi_vsize);
void PQ_HmeControl(void);
void PQ_GmeSetup(void);
void PQ_MADSetup(UINT32 vdi_hsize_i, UINT32 vdi_vsize, UINT32 vdi_total);
void PQ_2232DetSetup(UINT32 vdi_total);
void PQ_NERegion(BOOL bDemoMode, UINT32 vdi_hsize_i, UINT32 vdi_vsize);
BOOL PQ_CheckTableCheckSum(UINT8*);
void PQ_LoadSettingTable(UINT8*, UINT8 ucTableIndex);
void PQ_RegisterWrite_user_curve(UINT32 ulRegister,UINT32 ulValue);
UINT8 check_usr_curve_setup_ok(void);
void PQ_GetHistBin(UINT32 *Y_Hist);
void PQ_SetHistBinindex(UINT8 index);

//==========================local func. end================================

BOOL PQ_SetGammaTable(UINT32 *pulAddr);
UINT32 PQ_LoadGammaTable(UINT32 *pulAddr);
void PQ_SetLocationMode(UINT8 ucMode);
void PQ_SetCurrContrastValue(INT32 iValue);
INT32 PQ_GetCurrContrastValue(void);
INT32 PQ_GetMenuColorBias(UINT8 index);
BOOL PQ_GetColorProcessor(void);
void PQ_SetupColorSpaceConversionTable(void);
void PQ_PureColorControl(INT16 ucPure, INT8 ucPicture);
void PQ_ColorTempBias(PQ_COLOR_TEMP_BIAS ucType, INT32 iValue);
void PQ_SetColorMatrix(UINT8 ucEnable);
void PQ_FilterSetup(UINT8 ucSource, UINT8 ucSubSource);
void PQ_LowAngleSetting(void);
void PQ_PeakingFilterSetup(void);
void PQ_InitialTable(void);
void PQ_DefaultSetting(void);
void PQ_ColorProcesserDisable(void);
void PQ_ColorProcesser(UINT8 ucEnable);
BOOL PQ_ParsePQCmdSet(UINT32 *pulAddr);
void PQ_GetYavg(UINT32 *Y_AVG);
UINT8 PQ_GetAvgY_Value(void);
void PQ_GammaCorrect(UINT8);
void PQ_Hue(UINT8 ucIndex);
void PQ_ColorStyleSaturation(UINT8 ucType);
void PQ_Saturation(INT32 iValue);
void PQ_Brightness(UINT8 bReset, INT32 iValue);
void PQ_Sharpness(BOOL bReset,UINT8 ucValue);
void PQ_DemoModeWidth(void);
void PQ_Contrast(UINT8 bReset, INT32 iValue);
void PQ_EnablePrint(UINT8 ucEnable);
void PQ_GetVtabHwRange(UINT8 ucFunID, INT32* pMin, INT32* pMax, INT32* pMiddle);
void PQ_GetVtabHwRangeExt(UINT8 ucFunID, INT32* pMidLeft, INT32* pMidRight);
void PQ_VDISize(void);
INT32 PQ_WatchDemo_Get_AvgY(void);
void PQ_ColorTempGain(PQ_COLOR_TEMP_GAIN ucType, INT32 iValue);
void PQ_3DNoiseReductoin(UINT8 ucMode,UINT8 iUserMin, UINT8 iUserMax);
void PQ_Set_NR_BlockAlpha(UINT8 NRBlockAlphaType);
void PQ_Set_NR_SLR_SNR(UINT8 ucSLR_SNR_TYPE);
void PQ_MPEGNoiseReductoin(UINT8 ucLevel,UINT8 iUserMin, UINT8 iUserMax);
void PQ_SetupGammaTable(UINT8 ucEnable, UINT8 ucTableIndex);
void PQ_DemoModeEnable(UINT8 demo_enable);
void PQ_DPYDemoModeEnable(UINT8 demo_enable);
void PQ_StaticGammaSetup(INT8 cOffset);
void PQ_SetDithering(UINT8 ucStatus);
void PQ_DitheringLevel(UINT8 ucLevel);
void PQ_DitheringAlgo(UINT8 ucAlgo);
void PQ_SourceSetting(UINT8 ucSource, UINT8 ucSubSource);
void PQ_SourceSelect(UINT8 ucUserInputSource);
void PQ_SetMenuValue(UINT8 ucFunID, INT32 iValue);
void PQ_DPYSetup(UINT8 ucUserSource,UINT8 ucSubSource);
void PQ_HWDestroyWorkqueue(void);
INT32 PQ_GetMenuHueValue(void);
UINT8 PQ_GetGammaEnableSt(void);
void PQ_GetRegInfo(PQ_RegInfo* pRegInfo);


//#ifdef  VIP_SW_DC
#if 1

void PQ_GetSWDCParameter(void);
void PQ_SW_DynamicContrast_UserCurveAdjust(void);
void PQ_GetSWDCParamCmd(ST_SWDC_Param *param);
void PQ_SetSWDCParamCmd(ST_SWDC_Param *param);
void PQ_GetSWDCSlopeCmd(ST_SWDC_Slope *pstSlope);
void PQ_SetSWDCSlopeCmd(ST_SWDC_Slope *pstSlope);
void PQ_GetSWDCChromaCmd(ST_SWDC_Chroma*pstChroma);
void PQ_SetSWDCChromaCmd(ST_SWDC_Chroma*pstChroma);
void PQ_GetSWDCInfoCmd(ST_SWDC_Info *info);
void PQ_GetSWDCSourceCmd(UINT8 *param);
void PQ_SetSWDCSourceCmd(UINT8 *param);
void PQ_GetDrvCurrentSourceCmd(UINT8 *param);
void PQ_SW_DynamicContrast_UserCurveAdjust(void);
void PQ_SW_DynamicContrast_Param(UINT8 ucSource);
void PQ_SW_DynamicContrast_Enable(UINT8 wValue);
void PQ_SW_DynamicContrast_Y_Level(UINT16 wValue);
void PQ_SW_DynamicContrast_C_Level(UINT16 wValue);
void PQ_SW_DynamicContrast_Alpha_Mode(UINT8 bMode ,UINT8 bValue);
#endif
UINT8 VIP_Get_PQ_Source(UINT8 ucSource, UINT8 ucSubSource);


//330
UINT8 PQ_Get_Source_Grouped_Index(void);
void PQ_Default_Color_Lut_Setting(void);
BOOL PQ_SetupLUTTable(UINT8 ucEnable);
void PQ_SetupSaturationGainCurve(BOOL bEnable);
BOOL PQ_IsFadeEn(void);
void PQ_SetFadeValue(BOOL bFadeEn, UINT8 ucStartValue, UINT8 ucEndValue, UINT8 ucIncValue);
void PQ_SetFadeInOut(void);
void PQ_Set_UV_Coring(void);
void PQ_regionLumaAverage(UINT8 bRegionIndex,UINT8 bTotalHnum,UINT8 bTotalVnum);
void PQ_GetRegionLumaAverage(UINT16* bRegionYaverage);


#ifdef DYNAMIC_BACKLIGHT
UINT8 PQ_GETAllBlackStatus(void);
UINT32 PQ_GetBackLight(void);
void PQ_SetBackLight(UINT32 dwValue);
UINT32 PQ_GetRealBackLight(void);
void PQ_SetRealBackLight(UINT32 dwValue);
UINT32 PQ_GetHomeModeValue(UINT32 *pValue);
void PQ_GetLightSensorInfo(UINT8 ucLSensorEn,UINT8 ucIndex, UINT32 dwLight);
void PQ_SetBacklightParameter(UINT8 ucTop,UINT8 ucBot,UINT8 ucTh_low,UINT8 ucTh_High);
void PQ_LightSensorChange(void);
void PQ_InitDynamicBackLight(void);
void PQ_DynamicBackLightAP(UINT8 ucLevel, UINT32 dwMap);
void PQ_EnableDynamicBackLight(UINT8 ucLevel, UINT32 dwLightUser);
UINT32 PQ_BackLightTarget(UINT8 nDBLStatus, UINT8 nWhiteCondition, UINT32 dwCur);
BOOL PQ_ColorSearchAutoDet(UINT8 ucPath, UINT8 ucColorType ,UINT32 *pulMaxValue, UINT32*pulMinValue);
UINT8 PQ_AllBlackDetect(void);
void PQ_LEDBackLightDetect(BOOL bReset);
void PQ_FormalBackLightDetect(BOOL bReset);
UINT32 PQ_EEBackLightTarget(UINT8 nDBLStatus, UINT32 dwWhiteLevel, UINT32 dwCur);
void PQ_EEBackLightDetect(BOOL bReset);
void PQ_PresetContrast(BOOL bReset, INT32 iValue, INT32 nSpeed);
void PQ_PresetBackLight(BOOL bReset, UINT32 dwLightTarget, INT32 nSpeed);
void PQ_SISPresetContrast(UINT8 ucValue, INT32 nSpeed);
void PQ_SetDynamicBacklightMode(UINT8 ucMode);
void PQ_SetBacklightLevel(UINT8 ucLevel);
void PQ_SetBacklightHistMin(UINT8 ucValue);
void PQ_SetDynamicBLType(UINT8 ucType);
UINT8 PQ_GetDynamicBLType(void);
UINT8 PQ_GetOrderedBackLight(UINT32 *pLight);
void PQ_SetMaxPWM(UINT32 ucValue);
void PQ_FlDetLevel(UINT8 ucLevel);
UINT8 PQ_GetDefinitionIndex(void);

#endif

void PQ_HW_Initial(void);
UINT8 _VIP_InputWidthEnlargeRate(void);
UINT32 PQ_Get_VDI_VSize(void);
#endif //#ifndef _PQ_HW_H