1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78
79 ////////////////////////////////////////////////////////////////////////////////
80 //
81 // Copyright (c) 2008-2010 MStar Semiconductor, Inc.
82 // All rights reserved.
83 //
84 // Unless otherwise stipulated in writing, any and all information contained
85 // herein regardless in any format shall remain the sole proprietary of
86 // MStar Semiconductor Inc. and be kept in strict confidence
87 // ("MStar Confidential Information") by the recipient.
88 // Any unauthorized act including without limitation unauthorized disclosure,
89 // copying, use, reproduction, sale, distribution, modification, disassembling,
90 // reverse engineering and compiling of the contents of MStar Confidential
91 // Information is unlawful and strictly prohibited. MStar hereby reserves the
92 // rights to any and all damages, losses, costs and expenses resulting therefrom.
93 //
94 ////////////////////////////////////////////////////////////////////////////////
95
96 ///////////////////////////////////////////////////////////////////////////////////////////////////
97 /// file Mdrv_ldalgo.c
98 /// @brief local dimming algorithm
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 #define _MDRV_LDALGO_C_
103
104 #include "MsCommon.h"
105 #include "MsOS.h"
106 #include "utopia_dapi.h"
107 #include "mhal_xc_chip_config.h"
108 #include "hwreg_sc.h"
109 #include "drvXC_IOPort.h"
110 #include "apiXC.h"
111 #include "drv_sc_display.h"
112 #include "drv_sc_isr.h"
113 #include "apiXC_Adc.h"
114 #include "apiXC_Auto.h"
115 #include "apiXC_PCMonitor.h"
116 #include "apiXC_ModeParse.h"
117 #include "drvXC_HDMI_if.h"
118 #include "mvideo_context.h"
119 #include "drv_sc_ip.h"
120 // Internal Definition
121 #include "mdrv_ld.h"
122 #include "mdrv_ldalgo.h"
123 #include "mdrv_ld_gamma.h"
124
125 #include "mdrv_sc_3d.h"
126 #include "drv_sc_menuload.h"
127 #include "drvXC_ADC_Internal.h"
128 #include "mhal_sc.h"
129 #if FRC_INSIDE
130 #include "mdrv_frc.h"
131 #include "mhal_frc.h"
132 #endif
133 #include "XC_private.h"
134
135
136
137 #if (LD_ENABLE == 1)
138 //--------------------------------------------------------
139 //--------Local dimmming macro define---------------------
140 //--------------------------------------------------------
141 #define MAX_AVG_BLENDING 1
142 #define DIRECTTYPE_PATCH_ENABLE 0
143 #define ADD_OPPOSITE_LUMA 1
144
145 #define LUMA_AVG_DIFF_THRESHOLD1 0x38
146 #define LUMA_AVG_DIFF_THRESHOLD2 0x28
147 #define BIN_WIDTH 16
148
149 #ifndef MIN
150 #define MIN(a,b) (((a) < (b)) ? (a) : (b))
151 #endif
152
153 #ifndef MAX
154 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
155 #endif
156
157 #define ABS(x) (((x) > 0) ? (x) : (-(x)))
158 #define DIFF(a,b) (((a) > (b)) ? ((a) - (b)) : ((b) - (a)))
159 #define MINMAX(v,a,b) (((v) < (a)) ? (a) : ((v) > (b)) ? (b) : (v))
160
161 #ifndef UNUSED
162 #define UNUSED(x) ((x) = (x))
163 #endif
164
165 //----------------------------------------------------------
166 //--------Local dimmming Local variables--------------------
167 //----------------------------------------------------------
168 #if 0 //
169 static Enu_LD_BLOCK_NUM s_a_LDBlockTBL[]={
170 LD_BLOCK_10, //LD_PANEL_LG32inch_LR10
171 LD_BLOCK_10, //LD_PANEL_LG37inch_LR10
172 LD_BLOCK_16, //LD_PANEL_LG42inch_LR16
173 LD_BLOCK_16, //LD_PANEL_LG47inch_LR16
174 LD_BLOCK_16, //LD_PANEL_LG55inch_LR16
175 LD_BLOCK_TSB, //LD_PANEL_TOSHIBA_LR16
176 LD_BLOCK_TSB, //LD_PANEL_TOSHIBA_TB16
177 LD_BLOCK_DEFALUT, //===Empty===
178 LD_BLOCK_32, //LD_PANEL_LG50inchCinema_TB32
179 LD_BLOCK_32, //LD_PANEL_LG60inchCinema_TB32
180 LD_BLOCK_72, //LD_PANEL_LG47inch_Direct72
181 LD_BLOCK_96, //LD_PANEL_LG55inch_Direct96
182 LD_BLOCK_480, //LD_PANEL_LG72inch_Direct480
183 };
184 #endif
185
186
187 //-------------------------------------------------------------
188 //--------Local dimmming internal interface--------------------
189 //-------------------------------------------------------------
190
MDrv_appLDModeHandler_R2(void * pInstance)191 void MDrv_appLDModeHandler_R2(void *pInstance)
192 {
193 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
194 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
195 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
196 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
197 pXCResourcePrivate->stdrv_LDALGO._stLDInfo = MDrv_LD_GetLDInfo(pInstance);
198 //MFC_3D_FORMAT e3DMode = MDrv_SysInfo_GetInternal3DMode();
199 //Eun_LD_PANEL_TYPE eLDPanelType = MDrv_SysInfo_GetPanelLDType();
200 pXCResourcePrivate->stdrv_LDALGO._enLDBlock_Num = LD_BLOCK_16;///s_a_LDBlockTBL[eLDPanelType];
201
202 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh = pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LedNumV;
203 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth = pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LedNumH;
204 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth = pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LD_BackLightH;
205 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight = pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LD_BackLightV;
206 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize = pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LedNumV * pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LedNumH;
207 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16BLSize = pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LD_BackLightH * pXCResourcePrivate->stdrv_LDALGO._stLDInfo.u8LD_BackLightV;
208 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LD_Mode2D3D = 0;
209 pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LD_Mode2D3D_tmax = 0;
210 }
211
MDrv_Temporal_Max(void * pInstance,MS_BOOL bLR_Flag)212 MS_U32 MDrv_Temporal_Max(void *pInstance, MS_BOOL bLR_Flag) //NO_USE
213 {
214 MS_U8 u8MaxTemp1 = 0;
215 MS_U8 u8MaxTemp2 = 0;
216 MS_U8 u8MaxTemp3 = 0;
217 MS_U8 i = 0;
218 MS_U8 j = 0;
219 MS_U32 u32Luma_Sum = 0;
220 MS_U32 u32Luma_Avg = 0;
221 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
222 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
223 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
224 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
225 for (i = 0; i < BIN_WIDTH; i++)
226 {
227 pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i] = 0;
228 }
229
230 if (bLR_Flag)
231 {
232 for (j = 0 ; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
233 {
234 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
235 {
236 u8MaxTemp1 = pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i];
237 pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block_Pre[j][i] = pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i];
238 }
239 }
240 }
241 else
242 {
243 pXCResourcePrivate->stdrv_LDALGO._u16Histogram_Zero = 0;
244 for (j = 0 ; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
245 {
246 for (i = 0 ; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
247 {
248 u8MaxTemp1 = pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i];
249 u8MaxTemp2 = pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block_Pre[j][i];
250 u8MaxTemp3 = MAX(u8MaxTemp1, u8MaxTemp2);
251 pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i] = u8MaxTemp3;
252
253 pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[(pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i]/BIN_WIDTH)]++;
254 if(pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i] == 0)
255 {
256 pXCResourcePrivate->stdrv_LDALGO._u16Histogram_Zero++;
257 }
258 }
259 }
260 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize == 0)
261 {
262 return 0;
263 }
264 else
265 {
266 return u32Luma_Avg = u32Luma_Sum/pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize;
267 }
268 }
269
270 return 0;
271 }
272
273
274
MDrv_FramLockBffdepack_CSep_8B_Full(void * pInstance)275 MS_U32 MDrv_FramLockBffdepack_CSep_8B_Full(void *pInstance) // depack per 4 pixel = 128bit = 16 bytes
276 {
277 MS_U32 u32Ioffset = 0; // Byte index of packed data
278 MS_U8 u8Bpixel = 0, u8Rpixel = 0;
279 MS_U32 u32Luma_Avg = 0;
280 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
281 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
282 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
283 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
284 MS_U8 u8LDWidth_Input = pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth;
285 MS_U8 u8LDHeight_Input = pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight;
286 MS_U8 u8MaxTemp1 = 0;
287
288 #if (MAX_AVG_BLENDING == 0)
289 MS_U32 u32Block_Avg = 0;
290 MS_U32 u32Block_Max = 0;
291 //int block_alpha=0;
292 MS_U32 u32Block_Alpha_Tmp = 0;
293 //long u32Frame_Avg_Sum,u32Frame_Avg;
294 MS_U8 u8Block_Avg_Thrd_High = 50;
295 MS_U8 u8Block_Avg_Thrd_Low = 34;
296 #endif
297 pXCResourcePrivate->stdrv_LDALGO._u32Lluma_Sum = 0;
298
299 for (u8Rpixel = 0; u8Rpixel < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight; u8Rpixel++)
300 {
301 for (u8Bpixel = 0; u8Bpixel < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth; u8Bpixel++)
302 {
303 #if (MAX_AVG_BLENDING)
304 if (pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx_Final == 0)
305 {
306 u8MaxTemp1 = MDrv_LD_MIUReadByte(LD_BUF_ReadDBuf_1, u8Bpixel + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_LD*u8Rpixel);
307 }
308 else
309 {
310 u8MaxTemp1 = MDrv_LD_MIUReadByte(LD_BUF_ReadDBuf_0, u8Bpixel + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_LD*u8Rpixel);
311 }
312 pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[u8Rpixel][u8Bpixel] = u8MaxTemp1;
313 #else
314 {
315 //u32Block_Avg = readb(BANK_MIU+Ipack+8*(u8Bpixel+_stLDPanelPara.u8LDWidth*u8Rpixel)+FramLockMbase);
316 //u32Block_Max = readb(BANK_MIU+Ipack+8*(u8Bpixel+_stLDPanelPara.u8LDWidth*u8Rpixel)+4+FramLockMbase);
317 //block_alpha = readb(HAL_MSTAR_AEON_RIU_BASE+HAL_REGBANK_OFFSET(0x3300 / 2 + 0x1F)) & 0xF;
318 if (pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx_Final == 0)
319 {
320 u32Block_Avg = MDrv_LD_MIUReadByte(LD_BUF_ReadDBuf_1, 8*(u8Bpixel + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth * u8Rpixel));
321 u32Block_Max = MDrv_LD_MIUReadByte(LD_BUF_ReadDBuf_1, 8*(u8Bpixel + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth * u8Rpixel) + 4);
322 }
323 else
324 {
325 u32Block_Avg = MDrv_LD_MIUReadByte(LD_BUF_ReadDBuf_0, 8*(u8Bpixel + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth * u8Rpixel));
326 u32Block_Max = MDrv_LD_MIUReadByte(LD_BUF_ReadDBuf_0, 8*(u8Bpixel + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth * u8Rpixel) + 4);
327 }
328
329 if ( ABS(u32Block_Max-u32Block_Avg) >= u8Block_Avg_Thrd_High )
330 {
331 u8MaxTemp1 = (u32Block_Max * 16 + u32Block_Avg * 0)/16;
332 }
333 else if ( (ABS(u32Block_Max-u32Block_Avg) < u8Block_Avg_Thrd_High) && (ABS(u32Block_Max-u32Block_Avg) >= u8Block_Avg_Thrd_Low) )
334 {
335 u32Block_Alpha_Tmp = MAX(ABS(u32Block_Max - u32Block_Avg) - 34, 0);
336 u8MaxTemp1 = (u32Block_Max * u32Block_Alpha_Tmp + u32Block_Avg * (16 - u32Block_Alpha_Tmp))/16;
337 }
338 else
339 {
340 u8MaxTemp1 = (u32Block_Max * 0 + u32Block_Avg * 16)/16;
341 }
342
343 pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[u8Rpixel][u8Bpixel] = u8MaxTemp1;
344 }
345 #endif
346 pXCResourcePrivate->stdrv_LDALGO._u32Lluma_Sum += u8MaxTemp1;
347 u32Ioffset++;
348 }
349 }
350
351 if ( (u8LDHeight_Input == 0) || (u8LDWidth_Input == 0) )
352 return pXCResourcePrivate->stdrv_LDALGO._u32Lluma_Sum;
353 else
354 return u32Luma_Avg = pXCResourcePrivate->stdrv_LDALGO._u32Lluma_Sum/(u8LDHeight_Input * u8LDWidth_Input);
355 }
356
MDrv_LD_Get_Value(void * pInstance,MS_U8 * pu8LDValue,MS_U8 u8WSize,MS_U8 u8HSize)357 MS_BOOL MDrv_LD_Get_Value(void *pInstance, MS_U8 *pu8LDValue, MS_U8 u8WSize, MS_U8 u8HSize )
358 {
359 MS_U8 u8Bpixel = 0, u8Rpixel = 0;
360 MS_U16 i=0;
361 MS_U32 u32HScalingDownRatio=0, u32VScalingDownRatio=0;
362 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
363 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
364 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
365 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
366
367 MS_WINDOW_TYPE DEWin;
368 Hal_SC_get_disp_de_window(pInstance, &DEWin);
369
370 // boundary of weight / height
371 if((u8WSize > 32 || u8WSize < 1) || (u8HSize > 18 || u8HSize < 1))
372 {
373 return FALSE;
374 }
375
376 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_46_L, 0 ,0xFF);
377 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_72_L, 0 ,0xFF);
378
379 //Calculate [9:5]Height [4:0]Width
380 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_03_L, ((MS_U16)(u8HSize-1) << 5 |(u8WSize-1)) , 0x3FF);
381
382 if((DEWin.width <= 3000)&&(pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_Pnl_Misc.FRCInfo.bFRC))
383 {
384 //When FRC case input source is FHD. The NAPOLI output is 2k2k to FRC.
385 u32HScalingDownRatio = ((MS_U32)u8WSize * 1024 *1024*2 /pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width) +1 ;
386 }
387 else
388 {
389 //input horizontal scaling down ratio = (W_ledx1024x1024/W_lcd)+1
390 u32HScalingDownRatio = ((MS_U32)u8WSize * 1024 *1024 /pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Width) +1 ;
391 }
392
393 //input vertical scaling down ratio = (H_ledx1024x1024/H_lcd)+1
394 u32VScalingDownRatio = ((MS_U32)u8HSize * 1024 *1024 /pXCResourcePrivate->stdrvXC_MVideo_Context.g_XC_InitData.stPanelInfo.u16Height) +1 ;
395
396 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_19_L, (MS_U16)(u32HScalingDownRatio&0xFFFF) ,0xFFFF);
397 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1A_L, (MS_U16)((u32HScalingDownRatio>> 16)&0xF) ,0xF);
398 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1B_L, (MS_U16)(u32VScalingDownRatio&0xFFFF) ,0xFFFF);
399 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1C_L, (MS_U16)((u32VScalingDownRatio>> 16)&0xF) ,0xF);
400
401 SC_W2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_1F_L, 0x8 ,0xF);
402
403 for (u8Rpixel = 0; u8Rpixel < u8HSize; u8Rpixel++)
404 {
405 for (u8Bpixel = 0; u8Bpixel < u8WSize; u8Bpixel++)
406 {
407 pu8LDValue[i] = MDrv_LD_MIUReadByte(LD_BUF_ReadDBuf_0, u8Bpixel + u8WSize*u8Rpixel);
408 i++;
409 }
410 }
411 return TRUE;
412
413 }
414
MDrv_Output_SPIdata(void * pInstance)415 void MDrv_Output_SPIdata(void *pInstance)
416 {
417 MS_U8 i = 0,j = 0;
418 MS_U8 u8Tmp = 0;
419 #if 0 //for debug printf
420 MS_U8 h,v;
421 #endif
422 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
423 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
424 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
425 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
426 MS_U32 u32WriteBuf = ((pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx_Final == 0) ? LD_BUF_SPIBuf_0 : LD_BUF_SPIBuf_1);
427 MS_U8 u8Min_BLight_value = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_76_L, 0x00FF);//readb(HAL_MSTAR_AEON_RIU_BASE+HAL_REGBANK_OFFSET(0x3300 / 2 + 0xEC/2)) & 0xFF;
428
429 MS_U32 u32Frame_Avg_Sum = 0,u32Frame_Avg = 0;
430
431 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
432 {
433 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
434 {
435 u8Tmp = pXCResourcePrivate->stdrv_LDALGO._u8LED_resort[i + j * pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth];
436 pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[j][i] = MAX(u8Tmp, u8Min_BLight_value);
437 u32Frame_Avg_Sum += pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[j][i];
438 pXCResourcePrivate->stdrv_LDALGO._u8LD_AlgoSPIBuffer[j * pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth + i] = pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[j][i];
439 }
440 }
441
442 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth == 2)
443 {
444 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh % 2) // odd patch
445 {
446 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]);//1
447 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]);//2
448 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]);//3
449 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);//4
450 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);//9
451 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);//7
452 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);//2
453 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]);//4
454 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, 0);
455 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, 0);
456 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);//10
457 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);//8
458 }
459 else
460 {
461 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh == 6)
462 {
463 MDrv_LD_MIUWriteByte(u32WriteBuf, 0, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]);//1
464 MDrv_LD_MIUWriteByte(u32WriteBuf, 1, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);//2
465 MDrv_LD_MIUWriteByte(u32WriteBuf, 2, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]);//3
466 MDrv_LD_MIUWriteByte(u32WriteBuf, 3, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);//4
467 MDrv_LD_MIUWriteByte(u32WriteBuf, 4, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]);//9
468 MDrv_LD_MIUWriteByte(u32WriteBuf, 5, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);//7
469 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]);//2
470 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);//4
471 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);
472 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);
473 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][0]);//10
474 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][1]);//8
475 }
476 else
477 {
478 if (Mdrv_LD_GetPanelType(pInstance) == E_LD_PANEL_CMO42inch_LR16)
479 {
480 MDrv_LD_MIUWriteByte(u32WriteBuf, 0,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]);//1
481 MDrv_LD_MIUWriteByte(u32WriteBuf, 1,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]);//2
482 MDrv_LD_MIUWriteByte(u32WriteBuf, 2,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]);//2
483 MDrv_LD_MIUWriteByte(u32WriteBuf, 3,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]);//4
484 MDrv_LD_MIUWriteByte(u32WriteBuf, 4,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);//3
485 MDrv_LD_MIUWriteByte(u32WriteBuf, 5,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][0]);
486 MDrv_LD_MIUWriteByte(u32WriteBuf, 6,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][0]);//3
487 MDrv_LD_MIUWriteByte(u32WriteBuf, 7,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][0]);
488
489 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][1]);//4
490 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][1]);
491 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][1]);//9
492 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);//10
493 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);//7
494 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);
495 MDrv_LD_MIUWriteByte(u32WriteBuf, 6 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);
496 MDrv_LD_MIUWriteByte(u32WriteBuf, 7 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);
497 }
498 else
499 {
500 MDrv_LD_MIUWriteByte(u32WriteBuf, 0, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]);//1
501 MDrv_LD_MIUWriteByte(u32WriteBuf, 1, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]);//2
502 MDrv_LD_MIUWriteByte(u32WriteBuf, 2, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]);//2
503 MDrv_LD_MIUWriteByte(u32WriteBuf, 3, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]);//4
504 MDrv_LD_MIUWriteByte(u32WriteBuf, 4, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);//3
505 MDrv_LD_MIUWriteByte(u32WriteBuf, 5, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][0]);
506 MDrv_LD_MIUWriteByte(u32WriteBuf, 6, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][0]);//3
507 MDrv_LD_MIUWriteByte(u32WriteBuf, 7, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][0]);
508
509 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);//4
510 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);
511 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);//9
512 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);//10
513 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);//7
514 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][1]);
515 MDrv_LD_MIUWriteByte(u32WriteBuf, 6 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][1]);
516 MDrv_LD_MIUWriteByte(u32WriteBuf, 7 + pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][1]);
517 }
518 }
519 }
520 }
521 else
522 {
523 for (j = 0 ; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
524 {
525 for (i = 0;i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
526 {
527 MDrv_LD_MIUWriteByte(u32WriteBuf, i + j*pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[j][i]);
528 }
529 }
530 }
531
532 u32Frame_Avg = (u32Frame_Avg_Sum + (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize/2) )/(pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize);
533
534 if (REG_DEBUG_LD_DUMP_SEL == E_LD_DUMP_PWM_Block)
535 {
536 pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt = (pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt + 1)%8;
537 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
538 {
539 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
540 {
541 MDrv_LD_MIUWriteByte(LD_BUF_WriteBuf_0, (0x20 + pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt*2) + j*0x10 + i ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[j][i]);//1
542 }
543 }
544 }
545 #if 0
546 for( v = 0; v < 6; ++ v )
547 {
548 for( h = 0; h < 2; ++ h )
549 {
550 printf("0x%02X,", _u8LD_AlgoSPIBuffer[i] );
551 i += 1;
552 }
553 printf("\n" );
554 }
555 #endif
556 MDrv_LD_SetLocalDimmingData(pInstance, pXCResourcePrivate->stdrv_LDALGO._u8LD_AlgoSPIBuffer, (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh * pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth));
557 }
558
559
MDrv_Output_DigitalBLdata(void * pInstance)560 void MDrv_Output_DigitalBLdata(void *pInstance)
561 {
562 MS_U8 i = 0,j = 0;
563 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
564 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
565 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
566 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
567 MS_U32 u32WriteBuf = ((pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx_Final == 0) ? LD_BUF_WriteBuf_0 : LD_BUF_WriteBuf_1);
568
569 if ( pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth == 2)
570 {
571 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh % 2) // odd patch
572 {
573 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]);//1
574 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]);//2
575 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]);//3
576 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);//4
577 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);//9
578 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);//7
579 MDrv_LD_MIUWriteByte(u32WriteBuf, 0+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);//2
580 MDrv_LD_MIUWriteByte(u32WriteBuf, 1+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]);//4
581 MDrv_LD_MIUWriteByte(u32WriteBuf, 2+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,0);
582 MDrv_LD_MIUWriteByte(u32WriteBuf, 3+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,0);
583 MDrv_LD_MIUWriteByte(u32WriteBuf, 4+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);//10
584 MDrv_LD_MIUWriteByte(u32WriteBuf, 5+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);//8
585 }
586 else
587 {
588 #if 0
589 for(i = 0;i<_stLDPanelPara.u8PWMWidth;i++)
590 {
591 for(j=0 ; j< _stLDPanelPara.u8PWMHigh; j++)
592 {
593 MDrv_LD_MIUWriteByte(u32WriteBuf, j+i*_u8pack_length_PWM ,_u8PWM_Block[j][i]);
594 }
595 }
596 #endif
597 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh == 6)
598 {
599 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]);//1
600 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]);//2
601 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]);//3
602 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);//4
603 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);//9
604 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);//7
605 MDrv_LD_MIUWriteByte(u32WriteBuf, 0+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][0]);//2
606 MDrv_LD_MIUWriteByte(u32WriteBuf, 1+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);//4
607 MDrv_LD_MIUWriteByte(u32WriteBuf, 2+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]);
608 MDrv_LD_MIUWriteByte(u32WriteBuf, 3+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);
609 MDrv_LD_MIUWriteByte(u32WriteBuf, 4+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);//10
610 MDrv_LD_MIUWriteByte(u32WriteBuf, 5+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][1]);//8
611 }
612 else
613 {
614 if (Mdrv_LD_GetPanelType(pInstance) == E_LD_PANEL_CMO42inch_LR16)
615 {
616 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]); //1
617 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]); //2
618 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]); //2
619 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]); //4
620
621 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);//7
622 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);
623 MDrv_LD_MIUWriteByte(u32WriteBuf, 6 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);
624 MDrv_LD_MIUWriteByte(u32WriteBuf, 7 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);
625
626 MDrv_LD_MIUWriteByte(u32WriteBuf, 0+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][0]);//4
627 MDrv_LD_MIUWriteByte(u32WriteBuf, 1+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][0]);
628 MDrv_LD_MIUWriteByte(u32WriteBuf, 2+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][0]);//9
629 MDrv_LD_MIUWriteByte(u32WriteBuf, 3+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);//10
630
631 MDrv_LD_MIUWriteByte(u32WriteBuf, 4+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);//4
632 MDrv_LD_MIUWriteByte(u32WriteBuf, 5+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][1]);
633 MDrv_LD_MIUWriteByte(u32WriteBuf, 6+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][1]);//9
634 MDrv_LD_MIUWriteByte(u32WriteBuf, 7+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][1]);//10
635
636 }
637 else
638 {
639 MDrv_LD_MIUWriteByte(u32WriteBuf, 0 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][0]);//1
640 MDrv_LD_MIUWriteByte(u32WriteBuf, 1 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][0]);//2
641 MDrv_LD_MIUWriteByte(u32WriteBuf, 2 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][0]);//2
642 MDrv_LD_MIUWriteByte(u32WriteBuf, 3 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][0]);//4
643 MDrv_LD_MIUWriteByte(u32WriteBuf, 4 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][0]);//3
644 MDrv_LD_MIUWriteByte(u32WriteBuf, 5 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][0]);
645 MDrv_LD_MIUWriteByte(u32WriteBuf, 6 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][0]);//3
646 MDrv_LD_MIUWriteByte(u32WriteBuf, 7 ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][0]);
647
648 MDrv_LD_MIUWriteByte(u32WriteBuf, 0+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[0][1]);//4
649 MDrv_LD_MIUWriteByte(u32WriteBuf, 1+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[1][1]);
650 MDrv_LD_MIUWriteByte(u32WriteBuf, 2+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[2][1]);//9
651 MDrv_LD_MIUWriteByte(u32WriteBuf, 3+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[3][1]);//10
652 MDrv_LD_MIUWriteByte(u32WriteBuf, 4+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[4][1]);//7
653 MDrv_LD_MIUWriteByte(u32WriteBuf, 5+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[5][1]);
654 MDrv_LD_MIUWriteByte(u32WriteBuf, 6+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[6][1]);
655 MDrv_LD_MIUWriteByte(u32WriteBuf, 7+pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM ,pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[7][1]);
656 }
657 }
658 }
659 }
660 else
661 {
662 for (j = 0 ; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
663 {
664 for (i = 0;i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth;i++)
665 {
666 MDrv_LD_MIUWriteByte(u32WriteBuf, i + j * pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM, pXCResourcePrivate->stdrv_LDALGO._u8PWM_Block[j][i]);
667 }
668 }
669 }
670 }
671
672
MDrv_LD_3Ddownsample(void * pInstance,MS_U8 u8ModeSelection_3D)673 void MDrv_LD_3Ddownsample(void *pInstance, MS_U8 u8ModeSelection_3D)
674 {
675 MS_U8 i = 0,j = 0;
676 MS_U8 u8MaxL = 0,u8MaxR = 0;
677 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
678 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
679 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
680 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
681 switch (u8ModeSelection_3D)
682 {
683 case 0:
684 default:
685 return;
686
687 case 1:
688 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight); j++)
689 {
690 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth/2); i++)
691 {
692 u8MaxL = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i];
693 u8MaxR = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth/2];
694 pXCResourcePrivate->stdrv_LDALGO._u8SBSDown_Block[j][i] = MAX(u8MaxL, u8MaxR);
695 }
696 }
697 break;
698
699 case 2:
700 if ( pXCResourcePrivate->stdrv_LDALGO._enLDBlock_Num != LD_BLOCK_480)
701 {
702 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight/2); j++)
703 {
704 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth); i++)
705 {
706 u8MaxL = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i];
707 u8MaxR = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight/2][i];
708 pXCResourcePrivate->stdrv_LDALGO._u8TBDown_Block[j][i] = MAX(u8MaxL, u8MaxR);
709 }
710 }
711 }
712 else
713 {
714 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight+1)/2; j++)
715 {
716 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth); i++)
717 {
718 u8MaxL = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i];
719 u8MaxR = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight/2][i];
720 pXCResourcePrivate->stdrv_LDALGO._u8TBDown_Block[j][i] = MAX(u8MaxL, u8MaxR);
721 }
722 }
723 }
724 break;
725
726 case 3:
727 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight); j++)
728 {
729 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth/2); i++)
730 {
731 u8MaxL = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i];
732 u8MaxR = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth/2];
733 pXCResourcePrivate->stdrv_LDALGO._u8SBSDown_Block[j][i] = MAX(u8MaxL, 0);
734 }
735 }
736 break;
737
738 case 4:
739 if (pXCResourcePrivate->stdrv_LDALGO._enLDBlock_Num != LD_BLOCK_480)
740 {
741 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight/2); j++)
742 {
743 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth); i++)
744 {
745 u8MaxL = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i];
746 u8MaxR = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight/2][i];
747 pXCResourcePrivate->stdrv_LDALGO._u8TBDown_Block[j][i] = MAX(u8MaxL, 0);
748 }
749 }
750 }
751 else
752 {
753 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight+1)/2; j++)
754 {
755 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth); i++)
756 {
757 u8MaxL = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i];
758 u8MaxR = pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j + pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight/2][i];
759 pXCResourcePrivate->stdrv_LDALGO._u8TBDown_Block[j][i] = MAX(u8MaxL, 0);
760 }
761 }
762 }
763 break;
764 }
765 }
766
MDrv_Get_Histogram(void * pInstance)767 void MDrv_Get_Histogram(void *pInstance)
768 {
769 MS_U8 i = 0,j = 0;
770 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
771 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
772 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
773 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
774 pXCResourcePrivate->stdrv_LDALGO._u16Histogram_Zero = 0;
775
776 for (i = 0; i < BIN_WIDTH; i++)
777 {
778 pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i] = 0;
779 }
780
781
782 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight; j++)
783 {
784 for (i = 0 ; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth; i++)
785 {
786 pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[(pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i]/BIN_WIDTH)]++;
787 if (pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i] < 3)
788 {
789 pXCResourcePrivate->stdrv_LDALGO._u16Histogram_Zero++;
790 }
791 }
792 }
793 }
794
MDrv_BLMxNto2xN_White_8B(void * pInstance)795 void MDrv_BLMxNto2xN_White_8B(void *pInstance)
796 {
797 MS_U8 i = 0, j = 0;
798 MS_U8 u8Max = 0, u8Itemp = 0;
799 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
800 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
801 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
802 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
803 MDrv_Get_Histogram(pInstance);
804
805 MDrv_LD_3Ddownsample(pInstance, pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LD_Mode2D3D);
806
807 switch (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LD_Mode2D3D)
808 {
809 case 0:
810 default:
811 for (j = 0 ; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight); j++)
812 {
813 for (i = 0 ; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth); i=i+pXCResourcePrivate->stdrv_LDALGO._u8H_Down_Ratio )
814 {
815 u8Max = 0;
816 for (u8Itemp = 0 ; u8Itemp < pXCResourcePrivate->stdrv_LDALGO._u8H_Down_Ratio; u8Itemp++)
817 {
818 u8Max = MAX(u8Max,pXCResourcePrivate->stdrv_LDALGO._u8Input_Block[j][i+u8Itemp]);
819 }
820 if (pXCResourcePrivate->stdrv_LDALGO._u8H_Down_Ratio > 0)
821 {
822 pXCResourcePrivate->stdrv_LDALGO._u8HDown_Block[j][i/pXCResourcePrivate->stdrv_LDALGO._u8H_Down_Ratio] = u8Max;
823 }
824 }
825 }
826 break;
827
828 #if 0 //A5 no need 3D scaling
829 case 1:
830 case 3:
831 for (j = 0 ; j < (_stLDPanelPara.u8LDHigh); j++)
832 {
833 for (i = 0 ; i < (_stLDPanelPara.u8LDWidth/2); i=i+_u8H_Down_Ratio_3D)
834 {
835 u8Max = 0 ;
836 for (u8Itemp = 0 ; u8Itemp < _u8H_Down_Ratio_3D ; u8Itemp++)
837 u8Max = MAX(u8Max,_u8SBSdown_Block[j][i+u8Itemp]);
838 _u8Hdown_Block[j][i/_u8H_Down_Ratio_3D] = u8Max;
839 }
840 }
841 break;
842
843 case 2:
844 case 4:
845 for (j = 0 ; j < (_stLDPanelPara.u8LDHigh/2); j++)
846 {
847 for (i = 0 ; i < (_stLDPanelPara.u8LDWidth); i=i+_u8H_down_ratio)
848 {
849 u8Max = 0 ;
850 for (u8Itemp = 0 ; u8Itemp < _u8H_down_ratio ; u8Itemp++)
851 u8Max = MAX(u8Max,_u8TBdown_Block[j][i+u8Itemp]);
852
853 _u8Hdown_Block[j][i/_u8H_down_ratio] = u8Max;
854 }
855 }
856 break;
857
858 default:
859 break;
860 #endif
861 }
862
863 }
864
865
MDrv_BL2xNto2xNd3_White_8B(void * pInstance)866 void MDrv_BL2xNto2xNd3_White_8B(void *pInstance)
867 {
868 MS_U8 i =0,j = 0;
869 MS_U8 u8Max = 0, u8Itemp = 0;
870 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
871 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
872 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
873 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
874 switch (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LD_Mode2D3D)
875 {
876 case 0:
877 case 1:
878 case 3:
879 default:
880 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight); j = j + pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio )
881 {
882 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth); i++)
883 {
884 u8Max = 0;
885 for (u8Itemp = 0; u8Itemp < pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio ; u8Itemp++)
886 {
887 u8Max = MAX(u8Max, pXCResourcePrivate->stdrv_LDALGO._u8HDown_Block[j+u8Itemp][i]);
888 }
889 if (pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio > 0)
890 {
891 pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j/pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio][i] = u8Max;
892 }
893 }
894 }
895 break;
896
897 case 2:
898 case 4:
899 if (pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio_3D == 0)
900 {
901 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh/2); j++)
902 {
903 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth); i++)
904 {
905 u8Max = pXCResourcePrivate->stdrv_LDALGO._u8HDown_Block[j][i];
906 pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j*2][i] = u8Max;
907 pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j*2+1][i] = u8Max;
908 }
909 }
910 }
911 else if (pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio_3D == 1)
912 {
913 for (j = 0; j < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh); j++)
914 {
915 for (i = 0; i < (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth); i++)
916 {
917 pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i] = pXCResourcePrivate->stdrv_LDALGO._u8HDown_Block[j][i];
918 }
919 }
920 }
921 break;
922 }
923
924 if (REG_DEBUG_LD_DUMP_SEL == E_LD_DUMP_VDown_Block)
925 {
926 pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt = (pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt+1)%8;
927 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
928 {
929 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
930 {
931 MDrv_LD_MIUWriteByte(LD_BUF_WriteBuf_0, (0x20 + pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt*2) + j*0x10 + i , pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i]);//1
932 }
933 }
934 }
935
936 }
937
938 #if 0
939 void MDrv_BLMxNto2xN_White_8B_480block(void)
940 {
941 int i, j, u8Itemp;
942 int u8Max;
943
944 MDrv_Get_histogram();
945
946 MDrv_LD_3Ddownsample(_stLDPanelPara.u8LD_Mode2D3D);
947
948 if(_stLDPanelPara.u8LD_Mode2D3D==0 )
949 {
950 for (j = 0 ; j < (_stLDPanelPara.u8LDHigh); j++)
951 {
952 for (i = 0 ; i < (_stLDPanelPara.u8LDWidth); i=i+_u8H_down_ratio )
953 {
954 u8Max = 0 ;
955 for (u8Itemp = 0 ; u8Itemp < _u8H_down_ratio ; u8Itemp++)
956 u8Max = MAX(u8Max,_u8Input_Block[j][i+u8Itemp]);
957 _u8Hdown_Block[j][i/_u8H_down_ratio] = u8Max;
958 }
959 }
960 }
961 else if(_stLDPanelPara.u8LD_Mode2D3D==1 || _stLDPanelPara.u8LD_Mode2D3D==3)
962 {
963 for (j = 0 ; j < (_stLDPanelPara.u8LDHigh); j++)
964 {
965 for (i = 0 ; i < (_stLDPanelPara.u8PWMWidth/2); i++)
966 {
967 u8Max = _u8SBSdown_Block[j][i];
968 _u8Hdown_Block[j][i*2] = u8Max;
969 _u8Hdown_Block[j][i*2+1] = u8Max;
970 }
971 }
972 }
973 else if(_stLDPanelPara.u8LD_Mode2D3D==2 || _stLDPanelPara.u8LD_Mode2D3D==4)
974 {
975 for (j = 0 ; j < (_stLDPanelPara.u8LDHigh+1)/2 ; j++)
976 {
977 for (i = 0 ; i < (_stLDPanelPara.u8LDWidth); i=i+_u8H_down_ratio)
978 {
979 u8Max = 0 ;
980 for (u8Itemp = 0 ; u8Itemp < _u8H_down_ratio ; u8Itemp++)
981 u8Max = MAX(u8Max,_u8TBdown_Block[j][i+u8Itemp]);
982 _u8Hdown_Block[j][i/_u8H_down_ratio] = u8Max;
983 }
984 }
985 }
986 }
987
988
989 void MDrv_BL2xNto2xNd3_White_8B_480block(void)
990 {
991 int j, i;
992 int u8Max;
993 int u8Itemp;
994 if( _stLDPanelPara.u8LD_Mode2D3D==0 || _stLDPanelPara.u8LD_Mode2D3D==1 || _stLDPanelPara.u8LD_Mode2D3D==3)
995 {
996 for (j = 0 ; j < (_stLDPanelPara.u8LDHigh); j=j+_u8V_down_ratio )
997 {
998 for (i = 0 ; i < (_stLDPanelPara.u8PWMWidth); i++)
999 {
1000 u8Max = 0;
1001 for (u8Itemp = 0 ; u8Itemp < _u8V_down_ratio ; u8Itemp++)
1002 {
1003 u8Max = MAX(u8Max,_u8Hdown_Block[j+u8Itemp][i]);
1004 }
1005 _u8Vdown_Block[j/_u8V_down_ratio][i] = u8Max;
1006
1007 }
1008 }
1009 }
1010 else if( _stLDPanelPara.u8LD_Mode2D3D==2 || _stLDPanelPara.u8LD_Mode2D3D==4)
1011 {
1012 for (j = 0 ; j < (_stLDPanelPara.u8LDHigh); j++)
1013 {
1014 for (i = 0 ; i < (_stLDPanelPara.u8PWMWidth); i++)
1015 {
1016 u8Max = MAX ( _u8Hdown_Block[j/2][i],_u8Hdown_Block[MAX(j-(j/2),0)][i] );
1017 _u8Vdown_Block[j][i] = u8Max;
1018 }
1019 }
1020 }
1021 }
1022 #endif
1023
MDrv_Spatial_Filtering1D_Large(void * pInstance,MS_U8 x_index,MS_U8 y_index,MS_U8 u8Spatial_Strength)1024 MS_U8 MDrv_Spatial_Filtering1D_Large(void *pInstance, MS_U8 x_index, MS_U8 y_index, MS_U8 u8Spatial_Strength)
1025 {
1026 MS_U8 u8Max_Value = 0;
1027 MS_U8 u8Tmp_Value_Adj[5];
1028 MS_S8 x = 0,y = 0;
1029 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1030 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1031 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1032 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1033 if(pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth == 2)
1034 {
1035 for(y = -2; y < 3; y++)
1036 {
1037 if( ( (y+y_index >= 0) && (y+y_index < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh) ) )
1038 {
1039 u8Tmp_Value_Adj[y+2] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[y+y_index][x_index];
1040 }
1041 else
1042 {
1043 u8Tmp_Value_Adj[y+2] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[y_index][x_index];
1044 }
1045 }
1046 }
1047 else
1048 {
1049 for(x = -2; x < 3; x++)
1050 {
1051 if( ( (x+x_index >= 0) && (x+x_index < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh ) ) )
1052 {
1053 u8Tmp_Value_Adj[x+2] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[y_index][x+x_index];
1054 }
1055 else
1056 {
1057 u8Tmp_Value_Adj[x+2] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[y_index][x_index];
1058 }
1059 }
1060 }
1061 for(x = -2; x < 3; x++)
1062 {
1063 if(u8Tmp_Value_Adj[x+2] >= u8Max_Value)
1064 {
1065 u8Max_Value = u8Tmp_Value_Adj[x+2];
1066 }
1067 }
1068 if(u8Tmp_Value_Adj[2] == u8Max_Value )
1069 {
1070 return u8Max_Value;
1071 }
1072 else if(u8Tmp_Value_Adj[1] == u8Max_Value || u8Tmp_Value_Adj[3] == u8Max_Value)
1073 {
1074 if(u8Tmp_Value_Adj[2]>= MAX ( u8Max_Value -u8Spatial_Strength,0) )
1075 {
1076 return u8Tmp_Value_Adj[2];
1077 }
1078 else
1079 {
1080 return MAX( u8Max_Value - u8Spatial_Strength, 0);
1081 }
1082 }
1083 else if(u8Tmp_Value_Adj[0] == u8Max_Value || u8Tmp_Value_Adj[4] == u8Max_Value)
1084 {
1085 if(u8Tmp_Value_Adj[2] >= MAX ( u8Max_Value - 2*u8Spatial_Strength, 0) )
1086 {
1087 return u8Tmp_Value_Adj[2];
1088 }
1089 else
1090 {
1091 return MAX ( u8Max_Value - 2* u8Spatial_Strength,0);
1092 }
1093 }
1094 return 0;
1095 }
1096
MDrv_Spatial_Filtering2D(void * pInstance,MS_U8 i_index,MS_U8 j_index,MS_U8 u8Spatial_Strength)1097 MS_U8 MDrv_Spatial_Filtering2D(void *pInstance, MS_U8 i_index, MS_U8 j_index, MS_U8 u8Spatial_Strength)
1098 {
1099 MS_U8 u8Max_Value = 0;
1100 MS_U8 au8Tmp_Value_Adj[5][5];
1101 MS_U8 u8Max_Value_Array = 0, u8Max_Value_Array1 = 0, u8Max_Value_Array2 = 0;
1102 MS_U8 u8Loop_Circle = 2;
1103 MS_S8 i = 0,j = 0;
1104 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1105 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1106 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1107 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1108
1109 for (j = -2; j < 3; j++)
1110 {
1111 for (i = -2; i < 3; i++)
1112 {
1113 if (( (i+i_index >= 0) && (i + i_index<pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth ) )
1114 && ( (j+j_index >= 0) && (j+j_index<pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh) ))
1115 {
1116 au8Tmp_Value_Adj[j+2][i+2] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j+j_index][i+i_index];
1117 }
1118 else
1119 {
1120 au8Tmp_Value_Adj[j+2][i+2] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j_index][i_index];
1121 }
1122 }
1123 }
1124
1125 for (j = -2;j < 3; j++)
1126 {
1127 for ( i =-2; i < 3; i++)
1128 {
1129 if ( (au8Tmp_Value_Adj[j+2][i+2] > u8Max_Value_Array2) && (MAX( ABS(i),ABS(j)) == 2) )
1130 {
1131 u8Max_Value_Array2 = au8Tmp_Value_Adj[j+2][i+2];
1132 //u8Loop_Circle = 2;
1133 }
1134 if ( (au8Tmp_Value_Adj[j+2][i+2] > u8Max_Value_Array1) && (MAX( ABS(i),ABS(j)) == 1) )
1135 {
1136 u8Max_Value_Array1 = au8Tmp_Value_Adj[j+2][i+2];
1137 // u8Loop_Circle = 2;
1138 }
1139 }
1140 }
1141
1142 if (u8Max_Value_Array1 >= u8Max_Value_Array2)
1143 {
1144 u8Loop_Circle = 1;
1145 u8Max_Value_Array = u8Max_Value_Array1;
1146 }
1147 else
1148 {
1149 u8Loop_Circle = 2;
1150 u8Max_Value_Array = u8Max_Value_Array2;
1151 }
1152
1153 if ( au8Tmp_Value_Adj[2][2] >= u8Max_Value_Array)
1154 {
1155 u8Max_Value = au8Tmp_Value_Adj[2][2];
1156 }
1157 else
1158 {
1159 if (u8Loop_Circle == 2)
1160 {
1161 if (( au8Tmp_Value_Adj[2][2] >= MAX( u8Max_Value_Array1- u8Spatial_Strength, 0 )) && (au8Tmp_Value_Adj[2][2] >= MAX( u8Max_Value_Array2- u8Spatial_Strength*2, 0 )) )
1162 {
1163 u8Max_Value = au8Tmp_Value_Adj[2][2];
1164 }
1165 else if ( ( au8Tmp_Value_Adj[2][2] >= MAX( u8Max_Value_Array1- u8Spatial_Strength, 0 )) && (au8Tmp_Value_Adj[2][2] < MAX( u8Max_Value_Array2- u8Spatial_Strength*2, 0 )) )
1166 {
1167 u8Max_Value = MAX( u8Max_Value_Array2- u8Spatial_Strength*2, 0 );
1168 }
1169 else if ( ( au8Tmp_Value_Adj[2][2] < MAX( u8Max_Value_Array1- u8Spatial_Strength, 0 )) && (au8Tmp_Value_Adj[2][2] >= MAX( u8Max_Value_Array2- u8Spatial_Strength*2, 0 )) )
1170 {
1171 u8Max_Value = MAX( u8Max_Value_Array1- u8Spatial_Strength, 0 );
1172 }
1173 else if ( ( au8Tmp_Value_Adj[2][2] < MAX( u8Max_Value_Array1- u8Spatial_Strength, 0 )) && (au8Tmp_Value_Adj[2][2] < MAX( u8Max_Value_Array2- u8Spatial_Strength*2, 0 )) )
1174 {
1175 u8Max_Value = MAX( u8Max_Value_Array2-u8Spatial_Strength*2, 0 );
1176 }
1177 }
1178 else if (u8Loop_Circle == 1)
1179 {
1180 if (au8Tmp_Value_Adj[2][2] >= MAX( u8Max_Value_Array1 - u8Spatial_Strength, 0 ) )
1181 {
1182 u8Max_Value = au8Tmp_Value_Adj[2][2];
1183 }
1184 else
1185 {
1186 u8Max_Value = MAX( u8Max_Value_Array1 -u8Spatial_Strength, 0 );
1187 }
1188 }
1189 }
1190 return u8Max_Value;
1191 }
1192
MDrv_Spatial_Filtering1D(void * pInstance,MS_U8 i_index,MS_U8 j_index,MS_U8 u8Spatial_Strength)1193 MS_U8 MDrv_Spatial_Filtering1D(void *pInstance, MS_U8 i_index, MS_U8 j_index, MS_U8 u8Spatial_Strength)
1194 {
1195 MS_U8 u8Max_Value = 0;
1196 MS_U8 au8Tmp_Value_Adj[3];
1197 MS_S8 i = 0,j = 0;
1198 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1199 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1200 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1201 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1202 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth == 2)
1203 {
1204 for (j = -1; j < 2; j++)
1205 {
1206 if ( ( (j+j_index>=0) && (j+j_index<pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh) ))
1207 {
1208 au8Tmp_Value_Adj[j+1] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j+j_index][i_index];
1209 }
1210 else
1211 {
1212 au8Tmp_Value_Adj[j+1] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j_index][i_index];
1213 }
1214 }
1215 }
1216 else
1217 {
1218 for (i = -1; i < 2; i++)
1219 {
1220 if ( (i+i_index >= 0) && (i+i_index < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth ) )
1221 {
1222 au8Tmp_Value_Adj[i+1] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j_index][i+i_index];
1223 }
1224 else
1225 {
1226 au8Tmp_Value_Adj[i+1] = pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j_index][i_index];
1227 }
1228 }
1229 }
1230
1231 if ( (au8Tmp_Value_Adj[1] >= au8Tmp_Value_Adj[0]) && (au8Tmp_Value_Adj[1] >= au8Tmp_Value_Adj[2]) )
1232 {
1233 u8Max_Value = au8Tmp_Value_Adj[1];
1234 }
1235 else if ( ( DIFF(au8Tmp_Value_Adj[1],au8Tmp_Value_Adj[0]) <= u8Spatial_Strength) && (DIFF(au8Tmp_Value_Adj[1],au8Tmp_Value_Adj[2])<=u8Spatial_Strength) )
1236 {
1237 u8Max_Value = au8Tmp_Value_Adj[1];
1238 }
1239 else
1240 {
1241 u8Max_Value = MAX (MAX(au8Tmp_Value_Adj[0],au8Tmp_Value_Adj[2]) - u8Spatial_Strength, 0);
1242 }
1243 #if (ADD_OPPOSITE_LUMA)
1244 return MIN(u8Max_Value+pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j_index][(i_index == 1 ? 0 : 1)]/2,0xFF);
1245 #else
1246 return u8Max_Value;
1247 #endif
1248 }
1249
1250
MDrv_Maxnxn_FrameData_CSep_8B(void * pInstance,MS_U32 u32Luma_Avg_Diff,MS_U8 u8Idx,MS_U32 u32Luma_Avg_OSD_diff,MS_U8 u8Spatial_Strength)1251 void MDrv_Maxnxn_FrameData_CSep_8B(void *pInstance, MS_U32 u32Luma_Avg_Diff, MS_U8 u8Idx, MS_U32 u32Luma_Avg_OSD_diff, MS_U8 u8Spatial_Strength)
1252 {
1253 MS_U8 i = 0,j = 0;//, ChannelIdx;
1254 MS_U32 u32Frame_Factor =0;
1255 MS_U32 u32Frame_Factor_dec = 0;
1256 MS_U16 u16Pindex = 0,u16Pindex2 = 0;
1257 MS_U16 u16Tmp = 0;
1258 MS_U16 u16Tmp1 = 0;
1259 MS_U32 u32P_Tmp_Cur = 0, u32P_Tmp_Pre = 0, u32P_Tmp_IIR = 0;
1260 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1261 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1262 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1263 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1264
1265 u32Frame_Factor = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_24_L,0xFF00) >> 8;
1266 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
1267 {
1268 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
1269 {
1270 u16Pindex = ( j*pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth + i);
1271 u16Pindex2 = u16Pindex * 2;
1272
1273 if ( (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth == 2) || (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh == 2) )
1274 {
1275 u32P_Tmp_Cur = MDrv_Spatial_Filtering1D_Large(pInstance, i, j, u8Spatial_Strength)*256;
1276 }
1277 else
1278 {
1279 u32P_Tmp_Cur = MDrv_Spatial_Filtering2D(pInstance, i, j, u8Spatial_Strength)*256;
1280 }
1281
1282 u16Tmp = pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2B[u16Pindex2+1];
1283 u16Tmp1 = pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2B[u16Pindex2];
1284
1285 u32P_Tmp_Pre = u16Tmp*256 + u16Tmp1;
1286
1287 if ( (u32Luma_Avg_Diff >= LUMA_AVG_DIFF_THRESHOLD1) /*|| (u32Luma_Avg_OSD_diff > 200*/)//To fix konka flicker bug. Mantis 0265653 )
1288 {
1289 u32P_Tmp_IIR = (u32P_Tmp_Cur*(256-0) + u32P_Tmp_Pre*0 + 0 )>>8;//div 256;
1290 }
1291 else if ( (u32Luma_Avg_Diff<LUMA_AVG_DIFF_THRESHOLD1) && (u32Luma_Avg_Diff>=LUMA_AVG_DIFF_THRESHOLD2))
1292 {
1293 u32Frame_Factor_dec = u32Frame_Factor - (u32Frame_Factor/16) * (u32Luma_Avg_Diff - LUMA_AVG_DIFF_THRESHOLD2);
1294 u32P_Tmp_IIR = (u32P_Tmp_Cur * (256-u32Frame_Factor_dec) + u32P_Tmp_Pre * u32Frame_Factor_dec + 0 )>>8;//div 256;
1295 }
1296 else if ( u32Luma_Avg_Diff < LUMA_AVG_DIFF_THRESHOLD2)
1297 {
1298 u32P_Tmp_IIR = (u32P_Tmp_Cur*(256-u32Frame_Factor) + u32P_Tmp_Pre*u32Frame_Factor )>>8;//div 256;
1299 }
1300
1301 MS_U8 u8Gamma_Min = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_78_L, 0x00FF);//MFC_ReadByte(REG_2FF0);
1302 if (u8Gamma_Min == 1)
1303 {
1304 u32P_Tmp_IIR = (u32P_Tmp_Cur*(256-u32Frame_Factor) + u32P_Tmp_Pre*u32Frame_Factor )>>8;//div 256;
1305 }
1306
1307 if (u8Idx == 1)
1308 {
1309 u32P_Tmp_IIR = (255*256/1);
1310 }
1311
1312 pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2C[u16Pindex2] = u32P_Tmp_IIR & 0x0FF;
1313 pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2C[u16Pindex2+1] = (u32P_Tmp_IIR & 0x0000FF00)>>8;
1314 }
1315 }
1316
1317 //prepare for next frame
1318 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize*2; j++)
1319 {
1320 pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2B[j] = pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2C[j];
1321 }
1322 }
1323
1324
MDrv_BLgamma(void * pInstance,MS_BOOL bDark_Info)1325 void MDrv_BLgamma(void *pInstance, MS_BOOL bDark_Info)
1326 {
1327 MS_U8 i = 0,j = 0;
1328 MS_U8 u8LUT_Index_L = 0,u8LUT_Index_H = 0;
1329 MS_U8 u8Blending = 0;
1330 MS_U8 u8Gamma_Min = 0;//SC_R2BYTEMSK(REG_SC_BK2E_78_L,0xFF);
1331 const MS_U8* pu8GammaTbl = NULL;
1332 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1333 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1334 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1335 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1336
1337 #if (DIRECTTYPE_PATCH_ENABLE)
1338 if (bDark_Info)
1339 {
1340 pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Control = 1;
1341 }
1342
1343 #else
1344 pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Control = (SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_23_L,0xFF00))>>8;
1345 #endif
1346
1347 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
1348 {
1349 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
1350 {
1351 pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j][i] = pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i];
1352 }
1353 }
1354 switch (pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Control)
1355 {
1356 default:
1357 pu8GammaTbl = NULL; //No gamma adaptation
1358 break;
1359
1360 case 1:
1361 pu8GammaTbl = gamma_0dot4;
1362 break;
1363
1364 case 2:
1365 pu8GammaTbl = gamma_0dot6;
1366 break;
1367
1368 case 3:
1369 pu8GammaTbl = gamma_1dot2;
1370 break;
1371
1372 case 4:
1373 pu8GammaTbl = gamma_1dot4;
1374 break;
1375
1376 case 5:
1377 pu8GammaTbl = gamma_0dot9;
1378 break;
1379
1380 case 6:
1381 pu8GammaTbl = gamma_0dot8;
1382 break;
1383
1384 case 7:
1385 pu8GammaTbl = gamma_0dot7;
1386 break;
1387
1388 case 8:
1389 pu8GammaTbl = gamma_0dot75;
1390 break;
1391
1392 case 9:
1393 pu8GammaTbl = gamma_0dot78;
1394 break;
1395
1396 case 10:
1397 pu8GammaTbl = LGE_sample3;
1398 break;
1399
1400 case 11:
1401 pu8GammaTbl = LGE_sampleTHX;
1402 break;
1403
1404 case 12:
1405 case 13:
1406 case 14:
1407 case 15:
1408 case 16:
1409 case 17:
1410 case 18:
1411 case 19:
1412 case 20:
1413 pu8GammaTbl = LGE_sample1_adjust;
1414 break;
1415
1416 case 21:
1417 case 22:
1418 case 23:
1419 case 24:
1420 case 25:
1421 case 26:
1422 case 27:
1423 case 28:
1424 case 29:
1425 pu8GammaTbl = LGE_sample2_adjust;
1426 break;
1427
1428 case 30:
1429 case 31:
1430 case 32:
1431 case 33:
1432 case 34:
1433 case 35:
1434 case 36:
1435 case 37:
1436 case 38:
1437 pu8GammaTbl = LGE_sample7_adjust;
1438 break;
1439
1440 case 39:
1441 pu8GammaTbl = LGE_sample1_0dot81;
1442 break;
1443 }
1444
1445 if (pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Control)
1446 {
1447 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
1448 {
1449 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
1450 {
1451 u8LUT_Index_L = MINMAX(pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i]/4, 0, 63);
1452 u8LUT_Index_H = MINMAX(pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i]/4+1, 0, 63);
1453 u8Blending = pXCResourcePrivate->stdrv_LDALGO._u8VDown_Block[j][i] % 4;
1454 pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j][i] = ( (4-u8Blending)*pu8GammaTbl[u8LUT_Index_L] + (u8Blending)*pu8GammaTbl[u8LUT_Index_H] +2 )/4;
1455 }
1456 }
1457 }
1458
1459 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
1460 {
1461 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
1462 {
1463 pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j][i] = MAX(u8Gamma_Min, pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j][i]);
1464 }
1465 }
1466
1467 if(REG_DEBUG_LD_DUMP_SEL == E_LD_DUMP_Gamma_Block)
1468 {
1469 pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt = (pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt+1)%8;
1470 for (j = 0; j < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh; j++)
1471 {
1472 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth; i++)
1473 {
1474 MDrv_LD_MIUWriteByte(LD_BUF_WriteBuf_0, (0x20+pXCResourcePrivate->stdrv_LDALGO._u8DebugArrayDumpDummyCnt*2) + j*0x10 + i, pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Block[j][i]);//1
1475 }
1476 }
1477 }
1478 }
1479
1480
1481
MDrv_EdgeModeImpulse(void * pInstance)1482 void MDrv_EdgeModeImpulse(void *pInstance)
1483 {
1484 MS_U32 u32Rounding = 0,u32Value = 0;
1485 MS_U32 i = 0;
1486 MS_U16 u16BIN_Pulse = 0;
1487 MS_U8 u8BLStrength = 0;
1488 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1489 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1490 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1491 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1492 u16BIN_Pulse = SC_R2BYTE(psXCInstPri->u32DeviceID, REG_SC_BK2E_22_L);// readw(HAL_MSTAR_AEON_RIU_BASE+HAL_REGBANK_OFFSET(0x3300 / 2 + 0x44/2) );
1493 u8BLStrength = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_23_L, 0xFF); //readw(HAL_MSTAR_AEON_RIU_BASE+HAL_REGBANK_OFFSET(0x3300 / 2 + 0x46/2) );
1494
1495 for (i = 0;i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize*2;i = i+2)
1496 {
1497 u32Rounding = pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2C[i];
1498 u32Value = pXCResourcePrivate->stdrv_LDALGO._u32IIR_T2C[i+1];
1499 if (u32Value == 0xFF)
1500 {
1501 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[i/2] = 0xFF;
1502 }
1503 else
1504 {
1505 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[i/2] = MIN(u32Value + (u32Rounding/128), 0xFF);
1506 }
1507 }
1508
1509 if ( (u16BIN_Pulse > 0) && (u16BIN_Pulse != 0xFFFF) )//For testing control, only one lamp enabled, others off.
1510 {
1511 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth == 2) //LR edge type
1512 {
1513 for (i = 1; i <= pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize; i++)
1514 {
1515 if (i <= pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh)
1516 {
1517 if (i == u16BIN_Pulse)
1518 {
1519 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[(i*2-1)-1] = u8BLStrength;
1520 }
1521 else
1522 {
1523 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[(i*2-1)-1] = 0;
1524 }
1525 }
1526 else
1527 {
1528 if (i == u16BIN_Pulse)
1529 {
1530 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[((i - pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh)*2)-1] = u8BLStrength;
1531 }
1532 else
1533 {
1534 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[((i - pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh)*2)-1] = 0;
1535 }
1536 }
1537 }
1538 }
1539 else
1540 {
1541 for (i = 1; i <= pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize; i++)
1542 {
1543 if (i == u16BIN_Pulse)
1544 {
1545 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[i-1] = u8BLStrength;
1546 }
1547 else
1548 {
1549 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[i-1] = 0;
1550 }
1551 }
1552 }
1553
1554 }
1555 else if (u16BIN_Pulse == 0xFFFF)
1556 {
1557 for (i = 1; i <= pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize; i++)
1558 {
1559 pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[i-1] = u8BLStrength;
1560 }
1561 }
1562
1563 for (i = 0; i < pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16PWMSize; i++)
1564 {
1565 pXCResourcePrivate->stdrv_LDALGO._u8LED_resort[i] = pXCResourcePrivate->stdrv_LDALGO._u8IIR_T2[i];
1566 }
1567
1568 }
1569
1570
MDrv_volumn_OSD_patch(void)1571 MS_U8 MDrv_volumn_OSD_patch(void)
1572 {
1573 return 0;
1574 }
1575
1576
MDrv_GetFrameIndex(void * pInstance)1577 void MDrv_GetFrameIndex(void *pInstance)
1578 {
1579 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1580 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1581 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1582 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1583 pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_40_L, 0xFF) & 0x10 ;
1584 }
1585
MDrv_LDimmingFunction(void * pInstance)1586 void MDrv_LDimmingFunction(void *pInstance)
1587 {
1588 MS_U32 u32Luma_Cur = 0;
1589 MS_U32 u32Luma_Diff = 0;
1590 MS_U32 u32Luma_OSD_Diff = 0;
1591 MS_U8 u8Spatial_Strength = 0,u8Spatial_Strength_adj = 0;
1592 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1593 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1594 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1595 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1596 #if (DIRECTTYPE_PATCH_ENABLE)
1597 MS_U8 u8Histogram_Max1 = 0;
1598 MS_U8 u8Histogram_Max2 = 0;
1599 MS_U8 u8Histogram_Max1_bin = 0;
1600 MS_U8 u8Histogram_Max2_bin = 0xF;
1601 MS_U8 u8Histogram_Bin_Diff = 0;
1602 MS_BOOL bDark_Info = TRUE;
1603 MS_U8 i = 0;
1604 #endif
1605 MDrv_GetFrameIndex(pInstance);
1606
1607 pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx_Test = pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx;
1608 pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx_Final = pXCResourcePrivate->stdrv_LDALGO._u8Frame_Idx;
1609 //MDrv_Write2Byte(0x2620,0xA5A5);
1610 pXCResourcePrivate->stdrv_LDALGO._u8H_Down_Ratio = pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth/pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth;
1611 pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio = pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDHeight/pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh;
1612 pXCResourcePrivate->stdrv_LDALGO._u8H_Down_Ratio_3D = pXCResourcePrivate->stdrv_LDALGO._u8H_Down_Ratio/2;
1613 pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio_3D = pXCResourcePrivate->stdrv_LDALGO._u8V_Down_Ratio/2;
1614 pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_LD = (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8LDWidth>16) ? 32 : 16 ;
1615
1616 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth != 2 && pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh != 2 ) //direct type
1617 {
1618 pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM = (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth > 16) ? 32 : 16 ;
1619 }
1620 else //edge type
1621 {
1622 if (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth == 2) //LR edge
1623 {
1624 pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM = (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMHigh > 16) ? 32 : 16 ;
1625 }
1626 else //TB edge
1627 {
1628 pXCResourcePrivate->stdrv_LDALGO._u8Pack_Length_PWM = (pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u8PWMWidth > 16) ? 32 : 16 ;
1629 }
1630 }
1631
1632 u32Luma_Cur = MDrv_FramLockBffdepack_CSep_8B_Full(pInstance);
1633 MDrv_BLMxNto2xN_White_8B(pInstance);
1634 MDrv_BL2xNto2xNd3_White_8B(pInstance);
1635 //=======================================
1636 u8Spatial_Strength = SC_R2BYTEMSK(psXCInstPri->u32DeviceID, REG_SC_BK2E_24_L, 0xFF);
1637 u8Spatial_Strength_adj = u8Spatial_Strength;
1638
1639 #if (DIRECTTYPE_PATCH_ENABLE)
1640 for (i = 0; i < 16; i++)
1641 {
1642 if ((pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i] > u8Histogram_Max1 ) && ( pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i] > u8Histogram_Max2) )
1643 {
1644 u8Histogram_Max2_bin = u8Histogram_Max1_bin;
1645 u8Histogram_Max2 = u8Histogram_Max1;
1646 u8Histogram_Max1_bin = i;
1647 u8Histogram_Max1 = pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i];
1648 }
1649 else if ((pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i] < u8Histogram_Max1 ) && ( pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i] > u8Histogram_Max2) )
1650 {
1651 u8Histogram_Max2_bin = i;
1652 u8Histogram_Max2 = pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[i];
1653 }
1654 }
1655
1656 u8Histogram_Bin_Diff = ABS(u8Histogram_Max1_bin - u8Histogram_Max2_bin);
1657
1658 if ((pXCResourcePrivate->stdrv_LDALGO._u8Histogram_Image[0] >= pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16BLSize*9/10 )
1659 && (pXCResourcePrivate->stdrv_LDALGO._u16Histogram_Zero >= pXCResourcePrivate->stdrv_LDALGO._stLDPanelPara.u16BLSize*9/10 ) )
1660 {
1661 u8Spatial_Strength_adj = MINMAX( u8Spatial_Strength+0x80, 0, 0xFF );
1662 //MDrv_Write2Byte(0x3346,0x00FF);
1663 }
1664 else if ( u8Histogram_Max1_bin <= 8 && u8Histogram_Bin_Diff >= 5 )
1665 {
1666 u8Spatial_Strength_adj = MINMAX( u8Spatial_Strength , 0, 0xFF );
1667 bDark_Info = TRUE;
1668 }
1669 else if ( u8Histogram_Max1_bin <= 8 && MDrv_volumn_OSD_patch() == 1)
1670 {
1671 u8Spatial_Strength_adj = MINMAX(u8Spatial_Strength, 0, 0xFF);
1672 bDark_Info = TRUE;
1673 }
1674
1675 //===============================================================
1676 MDrv_BLgamma(pInstance, bDark_Info);
1677 #else
1678 MDrv_BLgamma(pInstance, FALSE);
1679 #endif
1680 u32Luma_Diff = DIFF(u32Luma_Cur, pXCResourcePrivate->stdrv_LDALGO._u8Iluma_Pre);
1681 pXCResourcePrivate->stdrv_LDALGO._u8Iluma_Pre = u32Luma_Cur;
1682
1683 if(pXCResourcePrivate->stdrv_LDALGO._u8OSDEnable && (u32Luma_Cur < 30))
1684 {
1685 u32Luma_OSD_Diff = 255;
1686 }
1687
1688 MDrv_Maxnxn_FrameData_CSep_8B(pInstance, u32Luma_Diff, pXCResourcePrivate->stdrv_LDALGO._bLDoff, u32Luma_OSD_Diff, u8Spatial_Strength_adj); //T2b -> T2
1689 // MDrv_Maxnxn_FrameData_CSep_8B(u32Luma_Diff,0,0,u8Spatial_Strength_adj);// T2b -> T2
1690 MDrv_EdgeModeImpulse(pInstance); // upperline / lower line T2
1691 MDrv_Output_SPIdata(pInstance); //for SPI data
1692 MDrv_Output_DigitalBLdata(pInstance); // 0xAA
1693 }
1694
MDrv_LDAlgo_Main(SC_INT_SRC enIntNum,void * pParam)1695 void MDrv_LDAlgo_Main(SC_INT_SRC enIntNum, void *pParam)
1696 {
1697 UNUSED(enIntNum);
1698 UNUSED(pParam);
1699 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1700 UtopiaInstanceGetPrivate(pu32XCInst, (void**)&psXCInstPri);
1701 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1702 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1703 #if 1
1704 if(pXCResourcePrivate->stdrv_LDALGO._bLDoff || !MDrv_LD_Get_LocalDimmingEn(pu32XCInst))
1705 {
1706 return;
1707 }
1708
1709 MDrv_appLDModeHandler_R2(pu32XCInst);
1710 MDrv_LDimmingFunction(pu32XCInst);
1711 #else
1712 static MS_U8 u8RandomStatus=0x0;
1713 *(volatile unsigned int *)(0x80000000+(LD_BUF_ADR))=u8RandomStatus;
1714 if (u8RandomStatus>=0x80)
1715 {
1716 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+1)=u8RandomStatus-0x10;
1717 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+2)=u8RandomStatus-0x15;
1718 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+3)=u8RandomStatus-0x19;
1719 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+4)=u8RandomStatus-0x35;
1720 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+5)=u8RandomStatus-0x70;
1721
1722 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+10)=u8RandomStatus-0x50;
1723 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+11)=u8RandomStatus-0x18;
1724 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+12)=u8RandomStatus-0x36;
1725 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+13)=u8RandomStatus-0x79;
1726 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+14)=u8RandomStatus-0x25;
1727 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+15)=u8RandomStatus-0x44;
1728 }
1729 else
1730 {
1731 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+01)=u8RandomStatus+0x10;
1732 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+02)=u8RandomStatus+0x15;
1733 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+03)=u8RandomStatus+0x19;
1734 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+04)=u8RandomStatus+0x35;
1735 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+05)=u8RandomStatus+0x70;
1736
1737 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+10)=u8RandomStatus+0x50;
1738 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+11)=u8RandomStatus+0x18;
1739 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+12)=u8RandomStatus+0x36;
1740 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+13)=u8RandomStatus+0x79;
1741 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+14)=u8RandomStatus+0x25;
1742 *(volatile unsigned char *)(0x80000000+(LD_BUF_ADR)+15)=u8RandomStatus+0x44;
1743 }
1744 if (u8RandomStatus == 0xFF)
1745 {
1746 u8RandomStatus =0x0;
1747 }
1748 else
1749 {
1750 u8RandomStatus = u8RandomStatus + 1;
1751 }
1752 #endif
1753 }
1754
MDrv_XC_LD_ISR(void * pInstance)1755 void MDrv_XC_LD_ISR(void* pInstance)
1756 {
1757 if(FALSE == MDrv_XC_InterruptIsAttached(pInstance, SC_INT_VSINT, MDrv_LDAlgo_Main, NULL))
1758 {
1759 MDrv_XC_InterruptAttach(pInstance, SC_INT_VSINT, MDrv_LDAlgo_Main, (void *) NULL);
1760 }
1761 }
1762
MDrv_LD_EnableLD(void * pInstance,MS_BOOL bLDEnable)1763 void MDrv_LD_EnableLD(void *pInstance, MS_BOOL bLDEnable)
1764 {
1765 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1766 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1767 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1768 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1769 if (pXCResourcePrivate->stdrv_LDALGO._bLDoff == bLDEnable)
1770 {
1771 pXCResourcePrivate->stdrv_LDALGO._bLDoff = !bLDEnable;
1772 MDrv_LD_Set_LocalDimmingEn(pInstance, bLDEnable);
1773 }
1774 }
1775
MDrv_LD_SetGammaControl(void * pInstance,MS_U8 u8GammaControl)1776 void MDrv_LD_SetGammaControl(void *pInstance, MS_U8 u8GammaControl)
1777 {
1778 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1779 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1780 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1781 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1782 pXCResourcePrivate->stdrv_LDALGO._u8Gamma_Control = u8GammaControl;
1783 }
1784
MDrv_LD_SetOSDEnable(void * pInstance,MS_U8 u8OSDEnable)1785 void MDrv_LD_SetOSDEnable(void *pInstance, MS_U8 u8OSDEnable)
1786 {
1787 XC_INSTANCE_PRIVATE *psXCInstPri = NULL;
1788 UtopiaInstanceGetPrivate(pInstance, (void**)&psXCInstPri);
1789 XC_RESOURCE_PRIVATE* pXCResourcePrivate = NULL;
1790 UtopiaResourceGetPrivate(g_pXCResource[_XC_SELECT_INTERNAL_VARIABLE(psXCInstPri->u32DeviceID)],(void**)(&pXCResourcePrivate));
1791 pXCResourcePrivate->stdrv_LDALGO._u8OSDEnable = u8OSDEnable;
1792 }
1793
1794 #endif
1795
1796