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 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94 #define MHAL_PQ_ADAPTIVE_C
95
96 //-------------------------------------------------------------------------------------------------
97 // Include Files
98 //-------------------------------------------------------------------------------------------------
99 #if !defined(MSOS_TYPE_LINUX_KERNEL)
100 #include "string.h"
101 #else
102 #include <linux/string.h>
103 #endif
104
105 // Common Definition
106 #include "MsCommon.h"
107 #include "MsOS.h"
108
109 // Internal Definition
110 #include "hwreg_utility2.h"
111 #include "color_reg.h"
112
113 #include "drvXC_IOPort.h"
114 #include "apiXC.h"
115 #include "apiXC_EX.h"
116 #include "apiXC_Dlc.h"
117 #include "mhal_pq_adaptive.h"
118
119 //-------------------------------------------------------------------------------------------------
120 // Driver Compiler Options
121 //-------------------------------------------------------------------------------------------------
122
123
124 //-------------------------------------------------------------------------------------------------
125 // Local Defines
126 //-------------------------------------------------------------------------------------------------
127 #define MSIF_ADAPTIVE_LIB_CODE_C {'A','D','A','P','T','I','V','E','_'}
128 #define MSIF_ADAPTIVE_VERSION_C {'0','0','0','0','0','1'}
129
130
131 #ifndef UNUSED //to avoid compile warnings...
132 #define UNUSED(var) (void)((var) = (var))
133 #endif
134
135 //-------------------------------------------------------------------------------------------------
136 // Local Structures
137 //-------------------------------------------------------------------------------------------------
138
139 //-------------------------------------------------------------------------------------------------
140 // Global Variables
141 //-------------------------------------------------------------------------------------------------
142 extern MS_U16 _u16PQSrcType_DBK_Detect[PQ_MAX_WINDOW]; //For Auto_DBK SW driver used
143 static MS_U16 _u16PQPre_SrcType = 255; //For Auto_DBK SW driver used
144 static MS_BOOL _bDataRead = true; //For Auto_DBK SW driver used
145 static MS_BOOL _bAnyCandenceEnable = TRUE;
146 XC_DEVICE_ID _XC_DeviceIdx = {0, E_XC_EX_DEVICE0};
147
148 //-------------------------------------------------------------------------------------------------
149 // Local Variables
150 //-------------------------------------------------------------------------------------------------
151
152
153 //-------------------------------------------------------------------------------------------------
154 // Debug Functions
155 //-------------------------------------------------------------------------------------------------
156
157
158 //-------------------------------------------------------------------------------------------------
159 // Local Functions
160 //-------------------------------------------------------------------------------------------------
161
162
163 //-------------------------------------------------------------------------------------------------
164 // Global Functions
165 //-------------------------------------------------------------------------------------------------
166 /******************************************************************************/
167 ///Get control register for adaptive tuning function
168 ///@return MS_U8: Control status
169 /******************************************************************************/
MDrv_SC_get_adaptive_ctrl(void)170 MS_U8 MDrv_SC_get_adaptive_ctrl(void)
171 {
172 MS_U8 u8Ctrl;
173
174 u8Ctrl = (MS_U8)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7C_L, 0xFF);
175
176 return u8Ctrl;
177 }
178
179 /******************************************************************************/
180 ///Get control register for adaptive tuning function
181 ///@return MS_U8: Control status
182 /******************************************************************************/
MDrv_SC_get_adaptive_ctrl2(void)183 MS_U8 MDrv_SC_get_adaptive_ctrl2(void)
184 {
185 MS_U8 u8Ctrl;
186
187 u8Ctrl = (MS_U8)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7C_L, 0xFF00) >> 8);
188
189 return u8Ctrl;
190 }
191
192 /******************************************************************************/
193 ///Get control register for adaptive tuning function
194 ///@return MS_U8: Control status
195 /******************************************************************************/
MDrv_SC_get_adaptive_ctrl3(void)196 MS_U8 MDrv_SC_get_adaptive_ctrl3(void)
197 {
198 MS_U8 u8Ctrl;
199
200 u8Ctrl = (MS_U8) (MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK30_01_L, 0x8000) >> 8);
201
202 return u8Ctrl;
203 }
204
205 /******************************************************************************/
206 ///Get control register for adaptive tuning function
207 ///@return MS_U8: Control status
208 /******************************************************************************/
MDrv_SC_get_adaptive_ctrl4(void)209 MS_U8 MDrv_SC_get_adaptive_ctrl4(void)
210 {
211 MS_U8 u8Ctrl;
212
213 u8Ctrl = (MS_U8)(MS_U8)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7E_L, 0xFF);
214
215 return u8Ctrl;
216 }
217
218 /******************************************************************************/
219 ///Read motion value (F2 motion status)
220 ///@return MS_U8: Motion value
221 /******************************************************************************/
MDrv_SC_read_motion_value1(void)222 MS_U32 MDrv_SC_read_motion_value1(void)
223 {
224 MS_U32 u32MotionValue;
225 MS_U32 u32RegMadi_1C, u32RegMadi_1B, u32RegMadi_1A;
226
227 u32RegMadi_1C = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_0E_L, 0x3F);
228 u32RegMadi_1B = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_0D_L, 0xFF00);
229 u32RegMadi_1A = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_0D_L, 0x00FF);
230
231 u32RegMadi_1C = u32RegMadi_1C * 0x10000UL;
232
233 u32MotionValue = (u32RegMadi_1C + u32RegMadi_1B + u32RegMadi_1A) ;
234
235 DRVSCA_DBG(printf("MotionValue = 0x%lx\n", u32MotionValue));
236
237 return u32MotionValue;
238 }
239
240 /******************************************************************************/
241 ///Read motion value (Motion count status)
242 ///@return MS_U8: Motion value
243 /******************************************************************************/
MDrv_SC_read_motion_value2(void)244 MS_U32 MDrv_SC_read_motion_value2(void)
245 {
246 MS_U32 u32MotionValue;
247
248 u32MotionValue = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_18_L, 0xFFF) + (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_1A_L, 0x7F);
249
250 return u32MotionValue;
251 }
252
253 /******************************************************************************/
254 ///Read motion value (Motion count status)
255 ///@return MS_U32: Motion value
256 /******************************************************************************/
MDrv_SC_read_motion_value3(void)257 MS_U32 MDrv_SC_read_motion_value3(void)
258 {
259 MS_U32 u32MotionValue;
260
261 u32MotionValue = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_18_L, 0x0FFF);
262
263 return u32MotionValue;
264 }
265
266 //-------------------------------------------------------------------------------------------------
267 /// Read motion value (Motion count status)
268 /// @return MS_U8: Motion value
269 //-------------------------------------------------------------------------------------------------
Hal_PQ_GetCurrentMotionValue(void * pInstance)270 MS_U8 Hal_PQ_GetCurrentMotionValue(void *pInstance)
271 {
272 MS_U8 u8MotionValue;
273
274 u8MotionValue = (MS_U8)((MApi_XC_R2BYTEMSK(REG_SC_BK22_0E_L, 0x3F) << 2) |
275 (MApi_XC_R2BYTEMSK(REG_SC_BK22_0D_L, 0xC000) >> 6));
276
277 return u8MotionValue;
278 }
279
280 /******************************************************************************/
281 ///Read VCnt value
282 ///@return MS_U8: VCnt value
283 /******************************************************************************/
MDrv_SC_read_v_cnt(void)284 MS_U8 MDrv_SC_read_v_cnt(void)
285 {
286 MS_U8 u8VCnt;
287
288 u8VCnt = (MS_U8)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_0E_L, 0xC0) >> 6);
289 return u8VCnt;
290 }
291
292 /******************************************************************************/
293 ///Read SDHDD Detect Threshold value
294 ///@return MS_U16: HDSDD_Det_Threshold value
295 /******************************************************************************/
MDrv_SC_read_HDSDD_Det_Threshold_value(void)296 MS_U16 MDrv_SC_read_HDSDD_Det_Threshold_value(void)
297 {
298 MS_U16 u16Value;
299
300 u16Value = (MS_U16)MApi_XC_R2BYTEMSK(REG_SC_BK22_7F_L, 0xFFFF);
301
302 return u16Value;
303 }
304
305 /******************************************************************************/
306 ///MCDi Driver
307 /******************************************************************************/
308 #define ENABLE_XXX_V_MOVING 0x01
309 #define ENABLE_XXX_SST 0x02
310 #define ENABLE_XXX_EodiWeight 0x04
311
MDrv_SC_mcdi_driver(MS_U32 u32MotionValue)312 void MDrv_SC_mcdi_driver(MS_U32 u32MotionValue)
313 {
314 MS_U32 u32Reg78, u32Reg79, u32Reg7A, u32Reg7B, u32Reg7C, u32Reg7D, u32Reg7E, filmFeatherCount;
315 MS_U32 curCounter3, cntDiff;
316 MS_U8 u8xxxCtrl;
317 MS_BOOL verticalMovingU, horizontalMoving, slowMotion, featheringScene, featheringScene2;
318 static MS_U8 u8SkipCnt;
319 static MS_U8 featheringFrameCount;
320 static MS_U8 s8DeBouncingCnt;
321 static MS_U8 stillFrameCnt;
322 static MS_U8 filmCnt = 0;
323 static MS_U32 preCounter3 = 0;
324 static MS_U8 eodiCnt = 0;
325 MS_BOOL skipCond;
326 MS_BOOL verticalMoving2;
327 MS_BOOL filmDisableMCDiDFK;
328
329 u8xxxCtrl = 0xFF; //MApi_XC_R2BYTE(REG_SC_BK2A_1F_L) >> 8;
330
331 u32Reg78 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_78_L);
332 u32Reg79 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_79_L);
333 u32Reg7A = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7A_L);
334 u32Reg7B = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7B_L);
335 u32Reg7C = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7C_L);
336 u32Reg7D = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7D_L);
337 u32Reg7E = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7E_L);
338 filmFeatherCount = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK0A_0B_L);
339
340 if(MApi_XC_EX_GetMirrorModeTypeEx(&_XC_DeviceIdx, E_XC_EX_MAIN_WINDOW) == E_XC_EX_MIRROR_NORMAL)
341 {
342 //Non_Mirror
343 verticalMovingU = (u32Reg7E > 0x0100) && (u32Reg7E > 8 * u32Reg7C) && (u32Reg7E > 8 * u32Reg7D);
344 verticalMoving2 = (((u32Reg7E > 0x200) && (u32Reg7E > u32Reg7C)) || ((u32Reg7D > 0x200) && (u32Reg7D > u32Reg7C)));
345 horizontalMoving = (u32Reg79 > 0x200) && (u32Reg7B < 0x40) && (u32Reg79 > u32Reg78) && (!verticalMoving2);
346 slowMotion = (u32Reg7A > 0x200) && (u32Reg7B < 0x40) && (!verticalMoving2);
347 featheringScene = (u32Reg7B > 0x100) && (u32Reg7B > u32Reg79 / 4) && (u32Reg7B > u32Reg7A / 4);
348 skipCond = (u32Reg7A > 8 * u32Reg79) && (u32Reg7B > 0x600);
349 featheringScene2 = (u32Reg7B > 0x200) && (u32Reg7B > u32Reg79 / 8) && (u32Reg7B > u32Reg7A / 8);
350 }
351 else
352 {
353 //Mirror
354 verticalMovingU = (u32Reg7D > 0x0100) && (u32Reg7D > 8 * u32Reg7C) && (u32Reg7D > 8 * u32Reg7E);
355 verticalMoving2 = (((u32Reg7D > 0x200) && (u32Reg7D > u32Reg7C)) || ((u32Reg7E > 0x200) && (u32Reg7E > u32Reg7C)));
356 horizontalMoving = (u32Reg79 > 0x200) && (u32Reg7B < 0x40) && (u32Reg79 > u32Reg78) && (!verticalMoving2);
357 slowMotion = (u32Reg7A > 0x200) && (u32Reg7B < 0x40) && (!verticalMoving2);
358 featheringScene = (u32Reg7B > 0x100) && (u32Reg7B > u32Reg79 / 4) && (u32Reg7B > u32Reg7A / 4);
359 skipCond = (u32Reg7A > 8 * u32Reg79) && (u32Reg7B > 0x600);
360 featheringScene2 = (u32Reg7B > 0x200) && (u32Reg7B > u32Reg79 / 8) && (u32Reg7B > u32Reg7A / 8);
361 }
362
363 if(false == skipCond)
364 {
365 if(u8SkipCnt == 0)
366 u8SkipCnt = 0;
367 else
368 u8SkipCnt--;
369 }
370 else
371 {
372 if(u8SkipCnt > 0x40)
373 u8SkipCnt = 0x40;
374 else
375 u8SkipCnt++;
376 }
377
378 if(filmFeatherCount > 0x100)
379 {
380 if(featheringFrameCount < 0x80)
381 featheringFrameCount ++;
382 }
383 else
384 {
385 featheringFrameCount = 0;
386 }
387
388 if((u32MotionValue == 0) && (u32Reg7B < 0x20))
389 {
390 if(stillFrameCnt < 0x20)
391 stillFrameCnt ++;
392 }
393 else
394 {
395 stillFrameCnt = 0;
396 }
397
398 ////////////////////////////////////////////////////////////////
399 // film content disable mcdi/dfk
400 ////////////////////////////////////////////////////////////////
401 curCounter3 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK0A_0B_L);
402
403 cntDiff = (preCounter3 > curCounter3) ? preCounter3 - curCounter3 : curCounter3 - preCounter3;
404
405 if(cntDiff > 0x1500)
406 {
407 if(filmCnt != 10)
408 filmCnt++;
409 }
410 else if(filmCnt != 0)
411 {
412 filmCnt--;
413 }
414
415 preCounter3 = curCounter3;
416 filmDisableMCDiDFK = (filmCnt > 5);
417
418 ////////////////////////////////////////////////////////////////
419 // eodi counter
420 ////////////////////////////////////////////////////////////////
421 if(featheringScene2)
422 {
423 if(eodiCnt < 40)
424 eodiCnt += 4;
425 }
426 else
427 {
428 if(eodiCnt > 0)
429 eodiCnt--;
430 }
431
432 /////////////////////////////////////////////////////////////////
433 // SST (De-Feathering)
434 /////////////////////////////////////////////////////////////////
435 if(u8xxxCtrl & ENABLE_XXX_SST)
436 {
437 if(featheringScene || filmDisableMCDiDFK) // moving & feather
438 {
439 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0x3100, 0xFF00); // increase SST weighting with checking feathering...
440 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0100, 0x0F00); // SST motion shift1
441 }
442 else if((u32Reg79 > 0x200) && (u32Reg7B < 0x40)) // patch sony temple
443 {
444 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0x1100, 0xFF00); // default SST setting
445 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0200, 0x0F00); // SST motion shift1
446 }
447 else
448 {
449 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0x3100, 0xFF00); // default SST setting
450 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0100, 0x0F00); // SST motion shift1
451 }
452 }
453
454 // disable DFK when verticalMovingU
455 if((true == verticalMovingU) || (u8SkipCnt > 0x20) || filmDisableMCDiDFK)
456 {
457 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_28_L, (MS_U16)0x0000, 0xFFFF); // disable DFK
458 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0000, 0xF000); // disable DFK
459 }
460 else if(verticalMoving2)
461 {
462 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_28_L, (MS_U16)0xA8FF, 0xFFFF); // default DFK
463 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0000, 0xF000); // default DFK
464 }
465 else
466 {
467 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_28_L, (MS_U16)0xA8FF, 0xFFFF); // default DFK
468 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x2000, 0xF000); // default DFK
469 }
470
471 // Favor MCDi-V when verticalMovingU
472 if(true == verticalMovingU)
473 {
474 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_04_L, (MS_U16)0x0800, 0x0800); // Enable MCDi-V
475 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_34_L, (MS_U16)0x0FF0, 0xFFFF); // favor MCDi Weight
476 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_36_L, (MS_U16)0x2800, 0x3C00); // enable MCDi U for blending and history
477 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x4000, 0xF000); // reduce motion history
478 }
479 else
480 {
481 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_04_L, (MS_U16)0x0000, 0x0800); // Disable MCDi-V
482 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_34_L, (MS_U16)0x8888, 0xFFFF); // default MCDi Weight
483 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_36_L, (MS_U16)0x0000, 0x3C00); // Use MCDi-H as default
484 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x4000, 0xF000); // default MCDi motion history
485 }
486
487 // DFK EodiW1, 2
488 if((s8DeBouncingCnt < 0x3) || filmDisableMCDiDFK) //new add
489 {
490 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0080, 0x00F0); // reduce DFK EodiWeight
491 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x4c30, 0xFF30); // disable EodiW for DFK
492 }
493 else if((true == verticalMovingU) || verticalMoving2)
494 {
495 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0010, 0x00F0); // increase EodiW -> tower
496 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x4c10, 0xFF30); // default
497 }
498 else if((false == verticalMovingU) && slowMotion)
499 {
500 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0080, 0x00F0); // reduce DFK EodiWeight
501 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x0c30, 0xFF30); // disable EodiW for DFK
502 }
503 else if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8))) // RF/AV default, eodi weight strong
504 {
505 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0010, 0x00F0); // increase EodiW
506 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x18F1, 0xFF30); // default
507 }
508 else // default
509 {
510 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0040, 0x00F0); // default DFK EodiWeight
511 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x0c10, 0xFF30); // default
512 }
513
514 if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8))) // RF/AV default, eodi weight strong
515 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4488, 0x00F0);
516 else
517 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x0020, 0x00F0);
518
519 // DFK check feathering gain
520 if((stillFrameCnt > 0x8) || filmDisableMCDiDFK) //new add
521 {
522 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0100, 0x0F00);
523 }
524 else if((false == verticalMovingU) && slowMotion)
525 {
526 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0800, 0x0F00); // reduce DFK feathering weight
527 }
528 else if(u32Reg7B > 0x100)
529 {
530 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0f00, 0x0F00); // feather -> increase
531 }
532 else
533 {
534 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0f00, 0x0F00); // default
535 }
536
537 // EodiWeight for MCDi
538 if(true == verticalMovingU)
539 {
540 if((u32Reg7A > 0x100) && (u32Reg7A / 2 > u32Reg79)) // not-found >> horizontal : Church
541 {
542 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0004, 0x000F); // reduce EodiWeight for MCDi
543 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4800, 0xFF0F); // church
544 }
545 else // Tower
546 {
547 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0004, 0x000F); // increase EodiWeight for MCDi
548 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4200, 0xFF0F); // Tower
549 }
550 }
551 else if((false == verticalMovingU) && horizontalMoving)
552 {
553 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0002, 0x000F); // reduce EodiWeight for MCDi
554 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x1800, 0xFF0F); // reduce EodiW for MCDi
555 }
556 else if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8))) // RF/AV default, eodi weight strong
557 {
558 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0002, 0x000F); // increase EodiWeight for MCDi
559 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4408, 0xFF0F);
560 }
561 else if(eodiCnt > 25)
562 {
563 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0001, 0x000F); // default EodiWeight for MCDi
564 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4400, 0xFF0F);
565 }
566 else if(eodiCnt < 10)
567 {
568 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0002, 0x000F); // default EodiWeight for MCDi
569 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4800, 0xFF0F);
570 }
571
572 if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8))) // RF/AV default, eodi weight strong
573 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_29_L, (MS_U16)0xC830, 0xFFFF); // reduce EodiW on MCDi
574 else
575 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_29_L, (MS_U16)0xC832, 0xFFFF); // reduce EodiW on MCDi
576
577 // MCDi check Feathering weight
578 if((true == verticalMovingU) || filmDisableMCDiDFK) //new add
579 {
580 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x0000, 0x00F0); // reduce MCDi feathering weight -> for church
581 }
582 else if(horizontalMoving)
583 {
584 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x0000, 0x00F0); // reduce MCDi feathering weight
585 }
586 else
587 {
588 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x0060, 0x00F0); // default MCDi Feathering Weight
589 }
590 // multi-burst skip
591 if((u8SkipCnt > 0x20) || filmDisableMCDiDFK)
592 {
593 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, (MS_U16)0x0000, 0x0080); // disable mcdi
594 }
595 else if(u8SkipCnt < 0x10)
596 {
597 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, (MS_U16)0x0080, 0x0080); // enable mcdi
598 }
599
600 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0xc000, 0xF000); //
601
602 /////////////////////////////////////////////////////////////////
603 // De-bouncing
604 /////////////////////////////////////////////////////////////////
605
606 MS_U16 reg_debouncing_th, reg_debouncing_cnt;
607
608 reg_debouncing_th = 0x0A;
609 reg_debouncing_cnt = 0x03;
610
611 if(u32MotionValue <= reg_debouncing_th)
612 {
613 s8DeBouncingCnt = 0;
614 }
615 else
616 {
617 if(s8DeBouncingCnt < 0xff)
618 s8DeBouncingCnt++;
619 }
620
621 MS_BOOL film;
622 film = ((MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0008) == 0x0008) || // film22
623 ((MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0010) == 0x0010) || // film32
624 ((MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0040) == 0x0040) ; // film any
625
626 if((s8DeBouncingCnt >= reg_debouncing_cnt) || (true == film))
627 {
628 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, 0x000c, 0x000e); // history weight = 6
629 }
630 else
631 {
632 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, 0x0004, 0x000e); // history weight = 1
633 }
634
635 }
636
MDrv_SC_mcdi_driver_new(MS_U32 u32MotionValue,MS_U8 u8MotLvl)637 void MDrv_SC_mcdi_driver_new(MS_U32 u32MotionValue, MS_U8 u8MotLvl)
638 {
639 MS_U32 u32Reg78, u32Reg79, u32Reg7A, u32Reg7B, u32Reg7C, u32Reg7D, u32Reg7E, filmFeatherCount;
640 MS_U32 curCounter3, cntDiff;
641 MS_U8 u8xxxCtrl;
642 MS_BOOL verticalMovingU, horizontalMoving, slowMotion, featheringScene, featheringScene2, movingScene;
643 static MS_U8 u8SkipCnt;
644 static MS_U8 featheringFrameCount;
645 static MS_U8 s8DeBouncingCnt;
646 static MS_U8 filmCnt = 0;
647 static MS_U32 preCounter3 = 0;
648 static MS_U8 eodiCnt = 0;
649 static MS_U8 verticalMovingUCnt = 0;
650 MS_BOOL skipCond;
651 MS_BOOL verticalMoving2;
652 MS_BOOL filmDisableMCDiDFK;
653
654 u8xxxCtrl = 0xFF; //MApi_XC_R2BYTE(REG_SC_BK2A_1F_L) >> 8;
655 u32Reg78 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_78_L); // isMV0
656 u32Reg79 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_79_L); // Horzontal Moving
657 u32Reg7A = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7A_L); // MV not found
658 u32Reg7B = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7B_L); // Feathering
659 u32Reg7C = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7C_L);
660 u32Reg7D = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7D_L);
661 u32Reg7E = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7E_L);
662 filmFeatherCount = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK0A_0B_L);
663
664 if(MApi_XC_EX_GetMirrorModeTypeEx(&_XC_DeviceIdx, E_XC_EX_MAIN_WINDOW) == E_XC_EX_MIRROR_NORMAL)
665 {
666 //Non_Mirror
667 verticalMovingU = ((u32Reg7E > 0x0100) && (u32Reg7E / 8 > u32Reg7C) && (u32Reg7E / 8 > u32Reg7D) && (u32Reg78 > u32Reg79 / 8)) ||
668 ((u32Reg7E > 0x0040) && (u32Reg7E / 32 > u32Reg7C) && (u32Reg7E / 32 > u32Reg7D) && (u32Reg78 > u32Reg79 / 8));
669 movingScene = (u32Reg7E > 0x0080) && (u32Reg7E / 4 > u32Reg7C) && (u32Reg7E / 4 > u32Reg7D) && // V-moving-up &&
670 (u32Reg79 > 0x0200) && (u32Reg79 / 4 > u32Reg78); // H-moving
671 }
672 else
673 {
674 //Mirror
675 verticalMovingU = ((u32Reg7D > 0x0100) && (u32Reg7D / 8 > u32Reg7C) && (u32Reg7D / 8 > u32Reg7E) && (u32Reg78 > u32Reg79 / 8)) ||
676 ((u32Reg7D > 0x0040) && (u32Reg7D / 32 > u32Reg7C) && (u32Reg7D / 32 > u32Reg7E) && (u32Reg78 > u32Reg79 / 8));
677 movingScene = (u32Reg7D > 0x0080) && (u32Reg7D / 4 > u32Reg7C) && (u32Reg7D / 4 > u32Reg7E) && // V-moving-up &&
678 (u32Reg79 > 0x0200) && (u32Reg79 / 4 > u32Reg78); // H-moving
679 }
680
681 verticalMoving2 = (((u32Reg7E > 0x200) && (u32Reg7E > u32Reg7C)) || ((u32Reg7D > 0x200) && (u32Reg7D > u32Reg7C))) && (u32Reg78 > u32Reg79 / 8);
682
683 horizontalMoving = (u32Reg79 > 0x200) && (u32Reg79 / 16 > u32Reg78) && (u32Reg79 > u32Reg7A / 2) &&
684 (u32Reg7C > 0x100) && (u32Reg7C / 2 > u32Reg7D) && (u32Reg7C / 2 > u32Reg7E) ;
685
686 slowMotion = (u32Reg7A > 0x200) && (u32Reg7B < 0x40) && (!verticalMoving2);
687 featheringScene = (u32Reg7B > 0x100) && (u32Reg7B > u32Reg79 / 4) && (u32Reg7B > u32Reg7A / 4) && (u32MotionValue > 0x10);
688 skipCond = (u32Reg7A > 8 * u32Reg79) && (u32Reg7B > 0x600);
689 featheringScene2 = (u32Reg7B > 0x200) && (u32Reg7B > u32Reg79 / 8) && (u32Reg7B > u32Reg7A / 8) && (!horizontalMoving) && (u32MotionValue > 0x10);
690
691 if(verticalMovingU)
692 {
693 if(verticalMovingUCnt != 0xff)
694 {
695 verticalMovingUCnt ++;
696 }
697 }
698 else
699 {
700 verticalMovingUCnt = 0;
701 }
702
703 if(false == skipCond)
704 {
705 if(u8SkipCnt == 0)
706 u8SkipCnt = 0;
707 else
708 u8SkipCnt--;
709 }
710 else
711 {
712 if(u8SkipCnt > 0x40)
713 u8SkipCnt = 0x40;
714 else
715 u8SkipCnt++;
716 }
717
718 if(filmFeatherCount > 0x100)
719 {
720 if(featheringFrameCount < 0x80)
721 featheringFrameCount ++;
722 }
723 else
724 {
725 featheringFrameCount = 0;
726 }
727
728 ////////////////////////////////////////////////////////////////
729 // film content disable mcdi/dfk
730 ////////////////////////////////////////////////////////////////
731
732 curCounter3 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK0A_0B_L);
733
734 cntDiff = (preCounter3 > curCounter3) ? preCounter3 - curCounter3 : curCounter3 - preCounter3;
735
736 if(cntDiff > 0x1500)
737 {
738 if(filmCnt != 10)
739 filmCnt++;
740 }
741 else if(filmCnt != 0)
742 {
743 filmCnt--;
744 }
745
746 preCounter3 = curCounter3;
747 filmDisableMCDiDFK = (filmCnt > 5);
748
749 ////////////////////////////////////////////////////////////////
750 // eodi counter
751 ////////////////////////////////////////////////////////////////
752
753 if(featheringScene2)
754 {
755 if(eodiCnt < 40)
756 eodiCnt += 4;
757 }
758 else
759 {
760 if(eodiCnt > 0)
761 eodiCnt--;
762 }
763
764 /////////////////////////////////////////////////////////////////
765 // SST (De-Feathering)
766 /////////////////////////////////////////////////////////////////
767 if(u8xxxCtrl & ENABLE_XXX_SST)
768 {
769 if(movingScene || filmDisableMCDiDFK)
770 {
771 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0xF100, 0xFF00); // increase SST weighting with checking feathering...
772 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0000, 0x0F00); // SST motion shift1
773 }
774 else if((u32MotionValue < 0x10) && (u32Reg7B > 0x1000)) // special patch for Toshiba... -> tend to still
775 {
776 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0x3100, 0xFF00); // increase SST weighting with checking feathering...
777 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0200, 0x0F00); // SST motion shift1
778 }
779 else if(featheringScene) // moving & feather
780 {
781 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0xF100, 0xFF00); // increase SST weighting with checking feathering...
782 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0000, 0x0F00); // SST motion shift1
783 }
784 else if((u8MotLvl >= 3) && (u32Reg7B > 0x40) && (u32Reg7B > u32Reg7A / 16)) // for sony champion bubbles
785 {
786 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0xF100, 0xFF00); // default SST setting
787 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0000, 0x0F00); // SST motion shift1
788 }
789 else // default
790 {
791 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_29_L, (MS_U16)0x2100, 0xFF00); // default SST setting
792 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0100, 0x0F00); // SST motion shift1
793 }
794 }
795
796 // disable DFK when verticalMovingU
797 if((true == verticalMovingU) || (u8SkipCnt > 0x20) || filmDisableMCDiDFK)
798 {
799 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_28_L, (MS_U16)0x0000, 0xFFFF); // disable DFK
800 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0000, 0xF000); // disable DFK
801 }
802 else if(verticalMoving2)
803 {
804 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_28_L, (MS_U16)0xA8FF, 0xFFFF); // default DFK
805 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0000, 0xF000); // default DFK
806 }
807 else
808 {
809 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_28_L, (MS_U16)0xA8FF, 0xFFFF); // default DFK
810 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x2000, 0xF000); // default DFK
811 }
812
813 if(verticalMovingUCnt > 0x20) // for church
814 {
815 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_34_L, (MS_U16)0x0FF0, 0xFFFF); // favor MCDi Weight
816 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_36_L, (MS_U16)0x2800, 0x3C0F); // enable MCDi U for blending and history
817 }
818 else
819 {
820 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_34_L, (MS_U16)0x8888, 0xFFFF); // default MCDi Weight
821 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_36_L, (MS_U16)0x0000, 0x3C0F); // Use MCDi-H as default
822 }
823
824 // Favor MCDi-V when verticalMovingU
825 if(1) //true == verticalMovingU )
826 {
827 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_04_L, (MS_U16)0x0800, 0x0800); // Enable MCDi-V
828 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x4000, 0xF000); // reduce motion history
829 }
830 else
831 {
832 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_04_L, (MS_U16)0x0800, 0x0800); // Disable MCDi-V
833 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x4000, 0xF000); // default MCDi motion history
834 }
835
836 // DFK EodiW1, 2
837 if((s8DeBouncingCnt < 0x3) || filmDisableMCDiDFK) //new add
838 {
839 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0080, 0x00F0); // reduce DFK EodiWeight
840 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x4c30, 0xFF30); // disable EodiW for DFK
841 }
842 else if((true == verticalMovingU) || verticalMoving2)
843 {
844 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0010, 0x00F0); // increase EodiW -> tower
845 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x4c10, 0xFF30); // default
846 }
847 else if((false == verticalMovingU) && slowMotion)
848 {
849 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0080, 0x00F0); // reduce DFK EodiWeight
850 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x0c30, 0xFF30); // disable EodiW for DFK
851 }
852 else if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8))) // RF/AV default, eodi weight strong
853 {
854 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0010, 0x00F0); // increase EodiW
855 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x18F1, 0xFF30); // default
856 }
857 else // default
858 {
859 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0040, 0x00F0); // default DFK EodiWeight
860 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)0x0c10, 0xFF30); // default
861 }
862
863 if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8))) // RF/AV default, eodi weight strong
864 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4488, 0x00F0);
865 else
866 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x0020, 0x00F0);
867
868 // DFK check feathering gain
869 if(filmDisableMCDiDFK) //new add
870 {
871 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0f00, 0x0F00);
872 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0xf000, 0xF000); //
873 }
874 else if(u32MotionValue == 0)
875 {
876 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0800, 0x0F00); // reduce DFK feathering weight
877 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0x1000, 0xF000); //
878 }
879 else if((false == verticalMovingU) && slowMotion)
880 {
881 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0800, 0x0F00); // reduce DFK feathering weight
882 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0x1000, 0xF000); //
883 }
884 else if(u32Reg7B > 0x100)
885 {
886 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0f00, 0x0F00); // feather -> increase
887 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0xc000, 0xF000); //
888 }
889 else
890 {
891 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2A_L, (MS_U16)0x0f00, 0x0F00); // default
892 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0x4000, 0xF000); //
893 }
894
895 // EodiWeight for MCDi
896 if(true == verticalMovingU)
897 {
898 if((u32Reg7A > 0x100) && (u32Reg7A / 2 > u32Reg79)) // not-found >> horizontal : Church
899 {
900 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0004, 0x000F); // reduce EodiWeight for MCDi
901 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4800, 0xFF0F); // church
902 }
903 else // Tower
904 {
905 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0004, 0x000F); // increase EodiWeight for MCDi
906 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4200, 0xFF0F); // Tower
907 }
908 }
909 else if((false == verticalMovingU) && horizontalMoving)
910 {
911 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0002, 0x000F); // reduce EodiWeight for MCDi
912 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x1800, 0xFF0F); // reduce EodiW for MCDi
913 }
914 else if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8))) // RF/AV default, eodi weight strong
915 {
916 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0002, 0x000F); // increase EodiWeight for MCDi
917 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4408, 0xFF0F);
918 }
919 else if(eodiCnt > 25)
920 {
921 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0001, 0x000F); // default EodiWeight for MCDi
922 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4400, 0xFF0F);
923 }
924 else if(eodiCnt < 10)
925 {
926 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2C_L, (MS_U16)0x0002, 0x000F); // default EodiWeight for MCDi
927 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)0x4800, 0xFF0F);
928 }
929
930 if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1F_L, BIT(8)) && (!horizontalMoving)) // RF/AV default, eodi weight strong
931 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_29_L, (MS_U16)0xC830, 0xFFFF); // reduce EodiW on MCDi
932 else if(!horizontalMoving)
933 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_29_L, (MS_U16)0xC832, 0xFFFF); // reduce EodiW on MCDi
934 else
935 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_29_L, (MS_U16)0xC836, 0xFFFF);
936
937 // MCDi check Feathering weight
938 if(filmDisableMCDiDFK)
939 {
940 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x0060, 0x00F0); // reduce MCDi feathering weight -> for church
941 }
942 else if(true == verticalMovingU) //new add
943 {
944 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x0000, 0x00F0); // reduce MCDi feathering weight -> for church
945 }
946 else if(horizontalMoving)
947 {
948 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x0000, 0x00F0); // reduce MCDi feathering weight
949 }
950 else
951 {
952 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)0x0060, 0x00F0); // default MCDi Feathering Weight
953 }
954 // multi-burst skip
955 if((u8SkipCnt > 0x20) || filmDisableMCDiDFK)
956 {
957 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, (MS_U16)0x0000, 0x0080); // disable mcdi
958 }
959 else if(u8SkipCnt < 0x10)
960 {
961 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, (MS_U16)0x0080, 0x0080); // enable mcdi
962 }
963
964 if(u32MotionValue == 0) // still picture -> tend to still
965 {
966 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0x0800, 0x0FFF); //
967 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0000, 0x00FF); //
968 }
969 else // default
970 {
971 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2B_L, (MS_U16)0x0888, 0x0FFF); //
972 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2C_L, (MS_U16)0x0088, 0x00FF); //
973 }
974
975 /////////////////////////////////////////////////////////////////
976 // De-bouncing
977 /////////////////////////////////////////////////////////////////
978
979 MS_BOOL film;
980 film = ((MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0008) == 0x0008) || // film22
981 ((MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0010) == 0x0010) || // film32
982 ((MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0040) == 0x0040) ; // film any
983
984 if((u8MotLvl >= 1) || (true == film))
985 {
986 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, 0x000c, 0x000e); // history weight = 6
987 }
988 else
989 {
990 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, 0x0004, 0x000e); // history weight = 2
991 }
992
993 }
994
995 #define MF_Gain 30
MDrv_SC_T12_UC_SmallMoving(void)996 MS_U32 MDrv_SC_T12_UC_SmallMoving(void)
997 {
998 MS_U32 before_MC_feather;
999 MS_U32 nonMV0_Comfirm, MV_Contradict;
1000 MS_U32 MovingFeather, MV_Confirm;
1001 static MS_U32 PrevMV_Confirm = 0;
1002
1003 before_MC_feather = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_77_L) ;
1004 nonMV0_Comfirm = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_79_L);
1005 MV_Contradict = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7A_L);
1006
1007 MV_Confirm = (nonMV0_Comfirm + MV_Contradict) >> 1;
1008
1009 MV_Confirm = (PrevMV_Confirm * 3 + MV_Confirm) >> 2;
1010 PrevMV_Confirm = MV_Confirm;
1011
1012 if(MV_Confirm > (before_MC_feather * MF_Gain))
1013 MovingFeather = MV_Confirm - ((before_MC_feather * MF_Gain)) ;
1014 else
1015 MovingFeather = 0;
1016
1017 return MovingFeather; // "Big": in seach range "Small": out of seach range
1018 }
1019
1020 #define OOSRF_Gain 4
1021 #define OOSRF_Power 2
MDrv_SC_T12_UC_InSearchRange_Feather(void)1022 MS_U32 MDrv_SC_T12_UC_InSearchRange_Feather(void)
1023 {
1024 MS_U32 before_MC_feather, after_MC_feather;
1025 MS_U32 MC_OOSRF;
1026 static MS_U32 Prev_before_MC_feather = 0;
1027 static MS_U32 Prev_after_MC_feather = 0;
1028
1029 before_MC_feather = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_77_L) ;
1030 after_MC_feather = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7B_L);
1031
1032 before_MC_feather = (Prev_before_MC_feather * 3 + before_MC_feather) >> 2;
1033 Prev_before_MC_feather = before_MC_feather;
1034
1035 after_MC_feather = (Prev_after_MC_feather * 3 + after_MC_feather) >> 2;
1036 Prev_after_MC_feather = after_MC_feather;
1037
1038 if(before_MC_feather > (after_MC_feather * OOSRF_Gain) >> OOSRF_Power)
1039 MC_OOSRF = before_MC_feather - ((after_MC_feather * OOSRF_Gain) >> OOSRF_Power) ;
1040 else
1041 MC_OOSRF = 0;
1042
1043 return MC_OOSRF; // "Big": in seach range "Small": out of seach range
1044 }
1045
1046 #define OOSRMC_Gain 20
MDrv_SC_T12_UC_InSearchRange_MvComfirm(void)1047 MS_U32 MDrv_SC_T12_UC_InSearchRange_MvComfirm(void)
1048 {
1049 MS_U32 MV0_Comfirm, nonMV0_Comfirm, MV_Contradict;
1050 static MS_U32 Prev_MV0_Comfirm = 0;
1051 static MS_U32 Prev_nonMV0_Comfirm = 0;
1052 static MS_U32 Prev_MV_Contradict = 0;
1053 MS_U32 MV_Comfirm, MC_OOSRMC;
1054
1055 MV0_Comfirm = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_78_L);
1056 nonMV0_Comfirm = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_79_L);
1057 MV_Contradict = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7A_L);
1058
1059 MV0_Comfirm = (Prev_MV0_Comfirm * 3 + MV0_Comfirm) >> 2;
1060 Prev_MV0_Comfirm = MV0_Comfirm;
1061
1062 nonMV0_Comfirm = (Prev_nonMV0_Comfirm * 3 + nonMV0_Comfirm) >> 2;
1063 Prev_nonMV0_Comfirm = nonMV0_Comfirm;
1064
1065 MV_Contradict = (Prev_MV_Contradict * 3 + MV_Contradict) >> 2;
1066 Prev_MV_Contradict = MV_Contradict;
1067
1068 MV_Comfirm = MV0_Comfirm + nonMV0_Comfirm;
1069
1070 if(MV_Comfirm > MV_Contradict * OOSRMC_Gain)
1071 MC_OOSRMC = MV_Comfirm - MV_Contradict * OOSRMC_Gain;
1072 else
1073 MC_OOSRMC = 0;
1074
1075 return MC_OOSRMC; // "Big": in seach range "Small": out of seach range
1076
1077 }
1078
1079 #define Confirm_Gain 5
MDrv_SC_UC_InSearchRange_MR_Offset(void)1080 MS_U8 MDrv_SC_UC_InSearchRange_MR_Offset(void)
1081 {
1082 MS_U32 MV0_Comfirm, nonMV0_Comfirm, MV_Contradict;
1083 static MS_U32 Prev_MV0_Comfirm = 0;
1084 static MS_U32 Prev_nonMV0_Comfirm = 0;
1085 static MS_U32 Prev_MV_Contradict = 0;
1086 MS_U32 MV_Comfirm;
1087 MS_U8 MR_Offset;
1088
1089 MV0_Comfirm = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_78_L);
1090 nonMV0_Comfirm = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_79_L);
1091 MV_Contradict = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7A_L);
1092
1093 MV0_Comfirm = (Prev_MV0_Comfirm * 3 + MV0_Comfirm) >> 2;
1094 Prev_MV0_Comfirm = MV0_Comfirm;
1095
1096 nonMV0_Comfirm = (Prev_nonMV0_Comfirm * 3 + nonMV0_Comfirm) >> 2;
1097 Prev_nonMV0_Comfirm = nonMV0_Comfirm;
1098
1099 MV_Contradict = (Prev_MV_Contradict * 3 + MV_Contradict) >> 2;
1100 Prev_MV_Contradict = MV_Contradict;
1101
1102 MV_Comfirm = MV0_Comfirm + nonMV0_Comfirm;
1103
1104 if(MV_Comfirm > (MV_Contradict * Confirm_Gain))
1105 MR_Offset = nonMV0_Comfirm;
1106 else
1107 MR_Offset = 0;
1108
1109 return MR_Offset;
1110 }
1111
1112 #define ISR_NONMV0_Gain 15
MDrv_SC_T12_UC_InSearchRange_nonMv0Comfirm(void)1113 MS_U32 MDrv_SC_T12_UC_InSearchRange_nonMv0Comfirm(void)
1114 {
1115 MS_U32 MV0_Comfirm, nonMV0_Comfirm, MV_Contradict;
1116 static MS_U32 Prev_MV0_Comfirm = 0;
1117 static MS_U32 Prev_nonMV0_Comfirm = 0;
1118 static MS_U32 Prev_MV_Contradict = 0;
1119 MS_U32 MV_Comfirm, Comfirm_Value;
1120
1121 MV0_Comfirm = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_78_L);
1122 nonMV0_Comfirm = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_79_L);
1123 MV_Contradict = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7A_L);
1124
1125 MV0_Comfirm = (Prev_MV0_Comfirm * 3 + MV0_Comfirm) >> 2;
1126 Prev_MV0_Comfirm = MV0_Comfirm;
1127
1128 nonMV0_Comfirm = (Prev_nonMV0_Comfirm * 3 + nonMV0_Comfirm) >> 2;
1129 Prev_nonMV0_Comfirm = nonMV0_Comfirm;
1130
1131 MV_Contradict = (Prev_MV_Contradict * 3 + MV_Contradict) >> 2;
1132 Prev_MV_Contradict = MV_Contradict;
1133
1134 MV_Comfirm = /*MV0_Comfim +*/nonMV0_Comfirm;
1135
1136 if(MV_Comfirm > (MV_Contradict * ISR_NONMV0_Gain))
1137 Comfirm_Value = MV_Comfirm - MV_Contradict * ISR_NONMV0_Gain;
1138 else
1139 Comfirm_Value = 0;
1140
1141 return Comfirm_Value; // "Big": in seach range "Small": out of seach range
1142
1143 }
1144
MDrv_SC_T12_DIPF_TemporalGainControl(MS_U32 OOSRMC,MS_U32 OOSRF,MS_U32 ISR_NONMV0)1145 void MDrv_SC_T12_DIPF_TemporalGainControl(MS_U32 OOSRMC, MS_U32 OOSRF, MS_U32 ISR_NONMV0)
1146 {
1147 static MS_U16 TemporalGainControl = 0x0F;
1148
1149 UNUSED(OOSRMC);
1150 UNUSED(OOSRF);
1151
1152 if(ISR_NONMV0 > 1000) //&& OOSRF > 50)
1153 {
1154 if(TemporalGainControl > 0x00)
1155 TemporalGainControl--;
1156 else
1157 TemporalGainControl = 0;
1158 }
1159 else
1160 {
1161 if(TemporalGainControl < 0x0F)
1162 TemporalGainControl++;
1163 else
1164 TemporalGainControl = 0x0F;
1165 }
1166 MApi_XC_W2BYTEMSK(REG_SC_BK22_14_L, (MS_U16)TemporalGainControl, 0x000F);
1167
1168 }
1169
1170 #define ComplexOffset_MaxValue 0x06
1171 #define ComplexOffset_MinValue 0x00
MDrv_SC_T12_UCDi_ComplexOffset(MS_U32 OOSRMC,MS_U32 OOSRF,MS_U32 ISR_NONMV0)1172 void MDrv_SC_T12_UCDi_ComplexOffset(MS_U32 OOSRMC, MS_U32 OOSRF, MS_U32 ISR_NONMV0)
1173 {
1174 static MS_U16 ComplexOffset = ComplexOffset_MaxValue;
1175
1176 UNUSED(OOSRMC);
1177 UNUSED(OOSRF);
1178
1179 if(ISR_NONMV0 > 1000) //&& OOSRF > 50)
1180 {
1181 if(ComplexOffset > ComplexOffset_MinValue)
1182 ComplexOffset--;
1183 else
1184 ComplexOffset = ComplexOffset_MinValue;
1185 }
1186 else
1187 {
1188 if(ComplexOffset < ComplexOffset_MaxValue)
1189 ComplexOffset++;
1190 else
1191 ComplexOffset = ComplexOffset_MaxValue;
1192 }
1193 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)ComplexOffset << 4, 0x00F0);
1194 }
1195
1196 #define OP1_HisWeight_MaxValue 0x0E
1197 #define OP1_HisWeight_MinValue 0x04
MDrv_SC_T12_UCDi_OP1_HisWeight(MS_U8 u8MotLvl)1198 void MDrv_SC_T12_UCDi_OP1_HisWeight(MS_U8 u8MotLvl)
1199 {
1200 MS_BOOL film;
1201
1202 film = ((MS_U16)MApi_XC_R2BYTEMSK(REG_SC_BK0A_21_L, 0x0008) == 0x0008) || // film22
1203 ((MS_U16)MApi_XC_R2BYTEMSK(REG_SC_BK0A_21_L, 0x0010) == 0x0010) || // film32
1204 ((MS_U16)MApi_XC_R2BYTEMSK(REG_SC_BK0A_21_L, 0x0040) == 0x0040) ; // film any
1205
1206 if((u8MotLvl >= 1) || (true == film))
1207 {
1208 MApi_XC_W2BYTEMSK(REG_SC_BK2A_02_L, OP1_HisWeight_MaxValue, 0x000e); // history weight = 6
1209 }
1210 else
1211 {
1212 MApi_XC_W2BYTEMSK(REG_SC_BK2A_02_L, OP1_HisWeight_MinValue, 0x000e); // history weight = 2
1213 }
1214 }
1215
1216 #define A5_HIS_MOTION_TH 0x0A
MDrv_SC_A5_UCDi_OP1_HisWeight(const MS_U32 u32MotionValue,const MS_U32 FeatherSum)1217 void MDrv_SC_A5_UCDi_OP1_HisWeight(const MS_U32 u32MotionValue,const MS_U32 FeatherSum)
1218 {
1219 static MS_U32 reg_his_weight = OP1_HisWeight_MinValue;
1220 static MS_U32 u32MotionValue_prev = 0;
1221
1222 if( u32MotionValue_prev < u32MotionValue )
1223 u32MotionValue_prev = ((u32MotionValue_prev*3 )+ u32MotionValue ) >> 2;
1224 else
1225 u32MotionValue_prev = u32MotionValue;
1226
1227 if( u32MotionValue_prev < A5_HIS_MOTION_TH )
1228 {
1229 reg_his_weight = OP1_HisWeight_MinValue;
1230 }
1231 else
1232 {
1233 if( reg_his_weight < OP1_HisWeight_MaxValue )
1234 reg_his_weight++;
1235 else
1236 reg_his_weight = OP1_HisWeight_MaxValue;
1237 }
1238
1239 if(FeatherSum > 0x3500)
1240 {
1241 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, OP1_HisWeight_MinValue, 0x000e); // history weight = 6
1242 }
1243 else
1244 {
1245 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_02_L, reg_his_weight, 0x000E);
1246 }
1247 }
1248
1249 #define FeatherValueGain_MaxValue 0x02
1250 #define FeatherValueGain_MinValue 0x00
MDrv_SC_T12_UCDi_FeatherValueGain(MS_U32 OOSRMC,MS_U32 OOSRF,MS_U32 ISR_NONMV0)1251 void MDrv_SC_T12_UCDi_FeatherValueGain(MS_U32 OOSRMC, MS_U32 OOSRF, MS_U32 ISR_NONMV0)
1252 {
1253 static MS_U16 FeatherValue = FeatherValueGain_MaxValue;
1254
1255 UNUSED(OOSRMC);
1256 UNUSED(OOSRF);
1257
1258 if(ISR_NONMV0 > 1000) //&& OOSRF > 50)
1259 {
1260 if(FeatherValue > FeatherValueGain_MinValue)
1261 FeatherValue--;
1262 else
1263 FeatherValue = FeatherValueGain_MinValue;
1264 }
1265 else
1266 {
1267 if(FeatherValue < FeatherValueGain_MaxValue)
1268 FeatherValue++;
1269 else
1270 FeatherValue = FeatherValueGain_MaxValue;
1271 }
1272 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2D_L, (MS_U16)FeatherValue << 12, 0xF000);
1273
1274 }
1275
1276 #define W2SadGain_MaxValue 0x0C
1277 #define W2SadGain_MinValue 0x08
MDrv_SC_T12_UCDi_W2SadGain(MS_U32 OOSRMC,MS_U32 OOSRF,MS_U32 ISR_NONMV0)1278 void MDrv_SC_T12_UCDi_W2SadGain(MS_U32 OOSRMC, MS_U32 OOSRF, MS_U32 ISR_NONMV0)
1279 {
1280 static MS_U16 W2SadGain = FeatherValueGain_MaxValue;
1281
1282 UNUSED(OOSRMC);
1283 UNUSED(OOSRF);
1284
1285 if(ISR_NONMV0 > 1000) //&& OOSRF > 50)
1286 {
1287 if(W2SadGain < W2SadGain_MaxValue)
1288 W2SadGain++;
1289 else
1290 W2SadGain = W2SadGain_MaxValue;
1291 }
1292 else
1293 {
1294 if(W2SadGain > W2SadGain_MinValue)
1295 W2SadGain--;
1296 else
1297 W2SadGain = W2SadGain_MinValue;
1298 }
1299 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2D_L, (MS_U16)W2SadGain << 8, 0x0F00);
1300
1301 }
1302
1303 #define VerticalMovingUdRatio_MaxValue 0x08
1304 #define VerticalMovingUdRatio_MinValue 0x07
MDrv_SC_T12_UCDi_VerticalMovingUdRatio(MS_U32 OOSRMC,MS_U32 OOSRF,MS_U32 ISR_NONMV0)1305 void MDrv_SC_T12_UCDi_VerticalMovingUdRatio(MS_U32 OOSRMC, MS_U32 OOSRF, MS_U32 ISR_NONMV0)
1306 {
1307 static MS_U16 VerticalMovingUdRatioValue = VerticalMovingUdRatio_MaxValue;
1308
1309 UNUSED(OOSRMC);
1310 UNUSED(ISR_NONMV0);
1311
1312 if( OOSRF > 0x300 )
1313 {
1314 if(VerticalMovingUdRatioValue > VerticalMovingUdRatio_MinValue)
1315 VerticalMovingUdRatioValue--;
1316 else
1317 VerticalMovingUdRatioValue = VerticalMovingUdRatio_MinValue;
1318 }
1319 else
1320 {
1321 if(VerticalMovingUdRatioValue < VerticalMovingUdRatio_MaxValue)
1322 VerticalMovingUdRatioValue++;
1323 else
1324 VerticalMovingUdRatioValue = VerticalMovingUdRatio_MaxValue;
1325 }
1326 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_28_L, (MS_U16)VerticalMovingUdRatioValue, 0x000F);
1327 }
1328
1329 #define KFC_8bitMotionGain_MaxValue 0x08
1330 #define KFC_8bitMotionGain_MinValue 0x04 //0 have feather issue.
MDrv_SC_T12_KFC_8bitMotionGain(MS_U32 SmallMoving)1331 void MDrv_SC_T12_KFC_8bitMotionGain(MS_U32 SmallMoving)
1332 {
1333 static MS_U16 KFC_8bitMotionGainValue = KFC_8bitMotionGain_MaxValue;
1334
1335 if(SmallMoving > 500)
1336 {
1337 if(KFC_8bitMotionGainValue > KFC_8bitMotionGain_MinValue)
1338 KFC_8bitMotionGainValue--;
1339 else
1340 KFC_8bitMotionGainValue = KFC_8bitMotionGain_MinValue;
1341 }
1342 else
1343 {
1344 if(KFC_8bitMotionGainValue < KFC_8bitMotionGain_MaxValue)
1345 KFC_8bitMotionGainValue++;
1346 else
1347 KFC_8bitMotionGainValue = KFC_8bitMotionGain_MaxValue;
1348 }
1349 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_3B_L, (MS_U16)KFC_8bitMotionGainValue << 4, 0x00F0);
1350 }
1351
1352 #define UCDi_EODiWGain_MaxValue 0x0F
1353 #define UCDi_EODiWGain_MinValue 0x00
MDrv_SC_T12_UCDi_EODiWGain(MS_U32 OOSRMC,MS_U32 OOSRF,MS_U32 ISR_NONMV0)1354 void MDrv_SC_T12_UCDi_EODiWGain(MS_U32 OOSRMC, MS_U32 OOSRF, MS_U32 ISR_NONMV0)
1355 {
1356 static MS_U16 EODiWGainValue = UCDi_EODiWGain_MaxValue;
1357
1358 UNUSED(OOSRMC);
1359
1360 if((ISR_NONMV0 > 1000) && (OOSRF > 50))
1361 {
1362 if(EODiWGainValue > UCDi_EODiWGain_MinValue)
1363 EODiWGainValue--;
1364 else
1365 EODiWGainValue = UCDi_EODiWGain_MinValue;
1366 }
1367 else
1368 {
1369 if(EODiWGainValue < UCDi_EODiWGain_MaxValue)
1370 EODiWGainValue++;
1371 else
1372 EODiWGainValue = UCDi_EODiWGain_MaxValue;
1373 }
1374 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_2A_L, (MS_U16)EODiWGainValue << 12, 0xF000);
1375 }
1376
1377 #define UCDi_HistoryRatio_MaxValue 0x07
1378 #define UCDi_HistoryRatio_MinValue 0x04
MDrv_SC_T12_UCDi_HistoryRatio(MS_U32 OOSRMC,MS_U32 OOSRF,MS_U32 ISR_NONMV0)1379 void MDrv_SC_T12_UCDi_HistoryRatio(MS_U32 OOSRMC, MS_U32 OOSRF, MS_U32 ISR_NONMV0)
1380 {
1381 static MS_U16 HistoryRatioValue = UCDi_HistoryRatio_MaxValue;
1382
1383 UNUSED(OOSRMC);
1384
1385 if((ISR_NONMV0 > 1000) && (OOSRF > 50))
1386 {
1387 if(HistoryRatioValue > UCDi_HistoryRatio_MinValue)
1388 HistoryRatioValue--;
1389 else
1390 HistoryRatioValue = UCDi_HistoryRatio_MinValue;
1391 }
1392 else
1393 {
1394 if(HistoryRatioValue < UCDi_HistoryRatio_MaxValue)
1395 HistoryRatioValue++;
1396 else
1397 HistoryRatioValue = UCDi_HistoryRatio_MaxValue;
1398 }
1399 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)HistoryRatioValue << 12, 0xF000);
1400 }
1401
1402 #define KFC_EODIW_GAIN_MAX 4
1403 #define KFC_EODIW_GAIN_MIN 0
MDrv_SC_A5_KFC_EODiW(const MS_U32 IsVerticalMoving)1404 void MDrv_SC_A5_KFC_EODiW(const MS_U32 IsVerticalMoving)
1405 {
1406 MS_U32 Statistics_cplx_pixel;
1407 static MS_U32 Statistics_cplx_pixel_iir = KFC_EODIW_GAIN_MIN;
1408 static MS_U32 reg_kfc_eodiw_gain = KFC_EODIW_GAIN_MAX ;
1409
1410 Statistics_cplx_pixel = ((Statistics_cplx_pixel_iir*3 )+ MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7F_L) ) >> 2;
1411 Statistics_cplx_pixel_iir = Statistics_cplx_pixel;
1412
1413 if( (IsVerticalMoving < 0x150) && (Statistics_cplx_pixel_iir > 0x1000) )
1414 {
1415 if( reg_kfc_eodiw_gain > KFC_EODIW_GAIN_MIN )
1416 reg_kfc_eodiw_gain--;
1417 else
1418 reg_kfc_eodiw_gain = KFC_EODIW_GAIN_MIN;
1419 }
1420 else
1421 {
1422 if( reg_kfc_eodiw_gain < KFC_EODIW_GAIN_MAX )
1423 reg_kfc_eodiw_gain++;
1424 else
1425 reg_kfc_eodiw_gain = KFC_EODIW_GAIN_MAX;
1426 }
1427 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_28_L, (MS_U16)reg_kfc_eodiw_gain << 12, 0xF000);
1428 }
1429
1430 #define SONYC_KFC_EN_MAX 1
1431 #define SONYC_KFC_EN_MIN 0
1432 #define SONYC_CPLX_GAIN_MAX 4
1433 #define SONYC_CPLX_GAIN_MIN 0
MDrv_SC_A5_SonyChurch(const MS_U32 IsVerticalMoving,const MS_U32 IsHorizontalMoving,const MS_U32 u32MotionValue,const MS_BOOL bL107_en)1434 void MDrv_SC_A5_SonyChurch(const MS_U32 IsVerticalMoving, const MS_U32 IsHorizontalMoving, const MS_U32 u32MotionValue, const MS_BOOL bL107_en)
1435 {
1436 static MS_U32 reg_kfc_en = SONYC_KFC_EN_MAX ;
1437 static MS_U32 reg_mcdi_cplx_gain = SONYC_CPLX_GAIN_MAX;
1438
1439 //IsHorizontalMoving=IsHorizontalMoving;
1440 if( (IsVerticalMoving > 0xF0) && (IsHorizontalMoving < 1) && (u32MotionValue > 0x40000) )
1441 {
1442 if( reg_mcdi_cplx_gain > SONYC_CPLX_GAIN_MIN )
1443 reg_mcdi_cplx_gain--;
1444 else
1445 reg_mcdi_cplx_gain = SONYC_CPLX_GAIN_MIN;
1446
1447 if( reg_kfc_en > SONYC_KFC_EN_MIN )
1448 reg_kfc_en--;
1449 else
1450 reg_kfc_en = SONYC_KFC_EN_MIN;
1451 }
1452 else
1453 {
1454 if( reg_mcdi_cplx_gain < SONYC_CPLX_GAIN_MAX )
1455 reg_mcdi_cplx_gain++;
1456 else
1457 reg_mcdi_cplx_gain = SONYC_CPLX_GAIN_MAX;
1458
1459 if( reg_kfc_en < SONYC_KFC_EN_MAX )
1460 reg_kfc_en++;
1461 else
1462 reg_kfc_en = SONYC_KFC_EN_MAX;
1463 }
1464
1465 if( !bL107_en )
1466 {
1467 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_04_L, (MS_U16)reg_kfc_en<<1, 0x0002);
1468 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)reg_mcdi_cplx_gain<<8, 0x0F00);
1469 }
1470 }
1471
1472 #define L107_FEATHER_GAIN_MAX 2
1473 #define L107_FEATHER_GAIN_MIN 0
1474 #define L107_CPLX_OFFSET_MAX 6
1475 #define L107_CPLX_OFFSET_MIN 0
1476 #define L107_CPLX_GAIN_MAX 15
1477 #define L107_CPLX_GAIN_MIN 4
MDrv_SC_A5_L107(const MS_U32 IsVerticalMoving,const MS_U32 IsHorizontalMoving,const MS_U32 total_feather,const MS_U32 mvComfirm,const MS_U32 colorSum,const MS_U32 u32MotionValue,const MS_U32 uComplex)1478 MS_BOOL MDrv_SC_A5_L107(const MS_U32 IsVerticalMoving, const MS_U32 IsHorizontalMoving, const MS_U32 total_feather, const MS_U32 mvComfirm, const MS_U32 colorSum,const MS_U32 u32MotionValue, const MS_U32 uComplex )
1479 {
1480 static MS_U32 reg_mcdi_feather_gain = L107_FEATHER_GAIN_MAX ;
1481 static MS_U32 reg_mcdi_cplx_offset = L107_CPLX_OFFSET_MAX ;
1482 static MS_U32 reg_mcdi_cplx_gain = L107_CPLX_GAIN_MIN ;
1483 MS_BOOL bL107_en;
1484
1485 if( (IsVerticalMoving < 20) && (IsHorizontalMoving < 200) && (total_feather < 100) && (mvComfirm > 200) && (colorSum > 200) && (u32MotionValue > 0x3500) && (uComplex < 0x700))
1486 {
1487 bL107_en = TRUE;
1488
1489 if( reg_mcdi_feather_gain > L107_FEATHER_GAIN_MIN )
1490 reg_mcdi_feather_gain--;
1491 else
1492 reg_mcdi_feather_gain = L107_FEATHER_GAIN_MIN;
1493
1494 if( reg_mcdi_cplx_offset > L107_CPLX_OFFSET_MIN )
1495 reg_mcdi_cplx_offset--;
1496 else
1497 reg_mcdi_cplx_offset = L107_CPLX_OFFSET_MIN;
1498
1499 if( reg_mcdi_cplx_gain < L107_CPLX_GAIN_MAX )
1500 reg_mcdi_cplx_gain++;
1501 else
1502 reg_mcdi_cplx_gain = L107_CPLX_GAIN_MAX;
1503 }
1504 else
1505 {
1506 bL107_en = FALSE;
1507
1508 if( reg_mcdi_feather_gain < L107_FEATHER_GAIN_MAX )
1509 reg_mcdi_feather_gain++;
1510 else
1511 reg_mcdi_feather_gain = L107_FEATHER_GAIN_MAX;
1512
1513 if( reg_mcdi_cplx_offset < L107_CPLX_OFFSET_MAX )
1514 reg_mcdi_cplx_offset++;
1515 else
1516 reg_mcdi_cplx_offset = L107_CPLX_OFFSET_MAX;
1517
1518 if( reg_mcdi_cplx_gain > L107_CPLX_GAIN_MIN )
1519 reg_mcdi_cplx_gain--;
1520 else
1521 reg_mcdi_cplx_gain = L107_CPLX_GAIN_MIN;
1522 }
1523
1524 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2D_L, (MS_U16)reg_mcdi_feather_gain<<12, 0xF000); // 2 to 0
1525 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)reg_mcdi_cplx_offset<<4, 0x00F0);// 6 to 0
1526 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_2E_L, (MS_U16)reg_mcdi_cplx_gain<<8, 0x0F00);// 4 to F
1527
1528 return bL107_en;
1529 }
1530
MDrv_SC_A5_ComplexSum(void)1531 MS_U32 MDrv_SC_A5_ComplexSum(void)
1532 {
1533 static MS_U32 IsComplex_iir = 0xFFFF;
1534 MS_U32 IsComplex;
1535
1536 IsComplex = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7F_L);
1537
1538 IsComplex = (IsComplex_iir*3 + IsComplex ) >> 2;
1539 IsComplex_iir = IsComplex;
1540
1541 return IsComplex_iir;
1542 }
1543
MDrv_SC_A5_KFC_IsVerticalMoving(void)1544 MS_U32 MDrv_SC_A5_KFC_IsVerticalMoving(void)
1545 {
1546 MS_U32 u32_mvc, u32_mvu, u32_mvd;
1547 MS_U32 me_vertical;
1548 static MS_U32 IsVerticalMoving_iir = 0;
1549
1550 u32_mvc = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7C_L);
1551 u32_mvu = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7D_L);
1552 u32_mvd = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7E_L);
1553
1554 if ((u32_mvu > u32_mvc) && (u32_mvu > u32_mvd) /*&& (u32_mvu > 0x200*/)
1555 {
1556 if( u32_mvu > (u32_mvc+u32_mvd)/2 )
1557 me_vertical = (u32_mvu - (u32_mvc+u32_mvd)/2);
1558 else
1559 me_vertical = 0;
1560 }
1561 else if((u32_mvd > u32_mvc) && (u32_mvd > u32_mvu) /*&& (u32_mvd > 0x200)*/)
1562 {
1563 if( u32_mvd > (u32_mvc+u32_mvu)/2 )
1564 me_vertical = (u32_mvd - (u32_mvc+u32_mvu)/2);
1565 else
1566 me_vertical = 0;
1567 }
1568 else
1569 {
1570 me_vertical = 0;
1571 }
1572
1573 if( me_vertical > 255 )
1574 me_vertical = 255;
1575
1576 me_vertical = (IsVerticalMoving_iir*3 + me_vertical ) >> 2;
1577 IsVerticalMoving_iir = me_vertical;
1578
1579 return me_vertical;
1580 }
1581
MDrv_SC_A5_IsHorizontalMoving(void)1582 MS_U32 MDrv_SC_A5_IsHorizontalMoving(void)
1583 {
1584 MS_U32 u32_mvc, u32_mvu, u32_mvd;
1585 MS_U32 me_horizontal;
1586 static MS_U32 IsHorizontalMoving_iir = 0;
1587
1588 u32_mvc = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7C_L);
1589 u32_mvu = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7D_L);
1590 u32_mvd = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7E_L);
1591
1592 if ((u32_mvc > u32_mvu) && (u32_mvc > u32_mvd) /*&& (u32_mvu > 0x200*/)
1593 {
1594 if( u32_mvc > (u32_mvu+u32_mvd)/2 )
1595 me_horizontal = (u32_mvc - (u32_mvu+u32_mvd)/2);
1596 else
1597 me_horizontal = 0;
1598 }
1599 else
1600 {
1601 me_horizontal = 0;
1602 }
1603
1604 if( me_horizontal > 255 )
1605 me_horizontal = 255;
1606
1607 me_horizontal = (IsHorizontalMoving_iir*3 + me_horizontal ) >> 2;
1608 IsHorizontalMoving_iir = me_horizontal;
1609
1610 return me_horizontal;
1611 }
1612
1613
MDrv_SC_A5_ColorPixelSum(void)1614 MS_U32 MDrv_SC_A5_ColorPixelSum(void)
1615 {
1616 MS_U32 colorSum;
1617 static MS_U32 colorSum_iir = 0;
1618
1619 colorSum = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK1A_6E_L);
1620 colorSum = colorSum / 8;
1621
1622 if( colorSum > 255 )
1623 colorSum = 255;
1624
1625 colorSum = ((colorSum_iir*3 )+ colorSum ) >> 2;
1626 colorSum_iir = colorSum;
1627
1628 return colorSum_iir;
1629 }
1630
1631
MDrv_SC_A5_TotalFeather(void)1632 MS_U32 MDrv_SC_A5_TotalFeather(void)
1633 {
1634 MS_U32 mv0_feather, nonMv0_feather;
1635 MS_U32 total_feather;
1636 static MS_U32 total_feather_iir = 255;
1637
1638 mv0_feather = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_77_L);
1639 nonMv0_feather = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7B_L);
1640
1641 total_feather = ( mv0_feather + nonMv0_feather ) / 4;
1642
1643 if( total_feather > 255 )
1644 total_feather = 255;
1645
1646 total_feather = ((total_feather_iir*3 )+ total_feather ) >> 2;
1647 total_feather_iir = total_feather;
1648
1649 return total_feather_iir;
1650 }
1651
MDrv_SC_TotalFeather_Sum(void)1652 MS_U32 MDrv_SC_TotalFeather_Sum(void)
1653 {
1654 MS_U32 mv0_feather, nonMv0_feather;
1655 MS_U32 total_feather;
1656 static MS_U32 total_feather_iir = 0;
1657
1658 mv0_feather = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_77_L);
1659 nonMv0_feather = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7B_L);
1660
1661 total_feather = mv0_feather + nonMv0_feather;
1662
1663 total_feather = ((total_feather_iir*3 )+ total_feather ) >> 2;
1664 total_feather_iir = total_feather;
1665
1666 return total_feather_iir;
1667 }
1668
1669 #define TOTAL_MV_TIME 10
MDrv_SC_A5_TotalMvComfirm(void)1670 MS_U32 MDrv_SC_A5_TotalMvComfirm(void)
1671 {
1672 MS_U32 mv0, nonMv0, notFound;
1673 MS_U32 total_mv, mvComfirm;
1674 static MS_U32 mvComfirm_iir = 0;
1675
1676 mv0 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_78_L);
1677 nonMv0 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_79_L);
1678 notFound = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx,REG_SC_BK2A_7A_L);
1679
1680 total_mv = mv0 + nonMv0;
1681
1682 if( total_mv > notFound*TOTAL_MV_TIME )
1683 mvComfirm = total_mv - notFound*TOTAL_MV_TIME;
1684 else
1685 mvComfirm = 0;
1686
1687 if( mvComfirm > 255 )
1688 mvComfirm = 255;
1689
1690 mvComfirm = ((mvComfirm_iir*3 )+ mvComfirm ) >> 2;
1691 mvComfirm_iir = mvComfirm;
1692
1693 return mvComfirm_iir;
1694 }
1695
1696 /******************************************************************************/
1697 ///Extend MCNR Driver
1698 /******************************************************************************/
MDrv_SC_Extend_UCNR_driver(void)1699 void MDrv_SC_Extend_UCNR_driver(void)
1700 {
1701 MS_U32 u32_is_mv0, u32_non_mv0, u32_mvNotFound, u32_mvc, u32_mvu, u32_mvd;
1702 MS_BOOL me_not_confirm , me_vertical, still_pattern;
1703 static MS_U8 u8notConfirmCnt;
1704 //static MS_U32 last_u32_mvNotFound;
1705
1706 u32_is_mv0 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_78_L);
1707 u32_non_mv0 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_79_L);
1708 u32_mvNotFound = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7A_L);
1709 u32_mvc = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7C_L);
1710 u32_mvu = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7D_L);
1711 u32_mvd = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7E_L);
1712
1713 /////////////////////////////////////////////////////////////////
1714 // NR Patch 1
1715 /////////////////////////////////////////////////////////////////
1716 me_not_confirm = (u32_is_mv0 < 0x0200) && (u32_non_mv0 < 0x0200) ;
1717 me_vertical = ((u32_mvu > u32_mvc) && (u32_mvu > u32_mvd) && (u32_mvu > 0x200)) ||
1718 ((u32_mvd > u32_mvc) && (u32_mvd > u32_mvu) && (u32_mvd > 0x200));
1719
1720 still_pattern = (u32_is_mv0 < 0x0020) && (u32_non_mv0 < 0x0020) && (u32_mvNotFound < 0x0020);
1721
1722 if(!still_pattern)
1723 {
1724 if(false == me_not_confirm)
1725 {
1726 if(u8notConfirmCnt > 0)
1727 {
1728 u8notConfirmCnt--;
1729 }
1730 }
1731 else
1732 {
1733 if(u8notConfirmCnt <= 0x40)
1734 {
1735 u8notConfirmCnt++;
1736 }
1737 }
1738 }
1739
1740 if(1)
1741 {
1742 if ( (u8notConfirmCnt > 0x30)|| me_vertical ) // low nr strength
1743 {
1744 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0xAAAA, 0xFFFF);
1745 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0xAAAA, 0xFFFF);
1746 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0xAAAA, 0xFFFF);
1747 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0xAAAA, 0xFFFF);
1748 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0xAAAA, 0xFFFF);
1749 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0xAA98, 0xFFFF);
1750 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x7654, 0xFFFF);
1751 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x3210, 0xFFFF);
1752 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0064, 0x00FF); // moving picture, increase random motion
1753 }
1754 else //if(u8notConfirmCnt < 0x10)
1755 {
1756 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0xAAAA, 0xFFFF);
1757 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0xAAAA, 0xFFFF);
1758 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0xAAAA, 0xFFFF);
1759 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0xAAAA, 0xFFFF);
1760 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0xAAAA, 0xFFFF);
1761 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0xAA98, 0xFFFF);
1762 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x7654, 0xFFFF);
1763 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x3210, 0xFFFF);
1764 }
1765
1766 if ( (u32_is_mv0 > 0x200) && ((u32_is_mv0/2) > u32_non_mv0) && ((u32_is_mv0/2) > u32_mvNotFound) )
1767 {
1768 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0044, 0x00FF); // still picture, reduce random motion
1769 }
1770 else if(u32_non_mv0 > u32_is_mv0)
1771 {
1772 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0044, 0x00FF); // moving picture, increase random motion
1773 }
1774 else
1775 {
1776 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0044, 0x00FF); // default random motion
1777 }
1778 }
1779
1780 //last_u32_mvNotFound = u32_mvNotFound;
1781 }
1782
MDrv_SC_A5_UC_PanScan(void)1783 MS_U8 MDrv_SC_A5_UC_PanScan(void)
1784 {
1785 MS_U32 nonMV0_Found, MV_NotFound;
1786 static MS_U32 Prev_nonMV0_Found = 0;
1787 static MS_U32 Prev_MV_NotFound = 0;
1788 static MS_U8 panCnt = 0;
1789
1790 nonMV0_Found = MApi_XC_R2BYTE(REG_SC_BK2A_79_L);
1791 MV_NotFound = MApi_XC_R2BYTE(REG_SC_BK2A_7A_L);
1792
1793 nonMV0_Found = (Prev_nonMV0_Found*3 + nonMV0_Found ) >> 2;
1794 Prev_nonMV0_Found = nonMV0_Found;
1795
1796 MV_NotFound = (Prev_MV_NotFound*3 + MV_NotFound ) >> 2;
1797 Prev_MV_NotFound = MV_NotFound;
1798
1799 if( nonMV0_Found > MV_NotFound*30 )
1800 {
1801 if(panCnt != 10)
1802 panCnt++;
1803 }
1804 else if(panCnt != 0)
1805 {
1806 panCnt--;
1807 }
1808
1809 return panCnt;
1810 }
1811
1812 #define LG107_FEATHER_GAIN_MAX 2
1813 #define LG107_FEATHER_GAIN_MIN 0
1814 #define LG107_CPLX_OFFSET_MAX 6
1815 #define LG107_CPLX_OFFSET_MIN 0
1816 #define LG107_CPLX_GAIN_MAX 15
1817 #define LG107_CPLX_GAIN_MIN 4
MDrv_SC_A5_UC_PanScanSetting(const MS_U8 PanScan)1818 void MDrv_SC_A5_UC_PanScanSetting( const MS_U8 PanScan )
1819 {
1820 static MS_U16 reg_mcdi_feather_gain = LG107_FEATHER_GAIN_MAX ;
1821 static MS_U16 reg_mcdi_cplx_offset = LG107_CPLX_OFFSET_MAX ;
1822
1823 if( PanScan > 8 )
1824 {
1825 reg_mcdi_feather_gain = LG107_FEATHER_GAIN_MIN;
1826 reg_mcdi_cplx_offset = LG107_FEATHER_GAIN_MIN;
1827 }
1828 else
1829 {
1830 reg_mcdi_feather_gain = LG107_FEATHER_GAIN_MAX;
1831 reg_mcdi_cplx_offset = LG107_FEATHER_GAIN_MAX;
1832 }
1833
1834 MApi_XC_W2BYTEMSK(REG_SC_BK2A_2D_L, (MS_U16)reg_mcdi_feather_gain<<12, 0xF000); // 2 to 0
1835 MApi_XC_W2BYTEMSK(REG_SC_BK2A_2E_L, (MS_U16)reg_mcdi_cplx_offset<<4, 0x00F0);// 6 to 0
1836 }
1837
1838 /******************************************************************************/
1839 ///MCNR Driver
1840 /******************************************************************************/
1841
MDrv_SC_mcnr_driver(MS_U32 nonHistoryMotionPixel)1842 void MDrv_SC_mcnr_driver( MS_U32 nonHistoryMotionPixel )
1843 {
1844 MS_U32 u32_is_mv0, u32_non_mv0, u32_mvNotFound, u32_mvFeathering, u32_mvc, u32_mvu, u32_mvd, u32_cplxPixel, temp1, temp2;
1845 MS_BOOL me_not_confirm , me_vertical, isHDSource, is24to60Hz/*, scene_change*/;
1846 static MS_U8 vMOvingReduceNR_HouseHDPatch_counter;
1847 static MS_U8 u8notConfirmCnt;
1848 //static MS_U32 last_u32_mvNotFound;
1849 static MS_U8 nrWeightPatchForVSweep = 0;
1850
1851 XC_EX_ApiStatus stXCStatus;
1852
1853 if(MApi_XC_EX_GetStatus(&_XC_DeviceIdx, &stXCStatus, E_XC_EX_MAIN_WINDOW) == FALSE)
1854 {
1855 //printf("MApi_XC_GetStatus failed because of InitData wrong, please update header file and compile again\n");
1856 }
1857
1858 is24to60Hz = (!stXCStatus.bInterlace) && (stXCStatus.u16InputVFreq < 300);
1859
1860 u32_is_mv0 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_78_L);
1861 u32_non_mv0 = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_79_L);
1862 u32_mvNotFound = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7A_L);
1863 u32_mvFeathering = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7B_L);
1864 u32_mvc = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7C_L);
1865 u32_mvu = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7D_L);
1866 u32_mvd = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7E_L);
1867 u32_cplxPixel = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK2A_7F_L);
1868 isHDSource = ( MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK12_0F_L, 0xFFFF) > 0x700 );
1869
1870 if ( (u32_cplxPixel > 0x1000) && (u32_is_mv0 > 0x1000) && (nonHistoryMotionPixel == 0) ) // patch for VSweep converge too slow
1871 {
1872 if ( nrWeightPatchForVSweep > 4 )
1873 nrWeightPatchForVSweep = nrWeightPatchForVSweep - 4;
1874 else
1875 nrWeightPatchForVSweep = 0;
1876 }
1877 else
1878 {
1879 if ( nrWeightPatchForVSweep < 0xD )
1880 nrWeightPatchForVSweep += 1;
1881 }
1882
1883 /////////////////////////////////////////////////////////////////
1884 // NR Patch 1
1885 /////////////////////////////////////////////////////////////////
1886 me_not_confirm = (u32_is_mv0 < 0x0200) && (u32_non_mv0 < 0x0200);
1887 me_vertical = ((u32_mvu > u32_mvc) && (u32_mvu > u32_mvd) && (u32_mvu > 0x200)) ||
1888 ((u32_mvd > u32_mvc) && (u32_mvd > u32_mvu) && (u32_mvd > 0x200));
1889
1890 if(false == me_not_confirm)
1891 {
1892 if(u8notConfirmCnt > 0)
1893 {
1894 u8notConfirmCnt--;
1895 }
1896 }
1897 else
1898 {
1899 if(u8notConfirmCnt <= 0x40)
1900 {
1901 u8notConfirmCnt++;
1902 }
1903 }
1904
1905 if(1)
1906 {
1907 MS_BOOL bBool = FALSE;
1908
1909 if (MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK20_10_L , 0x03) & 0x03)
1910 {
1911 bBool = (u8notConfirmCnt > 0x30);//main&sub
1912 }
1913 else if (MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK20_10_L , BIT(1)) & BIT(1))
1914 {
1915 bBool = (u8notConfirmCnt > 0x30);//sub only
1916 }
1917 else if (MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK20_10_L , BIT(0)) & BIT(0))
1918 {
1919 bBool = ( (u8notConfirmCnt > 0x30) || me_vertical ); // low nr strength
1920 }
1921
1922 if (bBool) // low nr strength
1923 {
1924 if ( !isHDSource )
1925 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0064, 0x00FF); // moving picture, increase random motion
1926 else
1927 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x00C2, 0x00FF); // Default 64 -> C2, moving picture, increase random motion
1928 if ( nrWeightPatchForVSweep >= 7 )
1929 {
1930 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0x7777, 0xFFFF);
1931 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0x7777, 0xFFFF);
1932 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0x7777, 0xFFFF);
1933 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0x7777, 0xFFFF);
1934 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0x6655, 0xFFFF);
1935 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0x4433, 0xFFFF);
1936 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x3322, 0xFFFF);
1937 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x1100, 0xFFFF);
1938 }
1939 else //if ( nrWeightPatchForVSweep >= 4 )
1940 {
1941 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0x4444, 0xFFFF);
1942 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0x4444, 0xFFFF);
1943 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0x4444, 0xFFFF);
1944 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0x4444, 0xFFFF);
1945 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0x4444, 0xFFFF);
1946 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0x4433, 0xFFFF);
1947 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x3322, 0xFFFF);
1948 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x1100, 0xFFFF);
1949 }
1950 }
1951 else if(u8notConfirmCnt < 0x10)
1952 {
1953 if ( (nrWeightPatchForVSweep >= 0xD) && (!is24to60Hz) )
1954 {
1955 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0xDDDD, 0xFFFF);
1956 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0xDDDD, 0xFFFF);
1957 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0xDDDD, 0xFFFF);
1958 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0xDDDD, 0xFFFF);
1959 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0xDDDD, 0xFFFF);
1960 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0xBA98, 0xFFFF);
1961 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x7654, 0xFFFF);
1962 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x3210, 0xFFFF);
1963 }
1964 else if ( (nrWeightPatchForVSweep >= 0xA) && (!is24to60Hz) )
1965 {
1966 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0xAAAA, 0xFFFF);
1967 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0xAAAA, 0xFFFF);
1968 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0xAAAA, 0xFFFF);
1969 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0xAAAA, 0xFFFF);
1970 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0xAAAA, 0xFFFF);
1971 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0xAA98, 0xFFFF);
1972 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x7654, 0xFFFF);
1973 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x3210, 0xFFFF);
1974 }
1975 else if ( nrWeightPatchForVSweep >= 7 )
1976 {
1977 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0x7777, 0xFFFF);
1978 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0x7777, 0xFFFF);
1979 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0x7777, 0xFFFF);
1980 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0x7777, 0xFFFF);
1981 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0x6655, 0xFFFF);
1982 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0x4433, 0xFFFF);
1983 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x3322, 0xFFFF);
1984 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x1100, 0xFFFF);
1985 }
1986 else //if ( nrWeightPatchForVSweep >= 4 )
1987 {
1988 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_08_L, (MS_U16)0x4444, 0xFFFF);
1989 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_09_L, (MS_U16)0x4444, 0xFFFF);
1990 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0A_L, (MS_U16)0x4444, 0xFFFF);
1991 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0B_L, (MS_U16)0x4444, 0xFFFF);
1992 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0C_L, (MS_U16)0x4444, 0xFFFF);
1993 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0D_L, (MS_U16)0x4433, 0xFFFF);
1994 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0E_L, (MS_U16)0x3322, 0xFFFF);
1995 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_0F_L, (MS_U16)0x1100, 0xFFFF);
1996 }
1997 }
1998
1999 if ( isHDSource && (u32_mvc < 0x10) && (( u32_mvu + u32_mvd ) > 0x40) )
2000 vMOvingReduceNR_HouseHDPatch_counter = 16;
2001 else if ( (u32_is_mv0 <= 0x10) && (u32_non_mv0 > 0x2000) && (u32_mvNotFound > 0x80) && (u32_mvFeathering > 0x8) && (u32_cplxPixel < 0x200) ) // patch shibasoku a little out-of-search range
2002 vMOvingReduceNR_HouseHDPatch_counter = 16;
2003 else if ( vMOvingReduceNR_HouseHDPatch_counter > 0 )
2004 vMOvingReduceNR_HouseHDPatch_counter --;
2005
2006 if ( is24to60Hz )
2007 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x00F0, 0x00FF);
2008 else if ( (u32_is_mv0 > 0x200) && ((u32_is_mv0/2) > u32_non_mv0) && ((u32_is_mv0/2) > u32_mvNotFound) && (vMOvingReduceNR_HouseHDPatch_counter == 0) )
2009 {
2010 if ( stXCStatus.bInterlace )
2011 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x006c, 0x00FF); // still picture, reduce random motion
2012 else
2013 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0064, 0x00FF); // still picture, reduce random motion
2014 }
2015 else if ( (u32_non_mv0 > u32_is_mv0) || (vMOvingReduceNR_HouseHDPatch_counter > 0 )) // moving picture, increase random motion
2016 {
2017 if ( !isHDSource )
2018 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0060, 0x00FF);
2019 else
2020 {
2021 if ( stXCStatus.bInterlace )
2022 {
2023 temp1 = ( 0xE * vMOvingReduceNR_HouseHDPatch_counter + 0x6 * ( 16 - vMOvingReduceNR_HouseHDPatch_counter ) ) >> 4;
2024 temp2 = ( 0x0 * vMOvingReduceNR_HouseHDPatch_counter + 0xC * ( 16 - vMOvingReduceNR_HouseHDPatch_counter ) ) >> 4;
2025 }
2026 else
2027 {
2028 temp1 = ( 0xE * vMOvingReduceNR_HouseHDPatch_counter + 0x6 * ( 16 - vMOvingReduceNR_HouseHDPatch_counter ) ) >> 4;
2029 temp2 = ( 0x0 * vMOvingReduceNR_HouseHDPatch_counter + 0x4 * ( 16 - vMOvingReduceNR_HouseHDPatch_counter ) ) >> 4;
2030 }
2031 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)((temp1<<4)|temp2), 0x00FF); // 60 -> E0. moving picture, increase random motion
2032 }
2033 }
2034 else // default
2035 {
2036 if ( !isHDSource )
2037 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x0064, 0x00FF); // default random motion
2038 else
2039 {
2040 if ( stXCStatus.bInterlace )
2041 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x00C2, 0x00FF); // Default 64 -> C2, moving picture, increase random motion
2042 else
2043 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK2A_1B_L, (MS_U16)0x00C2, 0x00FF); // Default 64 -> C2, moving picture, increase random motion
2044 }
2045 }
2046 }
2047 //last_u32_mvNotFound = u32_mvNotFound;
2048 }
2049
2050 /******************************************************************************/
2051 ///DeFeathering
2052 ///@param u32MotionValue \ IN: Motion value
2053 /******************************************************************************/
MDrv_SC_de_feathering(MS_U32 u32MotionValue)2054 void MDrv_SC_de_feathering(MS_U32 u32MotionValue)
2055 {
2056 static MS_U32 u32DeFeatherCntLv1 = 0;
2057 static MS_U32 u32DeFeatherCntLv2 = 0;
2058 static MS_U32 u32DeFeatherCntLv3 = 0;
2059 MS_U8 u8SST_Static_Core_TH;
2060 MS_U32 reg_defethering_lv1_cnt;
2061 MS_U32 reg_defethering_lv2_cnt;
2062 MS_U32 reg_mdp_cnt;
2063
2064 reg_defethering_lv1_cnt = 0x0A;
2065 reg_defethering_lv2_cnt = 0x08;
2066 reg_mdp_cnt = 0x01;
2067
2068 // motion level count
2069 if(u32MotionValue >= DEFETHERING_LV1_TH)
2070 {
2071 if(u32DeFeatherCntLv1 < reg_defethering_lv1_cnt)
2072 u32DeFeatherCntLv1++;
2073 }
2074 else
2075 {
2076 if(u32DeFeatherCntLv1 >= reg_mdp_cnt)
2077 u32DeFeatherCntLv1 = u32DeFeatherCntLv1 - reg_mdp_cnt;
2078 }
2079
2080 if(u32MotionValue >= DEFETHERING_LV2_TH)
2081 {
2082 if(u32DeFeatherCntLv2 < reg_defethering_lv2_cnt)
2083 u32DeFeatherCntLv2++;
2084 }
2085 else
2086 {
2087 if(u32DeFeatherCntLv2 >= reg_mdp_cnt)
2088 u32DeFeatherCntLv2 = u32DeFeatherCntLv2 - reg_mdp_cnt;
2089 }
2090
2091 if(u32MotionValue >= DEFETHERING_LV3_TH)
2092 {
2093 if(u32DeFeatherCntLv3 < DEFETHERING_LV3_CNT)
2094 u32DeFeatherCntLv3++;
2095 }
2096 else
2097 {
2098 if(u32DeFeatherCntLv3 >= reg_mdp_cnt)
2099 u32DeFeatherCntLv3 = u32DeFeatherCntLv3 - reg_mdp_cnt;
2100 }
2101
2102 //DeFeathering begin
2103 if(u32DeFeatherCntLv1 >= reg_defethering_lv1_cnt)
2104 {
2105 u8SST_Static_Core_TH = SST_STATIC_CORE_TH_LV1_VALUE;
2106 }
2107 else if(u32DeFeatherCntLv2 >= reg_defethering_lv2_cnt)
2108 {
2109 u8SST_Static_Core_TH = SST_STATIC_CORE_TH_LV2_VALUE;
2110 }
2111 else if(u32DeFeatherCntLv3 >= DEFETHERING_LV3_CNT)
2112 {
2113 u8SST_Static_Core_TH = SST_STATIC_CORE_TH_LV3_VALUE;
2114 }
2115 else
2116 {
2117 u8SST_Static_Core_TH = SST_STATIC_CORE_TH_LV4_VALUE;
2118 }
2119
2120 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_1A_L, (MS_U16)u8SST_Static_Core_TH, 0xFF);
2121 }
2122
2123
MDrv_SC_motion_level(MS_U32 u32MotionValue)2124 int MDrv_SC_motion_level(MS_U32 u32MotionValue)
2125 {
2126 static MS_U32 u32DeFeatherCntLv1 = 0;
2127 static MS_U32 u32DeFeatherCntLv2 = 0;
2128 static MS_U32 u32DeFeatherCntLv3 = 0;
2129 MS_U8 u8MotLvl;
2130 MS_U32 reg_defethering_lv1_cnt;
2131 MS_U32 reg_defethering_lv2_cnt;
2132 MS_U32 reg_mdp_cnt;
2133
2134 reg_defethering_lv1_cnt = 0x0A;
2135 reg_defethering_lv2_cnt = 0x08;
2136 reg_mdp_cnt = 0x01;
2137
2138 // motion level count
2139 if(u32MotionValue >= DEFETHERING_LV1_TH)
2140 {
2141 if(u32DeFeatherCntLv1 < reg_defethering_lv1_cnt)
2142 u32DeFeatherCntLv1++;
2143 }
2144 else
2145 {
2146 if(u32DeFeatherCntLv1 >= reg_mdp_cnt)
2147 u32DeFeatherCntLv1 = u32DeFeatherCntLv1 - reg_mdp_cnt;
2148 }
2149
2150 if(u32MotionValue >= DEFETHERING_LV2_TH)
2151 {
2152 if(u32DeFeatherCntLv2 < reg_defethering_lv2_cnt)
2153 u32DeFeatherCntLv2++;
2154 }
2155 else
2156 {
2157 if(u32DeFeatherCntLv2 >= reg_mdp_cnt)
2158 u32DeFeatherCntLv2 = u32DeFeatherCntLv2 - reg_mdp_cnt;
2159 }
2160
2161 if(u32MotionValue >= DEFETHERING_LV3_TH)
2162 {
2163 if(u32DeFeatherCntLv3 < DEFETHERING_LV3_CNT)
2164 u32DeFeatherCntLv3++;
2165 }
2166 else
2167 {
2168 if(u32DeFeatherCntLv3 >= reg_mdp_cnt)
2169 u32DeFeatherCntLv3 = u32DeFeatherCntLv3 - reg_mdp_cnt;
2170 }
2171
2172 //level begin
2173 if(u32DeFeatherCntLv1 >= reg_defethering_lv1_cnt)
2174 {
2175 u8MotLvl = 3;
2176 }
2177 else if(u32DeFeatherCntLv2 >= reg_defethering_lv2_cnt)
2178 {
2179 u8MotLvl = 2;
2180 }
2181 else if(u32DeFeatherCntLv3 >= DEFETHERING_LV3_CNT)
2182 {
2183 u8MotLvl = 1;
2184 }
2185 else
2186 {
2187 u8MotLvl = 0;
2188 }
2189
2190 return u8MotLvl;
2191 }
2192
2193
2194 /******************************************************************************/
2195 ///DeFlickering
2196 ///@param u32MotionValue \ IN: Motion value
2197 /******************************************************************************/
MDrv_SC_de_flickering(MS_U32 u32MotionValue)2198 void MDrv_SC_de_flickering(MS_U32 u32MotionValue)
2199 {
2200 static MS_S32 s32DeFlickerCnt = 0;
2201 MS_U32 reg_m_feat_smooth_hle_th, reg_m_feat_smooth_shrink;
2202
2203 reg_m_feat_smooth_hle_th = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_1E_L, 0xF000); // Feat Smooth HLE TH
2204 reg_m_feat_smooth_shrink = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_1E_L, 0x8F);
2205
2206 if(u32MotionValue >= DEFLICKERING_TH)
2207 {
2208 if(s32DeFlickerCnt < 65535)
2209 s32DeFlickerCnt++;
2210 }
2211 else
2212 {
2213 s32DeFlickerCnt = 0;
2214 }
2215
2216 if(s32DeFlickerCnt >= DEFLICKERING_CNT)
2217 {
2218 reg_m_feat_smooth_hle_th += 0x0300;
2219 reg_m_feat_smooth_shrink += 0x10;
2220 }
2221 else
2222 {
2223 reg_m_feat_smooth_hle_th += 0x0700;
2224 reg_m_feat_smooth_shrink += 0x30;
2225 }
2226
2227 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_1E_L, reg_m_feat_smooth_shrink, 0xFF);
2228 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_1E_L, reg_m_feat_smooth_hle_th, 0xFF00);
2229 }
2230
2231 /******************************************************************************/
2232 ///DeBouncing
2233 ///@param u32MotionValue \ IN: Motion value
2234 /******************************************************************************/
2235 #define DEBOUNCING_GAIN 1 //0
MDrv_SC_de_bouncing(MS_U32 u32MotionValue)2236 void MDrv_SC_de_bouncing(MS_U32 u32MotionValue)
2237 {
2238 static MS_S32 s32DeBouncingCnt = 0;
2239 MS_U32 reg_his_wt_f2;
2240 MS_U32 reg_debouncing_th;
2241 int reg_debouncing_cnt;
2242
2243 reg_debouncing_th = 0x0A;
2244 reg_debouncing_cnt = 0x03;
2245
2246 reg_his_wt_f2 = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_0A_L, 0xF8); // history ratio weighting
2247
2248 MS_BOOL film;
2249 film = ( (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0008) == 0x0008) || // film22
2250 ( (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0010) == 0x0010) || // film32
2251 ( (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, 0x0040) == 0x0040) ; // film any
2252
2253 if(u32MotionValue <= reg_debouncing_th * DEBOUNCING_GAIN)
2254 {
2255 s32DeBouncingCnt = 0;
2256 }
2257 else
2258 {
2259 if(s32DeBouncingCnt < 65535)
2260 s32DeBouncingCnt++;
2261 }
2262
2263 if(film || (s32DeBouncingCnt >= reg_debouncing_cnt))
2264 {
2265 reg_his_wt_f2 += 0x06; // history = 6 moving
2266 }
2267 else
2268 {
2269 reg_his_wt_f2 += 0x03; // history = 3 still
2270 }
2271 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_0A_L, reg_his_wt_f2, 0xFF);
2272 }
2273
2274 /******************************************************************************/
2275 ///DePreSNR
2276 ///@param u32MotionValue \ IN: Motion value
2277 /******************************************************************************/
MDrv_SC_de_pre_snr(MS_U32 u32MotionValue)2278 void MDrv_SC_de_pre_snr(MS_U32 u32MotionValue)
2279 {
2280 static MS_S32 s32DePreSNRCnt = 0;
2281 MS_U8 reg_preSnr_en = 0;
2282 MS_U32 reg_preSnr_th;
2283 int reg_preSnr_cnt;
2284
2285 reg_preSnr_th = 0x06;
2286 reg_preSnr_cnt = 0x01;
2287
2288 if(u32MotionValue <= reg_preSnr_th * DEBOUNCING_GAIN)
2289 {
2290 s32DePreSNRCnt = 0;
2291 }
2292 else
2293 {
2294 if(s32DePreSNRCnt < 65535)
2295 s32DePreSNRCnt++;
2296 }
2297
2298 if(s32DePreSNRCnt >= reg_preSnr_cnt)
2299 {
2300 reg_preSnr_en = 0x01; // enable pre-snr
2301 }
2302 else
2303 {
2304 reg_preSnr_en = 0x00; // disable pre-snr
2305 }
2306 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK06_22_L, (MS_U16)reg_preSnr_en, BIT(0));
2307 }
2308
2309 /******************************************************************************/
2310 ///Dynamic SNR
2311 ///@param u32MotionValue \ IN: Motion value
2312 /******************************************************************************/
MDrv_SC_dynamic_snr(MS_U32 u32MotionValue)2313 void MDrv_SC_dynamic_snr(MS_U32 u32MotionValue)
2314 {
2315 static MS_S32 s32DynamicSnrCnt = 0;
2316 #if (DBG_DYNAMIC_SNR)
2317 static MS_S32 s32CurrentLevel = -1;
2318 static MS_S32 s32LastLevel = -1;
2319 #endif
2320 MS_U8 u8SNR_Bypass;
2321 MS_U32 reg_snr_cnt;
2322
2323 reg_snr_cnt = (MS_U32)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0B_77_L, 0xFF);
2324
2325 if(u32MotionValue <= DYNAMIC_SNR_TH)
2326 {
2327 s32DynamicSnrCnt = 0;
2328 }
2329 else
2330 {
2331 if(s32DynamicSnrCnt < 65535)
2332 s32DynamicSnrCnt++;
2333 }
2334
2335 if(s32DynamicSnrCnt >= (MS_S32)reg_snr_cnt)
2336 {
2337 u8SNR_Bypass = 0; // SNR enable
2338
2339 #if (DBG_DYNAMIC_SNR)
2340 s32CurrentLevel = 1;
2341 #endif
2342 }
2343 else
2344 {
2345 u8SNR_Bypass = 1; // SNR disable
2346
2347 #if (DBG_DYNAMIC_SNR)
2348 s32CurrentLevel = 2;
2349 #endif
2350 }
2351 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_70_L, (MS_U16)u8SNR_Bypass, 0xFF);
2352
2353 #if (DBG_DYNAMIC_SNR)
2354 if(s32CurrentLevel != s32LastLevel)
2355 {
2356 if(s32CurrentLevel == 1)
2357 printf("SNR = Enable[%x]\n", s32CurrentLevel);
2358 else
2359 printf("SNR = Disable[%x]\n", s32CurrentLevel);
2360
2361 s32LastLevel = s32CurrentLevel;
2362 }
2363 #endif
2364 }
2365
2366 /******************************************************************************/
2367 ///FantasticDNR
2368 ///@param u32MotionValue \ IN: Motion value
2369 /******************************************************************************/
MDrv_SC_fantastic_dnr(void)2370 void MDrv_SC_fantastic_dnr(void)
2371 {
2372 static MS_S32 s32Cnt = 0;
2373 MS_U8 u8DNR_TblY_0L, u8DNR_TblY_0H, u8DNR_TblY_1L, u8DNR_TblY_1H;
2374 MS_U8 u8DNR_TblY_2L, u8DNR_TblY_2H, u8DNR_TblY_3L, u8DNR_TblY_3H;
2375
2376 s32Cnt++;
2377
2378 if(s32Cnt % 2 == 0)
2379 {
2380 u8DNR_TblY_0L = 0xDE;
2381 u8DNR_TblY_0H = 0xDD;
2382 u8DNR_TblY_1L = 0x79;
2383 u8DNR_TblY_1H = 0x67;
2384 u8DNR_TblY_2L = 0x56;
2385 u8DNR_TblY_2H = 0x45;
2386 u8DNR_TblY_3L = 0x11;
2387 u8DNR_TblY_3H = 0x00;
2388 }
2389 else
2390 {
2391 u8DNR_TblY_0L = 0xCD;
2392 u8DNR_TblY_0H = 0x39;
2393 u8DNR_TblY_1L = 0x34;
2394 u8DNR_TblY_1H = 0x11;
2395 u8DNR_TblY_2L = 0x00;
2396 u8DNR_TblY_2H = 0x00;
2397 u8DNR_TblY_3L = 0x00;
2398 u8DNR_TblY_3H = 0x00;
2399 }
2400 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_40_L, ((MS_U16)u8DNR_TblY_0L | (((MS_U16) u8DNR_TblY_0H) << 8)));
2401 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_41_L, ((MS_U16)u8DNR_TblY_1L | (((MS_U16) u8DNR_TblY_1H) << 8)));
2402 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_42_L, ((MS_U16)u8DNR_TblY_2L | (((MS_U16) u8DNR_TblY_2H) << 8)));
2403 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_43_L, ((MS_U16)u8DNR_TblY_3L | (((MS_U16) u8DNR_TblY_3H) << 8)));
2404 }
2405
2406 /******************************************************************************/
2407 ///Dynamic DNR
2408 ///@param u32MotionValue \ IN: Motion value
2409 /******************************************************************************/
2410 #define DYNAMIC_DNR_TH 1000
MDrv_SC_dynamic_dnr(MS_U32 u32MotionValue)2411 void MDrv_SC_dynamic_dnr(MS_U32 u32MotionValue)
2412 {
2413 static MS_S32 s32ZeroCnt = 0;
2414 static MS_S32 s32StillCnt = 0;
2415 MS_U8 u8DNR_TblY_0L, u8DNR_TblY_0H, u8DNR_TblY_1L, u8DNR_TblY_1H;
2416 MS_U8 u8DNR_TblY_2L, u8DNR_TblY_2H, u8DNR_TblY_3L, u8DNR_TblY_3H;
2417
2418 if(u32MotionValue <= DYNAMIC_DNR_TH)
2419 {
2420 if(s32StillCnt < 65535)
2421 s32StillCnt++;
2422 }
2423 else
2424 {
2425 s32StillCnt = 0;
2426 }
2427
2428 if(u32MotionValue == 0)
2429 {
2430 if(s32ZeroCnt < 65535)
2431 s32ZeroCnt++;
2432 }
2433 else
2434 {
2435 s32ZeroCnt = 0;
2436 }
2437
2438 if(s32ZeroCnt >= 18)
2439 {
2440 u8DNR_TblY_0L = 0xDE;
2441 u8DNR_TblY_0H = 0xDD;
2442 u8DNR_TblY_1L = 0x79;
2443 u8DNR_TblY_1H = 0x67;
2444 u8DNR_TblY_2L = 0x56;
2445 u8DNR_TblY_2H = 0x45;
2446 u8DNR_TblY_3L = 0x11;
2447 u8DNR_TblY_3H = 0x00;
2448 }
2449 else if(s32StillCnt >= 8) //still
2450 {
2451 u8DNR_TblY_0L = 0xCE;
2452 u8DNR_TblY_0H = 0xAC;
2453 u8DNR_TblY_1L = 0x78;
2454 u8DNR_TblY_1H = 0x34;
2455 u8DNR_TblY_2L = 0x12;
2456 u8DNR_TblY_2H = 0x00;
2457 u8DNR_TblY_3L = 0x00;
2458 u8DNR_TblY_3H = 0x00;
2459 }
2460 else //moving
2461 {
2462 u8DNR_TblY_0L = 0xCD;
2463 u8DNR_TblY_0H = 0x39;
2464 u8DNR_TblY_1L = 0x34;
2465 u8DNR_TblY_1H = 0x11;
2466 u8DNR_TblY_2L = 0x00;
2467 u8DNR_TblY_2H = 0x00;
2468 u8DNR_TblY_3L = 0x00;
2469 u8DNR_TblY_3H = 0x00;
2470 }
2471 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_40_L, ((MS_U16)u8DNR_TblY_0L | (((MS_U16) u8DNR_TblY_0H) << 8)));
2472 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_41_L, ((MS_U16)u8DNR_TblY_1L | (((MS_U16) u8DNR_TblY_1H) << 8)));
2473 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_42_L, ((MS_U16)u8DNR_TblY_2L | (((MS_U16) u8DNR_TblY_2H) << 8)));
2474 MApi_XC_EX_W2BYTE(&_XC_DeviceIdx, REG_SC_BK06_43_L, ((MS_U16)u8DNR_TblY_3L | (((MS_U16) u8DNR_TblY_3H) << 8)));
2475 }
2476
2477 /******************************************************************************/
2478 ///DHD Driver
2479 /******************************************************************************/
2480
MDrv_SC_Janus_DHD_driver(void)2481 void MDrv_SC_Janus_DHD_driver(void)
2482 {
2483 // dhd shining line patch
2484 static MS_U32 u32videoCnt = 0;
2485
2486 if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, BIT(3))) // film22
2487 u32videoCnt = 0;
2488 else if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, BIT(4))) // film32
2489 u32videoCnt = 0;
2490 else if(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0A_21_L, BIT(6)))
2491 u32videoCnt = 0;
2492 else if(u32videoCnt >= 10000)
2493 u32videoCnt = 10000;
2494 else
2495 u32videoCnt++;
2496
2497 if(u32videoCnt >= 60) // 2 sec
2498 {
2499 // turn on dhd, 6R
2500 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK12_05_L, 0x8000, 0x8000); // 6R
2501 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK05_20_L, 0x0001, 0x0001); // dhd on
2502 }
2503 else
2504 {
2505 // turn off dhd, 4R
2506 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK12_05_L, 0x0000, 0x8000); // 4R
2507 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK05_20_L, 0x0000, 0x0001); // dhd off
2508 }
2509 }
2510
2511 #define HD_ACT_TH 10
2512 #define HDSDD_SPEED 1
2513 #define HDSDD_DIV 0
2514 #define HD_SPEED 2
2515 #define SD_SPEED 8
2516
MDrv_SC_SDHD_DETECT_driver(void)2517 void MDrv_SC_SDHD_DETECT_driver(void)
2518 {
2519 MS_U8 u8Value;
2520 MS_U16 u16MinPixel, u16MaxPixel, MaxMinPixel;
2521 MS_U32 HDcnt_Act;
2522 MS_U32 SDcnt_Act;
2523 static MS_U16 HD_ConfirmCnt = 0xFF; // 0x7FFF == 0
2524 static MS_U8 u8PrevLuma = 0;
2525 static MS_U16 u16PrevMinPixel = 0;
2526 static MS_U16 u16PrevMaxPixel = 0;
2527 MS_U32 HD_ConfirmCnt_Reg;
2528 MS_U16 HDSDD_Det_threshold, HDSDD_Det_offset;
2529
2530 HDSDD_Det_offset = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7F_L, 0xFFFF);
2531 #ifndef KANO_TEMP
2532 u8Value = (MS_U32)((MS_U32)u8PrevLuma * 3 + MApi_XC_DLC_GetAverageValue()) >> 2;
2533 #endif
2534 u8PrevLuma = u8Value;
2535
2536 u16MaxPixel = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK1A_0B_L, 0x00FF);
2537 u16MaxPixel = (u16PrevMaxPixel * 3 + u16MaxPixel) >> 2;
2538 u16PrevMaxPixel = u16MaxPixel;
2539
2540 u16MinPixel = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK1A_0B_L, 0xFF00) >> 8;
2541 u16MinPixel = (u16PrevMinPixel * 3 + u16MinPixel) >> 2;
2542 u16PrevMinPixel = u16MinPixel;
2543
2544 MaxMinPixel = u16MaxPixel - u16MinPixel;
2545
2546 if(u8Value >= 0xFF)
2547 u8Value = 0xFF;
2548
2549 HDSDD_Det_threshold = HDSDD_Det_offset + ((MaxMinPixel * 6) >> 2) + ((u8Value * 5) >> 2);
2550
2551 if(HDSDD_Det_threshold >= 0xFFFF)
2552 {
2553 HDSDD_Det_threshold = 0xFFFF;
2554 }
2555 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK02_71_L, (MS_U16)HDSDD_Det_threshold, 0xFFFF);
2556 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK02_72_L, (MS_U16)(HDSDD_Det_threshold >> 1), 0xFFFF);
2557
2558 HDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_75_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_74_L);
2559 SDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_77_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_76_L);
2560
2561 if((HDcnt_Act > HD_ACT_TH) && (SDcnt_Act != 0))
2562 {
2563 if(HD_ConfirmCnt < HD_SPEED)
2564 HD_ConfirmCnt = 0;
2565 else
2566 HD_ConfirmCnt = HD_ConfirmCnt - HD_SPEED;
2567 }
2568 else if(SDcnt_Act != 0) //&& HDcnt_NonAct !=0) // && (HDcnt_NonAct < 0x90000))
2569 {
2570 if(HD_ConfirmCnt > (0xFF - SD_SPEED))
2571 HD_ConfirmCnt = 0xFF;
2572 else
2573 HD_ConfirmCnt = HD_ConfirmCnt + SD_SPEED;
2574 }
2575 else
2576 {
2577 if(HD_ConfirmCnt < 1)
2578 HD_ConfirmCnt = 0;
2579 else
2580 HD_ConfirmCnt = HD_ConfirmCnt - 1;
2581 }
2582
2583 if(HD_ConfirmCnt > 0x80)
2584 HD_ConfirmCnt_Reg = HD_ConfirmCnt - 0x80;
2585 else
2586 HD_ConfirmCnt_Reg = 0;
2587
2588 HD_ConfirmCnt_Reg = (HD_ConfirmCnt_Reg * HDSDD_SPEED) >> HDSDD_DIV;
2589
2590 if(HD_ConfirmCnt_Reg > 0x3F)
2591 HD_ConfirmCnt_Reg = 0x3F;
2592
2593 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK23_54_L, (MS_U16)HD_ConfirmCnt_Reg, 0x003F);
2594 }
2595
MDrv_SC_NEW_SDHD_DETECT_driver(void)2596 void MDrv_SC_NEW_SDHD_DETECT_driver(void)
2597 {
2598 MS_U8 u8Value,FEATHER_CNT_TH;
2599 MS_U16 u16MinPixel,u16MaxPixel, MaxMinPixel;
2600 MS_U32 HDcnt_Act;
2601 //MS_U32 HDcnt_NonAct;
2602 MS_U32 FeatherCnt;
2603 MS_U32 SDcnt_Act;
2604 //MS_U32 SDcnt_NonAct;
2605 static MS_U32 PreFeatherCnt = 0;
2606 static MS_U16 HD_ConfirmCnt = 0xFF; // 0x7FFF == 0
2607 static MS_U8 u8PrevLuma = 0;
2608 static MS_U16 u16PrevMinPixel = 0;
2609 static MS_U16 u16PrevMaxPixel = 0;
2610 MS_U32 HD_ConfirmCnt_Reg;
2611 MS_U16 HDSDD_Det_threshold,HDSDD_Det_offset;
2612
2613 HDSDD_Det_offset = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7F_L, 0xFFFF);
2614
2615 FeatherCnt = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK23_56_L); //New add for A1 chip
2616 FEATHER_CNT_TH = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7D_L, 0xFF00)>>8;
2617
2618 FeatherCnt = ( PreFeatherCnt*3 + FeatherCnt ) >> 2;
2619 PreFeatherCnt = FeatherCnt;
2620 #ifndef KANO_TEMP
2621 u8Value=(MS_U32)((MS_U32)u8PrevLuma*3 + MApi_XC_DLC_GetAverageValue())>>2;
2622 u8PrevLuma = u8Value;
2623 #endif
2624 u16MaxPixel = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK1A_0B_L, 0x00FF);
2625 u16MaxPixel = (u16PrevMaxPixel*3 + u16MaxPixel ) >> 2;
2626 u16PrevMaxPixel = u16MaxPixel;
2627
2628 u16MinPixel = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK1A_0B_L, 0xFF00)>>8;
2629 u16MinPixel = (u16PrevMinPixel*3 + u16MinPixel ) >> 2;
2630 u16PrevMinPixel = u16MinPixel;
2631
2632 MaxMinPixel = u16MaxPixel - u16MinPixel;
2633
2634 if(u8Value>=0xFF)
2635 u8Value = 0xFF;
2636
2637 HDSDD_Det_threshold = HDSDD_Det_offset +((MaxMinPixel*6)>>2) + ((u8Value*5)>>2);
2638
2639 if(HDSDD_Det_threshold >=0xFFFF)
2640 {
2641 HDSDD_Det_threshold=0xFFFF;
2642 }
2643 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK02_71_L, (MS_U16)HDSDD_Det_threshold, 0xFFFF);
2644 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK02_72_L, (MS_U16)(HDSDD_Det_threshold>>1), 0xFFFF);
2645
2646 HDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_75_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_74_L);
2647 SDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_77_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_76_L);
2648
2649 if( (HDcnt_Act > HD_ACT_TH) && (SDcnt_Act != 0) )
2650 {
2651 if(HD_ConfirmCnt < HD_SPEED)
2652 HD_ConfirmCnt = 0;
2653 else
2654 HD_ConfirmCnt = HD_ConfirmCnt - HD_SPEED;
2655 }
2656 else if( (SDcnt_Act != 0) && (FeatherCnt > FEATHER_CNT_TH) )//&& HDcnt_NonAct !=0) // && (HDcnt_NonAct < 0x90000))
2657 {
2658 if(HD_ConfirmCnt > (0xFF - SD_SPEED))
2659 HD_ConfirmCnt = 0xFF;
2660 else
2661 HD_ConfirmCnt = HD_ConfirmCnt + SD_SPEED;
2662 }
2663 else
2664 {
2665 if(HD_ConfirmCnt < 1)
2666 HD_ConfirmCnt = 0;
2667 else
2668 HD_ConfirmCnt = HD_ConfirmCnt - 1;
2669 }
2670
2671 if( HD_ConfirmCnt > 0x80 )
2672 HD_ConfirmCnt_Reg = HD_ConfirmCnt - 0x80;
2673 else
2674 HD_ConfirmCnt_Reg = 0;
2675
2676 HD_ConfirmCnt_Reg = (HD_ConfirmCnt_Reg*HDSDD_SPEED) >> HDSDD_DIV;
2677
2678 if( HD_ConfirmCnt_Reg > 0x3F )
2679 HD_ConfirmCnt_Reg = 0x3F;
2680
2681 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK23_54_L, (MS_U16)HD_ConfirmCnt_Reg, 0x003F);
2682 }
2683
MDrv_SC_A5_verticalMovingReduceKFC(MS_BOOL VerticalMovingForDHD)2684 void MDrv_SC_A5_verticalMovingReduceKFC( MS_BOOL VerticalMovingForDHD )
2685 {
2686 // reduce KFC reduce history motion when vertical moving
2687 if ( VerticalMovingForDHD || ((MS_U16)MApi_XC_R2BYTEMSK(REG_SC_BK22_7C_L, 0x2000) == 0x2000) )
2688 MApi_XC_W2BYTEMSK(REG_SC_BK2A_28_L, 0x0000, 0x0800);
2689 else
2690 MApi_XC_W2BYTEMSK(REG_SC_BK2A_28_L, 0x0800, 0x0800);
2691 }
2692
MDrv_SC_Amber5_DHD_driver1(MS_U8 u8SD2HDValue)2693 void MDrv_SC_Amber5_DHD_driver1( MS_U8 u8SD2HDValue )
2694 {
2695 // dhd news report patch: enhance dhd strength
2696 static MS_U32 u32sd2hdCnt = 0;
2697 int check_width = MApi_XC_R2BYTEMSK(REG_SC_BK12_0F_L, 0xFFFF);
2698 int is_PAL = (MApi_XC_R2BYTE(REG_SC_BK05_12_L)&0x4000)>>14;
2699
2700 MS_U8 MV0_Comfirm = MApi_XC_R2BYTE(REG_SC_BK2A_78_L)>>8;
2701
2702 if((u8SD2HDValue>=60)&&(check_width>0x700)&&(MV0_Comfirm>0x20)&&(is_PAL==0)) //When in HD case, detect SD
2703 {
2704 u32sd2hdCnt++;
2705
2706 if( u32sd2hdCnt >= 100 )
2707 {
2708 u32sd2hdCnt = 100;
2709 }
2710 }
2711 else
2712 {
2713 if( u32sd2hdCnt == 0 )
2714 {
2715 u32sd2hdCnt = 0;
2716 }
2717 else
2718 {
2719 u32sd2hdCnt--;
2720 }
2721 }
2722
2723 // divide into 11 level
2724 if( u32sd2hdCnt <= 2 )
2725 {
2726 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0030, 0x00FF); //c edge gain
2727 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x1000, 0xFF00); //y edge gain
2728 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0010, 0x00FF); //c value gain
2729 }
2730 else if( u32sd2hdCnt == 3 )
2731 {
2732 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0030, 0x00FF); //c edge gain
2733 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x2000, 0xFF00); //y edge gain
2734 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0020, 0x00FF); //c value gain
2735 }
2736 else if( u32sd2hdCnt == 4 )
2737 {
2738 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0030, 0x00FF); //c edge gain
2739 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x3000, 0xFF00); //y edge gain
2740 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0020, 0x00FF); //c value gain
2741 }
2742 else if( u32sd2hdCnt == 5 )
2743 {
2744 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0040, 0x00FF); //c edge gain
2745 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x4000, 0xFF00); //y edge gain
2746 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0030, 0x00FF); //c value gain
2747 }
2748 else if( u32sd2hdCnt == 6 )
2749 {
2750 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0050, 0x00FF); //c edge gain
2751 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x5000, 0xFF00); //y edge gain
2752 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0040, 0x00FF); //c value gain
2753 }
2754 else if( u32sd2hdCnt == 7 )
2755 {
2756 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0060, 0x00FF); //c edge gain
2757 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x6000, 0xFF00); //y edge gain
2758 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0050, 0x00FF); //c value gain
2759 }
2760 else if( u32sd2hdCnt == 8 )
2761 {
2762 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0070, 0x00FF); //c edge gain
2763 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x7000, 0xFF00); //y edge gain
2764 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0060, 0x00FF); //c value gain
2765 }
2766 else if( u32sd2hdCnt == 9 )
2767 {
2768 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0080, 0x00FF); //c edge gain
2769 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x8000, 0xFF00); //y edge gain
2770 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0070, 0x00FF); //c value gain
2771 }
2772 else if( u32sd2hdCnt == 10 )
2773 {
2774 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x0090, 0x00FF); //c edge gain
2775 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x9000, 0xFF00); //y edge gain
2776 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0080, 0x00FF); //c value gain
2777 }
2778 else if( u32sd2hdCnt == 11 )
2779 {
2780 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x00A0, 0x00FF); //c edge gain
2781 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0xA000, 0xFF00); //y edge gain
2782 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x0090, 0x00FF); //c value gain
2783 }
2784 else if( u32sd2hdCnt >= 12 )
2785 {
2786 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0x00B0, 0x00FF); //c edge gain
2787 MApi_XC_W2BYTEMSK(REG_SC_BK05_26_L, 0xB000, 0xFF00); //y edge gain
2788 MApi_XC_W2BYTEMSK(REG_SC_BK05_23_L, 0x00A0, 0x00FF); //c value gain
2789 }
2790 }
2791
MDrv_SC_Amber5_DHD_driver2(MS_U32 uComplex,MS_U32 IsHorizontalMoving,MS_U8 u8SD2HDValue,MS_BOOL VerticalMovingForDHD)2792 void MDrv_SC_Amber5_DHD_driver2( MS_U32 uComplex, MS_U32 IsHorizontalMoving, MS_U8 u8SD2HDValue, MS_BOOL VerticalMovingForDHD )
2793 {
2794 // dhd stadium patch: lower dhd strength
2795 static MS_U32 u32filmCnt = 0;
2796 int check_width = MApi_XC_R2BYTEMSK(REG_SC_BK12_0F_L, 0xFFFF);
2797 UNUSED(IsHorizontalMoving);
2798
2799 if (((u8SD2HDValue<10) && (uComplex>200)
2800 && (check_width>0x700)) || (VerticalMovingForDHD && (check_width>0x700) )
2801 || ( (u8SD2HDValue<5) && (check_width>0x700)))
2802 {
2803 u32filmCnt++;
2804
2805 if( u32filmCnt >= 50 )
2806 {
2807 u32filmCnt = 50;
2808 }
2809 }
2810 else
2811 {
2812 if( u32filmCnt == 0 )
2813 {
2814 u32filmCnt = 0;
2815 }
2816 else
2817 {
2818 u32filmCnt--;
2819 }
2820 }
2821
2822 if( u32filmCnt <= 2 )
2823 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x000F, 0x000F); //dhd user weight
2824 else if( u32filmCnt == 3 )
2825 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x000D, 0x000F); //dhd user weight
2826 else if( u32filmCnt == 4 )
2827 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x000B, 0x000F); //dhd user weight
2828 else if( u32filmCnt == 5 )
2829 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x0009, 0x000F); //dhd user weight
2830 else if( u32filmCnt == 6 )
2831 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x0007, 0x000F); //dhd user weight
2832 else if( u32filmCnt == 7 )
2833 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x0005, 0x000F); //dhd user weight
2834 else if( u32filmCnt == 8 )
2835 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x0003, 0x000F); //dhd user weight
2836 else if( u32filmCnt == 9 )
2837 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x0001, 0x000F); //dhd user weight
2838 else if( u32filmCnt >= 10 )
2839 MApi_XC_W2BYTEMSK(REG_SC_BK05_2C_L, 0x0000, 0x000F); //dhd user weight
2840 }
2841
2842 /******************************************************************************/
2843 ///CCS Driver
2844 /******************************************************************************/
2845
MDrv_SC_Amber5_CCS_driver(MS_U32 uComplex)2846 void MDrv_SC_Amber5_CCS_driver(MS_U32 uComplex)
2847 {
2848 // ccs moving color dot pattern patch: lower ccs strength
2849 static MS_U32 u32videoCnt = 0;
2850
2851 if( uComplex < 16 )
2852 {
2853 u32videoCnt++;
2854
2855 if( u32videoCnt >= 200 )
2856 {
2857 u32videoCnt = 200;
2858 }
2859 }
2860 else
2861 {
2862 if( u32videoCnt == 0 )
2863 {
2864 u32videoCnt = 0;
2865 }
2866 else
2867 {
2868 u32videoCnt--;
2869 }
2870 }
2871
2872 if( u32videoCnt <= 2 )
2873 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x000F, 0x000F); //ccs user weight
2874 else if( u32videoCnt == 3 )
2875 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x000D, 0x000F); //ccs user weight
2876 else if( u32videoCnt == 4 )
2877 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x000B, 0x000F); //ccs user weight
2878 else if( u32videoCnt == 5 )
2879 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0009, 0x000F); //ccs user weight
2880 else if( u32videoCnt == 6 )
2881 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0007, 0x000F); //ccs user weight
2882 else if( u32videoCnt == 7 )
2883 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0005, 0x000F); //ccs user weight
2884 else if( u32videoCnt == 8 )
2885 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0003, 0x000F); //ccs user weight
2886 else if( u32videoCnt == 9 )
2887 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0001, 0x000F); //ccs user weight
2888 else if( u32videoCnt >= 10 )
2889 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0000, 0x000F); //ccs user weight
2890 }
2891
MDrv_SC_Amber5_CCS_driver2(MS_U32 OOSRMC,MS_U32 IsHorizontalMoving)2892 void MDrv_SC_Amber5_CCS_driver2(MS_U32 OOSRMC, MS_U32 IsHorizontalMoving)
2893 {
2894 // horizontal moving => lower ccs weight
2895 static MS_U32 u32videoCnt = 0;
2896
2897 if( (OOSRMC < 20) || (IsHorizontalMoving >25) )
2898 {
2899 u32videoCnt++;
2900
2901 if( u32videoCnt >= 200 )
2902 {
2903 u32videoCnt = 200;
2904 }
2905 }
2906 else
2907 {
2908 if( u32videoCnt == 0 )
2909 {
2910 u32videoCnt = 0;
2911 }
2912 else
2913 {
2914 u32videoCnt--;
2915 }
2916 }
2917
2918 if( u32videoCnt <= 2 )
2919 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x000F, 0x000F); //ccs user weight
2920 else if( u32videoCnt == 3 )
2921 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x000D, 0x000F); //ccs user weight
2922 else if( u32videoCnt == 4 )
2923 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x000B, 0x000F); //ccs user weight
2924 else if( u32videoCnt == 5 )
2925 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0009, 0x000F); //ccs user weight
2926 else if( u32videoCnt == 6 )
2927 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0007, 0x000F); //ccs user weight
2928 else if( u32videoCnt == 7 )
2929 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0005, 0x000F); //ccs user weight
2930 else if( u32videoCnt == 8 )
2931 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0003, 0x000F); //ccs user weight
2932 else if( u32videoCnt == 9 )
2933 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0001, 0x000F); //ccs user weight
2934 else if( u32videoCnt >= 10 )
2935 MApi_XC_W2BYTEMSK(REG_SC_BK05_5C_L, 0x0000, 0x000F); //ccs user weight
2936 }
2937
MDrv_SC_NEW_SDHD_DETECT_report2(void)2938 MS_U8 MDrv_SC_NEW_SDHD_DETECT_report2( void )
2939 {
2940 MS_U32 HDcnt_Act,SDcnt_Act;
2941 //static MS_U32 prvHDcnt_Act = 0;
2942 static MS_U32 prvSDcnt_Act = 0;
2943 static MS_U16 reg_HD_th = 0;
2944 static MS_U16 reg_SD_th = 0;
2945 static MS_U8 SD_cnt = 0;
2946
2947 reg_HD_th = MApi_XC_R2BYTE(REG_SC_BK02_71_L );
2948 reg_SD_th = MApi_XC_R2BYTE(REG_SC_BK02_72_L );
2949
2950 MApi_XC_W2BYTEMSK(REG_SC_BK02_71_L, 0x100, 0xFFFF);
2951 MApi_XC_W2BYTEMSK(REG_SC_BK02_72_L, 0x100, 0xFFFF);
2952
2953 HDcnt_Act = (MApi_XC_R2BYTE(REG_SC_BK02_75_L) << 16) + MApi_XC_R2BYTE(REG_SC_BK02_74_L);
2954 SDcnt_Act = (MApi_XC_R2BYTE(REG_SC_BK02_77_L) << 16) + MApi_XC_R2BYTE(REG_SC_BK02_76_L);
2955
2956 HDcnt_Act = ( prvSDcnt_Act*3 + HDcnt_Act ) >> 2;
2957 //prvHDcnt_Act = HDcnt_Act;
2958
2959 SDcnt_Act = ( prvSDcnt_Act*3 + SDcnt_Act ) >> 2;
2960 prvSDcnt_Act = SDcnt_Act;
2961
2962 if( (HDcnt_Act < 1) && (SDcnt_Act!= 0) )
2963 {
2964 SD_cnt += 1;
2965 }
2966 else
2967 {
2968 SD_cnt = 0;
2969 }
2970
2971 MApi_XC_W2BYTEMSK(REG_SC_BK02_71_L, reg_HD_th, 0xFFFF);
2972 MApi_XC_W2BYTEMSK(REG_SC_BK02_72_L, reg_SD_th, 0xFFFF);
2973
2974 return SD_cnt;
2975 }
2976
2977
MDrv_SC_NEW_SDHD_DETECT_report(void)2978 MS_U8 MDrv_SC_NEW_SDHD_DETECT_report(void)
2979 {
2980 MS_U8 u8Value;
2981 //MS_U8 FEATHER_CNT_TH;
2982 MS_U16 u16MinPixel,u16MaxPixel, MaxMinPixel;
2983 MS_U32 HDcnt_Act, FeatherCnt;
2984 MS_U32 SDcnt_Act;
2985 //MS_U32 HDcnt_NonAct, SDcnt_NonAct;
2986 static MS_U32 PreFeatherCnt = 0;
2987 static MS_U16 HD_ConfirmCnt = 0xFF; // 0x7FFF == 0
2988 static MS_U8 u8PrevLuma = 0;
2989 static MS_U16 u16PrevMinPixel = 0;
2990 static MS_U16 u16PrevMaxPixel = 0;
2991 MS_U32 HD_ConfirmCnt_Reg;
2992 MS_U16 HDSDD_Det_threshold,HDSDD_Det_offset;
2993
2994 HDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_75_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_74_L);
2995 SDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_77_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_76_L);
2996 //HDcnt_NonAct = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_79_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_78_L);
2997 //SDcnt_NonAct = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_7B_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_7A_L);
2998 HDSDD_Det_offset = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7F_L, 0xFFFF);
2999
3000 FeatherCnt = MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK23_56_L); //New add for A1 chip
3001 //FEATHER_CNT_TH = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK22_7D_L, 0xFF00)>>8;
3002
3003 FeatherCnt = ( PreFeatherCnt*3 + FeatherCnt ) >> 2;
3004 PreFeatherCnt = FeatherCnt;
3005 #ifndef KANO_TEMP
3006 u8Value=(MS_U32)((MS_U32)u8PrevLuma*3 + MApi_XC_DLC_GetAverageValue())>>2;
3007 u8PrevLuma = u8Value;
3008 #endif
3009 u16MaxPixel = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK1A_0B_L, 0x00FF);
3010 u16MaxPixel = (u16PrevMaxPixel*3 + u16MaxPixel ) >> 2;
3011 u16PrevMaxPixel = u16MaxPixel;
3012
3013 u16MinPixel = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK1A_0B_L, 0xFF00)>>8;
3014 u16MinPixel = (u16PrevMinPixel*3 + u16MinPixel ) >> 2;
3015 u16PrevMinPixel = u16MinPixel;
3016
3017 MaxMinPixel = u16MaxPixel - u16MinPixel;
3018
3019 if(u8Value>=0xFF)
3020 u8Value = 0xFF;
3021
3022 HDSDD_Det_threshold = HDSDD_Det_offset +((MaxMinPixel*6)>>2) + ((u8Value*5)>>2);
3023
3024 if(HDSDD_Det_threshold >=0xFFFF)
3025 {
3026 HDSDD_Det_threshold=0xFFFF;
3027 }
3028 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK02_71_L, (MS_U16)HDSDD_Det_threshold, 0xFFFF);
3029 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK02_72_L, (MS_U16)(HDSDD_Det_threshold>>1), 0xFFFF);
3030
3031 HDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_75_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_74_L);
3032 SDcnt_Act = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_77_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_76_L);
3033 //HDcnt_NonAct = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_79_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_78_L);
3034 //SDcnt_NonAct = (MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_7B_L) << 16) + MApi_XC_EX_R2BYTE(&_XC_DeviceIdx, REG_SC_BK02_7A_L);
3035
3036 if( (HDcnt_Act > 0x10) && (SDcnt_Act != 0) )
3037 {
3038 if(HD_ConfirmCnt < HD_SPEED)
3039 HD_ConfirmCnt = 0;
3040 else
3041 HD_ConfirmCnt = HD_ConfirmCnt - HD_SPEED;
3042 }
3043 else if( SDcnt_Act != 0 ) //*&& FeatherCnt > FEATHER_CNT_TH*/ )//&& HDcnt_NonAct !=0) // && (HDcnt_NonAct < 0x90000))
3044 {
3045 if(HD_ConfirmCnt > (0xFF - SD_SPEED))
3046 HD_ConfirmCnt = 0xFF;
3047 else
3048 HD_ConfirmCnt = HD_ConfirmCnt + SD_SPEED;
3049 }
3050 else
3051 {
3052 if(HD_ConfirmCnt < 1)
3053 HD_ConfirmCnt = 0;
3054 else
3055 HD_ConfirmCnt = HD_ConfirmCnt - 1;
3056 }
3057
3058 if( HD_ConfirmCnt > 0x80 )
3059 HD_ConfirmCnt_Reg = HD_ConfirmCnt - 0x80;
3060 else
3061 HD_ConfirmCnt_Reg = 0;
3062
3063 HD_ConfirmCnt_Reg = (HD_ConfirmCnt_Reg*HDSDD_SPEED) >> HDSDD_DIV;
3064
3065 if( HD_ConfirmCnt_Reg > 0x3F )
3066 HD_ConfirmCnt_Reg = 0x3F;
3067
3068 return (HD_ConfirmCnt_Reg&0x003F);
3069 }
3070
3071
3072 #if (Auto_DeBlock_En)
3073 #define ADBW_HD_Loop_Ini_Start 40
3074 #define ADBW_HD_Max_Range_End 1440
3075 #define ADBW_SD_Loop_Ini_Start 20
3076 #define ADBW_SD_Max_Range_End 720
3077 static MS_U32 Auto_DBK_Width_val = 8;
3078 static MS_U32 Auto_DBK_Width_val_tmp = 32; // format is xxxxx.xx
3079 static MS_U32 Pre_DBK_Width_val = 8;
3080
MDrv_SC_Auto_Detect_Blocking_Width_driver(MS_U8 u8SD2HDValue)3081 void MDrv_SC_Auto_Detect_Blocking_Width_driver(MS_U8 u8SD2HDValue)
3082 {
3083 int data_ack_en;
3084 //int temp_data;
3085 int blkwidth_data[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
3086 int blkwidth_s_data[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
3087 long blockiness_data[1440];
3088 MS_BOOL blocking_peakidx[1440];
3089 int bin;
3090 int check_width = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK12_0F_L, 0xFFFF);
3091 int Loop_Ini_Start = (check_width>0x700) ? ADBW_HD_Loop_Ini_Start : ADBW_SD_Loop_Ini_Start;
3092 int Max_Range_End = (check_width>0x700) ? ADBW_HD_Max_Range_End : ADBW_SD_Max_Range_End;
3093 //long fme_blockiness;
3094 long frame_maxin_d = 0;
3095 long local_maxin_d;
3096 int left7,right7;
3097 int left2 = 0;
3098 int right2 = 0;
3099 int left1,right1;
3100 int bestblock_width = 8;
3101 MS_U32 iir_strength = 2;
3102 MS_U32 DBK_frame_blockiness = 0;
3103 MS_U32 DBK_frame_blockiness_sum = 0;
3104 static MS_U32 DBK_frame_blockiness_iir = 0;
3105 MS_U16 test_dummy = 0x2500 ; //MApi_XC_R2BYTEMSK(REG_SC_BK30_01_L, 0x7FFF);
3106 MS_U16 test_dummy2 = 0x2000 ; //MApi_XC_R2BYTEMSK(REG_SC_BK30_02_L, 0x7FFF);
3107
3108 MS_U16 dbk_iir_diff_thrd = 0x12;//MApi_XC_R2BYTEMSK(REG_SC_BK30_03_L, 0x7F00)>>8;
3109 static MS_U16 NMR_Ctrl=0;
3110 static MS_U16 NMR_Strength=0;
3111 MS_U32 iir_strength_NM = 2;
3112 MS_S32 DBK_frame_blockiness_diff=0;
3113
3114 static MS_U32 pre_DBK_frame_blockiness=0;
3115 int peak_from_blkwidth_data=0;
3116 static MS_U16 NMR_Strength_iir = 0 ;
3117 MS_U16 NMR_Strength_new = 0 ;
3118 MS_U16 NMR_Strength_new_adjust = 0 ;
3119
3120 //MS_U16 test_dummy4 = 0 ;//MApi_XC_R2BYTEMSK(REG_SC_BK30_02_L, 0xFFFF)>>15;
3121 //MS_U16 dbk_apply=0;
3122 MS_U16 count_thrd = 0x6 ; //MApi_XC_R2BYTEMSK(REG_SC_BK30_05_L, 0x00FF);
3123 MS_U16 iir_diff_thrd = 0x1 ; //MApi_XC_R2BYTEMSK(REG_SC_BK30_05_L, 0xFF00)>>8;
3124
3125 // setting HD mode enable
3126 if(check_width>0x700)
3127 {
3128 if(u8SD2HDValue>=60)
3129 {
3130 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_41_L, 0x1, 0x0001); // SDHD mode
3131 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_42_L, 0x6, 0x0007); // SDHD mode
3132 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_42_L, 15<<8, 0x0F00); // SDHD mode
3133 }
3134 else
3135 {
3136 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_41_L, 0x0, 0x0001); // SDHD mode
3137 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_42_L, 0x2, 0x0007); // SDHD mode
3138 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_42_L, 4<<8, 0x0F00); // SDHD mode
3139 }
3140 }
3141 else
3142 {
3143 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_41_L, 0x0, 0x0001); // SD mode & HD mode
3144 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_42_L, 0x2, 0x0007); // SDHD mode
3145 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_42_L, 4<<8, 0x0F00); // SDHD mode
3146 }
3147
3148 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_38_L, 0x4, 0x0004); // setting vertical iir enable
3149
3150 // write 1 to request register
3151 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_0D_L, 1, 0x0001);
3152
3153 data_ack_en = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_0D_L, 0x0002);
3154
3155 if(data_ack_en)
3156 {
3157 // write 1 to sram_io_en register
3158 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_0D_L, 0x100, 0x0100);
3159 for(bin = 0; bin < Max_Range_End; bin++)
3160 {
3161 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_0E_L, (MS_U16)(0x8000 + bin), 0xFFFF);
3162 // read data from selected address
3163 blockiness_data[bin] = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_0F_L, 0xFFFF);
3164 }
3165
3166 //read frame blockiness data
3167 //fme_blockiness = ((MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_61_L, 0xFFFF))<<16) | (MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_60_L, 0xFFFF)); // frame blockiness data report 32 bit
3168
3169 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_0D_L, 0, 0x0001);
3170
3171 //------- find the max local minmax difference start -------//
3172 for(bin = Loop_Ini_Start; bin < (Max_Range_End - 40); bin++)
3173 {
3174 left2 = bin - 2;
3175 right2 = bin + 2;
3176
3177 int loc_max = 0;
3178 int loc_min = 65535;
3179 int cnt;
3180
3181 for(cnt = left2; cnt <= right2; cnt++)
3182 {
3183 //find max
3184 if(blockiness_data[cnt] > loc_max)
3185 loc_max = blockiness_data[cnt];
3186
3187 //find min
3188 if(blockiness_data[cnt] < loc_min)
3189 loc_min = blockiness_data[cnt];
3190 }
3191
3192 if(loc_max > loc_min)
3193 local_maxin_d = loc_max - loc_min;
3194 else
3195 local_maxin_d = 0;
3196
3197 if(local_maxin_d > frame_maxin_d)
3198 frame_maxin_d = local_maxin_d;
3199
3200 }
3201 //------- find the max local minmax difference end -------//
3202
3203 for(bin = 0; bin < Max_Range_End; bin++)
3204 blocking_peakidx[bin] = false;
3205
3206 //------- find peak index start -------//
3207 for(bin = 0; bin < (Max_Range_End - 40); bin++)
3208 {
3209 left7 = (bin < 7) ? 0 : bin - 7;
3210 left1 = (bin < 1) ? 0 : bin - 1;
3211 right1 = bin + 1;
3212 right7 = bin + 7;
3213
3214 int loc_max = 0;
3215 int loc_min = 65535;
3216 int cnt;
3217
3218 for(cnt = left7; cnt <= right7; cnt++)
3219 {
3220 //find max
3221 if(blockiness_data[cnt] > loc_max)
3222 loc_max = blockiness_data[cnt];
3223
3224 //find min
3225 if(blockiness_data[cnt] < loc_min)
3226 loc_min = blockiness_data[cnt];
3227 }
3228
3229 if(loc_max > loc_min)
3230 local_maxin_d = loc_max - loc_min;
3231 else
3232 local_maxin_d = 0;
3233
3234 int Currx2_0 = (blockiness_data[bin]<<1); // data x 2
3235 int Lf12x1_1 = ((blockiness_data[left1] + blockiness_data[left2])*11)/10; // data x 1.1
3236 int Rt12x1_1 = ((blockiness_data[right1] + blockiness_data[right2])*11)/10; // data x 1.1
3237 int Currx1 = blockiness_data[bin]; // data x 1
3238 int Loc_Maxx0_99 = (loc_max*85)/100; // data x 0.85 // ori is data x 0.99
3239 int local_maxin_dx3 = local_maxin_d*3; // data x 3
3240
3241 if((Currx2_0>Lf12x1_1)&&(Currx2_0>Rt12x1_1)&&(Currx1>Loc_Maxx0_99)&&(local_maxin_dx3>frame_maxin_d) && (blockiness_data[bin] > blockiness_data[left1]) && (blockiness_data[bin] > blockiness_data[right1]))
3242 blocking_peakidx[cnt] = true;
3243 }
3244
3245 //------- find best block width start -------//
3246 int start_idx = 0;
3247
3248 for(bin = 0; bin < Max_Range_End; bin++)
3249 {
3250 if((blocking_peakidx[bin]==true)&&(bin!=start_idx))
3251 {
3252 int cnt = bin - start_idx;
3253 if( cnt < 31)
3254 blkwidth_data[cnt] += 1;
3255
3256 start_idx = bin;
3257 }
3258 }
3259 //------- find best block width end -------//
3260 //------- summarize 1x3 on blkwidth start -------//
3261 for(bin = 5; bin < 31; bin ++)
3262 {
3263 left1 = (bin < 1) ? 0 : bin - 1;
3264 right1 = (bin >= 31) ? 30 : bin + 1;
3265
3266 int loc_max = 0;
3267 int cnt;
3268
3269 for(cnt = left1; cnt <= right1; cnt++)
3270 {
3271 //find max
3272 if(blkwidth_data[cnt] > loc_max)
3273 loc_max = blkwidth_data[cnt];
3274 }
3275
3276 if(blkwidth_data[bin] > (loc_max>>1))
3277 blkwidth_s_data[bin] = blkwidth_data[left1] + blkwidth_data[bin] + blkwidth_data[right1];
3278 }
3279 //------- summarize 1x3 on blkwidth end -------//
3280
3281 //------- find the 1st max block width start -------//
3282 int bestblock_cnt_m = 0;
3283 int bestblock_lf1 = 0;
3284 int bestblock_idx = 0;
3285 int bestblock_rt1 = 0;
3286
3287 for(bin = 5; bin < 31; bin++)
3288 {
3289 if(blkwidth_s_data[bin] > bestblock_cnt_m)
3290 {
3291 bestblock_cnt_m = blkwidth_s_data[bin];
3292 bestblock_idx = bin;
3293 }
3294 }
3295
3296 bestblock_lf1 = bestblock_idx - 1;
3297 bestblock_rt1 = bestblock_idx + 1;
3298 blkwidth_s_data[bestblock_idx] = 0;
3299
3300 //------- find the 2nd max block width start -------//
3301 int bestblock_cnt_m2 = 0;
3302 int bestblock_idx2 = 0;
3303
3304 for(bin = 5; bin < 31; bin++)
3305 {
3306 if((blkwidth_s_data[bin] > bestblock_cnt_m2)&&((bin > bestblock_rt1) || (bin < bestblock_lf1)))
3307 {
3308 bestblock_cnt_m2 = blkwidth_s_data[bin];
3309 bestblock_idx2 = bin;
3310 }
3311 }
3312
3313 bestblock_lf1 = bestblock_idx2 - 1;
3314 bestblock_rt1 = bestblock_idx2 + 1;
3315 blkwidth_s_data[bestblock_idx2] = 0;
3316
3317 //------- find the 3rd max block width start -------//
3318 int bestblock_cnt_m3 = 0;
3319 int bestblock_idx3 = 0;
3320
3321 for(bin = 5; bin < 31; bin++)
3322 {
3323 if((blkwidth_s_data[bin] > bestblock_cnt_m3)&&((bin > bestblock_rt1) || (bin < bestblock_lf1)))
3324 {
3325 bestblock_cnt_m3 = blkwidth_s_data[bin];
3326 bestblock_idx3 = bin;
3327 }
3328 }
3329
3330 if((u8SD2HDValue>=60)&&(check_width>0x700))
3331 {
3332 if((bestblock_idx>=20)&&(bestblock_idx<=22)&&(bestblock_cnt_m>=5))
3333 {
3334 bestblock_cnt_m = 100;
3335 }
3336 else if((bestblock_idx2>=20)&&(bestblock_idx2<=22)&&(bestblock_cnt_m2>=5))
3337 {
3338 bestblock_idx = bestblock_idx2;
3339 bestblock_cnt_m = 100;
3340 }
3341 else if((bestblock_idx3>=20)&&(bestblock_idx3<=22)&&(bestblock_cnt_m3>=5))
3342 {
3343 bestblock_idx = bestblock_idx3;
3344 bestblock_cnt_m = 100;
3345 }
3346 }
3347
3348 //------- calculate best block width start -------//
3349 MS_BOOL condition1 = ((bestblock_cnt_m<<1) >= (bestblock_cnt_m2*3)) ? true : false; // m1 >= m2*1.5
3350 MS_BOOL condition2 = ((bestblock_cnt_m ) >= (bestblock_cnt_m2<<1)) ? true : false; // m1 >= m3*2
3351 MS_BOOL condition3 = (bestblock_cnt_m > 15) ? true : false;
3352 MS_BOOL condition4 = (bestblock_idx > 6) ? true : false;
3353
3354 if(condition1&& condition2&&condition3&&condition4)
3355 {
3356 bestblock_width = bestblock_idx;
3357
3358 if((u8SD2HDValue==00)&&(check_width>0x700)&&(bestblock_width==16))
3359 bestblock_width = 8;
3360
3361 Pre_DBK_Width_val = bestblock_width;
3362 }
3363 else
3364 {
3365 if((bestblock_cnt_m<count_thrd)||(bestblock_idx<=6))
3366 Pre_DBK_Width_val = 8;
3367 }
3368
3369 // iir
3370 int Pre_DBK_Width_val_tmp = (Pre_DBK_Width_val<<2); // format is xxxxx.xx
3371 Auto_DBK_Width_val_tmp = ((iir_strength*Pre_DBK_Width_val_tmp) + (8-iir_strength)*Auto_DBK_Width_val_tmp)/8; // format is xxxxx.xx
3372 Auto_DBK_Width_val = (Auto_DBK_Width_val_tmp>>2); // format is xxxxx.0
3373
3374 if(Auto_DBK_Width_val<=8)
3375 {
3376 Auto_DBK_Width_val = 8;
3377 left1 = 9;
3378 right1 = 8;
3379 }
3380 else
3381 {
3382 left1 = (Auto_DBK_Width_val < 1) ? 0 : Auto_DBK_Width_val - 1;
3383 right1 = (Auto_DBK_Width_val >=31) ? 31 : Auto_DBK_Width_val + 1;
3384 }
3385
3386 // write interval left && interval right
3387 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_39_L, (MS_U16)((right1<<8)|left1), 0xFFFF);
3388 //------- calculate best block width end -------//
3389
3390 if(_bDataRead)
3391 {
3392 NMR_Ctrl = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_50_L, 0x0001);
3393 NMR_Strength = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_54_L, 0x003F);
3394 _bDataRead = false;
3395 }
3396
3397 DBK_frame_blockiness_sum=0;
3398 for(bin = 0; bin < (Max_Range_End ); bin=bin+Auto_DBK_Width_val)
3399 {
3400 MS_U32 loc_max = 0;
3401 MS_U32 loc_min = 0xFFFFFFFF;
3402 MS_U32 cnt;
3403
3404 for(cnt = 0; cnt <= Auto_DBK_Width_val-1; cnt++)
3405 {
3406 //find max
3407 if(((MS_U32)blockiness_data[bin+cnt] > loc_max)&&((bin+cnt)<1440))
3408 loc_max = (MS_U32)blockiness_data[bin+cnt];
3409
3410 //find min
3411 if(((MS_U32)blockiness_data[bin+cnt] < loc_min)&&((bin+cnt)<1440))
3412 loc_min = (MS_U32)blockiness_data[bin+cnt];
3413 }
3414
3415 if(loc_max > loc_min)
3416 {
3417 local_maxin_d = loc_max - loc_min;
3418 }
3419 else
3420 {
3421 local_maxin_d = 0;
3422 }
3423 DBK_frame_blockiness_sum += local_maxin_d;
3424 }
3425
3426 DBK_frame_blockiness = DBK_frame_blockiness_sum*Auto_DBK_Width_val / (Max_Range_End) ;
3427
3428 DBK_frame_blockiness_diff = abs(DBK_frame_blockiness - pre_DBK_frame_blockiness);
3429
3430 if( DBK_frame_blockiness_diff > ((dbk_iir_diff_thrd<<8) ))
3431 {
3432 iir_strength_NM = 2;
3433 }
3434 else
3435 {
3436 iir_strength_NM = 2;
3437 }
3438
3439 DBK_frame_blockiness_iir = (DBK_frame_blockiness*iir_strength_NM+ DBK_frame_blockiness_iir*(8-iir_strength_NM))/8;
3440
3441 pre_DBK_frame_blockiness = DBK_frame_blockiness;
3442
3443 peak_from_blkwidth_data = 0;
3444 for(bin = 8; bin < 31; bin ++)
3445 {
3446 if( blkwidth_data[bin]> peak_from_blkwidth_data )
3447 peak_from_blkwidth_data = blkwidth_data[bin];
3448 }
3449
3450 /*if(test_dummy4)
3451 {
3452 if( (abs(Auto_DBK_Width_val - bestblock_idx)<=2) && (peak_from_blkwidth_data>=10) )
3453 dbk_apply=1;
3454 else
3455 dbk_apply=0;
3456 }
3457 else
3458 {
3459 if( (abs(Auto_DBK_Width_val - bestblock_idx)<=2) || (peak_from_blkwidth_data>=10) )
3460 dbk_apply=1;
3461 else
3462 dbk_apply=0;
3463 }*/
3464
3465 if (1)//(fme_blockiness>= (test_dummy3 <<8) ) //0x100000 // multiburst pan
3466 {
3467 if(DBK_frame_blockiness>= (0x2500))
3468 {
3469 NMR_Ctrl = 1 ;
3470 NMR_Strength_new = 0x3F ;
3471 }
3472 else if((DBK_frame_blockiness< (test_dummy)) && (DBK_frame_blockiness >= (test_dummy2)))
3473 {
3474 NMR_Ctrl = 1 ;
3475 NMR_Strength_new = 0x1f;
3476 }
3477 else
3478 {
3479 NMR_Strength_new = NMR_Strength;
3480 }
3481 }
3482 else
3483 {
3484 NMR_Strength_new = NMR_Strength;
3485 }
3486
3487 if(abs(NMR_Strength_new*4 - NMR_Strength_iir)>=(iir_diff_thrd*4) )
3488 {
3489 if((NMR_Strength_new*4)>=NMR_Strength_iir)
3490 {
3491 NMR_Strength_new_adjust = NMR_Strength_iir + iir_diff_thrd*4;
3492 NMR_Strength_iir = (NMR_Strength_iir*2+ NMR_Strength_new_adjust*6)/8; //*4/8(iir) = /2 ==> X.2 format
3493 }
3494 else
3495 {
3496 NMR_Strength_new_adjust = NMR_Strength_new*4;
3497 NMR_Strength_iir = (NMR_Strength_iir*0+ NMR_Strength_new_adjust*8)/8; //*4/8(iir) = /2 ==> X.2 format
3498 }
3499 }
3500 else
3501 {
3502 NMR_Strength_new_adjust = NMR_Strength_new*4;
3503 NMR_Strength_iir = (NMR_Strength_iir*2+ NMR_Strength_new_adjust*6)/8; //*4/8(iir) = /2 ==> X.2 format
3504 }
3505
3506 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_50_L, NMR_Ctrl, 0x0001);
3507 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0C_54_L, (NMR_Strength_iir/4+ (NMR_Strength_iir&2)/2 ), 0x003F);
3508 }
3509 //--------- Function Process end ---------//
3510 }
3511 #endif
3512
3513 static MS_U32 md_adjust_level_iir = 0;
3514 static MS_U32 psnr_std_level_thrd_iir = 0;
3515 static MS_U32 dnr_std_thrd_iir = 0;
3516 static MS_U32 luma_sum_pre=0;
3517 static MS_U16 dnr_md_high_thrd_level_iir =0;
3518 static MS_U16 dnr_md_low_thrd_level_iir =0;
3519
MDrv_SC_HISNR_driver(MS_U16 u16Width,MS_U16 u16Height)3520 void MDrv_SC_HISNR_driver(MS_U16 u16Width, MS_U16 u16Height)
3521 {
3522 MS_BOOL histogram_ack_en=0;
3523 MS_U16 noise_histogram[16];
3524 MS_U16 noise_histogram_scaled[16];
3525 MS_U32 scaled_ratio = 4;
3526 MS_U16 bin;
3527 // define value
3528 MS_U16 noise_level_low_thrd_0 = 0x0;
3529 MS_U16 noise_level_low_thrd_1 = 0x18;
3530 MS_U16 noise_level_low_thrd_2 = 0x28;
3531 MS_U16 noise_level_low_thrd_3 = 0x38;
3532 MS_U16 noise_level_high_thrd_3 = 0x60;
3533 // AUTO NR, HISDNR
3534 MS_U16 noise_bin_step = 0x00;
3535 MS_U16 noise_bin_thrd = 0x4C;
3536 MS_U16 pause_ack = 0;
3537 MS_U16 dnr_std_level0,dnr_std_level1,dnr_std_level2, dnr_std_level3;
3538 MS_U16 md_adjust_level0,md_adjust_level1,md_adjust_level2, md_adjust_level3;
3539 MS_U16 psnr_std_level0_thrd,psnr_std_level1_thrd,psnr_std_level2_thrd, psnr_std_level3_thrd;
3540 MS_U16 dnr_md_high_thrd_level0,dnr_md_low_thrd_level0;
3541 MS_U16 dnr_md_high_thrd_level1,dnr_md_low_thrd_level1;
3542 MS_U16 dnr_md_high_thrd_level2,dnr_md_low_thrd_level2;
3543 MS_U16 dnr_md_high_thrd_level3,dnr_md_low_thrd_level3;
3544 MS_U16 dnr_std_level=0;
3545 MS_U16 dnr_md_high_thrd_level=0;
3546 MS_U16 dnr_md_low_thrd_level=0;
3547 MS_U16 md_adjust_level=0;
3548 MS_U16 psnr_std_level_thrd=0;
3549 MS_U16 md_pre_shift=0;
3550 MS_U16 md_pre_gain=0;
3551 MS_U16 u16Height_div;
3552 MS_U16 V_start_height;
3553 MS_U16 V_end_height;
3554 MS_U16 V_active_height;
3555 MS_U16 H_start_width,H_end_width;
3556 MS_U16 H_active_width;
3557 MS_U32 pixel_number; // directly take
3558 MS_U16 LargerThanHigh;
3559 MS_U16 Off_from_low;
3560 MS_U16 adjust_alpha;
3561 MS_U32 weighted_sum;
3562 MS_U32 weighted_sumother=0;
3563 MS_U32 luma_sum;
3564 MS_S32 luma_avg_pre; // 16bits
3565 MS_S32 luma_avg;
3566 MS_S32 luma_avg_diff;
3567 MS_U32 iir_strength;
3568 MS_U16 histogram_max = 0;
3569 MS_U16 histogram_maxdiff=0;
3570 MS_U16 BitsValue_4;
3571 MS_U16 max_bin = 0;
3572 MS_U16 max_value = 0;
3573 MS_U16 result;
3574 MS_U32 adjust_result;
3575 MS_U16 calculated_result;
3576 MS_U16 noise_level_int=0;
3577 MS_U16 noise_strength;
3578 MS_S16 md_adjust_level_offset=md_adjust_level;
3579
3580 XC_EX_ApiStatus stXCStatus;
3581 memset(&stXCStatus, 0x00, sizeof(stXCStatus));
3582
3583 if(MApi_XC_EX_GetStatus(&_XC_DeviceIdx, &stXCStatus, E_XC_EX_MAIN_WINDOW) == FALSE)
3584 {
3585 printf("MApi_XC_GetStatus failed because of InitData wrong, please update header file and compile again\n");
3586 }
3587
3588 if(stXCStatus.bInterlace)
3589 u16Height_div = u16Height / 2 ;
3590 else
3591 u16Height_div = u16Height ;
3592
3593 scaled_ratio = (MS_U32)(4 * (u16Width*u16Height_div/172800)); // 720*240 = 172800
3594
3595 if(scaled_ratio<4)
3596 scaled_ratio =4;
3597
3598 if(u16Width<=1000)
3599 V_start_height = u16Height_div/240;
3600 else
3601 V_start_height = 0x10;
3602
3603 V_end_height = (u16Height_div - V_start_height*8)/8;
3604 V_active_height = (V_end_height-V_start_height)*8;
3605
3606 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_32_L, V_start_height, 0x00FF);
3607 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_32_L, V_end_height<<8, 0xFF00);
3608
3609 H_start_width = 0;
3610 H_end_width = u16Width/8;
3611
3612 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_31_L, H_start_width, 0x00FF);
3613 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_31_L, H_end_width<<8, 0xFF00);
3614
3615 H_active_width = (H_end_width-H_start_width)*8;
3616 pixel_number =(H_active_width*V_active_height) ; // directly take
3617
3618 //-------------------------------------------------------
3619 while ( !histogram_ack_en )
3620 histogram_ack_en = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_01_L, BIT(2));
3621
3622 if (histogram_ack_en)
3623 {
3624 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_01_L, 1, BIT(2));
3625
3626 noise_histogram[0] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_10_L, 0xFFFF);
3627 noise_histogram[1] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_11_L, 0xFFFF);
3628 noise_histogram[2] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_12_L, 0xFFFF);
3629 noise_histogram[3] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_13_L, 0xFFFF);
3630 noise_histogram[4] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_14_L, 0xFFFF);
3631 noise_histogram[5] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_15_L, 0xFFFF);
3632 noise_histogram[6] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_16_L, 0xFFFF);
3633 noise_histogram[7] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_17_L, 0xFFFF);
3634 noise_histogram[8] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_18_L, 0xFFFF);
3635 noise_histogram[9] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_19_L, 0xFFFF);
3636 noise_histogram[10] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_1A_L, 0xFFFF);
3637 noise_histogram[11] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_1B_L, 0xFFFF);
3638 noise_histogram[12] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_1C_L, 0xFFFF);
3639 noise_histogram[13] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_1D_L, 0xFFFF);
3640 noise_histogram[14] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_1E_L, 0xFFFF);
3641 noise_histogram[15] = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_1F_L, 0xFFFF);
3642
3643 for(bin=0; bin<16; bin++)
3644 noise_histogram_scaled[bin] = (MS_U16)((MS_S32)noise_histogram[bin]/scaled_ratio);
3645
3646 weighted_sum = noise_histogram_scaled[0]*64*scaled_ratio; // 6bits
3647
3648 for(bin=5; bin<16; bin++)
3649 weighted_sumother += noise_histogram_scaled[bin];
3650 // read luma sum
3651 luma_sum = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_48_L, 0xFFFF);
3652
3653 // get image size 480i,1080i
3654 luma_avg_pre = (luma_sum_pre*16384)/pixel_number; // 16bits
3655 luma_avg = (luma_sum*16384)/pixel_number;
3656 luma_avg_diff = (MS_U16) abs(luma_avg_pre-luma_avg);
3657
3658 luma_sum_pre = luma_sum;
3659
3660 iir_strength=2;
3661
3662 // remove pause_ack
3663 if(luma_avg_diff>=20)
3664 iir_strength=8;
3665
3666 // alpha before moodify
3667 if( (weighted_sum >= (3*pixel_number/4)) && (weighted_sumother!=0))
3668 {
3669 pause_ack = 2;
3670 }
3671
3672 //if(pause_ack==0)
3673 {
3674 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_20_L, noise_histogram_scaled[0], 0x03FF);
3675 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_21_L, noise_histogram_scaled[1], 0x03FF);
3676 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_22_L, noise_histogram_scaled[2], 0x03FF);
3677 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_23_L, noise_histogram_scaled[3], 0x03FF);
3678 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_24_L, noise_histogram_scaled[4], 0x03FF);
3679 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_25_L, noise_histogram_scaled[5], 0x03FF);
3680 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_26_L, noise_histogram_scaled[6], 0x03FF);
3681 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_27_L, noise_histogram_scaled[7], 0x03FF);
3682 }
3683
3684 dnr_std_level0 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_07_L, 0xFF00)>>8);
3685 dnr_std_level1 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_08_L, 0xFF00)>>8);
3686 dnr_std_level2 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_09_L, 0xFF00)>>8);
3687 dnr_std_level3 = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_4B_L, 0x00FF);
3688
3689 dnr_md_high_thrd_level0 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_03_L, 0xFF00)>>8);
3690 dnr_md_low_thrd_level0 = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_03_L, 0x00FF);
3691 dnr_md_high_thrd_level1 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_04_L, 0xFF00)>>8);
3692 dnr_md_low_thrd_level1 = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_04_L, 0x00FF);
3693 dnr_md_high_thrd_level2 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_05_L, 0xFF00)>>8);
3694 dnr_md_low_thrd_level2 = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_05_L, 0x00FF);
3695 dnr_md_high_thrd_level3 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_4A_L, 0xFF00)>>8);
3696 dnr_md_low_thrd_level3 = (MS_U16)MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_4A_L, 0x00FF);
3697
3698 md_adjust_level0 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_06_L, 0x000F)>>0);
3699 md_adjust_level1 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_06_L, 0x00F0)>>4);
3700 md_adjust_level2 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_06_L, 0x0F00)>>8);
3701 md_adjust_level3 = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_49_L, 0x000F)>>0);
3702
3703 psnr_std_level0_thrd = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_2A_L, 0x00FF)>>0);
3704 psnr_std_level1_thrd = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_2B_L, 0xFF00)>>8);
3705 psnr_std_level2_thrd = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_2C_L, 0x00FF)>>0);
3706 psnr_std_level3_thrd = (MS_U16)(MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_2D_L, 0x00FF)>>0);
3707
3708 for (bin =0; bin<8;bin++)
3709 {
3710 if(histogram_max<=noise_histogram_scaled[bin])
3711 histogram_max=noise_histogram_scaled[bin] ;
3712 }
3713
3714 for (bin =0; bin<8;bin++)
3715 histogram_maxdiff +=abs(histogram_max-noise_histogram_scaled[bin]) ;
3716
3717 if( histogram_maxdiff > noise_bin_thrd )
3718 {
3719 //cond_diagonal = 1;
3720 adjust_alpha = 0xF;
3721 }
3722 else
3723 {
3724 Off_from_low = noise_bin_thrd - histogram_maxdiff;
3725 //cond_diagonal = 0;
3726 switch( noise_bin_step )
3727 {
3728 case 0: BitsValue_4 = Off_from_low &0xF;
3729 LargerThanHigh = ( ( Off_from_low >> 4) >0 ) ? 1 : 0;
3730 break;
3731 case 1: BitsValue_4 = (Off_from_low>>1 )&0xF;
3732 LargerThanHigh = ( ( Off_from_low >>5) >0 ) ? 1 : 0;
3733 break;
3734 case 2: BitsValue_4 = ( Off_from_low >>2)&0xF;
3735 LargerThanHigh = ( ( Off_from_low >>6) >0 ) ? 1 : 0;
3736 break;
3737 case 3: BitsValue_4 = ( Off_from_low>>3 )&0xF;
3738 LargerThanHigh = ( ( Off_from_low >>7) >0 ) ? 1 : 0;
3739 break;
3740
3741 default:
3742 break;
3743 } // end switch
3744
3745 if( LargerThanHigh == 1)
3746 adjust_alpha = 0;
3747 else
3748 adjust_alpha = ~BitsValue_4;
3749 adjust_alpha = adjust_alpha &0x0F;
3750
3751 } // end of diag switch
3752
3753 for(bin=0; bin<5;bin++)
3754 {
3755 if(noise_histogram_scaled[bin]+noise_histogram_scaled[bin+1]>=max_value)
3756 max_value = noise_histogram_scaled[bin]+noise_histogram_scaled[bin+1];
3757 }
3758
3759 for (bin=0; bin<5;bin++)
3760 {
3761 if( (noise_histogram_scaled[bin]+noise_histogram_scaled[bin+1])==max_value)
3762 max_bin = bin;
3763 }
3764
3765 if ( 0 == max_bin ) //34 is ok , wh
3766 result = 16;
3767 else if ( 1 == max_bin)
3768 result = 32;
3769 else if ( 2 == max_bin)
3770 result = 48;
3771 else if(3 == max_bin)
3772 result =64;
3773 else if( (4 == max_bin) || (5 == max_bin) )
3774 result = 80;
3775 else
3776 result= 16;
3777
3778 adjust_result = (MS_U32)((result * adjust_alpha+8)/16);
3779 calculated_result = (MS_U16)(adjust_result);
3780
3781 if ( (noise_level_low_thrd_0 <= calculated_result) && (calculated_result < noise_level_low_thrd_1)) //34 is ok , wh
3782 {
3783 noise_level_int = 0;
3784 }
3785 else if ( (noise_level_low_thrd_1 <= calculated_result) && (calculated_result< noise_level_low_thrd_2))
3786 {
3787 noise_level_int = 1;
3788 }
3789 else if ( (noise_level_low_thrd_2 <= calculated_result) && (calculated_result< noise_level_low_thrd_3))
3790 {
3791 noise_level_int = 2;
3792 }
3793 else if((noise_level_low_thrd_3 <= calculated_result) && (calculated_result < noise_level_high_thrd_3))
3794 {
3795 noise_level_int =3;
3796 }
3797
3798 noise_strength = MApi_XC_EX_R2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_4B_L, 0xFF00)>>8;
3799
3800 if(noise_level_int==0)
3801 {
3802 //hismatch_level_thrd = hismatch_level0;
3803 dnr_std_level = dnr_std_level0;
3804 dnr_md_high_thrd_level = dnr_md_high_thrd_level0;
3805 dnr_md_low_thrd_level = dnr_md_low_thrd_level0;
3806 md_adjust_level = md_adjust_level0;
3807 psnr_std_level_thrd = psnr_std_level0_thrd;
3808 md_pre_shift = 5;
3809 md_pre_gain = 6;
3810 }
3811 else if(noise_level_int==1)
3812 {
3813 //hismatch_level_thrd = hismatch_level1;
3814 dnr_std_level = dnr_std_level1;
3815 dnr_md_high_thrd_level = dnr_md_high_thrd_level1;
3816 dnr_md_low_thrd_level = dnr_md_low_thrd_level1;
3817 md_adjust_level = md_adjust_level1;
3818 psnr_std_level_thrd = psnr_std_level1_thrd;
3819 md_pre_shift = 2;
3820 md_pre_gain = 1;
3821 }
3822 else if(noise_level_int==2)
3823 {
3824 //hismatch_level_thrd = hismatch_level2;
3825 dnr_std_level = dnr_std_level2;
3826 dnr_md_high_thrd_level = dnr_md_high_thrd_level2;
3827 dnr_md_low_thrd_level = dnr_md_low_thrd_level2;
3828 md_adjust_level = md_adjust_level2;
3829 psnr_std_level_thrd = psnr_std_level2_thrd;
3830 md_pre_shift = 2;
3831 md_pre_gain = 1;
3832
3833 }
3834 else if(noise_level_int==3 )
3835 {
3836 //hismatch_level_thrd = hismatch_level3 ;
3837 dnr_std_level = dnr_std_level3;
3838 dnr_md_high_thrd_level = dnr_md_high_thrd_level3;
3839 dnr_md_low_thrd_level = dnr_md_low_thrd_level3;
3840 md_adjust_level = md_adjust_level3;
3841 psnr_std_level_thrd = psnr_std_level3_thrd;
3842 md_pre_shift = 2;
3843 md_pre_gain = 1;
3844 }
3845
3846 md_adjust_level_offset = md_adjust_level;
3847
3848 if(noise_strength==0)
3849 md_adjust_level_offset = (md_adjust_level-2);
3850 else if(noise_strength==1)
3851 md_adjust_level_offset = (md_adjust_level-1);
3852 else if(noise_strength==3)
3853 md_adjust_level_offset = (md_adjust_level+1);
3854 else if(noise_strength==4)
3855 md_adjust_level_offset = (md_adjust_level+2);
3856
3857 if(md_adjust_level_offset<0)
3858 md_adjust_level_offset = 0;
3859 else if(md_adjust_level_offset>0xF)
3860 md_adjust_level_offset = 0xF;
3861
3862 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_30_L, md_pre_gain, 0x003F);
3863 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_30_L, (md_pre_shift<<8), 0x0700);
3864
3865 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_0C_L, 0 , 0x00FF);
3866
3867 dnr_std_thrd_iir = (iir_strength*dnr_std_level *4+ (8-iir_strength)*dnr_std_thrd_iir)/8 ; // *4/8(iir) = /2 ==> X.2 format
3868
3869 if(pause_ack == 2)
3870 dnr_std_thrd_iir= 5*4 ;
3871
3872 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_0D_L, (MS_U16)( dnr_std_thrd_iir/4 + (dnr_std_thrd_iir&0x02)/2 ) , 0x00FF);
3873
3874 dnr_md_high_thrd_level_iir= (MS_U16)((iir_strength*dnr_md_high_thrd_level *4+ (8-iir_strength)*dnr_md_high_thrd_level_iir)/8) ; // *4/8(iir) = /2 ==> X.2 format
3875
3876 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_0B_L, (MS_U16)(dnr_md_high_thrd_level_iir/4 + (dnr_md_high_thrd_level_iir&0x02)/2) , 0x00FF);
3877
3878 dnr_md_low_thrd_level_iir= (iir_strength*dnr_md_low_thrd_level*4+ (8-iir_strength)*dnr_md_low_thrd_level_iir)/8 ; // *4/8(iir) = /2 ==> X.2 format
3879
3880 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_0A_L, (MS_U16)(dnr_md_low_thrd_level_iir/4 + (dnr_md_low_thrd_level_iir&0x02)/2 ) , 0x00FF);
3881
3882 md_adjust_level_iir= (iir_strength*md_adjust_level_offset*4 +(8-iir_strength)*md_adjust_level_iir)/8 ;
3883
3884 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_06_L, ((MS_U16)(md_adjust_level_iir/4 + (md_adjust_level_iir&0x02)/2) )<<0xC , 0xF000);
3885
3886 psnr_std_level_thrd_iir= (iir_strength*psnr_std_level_thrd*4 + (8-iir_strength)*psnr_std_level_thrd_iir)/8 ;
3887
3888 MApi_XC_EX_W2BYTEMSK(&_XC_DeviceIdx, REG_SC_BK0E_2D_L, ((MS_U16)( psnr_std_level_thrd_iir/4 + (psnr_std_level_thrd_iir&0x02)/2 ) )<<0x8 , 0xFF00);
3889 }
3890 }
3891
3892
3893 static MS_U16 g_u16BK0A_24 = 0;
3894 static MS_U16 g_u16BK0C_10 = 0;
3895 static MS_U16 g_u16BK0C_39 = 0;
3896 static MS_U16 g_u16BK0C_3A = 0;
3897 static MS_U16 g_u16BK0C_40 = 0;
3898 static MS_U16 g_u16BK0C_41 = 0;
3899 static MS_U16 g_u16BK0C_42 = 0;
3900 static MS_U16 g_u16BK26_10 = 0;
3901 static MS_U16 g_u16BK26_11 = 0;
3902 static MS_U16 g_u16BK26_12 = 0;
3903 static MS_U16 g_u16BK26_13 = 0;
3904 static MS_U16 g_u16BK26_18 = 0;
3905
3906 /******************************************************************************/
3907 ///Film mode control for Any Candence
3908 ///@param bEnable \ IN: Enable/Disable control
3909 /******************************************************************************/
Hal_PQ_FilmMode_AnyCandence_Enable(void * pInstance,MS_BOOL bEnable)3910 void Hal_PQ_FilmMode_AnyCandence_Enable(void *pInstance, MS_BOOL bEnable)
3911 {
3912 MApi_XC_W2BYTEMSK(REG_SC_BK0A_24_L, (bEnable ? (BIT(15)) : 0), BIT(15));
3913 _bAnyCandenceEnable = bEnable;
3914 }
3915
3916 /******************************************************************************/
3917 ///Store the Current value
3918 /******************************************************************************/
Hal_PQ_StoreCurrentValue(void * pInstance)3919 void Hal_PQ_StoreCurrentValue(void *pInstance)
3920 {
3921 //for AnyCandence Film Mode
3922 g_u16BK0A_24 = MApi_XC_R2BYTEMSK(REG_SC_BK0A_24_L, BIT(15));
3923
3924 //for DBK
3925 g_u16BK0C_10 = MApi_XC_R2BYTE(REG_SC_BK0C_10_L);
3926 g_u16BK0C_39 = MApi_XC_R2BYTE(REG_SC_BK0C_39_L);
3927 g_u16BK0C_3A = MApi_XC_R2BYTE(REG_SC_BK0C_3A_L);
3928 g_u16BK0C_40 = MApi_XC_R2BYTE(REG_SC_BK0C_40_L);
3929 g_u16BK0C_41 = MApi_XC_R2BYTE(REG_SC_BK0C_41_L);
3930 g_u16BK0C_42 = MApi_XC_R2BYTE(REG_SC_BK0C_42_L);
3931
3932 //for DMS
3933 g_u16BK26_10 = MApi_XC_R2BYTE(REG_SC_BK26_10_L);
3934 g_u16BK26_11 = MApi_XC_R2BYTE(REG_SC_BK26_11_L);
3935 g_u16BK26_12 = MApi_XC_R2BYTE(REG_SC_BK26_12_L);
3936 g_u16BK26_13 = MApi_XC_R2BYTE(REG_SC_BK26_13_L);
3937 g_u16BK26_18 = MApi_XC_R2BYTE(REG_SC_BK26_18_L);
3938 }
3939
3940
3941 /******************************************************************************/
3942 ///Store the Current value
3943 /******************************************************************************/
Hal_PQ_ReStoreToDefault(void * pInstance)3944 void Hal_PQ_ReStoreToDefault(void *pInstance)
3945 {
3946 //for AnyCandence Film Mode
3947 MApi_XC_W2BYTEMSK(REG_SC_BK0A_24_L, g_u16BK0A_24, BIT(15));
3948
3949 //for DBK
3950 MApi_XC_W2BYTE(REG_SC_BK0C_10_L, g_u16BK0C_10);
3951 MApi_XC_W2BYTE(REG_SC_BK0C_39_L, g_u16BK0C_39);
3952 MApi_XC_W2BYTE(REG_SC_BK0C_3A_L, g_u16BK0C_3A);
3953 MApi_XC_W2BYTE(REG_SC_BK0C_40_L, g_u16BK0C_40);
3954 MApi_XC_W2BYTE(REG_SC_BK0C_41_L, g_u16BK0C_41);
3955 MApi_XC_W2BYTE(REG_SC_BK0C_42_L, g_u16BK0C_42);
3956
3957 //for DMS
3958 MApi_XC_W2BYTE(REG_SC_BK26_10_L, g_u16BK26_10);
3959 MApi_XC_W2BYTE(REG_SC_BK26_11_L, g_u16BK26_11);
3960 MApi_XC_W2BYTE(REG_SC_BK26_12_L, g_u16BK26_12);
3961 MApi_XC_W2BYTE(REG_SC_BK26_13_L, g_u16BK26_13);
3962 MApi_XC_W2BYTE(REG_SC_BK26_18_L, g_u16BK26_18);
3963 }
3964
3965 static MS_BOOL bFakeOutCusEnable = TRUE;
3966
Hal_PQ_SetFakeOutEnable(void * pInstance,MS_BOOL bEnable)3967 MS_BOOL Hal_PQ_SetFakeOutEnable(void *pInstance,MS_BOOL bEnable)
3968 {
3969 bFakeOutCusEnable = bEnable;
3970 return TRUE;
3971 }
3972
3973 #define ENABLE_SCALER_DEFEATHERING 0x01 //BK22_7C_L
3974 #define ENABLE_SCALER_DEFLICKERING 0x02
3975 #define ENABLE_SCALER_DEBOUNCING 0x04
3976 #define ENABLE_SCALER_DYNAMIC_SNR 0x08
3977 #define ENABLE_SCALER_DYNAMIC_DNR 0x10
3978 #define ENABLE_SCALER_DYNAMIC_FILM22 0x20
3979 #define ENABLE_SCALER_DEPRESNR 0x40
3980 #define ENABLE_SCALER_FANTASTICDNR 0x80
3981 #define ENABLE_SCALER_MCDI_DRIVER 0x01 //BK22_7C_H
3982 #define ENABLE_SCALER_MCNR_DRIVER 0x02
3983 #define ENABLE_SCALER_FILM_DRIVER 0x04
3984 #define ENABLE_SCALER_JANUS_DHD_DRIVER 0x08
3985 #define ENABLE_SCALER_HISDNR_DRIVER 0x10
3986 #define ENABLE_SCALER_SDHD_DETECT_DRIVER 0x20
3987 #define ENABLE_SCALER_T12_UCDI_DRIVER 0x40
3988 #define ENABLE_SCALER_NEW_SDHD_DETECT_DRIVER 0x80
3989 #define ENABLE_SCALER_EXTEND_UCDI_DRIVER 0x01 //BK22_7E_L
3990 #define ENABLE_SCALER_NEW_FILM_DRIVER 0x02
3991 #define ENABLE_SCALER_EXTEND_UCNR_DRIVER 0x04
3992 #define ENABLE_SCALER_AUTO_DBK_HD_DRIVER 0x08 // Auto_DBK w/o SDHDD
3993 #define ENABLE_SCALER_AUTO_DBK_DRIVER 0x80 // BK30_01_L[15]
3994
3995 //-------------------------------------------------------------------------------------------------
3996 /// this function does adaptive tuning periodic
3997 //-------------------------------------------------------------------------------------------------
Hal_PQ_AdaptiveTuning(void * pInstance)3998 void Hal_PQ_AdaptiveTuning(void *pInstance)
3999 {
4000 static MS_U8 u8PreviousVcnt = 0;
4001 MS_U8 u8CurrentVcnt;
4002 MS_U8 u8Ctrl,ColorSum,MR_Offset;
4003 MS_U8 u8Ctrl2;
4004 MS_U8 u8Ctrl3;
4005 MS_U8 u8Ctrl4;
4006 MS_U32 u32MotionValue,u32MotionValue2,OOSRMC,OOSRF,ISR_NONMV0,SmallMoving,VerticalMoving,HorizontalMoving,TotalFeather,TotalMvComfirm;
4007 //MS_U32 u32MotionValue3;
4008 MS_U32 uComplex,FeatherSum,u32MotionValue_Sum;
4009 MS_U8 u8MotLvl,u8SDHDDReportValue;
4010 XC_EX_ApiStatus stXCStatus;
4011 MS_BOOL bL107_en;
4012 memset(&stXCStatus, 0x00, sizeof(stXCStatus));
4013
4014 //
4015 // Check VCnt
4016 //
4017 u8CurrentVcnt = MDrv_SC_read_v_cnt();
4018 if (u8PreviousVcnt == u8CurrentVcnt)
4019 {
4020 return;
4021 }
4022 else
4023 {
4024 u8PreviousVcnt = u8CurrentVcnt;
4025 }
4026
4027 //
4028 // Get adaptive function control
4029 //
4030 u8Ctrl = MDrv_SC_get_adaptive_ctrl();
4031 u8Ctrl2 = MDrv_SC_get_adaptive_ctrl2();
4032 u8Ctrl3 = MDrv_SC_get_adaptive_ctrl3();
4033 u8Ctrl4 = MDrv_SC_get_adaptive_ctrl4();
4034 //
4035 // Get motion value
4036 //
4037 u32MotionValue = MDrv_SC_read_motion_value1();
4038 u32MotionValue2 = MDrv_SC_read_motion_value2();
4039 //u32MotionValue3 = MDrv_SC_read_motion_value3();
4040
4041 //
4042 // Get UCDi status
4043 //
4044 OOSRMC = MDrv_SC_T12_UC_InSearchRange_MvComfirm();
4045 OOSRF = MDrv_SC_T12_UC_InSearchRange_Feather();
4046 ISR_NONMV0 = MDrv_SC_T12_UC_InSearchRange_nonMv0Comfirm();
4047 SmallMoving = MDrv_SC_T12_UC_SmallMoving();
4048 VerticalMoving = MDrv_SC_A5_KFC_IsVerticalMoving();
4049
4050 HorizontalMoving = MDrv_SC_A5_IsHorizontalMoving();
4051 TotalFeather = MDrv_SC_A5_TotalFeather();
4052 FeatherSum = MDrv_SC_TotalFeather_Sum();
4053 TotalMvComfirm = MDrv_SC_A5_TotalMvComfirm();
4054 ColorSum = MDrv_SC_A5_ColorPixelSum();
4055 uComplex = MDrv_SC_A5_ComplexSum();
4056 MR_Offset = MDrv_SC_UC_InSearchRange_MR_Offset();
4057 u32MotionValue_Sum = u32MotionValue2 + MR_Offset;
4058
4059 // Adaptive functions
4060 if(_u16PQPre_SrcType != _u16PQSrcType_DBK_Detect[PQ_MAIN_WINDOW]) //For Auto_DBK SW driver used
4061 {
4062 _u16PQPre_SrcType = _u16PQSrcType_DBK_Detect[PQ_MAIN_WINDOW];
4063 _bDataRead = true;
4064 }
4065
4066 if ((u8Ctrl3 & ENABLE_SCALER_AUTO_DBK_DRIVER)||(u8Ctrl4 & ENABLE_SCALER_AUTO_DBK_HD_DRIVER)) //New Add for AUTO DBK Test
4067 {
4068 if(MApi_XC_EX_GetStatus(&_XC_DeviceIdx, &stXCStatus, E_XC_EX_MAIN_WINDOW) == FALSE)
4069 {
4070 printf("MApi_XC_GetStatus failed because of InitData wrong, please update header file and compile again\n");
4071 }
4072 u8SDHDDReportValue = MDrv_SC_NEW_SDHD_DETECT_report(); // W/O Feather detect
4073 MDrv_SC_Auto_Detect_Blocking_Width_driver(u8SDHDDReportValue); // Auto_Detect_Blocking_Width
4074 }
4075
4076 if(u8Ctrl4 & ENABLE_SCALER_EXTEND_UCDI_DRIVER)
4077 {
4078 MDrv_SC_A5_UCDi_OP1_HisWeight(u32MotionValue_Sum,FeatherSum);
4079 }
4080 else
4081 {
4082 // T12 UCDi function
4083 if (u8Ctrl2 & ENABLE_SCALER_T12_UCDI_DRIVER)
4084 {
4085 MDrv_SC_T12_UCDi_FeatherValueGain(OOSRMC, OOSRF, ISR_NONMV0);
4086 MDrv_SC_T12_UCDi_VerticalMovingUdRatio(OOSRMC, OOSRF, ISR_NONMV0);
4087 MDrv_SC_T12_UCDi_ComplexOffset(OOSRMC, OOSRF, ISR_NONMV0);
4088 MDrv_SC_T12_UCDi_W2SadGain(OOSRMC, OOSRF, ISR_NONMV0);
4089 MDrv_SC_T12_KFC_8bitMotionGain(SmallMoving);
4090 MDrv_SC_T12_UCDi_EODiWGain(OOSRMC, OOSRF, ISR_NONMV0);
4091 MDrv_SC_T12_UCDi_HistoryRatio(OOSRMC, OOSRF, ISR_NONMV0);
4092 MDrv_SC_A5_UCDi_OP1_HisWeight(u32MotionValue_Sum,FeatherSum);
4093 MDrv_SC_A5_KFC_EODiW(VerticalMoving);
4094 bL107_en = MDrv_SC_A5_L107(VerticalMoving, HorizontalMoving, TotalFeather, TotalMvComfirm,ColorSum,u32MotionValue, uComplex);
4095 MDrv_SC_A5_SonyChurch(VerticalMoving, HorizontalMoving, u32MotionValue, bL107_en );
4096 }
4097 else
4098 {
4099 if (u8Ctrl2 & ENABLE_SCALER_MCDI_DRIVER)
4100 {
4101 MDrv_SC_mcdi_driver(u32MotionValue2);
4102 }
4103 else
4104 {
4105 u8MotLvl = MDrv_SC_motion_level(u32MotionValue);
4106 MDrv_SC_mcdi_driver_new(u32MotionValue2, u8MotLvl);
4107 }
4108 }
4109 }
4110
4111 if(u8Ctrl4 & ENABLE_SCALER_EXTEND_UCNR_DRIVER)
4112 {
4113 MDrv_SC_Extend_UCNR_driver();
4114 }
4115 else
4116 {
4117 if (u8Ctrl2 & ENABLE_SCALER_MCNR_DRIVER)
4118 {
4119 MDrv_SC_mcnr_driver(u32MotionValue2);
4120 }
4121 }
4122 if (u8Ctrl2 & ENABLE_SCALER_SDHD_DETECT_DRIVER)
4123 {
4124 MDrv_SC_SDHD_DETECT_driver();
4125 }
4126
4127 if (u8Ctrl2 & ENABLE_SCALER_NEW_SDHD_DETECT_DRIVER)
4128 {
4129 MDrv_SC_NEW_SDHD_DETECT_driver();
4130 }
4131
4132 if(u8Ctrl4 & ENABLE_SCALER_NEW_FILM_DRIVER)
4133 {
4134
4135 }
4136 else
4137 {
4138 if (u8Ctrl2 & ENABLE_SCALER_FILM_DRIVER)
4139 {
4140 if(MApi_XC_EX_GetStatus(&_XC_DeviceIdx, &stXCStatus, E_XC_EX_MAIN_WINDOW) == FALSE)
4141 {
4142 printf("MApi_XC_GetStatus failed because of InitData wrong, please update header file and compile again\n");
4143 }
4144 }
4145 }
4146
4147 if (u8Ctrl2 & ENABLE_SCALER_JANUS_DHD_DRIVER)
4148 {
4149 MDrv_SC_Janus_DHD_driver();
4150 }
4151
4152 if (u8Ctrl2 & ENABLE_SCALER_HISDNR_DRIVER)
4153 {
4154 if(MApi_XC_EX_GetStatus(&_XC_DeviceIdx, &stXCStatus, E_XC_EX_MAIN_WINDOW) == FALSE)
4155 {
4156 printf("MApi_XC_GetStatus failed because of InitData wrong, please update header file and compile again\n");
4157 }
4158 MDrv_SC_HISNR_driver(stXCStatus.stCropWin.width, stXCStatus.stCropWin.height);
4159 }
4160
4161 if (u8Ctrl & ENABLE_SCALER_DEFEATHERING)
4162 {
4163 MDrv_SC_de_feathering(u32MotionValue);
4164 }
4165
4166 if (u8Ctrl & ENABLE_SCALER_DEFLICKERING)
4167 {
4168 MDrv_SC_de_flickering(u32MotionValue);
4169 }
4170
4171 if (u8Ctrl & ENABLE_SCALER_DEBOUNCING)
4172 {
4173 MDrv_SC_de_bouncing(u32MotionValue2);
4174 MDrv_SC_A5_UCDi_OP1_HisWeight(u32MotionValue_Sum,FeatherSum);
4175 }
4176
4177 if (u8Ctrl & ENABLE_SCALER_DYNAMIC_SNR)
4178 {
4179 MDrv_SC_dynamic_snr(u32MotionValue);
4180 }
4181
4182 if (u8Ctrl & ENABLE_SCALER_DYNAMIC_DNR)
4183 {
4184 MDrv_SC_dynamic_dnr(u32MotionValue);
4185 }
4186
4187 if (u8Ctrl & ENABLE_SCALER_DEPRESNR)
4188 {
4189 MDrv_SC_de_pre_snr(u32MotionValue2);
4190 }
4191
4192 if (u8Ctrl & ENABLE_SCALER_FANTASTICDNR)
4193 {
4194 MDrv_SC_fantastic_dnr();
4195 }
4196 }
4197
4198