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
95 #define _MDRV_PQ_CUS_C_
96
97 #ifdef MSOS_TYPE_LINUX
98 #include <pthread.h>
99 #endif
100 #if !defined(MSOS_TYPE_LINUX_KERNEL)
101 #include "string.h"
102 #else
103 #include <linux/string.h>
104 #endif
105
106 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
107 #include <sys/ioctl.h>
108 #include <unistd.h>
109 #include <fcntl.h> // O_RDWR
110 #endif
111
112 #include "MsCommon.h"
113 //#include "MsVersion.h"
114 #include "MsOS.h"
115 #include "MsTypes.h"
116 //#include "hwreg_utility2.h"
117 #include "color_reg.h"
118 #include "utopia.h"
119 #include "utopia_dapi.h"
120
121 #include "drvXC_IOPort.h"
122 #include "apiXC.h"
123 //#include "apiXC_Ace.h"
124 //#include "drvMVOP.h"
125
126 #include "drvPQ_Define.h"
127 #include "drvPQ_Define_cus.h"
128
129 #include "drvPQ_Declare.h"
130 #include "drvPQ.h"
131 #include "drvPQ_cus.h"
132 #include "drvPQ_Datatypes.h"
133 #include "mhal_pq.h"
134 #include "mhal_pq_cus.h"
135 #include "mhal_pq_adaptive.h"
136 #include "drvPQ_Bin.h"
137 #include "apiPNL.h"
138
139 #include "../../modules/xc/drv/xc/mdrv_xc_io.h"
140 #include "../../modules/xc/drv/xc/mdrv_xc_st.h"
141
142 #include "QualityMode.h"
143 #include "apiPQ_v2.h"
144 #include "PQ_private.h"
145 #if PQ_ENABLE_DEBUG
146 extern MS_U16 _u16PQDbgSwitch;
147 #endif
148
149 #ifndef UNUSED //to avoid compile warnings...
150 #define UNUSED(var) (void)((var) = (var))
151 #endif
152
153 #ifndef PQ_GRULE_SLZ_ENABLE
154 #define PQ_GRULE_SLZ_ENABLE 0
155 #endif
156
157 #ifndef PQ_QM_HDMI_4K2K
158 #define PQ_QM_HDMI_4K2K 0
159 #endif
160
161 #ifndef PQ_QM_DTV_4K2K
162 #define PQ_QM_DTV_4K2K 0
163 #endif
164
165 #ifndef PQ_OSD_BW_VER
166 #define PQ_OSD_BW_VER 1
167 #endif
168
169 #ifndef ENABLE_PQ_UFSC_DLC
170 #define ENABLE_PQ_UFSC_DLC 0
171 #endif
172
173 #ifndef ENABLE_PQ_UFSC_BYPASS
174 #define ENABLE_PQ_UFSC_BYPASS 0
175 #endif
176
177 /********************************************************************************
178 // PQ_IOCTL_SET_UC_FEATURE is flag for set UCNR During SetWin(if enable this switch please sync CL641359)
179 // and please check PQ excel skipRule(UC_CTL/UCDi/MADi_EODiW/MADi_SSTMADi_Motion need skip)item to prevent to set UCNR twice
180 **********************************************************************************/
181 #ifndef PQ_IOCTL_SET_UC_FEATURE
182 #define PQ_IOCTL_SET_UC_FEATURE 0
183 #endif
184
185 #ifndef PQ_VIP_OFF_MINUS16
186 #define PQ_VIP_OFF_MINUS16 0
187 #endif
188
189 #define PQGRULE_DBG(x) do { if( _u16PQDbgSwitch & PQ_DBG_GRULE) x; } while(0);
190 #define PQMODE_DBG(x) //x
191 #define PQ_IS_4K2K_INPUT(HSize,Vsize) (((HSize) > 3800) && ((Vsize) >= 1900))
192 #define GateFor30P 450
193 #define PQ_IS_4K_INPUT(HSize,Vsize) (((HSize) > 3000) && ((Vsize) >= 1050)) //Load 4k2k PQ mode if input is 4k2k or 4k1k.
194 #define PQ_IS_DTV_4K_INPUT(HSize,Vsize) (((HSize) > 2096) && ((Vsize) >= 1050)) // SC line buffer size is 2096, Load 4k2k PQ mode if input H > 2096
195
196 #define CFD_ANALOG_VERSION 0
197 #define CFD_LINEAR_RGB_VERSION 0
198 #define CFD_FIRE_VERSION 0
199
200 //#define TRACE_DBG
201 extern MS_U16 _u16PQSrcType[PQ_MAX_WINDOW];
202 extern MS_U16 _u16PQDbgSwitch;
203
204 extern MS_BOOL gbPQBinEnable;
205 extern MS_PQBin_Header_Info stPQBinHeaderInfo[MAX_PQ_BIN_NUM];
206 extern MS_PQTextBin_Header_Info stPQTextBinHeaderInfo[MAX_PQ_TEXT_BIN_NUM];
207 extern MS_BOOL gbEnablePQTextBin;
208 extern MS_PQ_Vd_Info _stVD_Info[PQ_MAX_WINDOW];
209 extern MS_PQ_MuliMedia_Info _stMultiMedia_Info[PQ_MAX_WINDOW];
210 extern MS_PQ_Mode_Info _stMode_Info[PQ_MAX_WINDOW];
211 extern MS_U8 _u8ModeIndex[PQ_MAX_WINDOW];
212 extern MS_PQ_Hdmi_Info _stHDMI_Info[PQ_MAX_WINDOW];
213 extern MS_PQ_Dtv_Info _stDTV_Info[PQ_MAX_WINDOW];
214 extern MS_BOOL _bOSD_On;
215 extern MS_BOOL _gbMemfmt422[PQ_MAX_WINDOW];
216 extern MS_BOOL _gbMemfmt422[PQ_MAX_WINDOW];
217 extern MS_BOOL _bDS_En;
218 extern MS_U16 _u16RW_Method;
219 extern MS_BOOL _bRWNumIsReset[PQ_MAX_WINDOW];
220 extern MS_BOOL bSetFrameCount;
221 extern MS_U16 _gu16SetMemfmt_Madi[PQ_MAX_WINDOW];
222 extern MS_U16 _gu16SetMemfmt_Madi_Motion[PQ_MAX_WINDOW];
223
224 MS_BOOL _gIsH264 = 0;
225 MS_BOOL _gIsMVC4kx1k = 0;
226 MS_BOOL _gbIsG3D = 0; //priority for G3D
227 MS_BOOL _gIsMMplayer=0;
228 MS_BOOL _gIsRmvb[PQ_MAX_WINDOW] = {0,0};
229 MS_BOOL _gIsNetworkMM = 0;
230 MS_BOOL _gbSubWin_En = FALSE; //indicate subwindow enable or not, for bw setting
231 MS_BOOL _gIsDualDecode = 0;
232 MS_BOOL _gIs1KTraveling = 0;
233 MS_BOOL _gIsThroughMode = FALSE;
234 static MS_U16 gu16DisplayWidth = 0;
235
236 #if (PQ_ENABLE_PIP)
237 static PQ_DISPLAY_TYPE genDisplayType = PQ_DISPLAY_ONE;
238 #endif
239
240 #if PQ_GRULE_DDR_SELECT_ENABLE
241 extern BW_INFO_t bw_info;
242 #endif
243 #if PQ_DLC_CTL_FOR_MVC4KX1K
244 extern MS_BOOL _gIsMVC4kx1k;
245 #endif
246 #if (PQ_QM_BYPASS_COLOR)
247 extern MS_BOOL _bBypassModeOn[PQ_MAX_WINDOW];
248 #endif
249
250 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
251 extern MS_BOOL _bCustomerMainPQEn;
252 #endif
253 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
254 extern MS_BOOL _bCustomerSubPQEn;
255 #endif
256
257 extern MS_BOOL _enPQDisplayType;
258
259 #ifdef UFO_XC_HDR
260 #if (UFO_XC_HDR_VERSION == 2)
261 #ifdef MSOS_TYPE_LINUX
262 static MS_S32 _s32FdScaler = -1;
263 #endif
264 #endif
265 #endif
266
267 #if (defined(MSOS_TYPE_LINUX_KERNEL) && defined(CONFIG_MSTAR_XC_HDR_SUPPORT))
268 extern MS_BOOL MDrv_XC_CFDControl(ST_KDRV_XC_CFD_CONTROL_INFO *pstKdrvCFDCtrlInfo);
269 #endif
MDrv_PQ_SendCfd(EN_PQ_CFD_CTRL_TYPE enCtrlType,void * pstCfdInfo,MS_U32 u32Size)270 MS_BOOL MDrv_PQ_SendCfd(EN_PQ_CFD_CTRL_TYPE enCtrlType, void *pstCfdInfo, MS_U32 u32Size)
271 {
272 #ifdef UFO_XC_HDR
273 #if (UFO_XC_HDR_VERSION == 2)
274
275 ST_PQ_CFD_CONTROL_INFO stCfdCtrlInfo;
276 memset(&stCfdCtrlInfo, 0, sizeof(ST_PQ_CFD_CONTROL_INFO));
277 stCfdCtrlInfo.enCtrlType = enCtrlType;
278 stCfdCtrlInfo.pParam = pstCfdInfo;
279 stCfdCtrlInfo.u32ParamLen = u32Size;
280 #if (defined MSOS_TYPE_LINUX) || (defined ANDROID)
281
282 if(0 > _s32FdScaler)
283 {
284 _s32FdScaler = open("/dev/scaler", O_RDWR);
285
286 if(0 > _s32FdScaler)
287 {
288 return FALSE;
289 }
290 }
291
292 if (ioctl(_s32FdScaler, MDRV_XC_IOC_CFDCONCTRL, &stCfdCtrlInfo))
293 {
294 return FALSE;
295 }
296
297 return TRUE;
298 #elif (defined(MSOS_TYPE_LINUX_KERNEL) && defined(CONFIG_MSTAR_XC_HDR_SUPPORT))
299 MDrv_XC_CFDControl(&stCfdCtrlInfo);
300 return TRUE;
301 #else
302 printf("MDrv_PQ_SendCfd unsupport OS type\n");
303 #endif
304 #endif
305 #endif
306 return FALSE;
307 }
QM_InputSourceToIndex(void * pInstance,PQ_WIN eWindow,MS_U8 enInputSourceType)308 MS_U16 QM_InputSourceToIndex(void* pInstance, PQ_WIN eWindow, MS_U8 enInputSourceType)
309 {
310 MS_U16 u16SrcType = 0;
311 MS_U16 u16Input_HSize = QM_GetInputHSize(eWindow);
312 MS_U16 u16Input_VSize = QM_GetInputVSize(eWindow);
313 MS_U16 u16Input_VFreq = QM_GetInputVFreq(eWindow);
314 MS_BOOL bIsInterlaced = QM_IsInterlaced(eWindow);
315
316 #if (PQ_QM_CVBS)
317 PQ_VIDEOSTANDARD_TYPE eStandard;
318 #endif
319
320 #if (PQ_QM_HDMI_PC) || (PQ_QM_PC)
321 MS_U16 u16Disp_HSize = QM_GetDispHSize(eWindow);
322 MS_U16 u16Disp_VSize = QM_GetDispVSize(eWindow);
323
324 PQMODE_DBG(printf("\r\n QM: Src = %u, H = %u, V = %u", enInputSourceType, u16Input_HSize, u16Input_VSize));
325 PQMODE_DBG(printf("\r\n VFreq = %u, IsInterlace = %u", u16Input_VFreq, (MS_U16)bIsInterlaced));
326 PQMODE_DBG(printf("\r\n DispH = %u, DispV = %u", u16Disp_HSize, u16Disp_VSize));
327 #endif
328
329 #if (PQ_QM_BYPASS_COLOR)
330
331 // Only when bypass mode is on .
332 if (_bBypassModeOn[eWindow])
333 {
334 if (bIsInterlaced)
335 u16SrcType = QM_BypassColor_interlace_Main;
336 else
337 u16SrcType = QM_BypassColor_progressive_Main;
338
339 return u16SrcType;
340 }
341 #endif
342
343 #if ENABLE_VGA_EIA_TIMING
344 // Only Progressiv mode
345 if ((QM_IsSourceVGA(enInputSourceType) || QM_IsSourceDVI_HDMIPC(enInputSourceType, eWindow)) && (!bIsInterlaced))
346 #else
347 // Only DVI progressive mode, VGA could be interlace
348 if (QM_IsSourceVGA(enInputSourceType) || (QM_IsSourceDVI_HDMIPC(enInputSourceType, eWindow) && !bIsInterlaced))
349 #endif
350 {
351 //DVI YUV mode is some special pattern gen timing in Korea company
352 if(QM_IsSourceHDMI(enInputSourceType) && QM_HDMIPC_COLORYUV444(eWindow))
353 {
354 #if (PQ_QM_HDMI_PC)
355 // PC YUV444
356 if (u16Input_HSize < u16Disp_HSize)
357 {
358 if (u16Input_VSize < u16Disp_VSize)
359 {
360 u16SrcType = QM_HDMI_444_PC_Hup_Vup_Main;
361 }
362 else if (u16Input_VSize > u16Disp_VSize)
363 {
364 u16SrcType = QM_HDMI_444_PC_Hup_Vdown_Main;
365 }
366 else
367 {
368 u16SrcType = QM_HDMI_444_PC_Hup_Vno_Main;
369 }
370 }
371 else if (u16Input_HSize > u16Disp_HSize)
372 {
373 if (u16Input_VSize < u16Disp_VSize)
374 {
375 u16SrcType = QM_HDMI_444_PC_Hdown_Vup_Main;
376 }
377 else if (u16Input_VSize > u16Disp_VSize)
378 {
379 u16SrcType = QM_HDMI_444_PC_Hdown_Vdown_Main;
380 }
381 else
382 {
383 u16SrcType = QM_HDMI_444_PC_Hdown_Vno_Main;
384 }
385 }
386 else
387 {
388 if (u16Input_VSize < u16Disp_VSize)
389 {
390 u16SrcType = QM_HDMI_444_PC_Hno_Vup_Main;
391 }
392 else if (u16Input_VSize > u16Disp_VSize)
393 {
394 u16SrcType = QM_HDMI_444_PC_Hno_Vdown_Main;
395 }
396 else
397 {
398 u16SrcType = QM_HDMI_444_PC_Hno_Vno_Main;
399 }
400 }
401 #endif
402 }
403 else if (QM_IsSourceHDMI(enInputSourceType) && QM_HDMIPC_COLORYUV422(eWindow))
404 {
405 #if (PQ_QM_HDMI_PC)
406 // PC YUV422
407 if (u16Input_HSize < u16Disp_HSize)
408 {
409 if (u16Input_VSize < u16Disp_VSize)
410 {
411 u16SrcType = QM_HDMI_422_PC_Hup_Vup_Main;
412 }
413 else if (u16Input_VSize > u16Disp_VSize)
414 {
415 u16SrcType = QM_HDMI_422_PC_Hup_Vdown_Main;
416 }
417 else
418 {
419 u16SrcType = QM_HDMI_422_PC_Hup_Vno_Main;
420 }
421 }
422 else if (u16Input_HSize > u16Disp_HSize)
423 {
424 if (u16Input_VSize < u16Disp_VSize)
425 {
426 u16SrcType = QM_HDMI_422_PC_Hdown_Vup_Main;
427 }
428 else if (u16Input_VSize > u16Disp_VSize)
429 {
430 u16SrcType = QM_HDMI_422_PC_Hdown_Vdown_Main;
431 }
432 else
433 {
434 u16SrcType = QM_HDMI_422_PC_Hdown_Vno_Main;
435 }
436 }
437 else
438 {
439 if (u16Input_VSize < u16Disp_VSize)
440 {
441 u16SrcType = QM_HDMI_422_PC_Hno_Vup_Main;
442 }
443 else if (u16Input_VSize > u16Disp_VSize)
444 {
445 u16SrcType = QM_HDMI_422_PC_Hno_Vdown_Main;
446 }
447 else
448 {
449 u16SrcType = QM_HDMI_422_PC_Hno_Vno_Main;
450 }
451 }
452 #endif
453 }
454 else //(QM_HDMIPC_COLORRGB(eWindow)) & default
455 {
456 #if (PQ_QM_PC)
457 // PC RGB
458 if (u16Input_HSize < u16Disp_HSize)
459 {
460 if (u16Input_VSize < u16Disp_VSize)
461 {
462 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hup_Vup_Main;
463 }
464 else if (u16Input_VSize > u16Disp_VSize)
465 {
466 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hup_Vdown_Main;
467 }
468 else
469 {
470 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hup_Vno_Main;
471 }
472 }
473 else if (u16Input_HSize > u16Disp_HSize)
474 {
475 if (u16Input_VSize < u16Disp_VSize)
476 {
477 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hdown_Vup_Main;
478 }
479 else if (u16Input_VSize > u16Disp_VSize)
480 {
481 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hdown_Vdown_Main;
482 }
483 else
484 {
485 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hdown_Vno_Main;
486 }
487 }
488 else
489 {
490 if (u16Input_VSize < u16Disp_VSize)
491 {
492 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hno_Vup_Main;
493 }
494 else if (u16Input_VSize > u16Disp_VSize)
495 {
496 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hno_Vdown_Main;
497 }
498 else
499 {
500 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hno_Vno_Main;
501 }
502 }
503 #endif
504 }
505 }
506 else if (QM_IsSourceHDMI(enInputSourceType)
507 #if ENABLE_VGA_EIA_TIMING
508 || QM_IsSourceVGA(enInputSourceType) //interlace VGA comes here
509 #endif
510 )
511 {
512 #if (PQ_QM_HMDI)
513 #if 0//debug message
514 if(QM_HDMIPC_COLORRGB(eWindow))
515 printf("HDMI RGB\n");
516 else if(QM_HDMIPC_COLORYUV444(eWindow))
517 printf("HDMI YUV 444\n");
518 else
519 printf("HDMI YUV 422\n");
520 #endif
521 if( QM_IsSourceHDMI(enInputSourceType) && QM_HDMIPC_COLORRGB(eWindow) &&
522 (MDrv_PQ_Get_PointToPoint_U2(pInstance, eWindow)) && (!bIsInterlaced) &&
523 (!PQ_IS_4K2K_INPUT(u16Input_HSize,u16Input_VSize)))
524 {
525 // HDMI RGB progressive
526 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hno_Vno_Main;
527 }
528 else if( QM_IsSourceHDMI(enInputSourceType) && QM_HDMIPC_COLORYUV444(eWindow) &&
529 (MDrv_PQ_Get_PointToPoint_U2(pInstance,eWindow)) && (!bIsInterlaced) &&
530 (!PQ_IS_4K2K_INPUT(u16Input_HSize,u16Input_VSize)))
531 {
532 // HDMI YUV444 progressive
533 u16SrcType = QM_HDMI_444_PC_Hno_Vno_Main;
534 }
535 #if (PQ_SUPPORT_HDMI_4K2K_P2P == 1)
536 else if( QM_IsSourceHDMI(enInputSourceType) && QM_HDMIPC_COLORRGB(eWindow) &&
537 (MDrv_PQ_Get_PointToPoint_U2(pInstance,eWindow)) && (!bIsInterlaced) &&
538 PQ_IS_4K2K_INPUT(u16Input_HSize,u16Input_VSize))
539 {
540 // HDMI 4K2K RGB progressive
541 u16SrcType = QM_DVI_Dsub_HDMI_RGB_PC_Hno_Vno_4K_Main;
542 }
543 else if( QM_IsSourceHDMI(enInputSourceType) && QM_HDMIPC_COLORYUV444(eWindow) &&
544 (MDrv_PQ_Get_PointToPoint_U2(pInstance,eWindow)) && (!bIsInterlaced) &&
545 PQ_IS_4K2K_INPUT(u16Input_HSize,u16Input_VSize))
546 {
547 // HDMI YUV444 progressive
548 u16SrcType = QM_HDMI_444_PC_Hno_Vno_4K_Main;
549 }
550 #endif
551 else
552 {
553 // HDMI
554 if ((u16Input_HSize < 800) && (u16Input_VSize < 500))
555 {
556 if (bIsInterlaced)
557 u16SrcType = QM_HDMI_480i_Main;
558 else
559 u16SrcType = QM_HDMI_480p_Main;
560 }
561 else if ((u16Input_HSize < 800) && (u16Input_VSize < 600))
562 {
563 if (bIsInterlaced)
564 u16SrcType = QM_HDMI_576i_Main;
565 else
566 u16SrcType = QM_HDMI_576p_Main;
567 }
568 else if ((u16Input_HSize < 1300) && (u16Input_VSize < 800) && (!bIsInterlaced))
569 {
570 if (u16Input_VFreq > 550)
571 {
572 u16SrcType = QM_HDMI_720p_60hz_Main;
573 }
574 else if(u16Input_VFreq > 250)
575 {
576 u16SrcType = QM_HDMI_720p_50hz_Main;
577 }
578 else
579 {
580 u16SrcType = QM_HDMI_720p_24hz_Main;
581 }
582 }
583 #if (PQ_QM_HDMI_4K2K)
584 else if(PQ_IS_4K2K_INPUT(u16Input_HSize,u16Input_VSize))
585 {
586 if (u16Input_VFreq > 280)
587 {
588 u16SrcType = QM_4K2K_30Hz_Main;
589 }
590 else
591 {
592 u16SrcType = QM_4K2K_24Hz_Main;
593 }
594 }
595 #endif
596 else
597 {
598 if (bIsInterlaced)
599 {
600 #if PQ_QM_HDMI_FP_VIDEO
601 if(u16Input_VSize > 2000) //1920x2228 i.it will not go this path now, but may used in future.
602 {
603 u16SrcType = QM_HDMI_FP_1080i_Main;
604 }
605 else
606 #endif
607 if (u16Input_VFreq > 550)
608 {
609 u16SrcType = QM_HDMI_1080i_60hz_Main;
610 }
611 else
612 {
613 u16SrcType = QM_HDMI_1080i_50hz_Main;
614 }
615 }
616 else
617 {
618 #if PQ_QM_HDMI_FP_VIDEO
619 if((u16Input_HSize > 1910)
620 && (u16Input_HSize < 1930)
621 && (u16Input_VSize > 2218)
622 && (u16Input_VSize < 2238)) //1920x2228 i frame packing
623 {
624 u16SrcType = QM_HDMI_FP_1080i_Main;
625 }
626 else if(((u16Input_HSize > 1430) && (u16Input_HSize < 1450))
627 && (((u16Input_VSize > 591) && (u16Input_VSize < 611)) || ((u16Input_VSize > 493) && (u16Input_VSize < 513))))
628 {
629 u16SrcType = QM_HDMI_FP_1080i_Main;
630 }
631 else if((u16Input_HSize > 1910)
632 && (u16Input_HSize < 1930)
633 && (u16Input_VSize > 2195)
634 && (u16Input_VSize < 2215)) //1920x2205 p frame packing
635 {
636 u16SrcType = QM_HDMI_FP_1080p_Main;
637 }
638 else if((u16Input_HSize > 1270)
639 && (u16Input_HSize < 1290)
640 && (u16Input_VSize > 1460)
641 && (u16Input_VSize < 1480)) //1280x1470 p frame packing
642 {
643 u16SrcType = QM_HDMI_FP_720p_Main;
644 }
645 else
646 #endif
647 // 1500 is for framepacking case vsize 2205
648 if ((u16Input_VFreq > 550) || (u16Input_VSize > 1500))
649 {
650 u16SrcType = QM_HDMI_1080p_60hz_Main;
651 }
652 else if(u16Input_VFreq > GateFor30P)
653 {
654 u16SrcType = QM_HDMI_1080p_50hz_Main;
655 }
656 else // Other timing
657 {
658 u16SrcType = QM_HDMI_1080p_24hz_Main;
659 }
660 }
661 }
662 }
663 #endif
664 }
665 else if (QM_IsSourceYPbPr(enInputSourceType))
666 {
667 #if (PQ_QM_YPBPR)
668 if( QM_IsSourceYPbPr(enInputSourceType) &&
669 (MDrv_PQ_Get_PointToPoint_U2(pInstance,eWindow)) && (!bIsInterlaced))
670 {
671 // YUV444 progressive
672 u16SrcType = QM_HDMI_444_PC_Hno_Vno_Main;
673 }
674 else if (QM_IsYPbPr_720x480_60I(eWindow)){
675 u16SrcType = QM_YPbPr_480i_Main;
676 }
677 else if (QM_IsYPbPr_720x480_60P(eWindow)){
678 u16SrcType = QM_YPbPr_480p_Main;
679 }
680 else if (QM_IsYPbPr_720x576_50I(eWindow)){
681 u16SrcType = QM_YPbPr_576i_Main;
682 }
683 else if (QM_IsYPbPr_720x576_50P(eWindow)){
684 u16SrcType = QM_YPbPr_576p_Main;
685 }
686 else if (QM_IsYPbPr_1280x720_50P(eWindow)){
687 u16SrcType = QM_YPbPr_720p_50hz_Main;
688 }
689 else if (QM_IsYPbPr_1280x720_60P(eWindow)){
690 u16SrcType = QM_YPbPr_720p_60hz_Main;
691 }
692 else if (QM_IsYPbPr_1920x1080_50I(eWindow)){
693 u16SrcType = QM_YPbPr_1080i_50hz_Main;
694 }
695 else if (QM_IsYPbPr_1920x1080_60I(eWindow)){
696 u16SrcType = QM_YPbPr_1080i_60hz_Main;
697 }
698 else if (QM_IsYPbPr_1920x1080_24P(eWindow) || QM_IsYPbPr_1920x1080_30P(eWindow) || QM_IsYPbPr_1920x1080_25P(eWindow) ){
699 u16SrcType = QM_YPbPr_1080p_24hz_Main;
700 }
701 else if (QM_IsYPbPr_1920x1080_50P(eWindow)){
702 u16SrcType = QM_YPbPr_1080p_50hz_Main;
703 }
704 else if (QM_IsYPbPr_1920x1080_60P(eWindow)){
705 u16SrcType = QM_YPbPr_1080p_60hz_Main;
706 }
707 else {
708 u16SrcType = QM_YPbPr_720p_24hz_Main;
709 }
710 #endif
711 }
712 else if (QM_IsSourceDTV(enInputSourceType))
713 {
714 #if (PQ_QM_DTV)
715 if(QM_IsDTV_IFRAME(eWindow))
716 {
717 #if 1 //( CHIP_FAMILY_TYPE != CHIP_FAMILY_S7J)
718 //If PQ has devide the iframe setting according to P/I mode, then use new PQ srctype
719 if (u16Input_VSize < 720)
720 {
721 if (bIsInterlaced)
722 u16SrcType = QM_DTV_iFrame_SD_interlace_Main;
723 else
724 u16SrcType = QM_DTV_iFrame_SD_progressive_Main;
725 }
726 else
727 {
728 if (bIsInterlaced)
729 u16SrcType = QM_DTV_iFrame_HD_interlace_Main;
730 else
731 u16SrcType = QM_DTV_iFrame_HD_progressive_Main;
732 }
733 #else
734 u16SrcType = QM_DTV_iFrame_Main;
735 #endif
736 }
737 else if (QM_IsDTV_MPEG2(eWindow))
738 {
739 if (u16Input_VSize < 500)
740 {
741 if ((u16Input_HSize < 400) && bIsInterlaced)
742 {
743 u16SrcType = QM_DTV_480i_352x480_MPEG2_Main;
744 }
745 else
746 {
747 if (bIsInterlaced)
748 u16SrcType = QM_DTV_480i_MPEG2_Main;
749 else
750 u16SrcType = QM_DTV_480p_MPEG2_Main;
751 }
752 }
753 else if (u16Input_VSize < 650)
754 {
755 if (bIsInterlaced)
756 u16SrcType = QM_DTV_576i_MPEG2_Main;
757 else
758 u16SrcType = QM_DTV_576p_MPEG2_Main;
759 }
760 else if ((u16Input_VSize < 900) && (bIsInterlaced==0))
761 {
762 if (u16Input_VFreq > 550)
763 {
764 u16SrcType = QM_DTV_720p_60hz_MPEG2_Main;
765 }
766 else if(u16Input_VFreq > 250)
767 {
768 u16SrcType = QM_DTV_720p_50hz_MPEG2_Main;
769 }
770 else
771 {
772 u16SrcType = QM_DTV_720p_24hz_MPEG2_Main;
773 }
774 }
775 else
776 {
777 if (bIsInterlaced)
778 {
779 #if PQ_QM_DTV_4K2K
780 if(PQ_IS_DTV_4K_INPUT(u16Input_HSize,u16Input_VSize)) // 4K2K case
781 {
782 #if (PQ_QM_4K2K_60Hz)
783 if(u16Input_VFreq > GateFor30P)
784 u16SrcType = QM_DTV_4K2K_60Hz_MPEG2_Main;
785 else
786 #endif
787 u16SrcType = QM_DTV_4K2K_MPEG2_Main;
788 }
789 else
790 #endif
791 if (u16Input_VFreq > 550)
792 {
793 u16SrcType = QM_DTV_1080i_60hz_MPEG2_Main;
794 }
795 else
796 {
797 u16SrcType = QM_DTV_1080i_50hz_MPEG2_Main;
798 }
799 }
800 else
801 {
802 #if PQ_QM_DTV_4K2K
803 if(PQ_IS_DTV_4K_INPUT(u16Input_HSize,u16Input_VSize)) // 4K2K case
804 {
805 #if (PQ_QM_4K2K_60Hz)
806 if(u16Input_VFreq > GateFor30P)
807 u16SrcType = QM_DTV_4K2K_60Hz_MPEG2_Main;
808 else
809 #endif
810 u16SrcType = QM_DTV_4K2K_MPEG2_Main;
811 }
812 else
813 #endif
814 if (u16Input_VFreq > 550)
815 {
816 u16SrcType = QM_DTV_1080p_60hz_MPEG2_Main;
817 }
818 else if(u16Input_VFreq > 250)
819 {
820 u16SrcType = QM_DTV_1080p_50hz_MPEG2_Main;
821 }
822 else
823 {
824 u16SrcType = QM_DTV_1080p_24hz_MPEG2_Main;
825 }
826
827 }
828 }
829 }
830 else // QM_IsDTV_H264(eWindow)
831 {
832 if ((u16Input_HSize < 1260) && (u16Input_VSize < 650))
833 {
834 if (u16Input_VSize < 500)
835 {
836 if ((u16Input_HSize < 400) && bIsInterlaced)
837 {
838 u16SrcType = QM_DTV_480i_352x480_H264_Main;
839 }
840 else
841 {
842 if (bIsInterlaced)
843 u16SrcType = QM_DTV_480i_H264_Main;
844 else
845 u16SrcType = QM_DTV_480p_H264_Main;
846 }
847 }
848 else
849 {
850 if (bIsInterlaced)
851 u16SrcType = QM_DTV_576i_H264_Main;
852 else
853 u16SrcType = QM_DTV_576p_H264_Main;
854 }
855 }
856 else
857 {
858 if ((u16Input_VSize < 900) && (bIsInterlaced==0))
859 {
860 if (u16Input_VFreq > 550)
861 {
862 u16SrcType = QM_DTV_720p_60hz_H264_Main;
863 }
864 else if(u16Input_VFreq > 250)
865 {
866 u16SrcType = QM_DTV_720p_50hz_H264_Main;
867 }
868 else
869 {
870 u16SrcType = QM_DTV_720p_24hz_H264_Main;
871 }
872 }
873 else
874 {
875 if (bIsInterlaced)
876 {
877 #if PQ_QM_DTV_4K2K
878 if(PQ_IS_DTV_4K_INPUT(u16Input_HSize,u16Input_VSize)) // 4K2K case
879 {
880 #if (PQ_QM_4K2K_60Hz)
881 if(u16Input_VFreq > GateFor30P)
882 u16SrcType = QM_DTV_4K2K_60Hz_H264_Main;
883 else
884 #endif
885 u16SrcType = QM_DTV_4K2K_H264_Main;
886 }
887 else
888 #endif
889 if (u16Input_VFreq > 550)
890 {
891 u16SrcType = QM_DTV_1080i_60hz_H264_Main;
892 }
893 else
894 {
895 u16SrcType = QM_DTV_1080i_50hz_H264_Main;
896 }
897 }
898 else
899 {
900 #if PQ_QM_DTV_4K2K
901 if(PQ_IS_DTV_4K_INPUT(u16Input_HSize,u16Input_VSize)) // 4K2K case
902 {
903 #if (PQ_QM_4K2K_60Hz)
904 if(u16Input_VFreq > GateFor30P)
905 u16SrcType = QM_DTV_4K2K_60Hz_H264_Main;
906 else
907 #endif
908 u16SrcType = QM_DTV_4K2K_H264_Main;
909 }
910 else
911 #endif
912 if (u16Input_VFreq > 550)
913 {
914 u16SrcType = QM_DTV_1080p_60hz_H264_Main;
915 }
916 else if(u16Input_VFreq > 250)
917 {
918 u16SrcType = QM_DTV_1080p_50hz_H264_Main;
919 }
920 else
921 {
922 u16SrcType = QM_DTV_1080p_24hz_H264_Main;
923 }
924 }
925 }
926 }
927 }
928 #endif
929 }
930 else if (QM_IsSourceMultiMedia(enInputSourceType))
931 {
932 #if (PQ_QM_MM_VIDEO) || (PQ_QM_MM_PHOTO)
933 #if PQ_QM_NETMM_VIDEO
934 if(_gIsNetworkMM)
935 {
936 if ((u16Input_HSize <= 720) && (u16Input_VSize <= 576))
937 {
938 if (bIsInterlaced)
939 {
940 u16SrcType = QM_Multimedia_video_online_SD_interlace_Main;
941 }
942 else
943 {
944 if(u16Input_VFreq > GateFor30P)
945 {
946 u16SrcType = QM_Multimedia_video_online_SD_progressive_Main;
947 }
948 else
949 {
950 u16SrcType = QM_Multimedia_video_online_SD_progressive_24hz_Main;
951 }
952 }
953 }
954 else
955 {
956 if (bIsInterlaced)
957 {
958 u16SrcType = QM_Multimedia_video_online_HD_interlace_Main;
959 }
960 else
961 {
962 if(u16Input_VFreq > GateFor30P)
963 {
964 u16SrcType = QM_Multimedia_video_online_HD_progressive_Main;
965 }
966 else
967 {
968 u16SrcType = QM_Multimedia_video_online_HD_progressive_24hz_Main;
969 }
970 }
971 }
972 }
973 else
974 #endif
975 #if ((defined (ANDROID)||defined(MSOS_TYPE_LINUX_KERNEL)) && defined(UFO_XC_DS_PQ))
976 if(MApi_XC_Is_SupportSWDS())
977 {
978 _stMultiMedia_Info[eWindow].eType = E_PQ_MULTIMEDIA_MOVIE;
979 }
980 #endif
981 if (QM_IsMultiMediaMOVIE(eWindow))
982 {
983 #if PQ_QM_HDMI_FP_VIDEO
984 if((u16Input_HSize > 1910)
985 && (u16Input_HSize < 1930)
986 && (u16Input_VSize > 2218)
987 && (u16Input_VSize < 2238)) //1920x2228 i frame packing
988 {
989 u16SrcType = QM_HDMI_FP_1080i_Main;
990 }
991 else if(((u16Input_HSize > 1430) && (u16Input_HSize < 1450))
992 && (((u16Input_VSize > 591) && (u16Input_VSize < 611)) || ((u16Input_VSize > 493) && (u16Input_VSize < 513))))
993 {
994 u16SrcType = QM_HDMI_FP_1080i_Main;
995 }
996 else if((u16Input_HSize > 1910)
997 && (u16Input_HSize < 1930)
998 && (u16Input_VSize > 2195)
999 && (u16Input_VSize < 2215)) //1920x2205 p frame packing
1000 {
1001 u16SrcType = QM_HDMI_FP_1080p_Main;
1002 }
1003 else if((u16Input_HSize > 1270)
1004 && (u16Input_HSize < 1290)
1005 && (u16Input_VSize > 1460)
1006 && (u16Input_VSize < 1480)) //1280x1470 p frame packing
1007 {
1008 u16SrcType = QM_HDMI_FP_720p_Main;
1009 }
1010 else
1011 #endif
1012
1013 if ((u16Input_HSize <= 720) && (u16Input_VSize <= 576))
1014 {
1015 if (bIsInterlaced)
1016 {
1017 u16SrcType = QM_Multimedia_video_SD_interlace_Main;
1018 }
1019 else
1020 {
1021 #if PQ_QM_24HZMM_VIDEO
1022 if(u16Input_VFreq > GateFor30P)
1023 {
1024 u16SrcType = QM_Multimedia_video_SD_progressive_Main;
1025 }
1026 else
1027 {
1028 u16SrcType = QM_Multimedia_video_SD_progressive_24hz_Main;
1029 }
1030 #else
1031 u16SrcType = QM_Multimedia_video_SD_progressive_Main;
1032 #endif
1033 }
1034 }
1035 else
1036 {
1037 if (bIsInterlaced)
1038 {
1039 u16SrcType = QM_Multimedia_video_HD_interlace_Main;
1040 }
1041 else
1042 {
1043 #if PQ_QM_24HZMM_VIDEO
1044 #if (PQ_QM_4K2K)
1045 if(_gIsMVC4kx1k)
1046 {
1047 u16SrcType = QM_Multimedia_video_4K2K_FS_progressive_Main;
1048 }
1049 else
1050 #endif
1051 if(u16Input_VFreq > GateFor30P)
1052 {
1053 u16SrcType = QM_Multimedia_video_HD_progressive_Main;
1054 }
1055 else
1056 {
1057 u16SrcType = QM_Multimedia_video_HD_progressive_24hz_Main;
1058 }
1059 #else
1060 #if (PQ_QM_4K2K)
1061 if(_gIsMVC4kx1k)
1062 {
1063 u16SrcType = QM_Multimedia_video_4K2K_FS_progressive_Main;
1064 }
1065 else
1066 #endif
1067 {
1068 u16SrcType = QM_Multimedia_video_HD_progressive_Main;
1069 }
1070 #endif
1071
1072 #if (PQ_QM_4K2K)
1073 if((u16Input_HSize > 3800) && (u16Input_VSize > 1050) && (u16Input_VSize < 1900))
1074 {
1075 //#if(ENABLE_4K2K_NIKEU == 1)
1076 //u16SrcType = QM_MM_4K1K_Main;
1077 //#else
1078 #if (PQ_QM_4K2K_60Hz)
1079 if(u16Input_VFreq > GateFor30P)
1080 u16SrcType = QM_MM_4K2K_60Hz_Main;
1081 else
1082 #endif
1083 u16SrcType = QM_MM_4K2K_Main;
1084 //#endif
1085 }
1086 else if(PQ_IS_4K2K_INPUT(u16Input_HSize,u16Input_VSize))
1087 {
1088 #if (PQ_QM_4K2K_60Hz)
1089 if(u16Input_VFreq > GateFor30P)
1090 u16SrcType = QM_MM_4K2K_60Hz_Main;
1091 else
1092 #endif
1093 u16SrcType = QM_MM_4K2K_Main;
1094 }
1095 #endif
1096 }
1097 }
1098 }
1099 else //QM_IsMultiMediaPHOTO(eWindow)
1100 {
1101 if ((u16Input_HSize <= 720) && (u16Input_VSize <= 576))
1102 {
1103 u16SrcType = QM_Multimedia_photo_SD_progressive_Main;
1104 }
1105 #if (PQ_QM_4K2K)
1106 ///for 4K photo
1107 else if((u16Input_HSize < 1500) && (u16Input_VSize >= 1900) )
1108 {
1109 u16SrcType = QM_MM_non_4K2K_Main;
1110 }
1111 else if((u16Input_HSize > 3800) && (u16Input_VSize > 1050))
1112 {
1113 u16SrcType = QM_MM_4K2K_Photo_Main;
1114 }
1115 #endif
1116 else
1117 {
1118 u16SrcType = QM_Multimedia_photo_HD_progressive_Main;
1119 }
1120 }
1121 #endif
1122 }
1123 else if (QM_IsSourceScartCVBS(enInputSourceType, eWindow) || QM_IsSourceScartRGB(enInputSourceType, eWindow))
1124 {
1125 #if (PQ_QM_CVBS)
1126 eStandard = QM_GetATVStandard(eWindow);
1127 switch(eStandard)
1128 {
1129 case E_PQ_VIDEOSTANDARD_PAL_M:
1130 u16SrcType = QM_SCART_AV_PAL_M_Main;
1131 break;
1132 case E_PQ_VIDEOSTANDARD_PAL_N:
1133 u16SrcType = QM_SCART_AV_PAL_N_Main;
1134 break;
1135 case E_PQ_VIDEOSTANDARD_NTSC_44:
1136 u16SrcType = QM_SCART_AV_NTSC_44_Main;
1137 break;
1138 case E_PQ_VIDEOSTANDARD_PAL_60:
1139 u16SrcType = QM_SCART_AV_PAL_60_Main;
1140 break;
1141 case E_PQ_VIDEOSTANDARD_NTSC_M:
1142 u16SrcType = QM_SCART_AV_NTSC_M_Main;
1143 break;
1144 case E_PQ_VIDEOSTANDARD_SECAM:
1145 u16SrcType = QM_SCART_AV_SECAM_Main;
1146 break;
1147 case E_PQ_VIDEOSTANDARD_PAL_BGHI:
1148 default:
1149 u16SrcType = QM_SCART_AV_PAL_BGHI_Main;
1150 break;
1151 }
1152 #endif
1153 }
1154 else if (QM_IsSourceATV(enInputSourceType))
1155 {
1156 #if (PQ_QM_CVBS)
1157 eStandard = QM_GetATVStandard(eWindow);
1158 if (QM_FRONTEND_RFIN(eWindow))
1159 {
1160 switch(eStandard)
1161 {
1162 case E_PQ_VIDEOSTANDARD_PAL_M:
1163 u16SrcType = QM_RF_PAL_M_Main;
1164 break;
1165 case E_PQ_VIDEOSTANDARD_PAL_N:
1166 u16SrcType = QM_RF_PAL_N_Main;
1167 break;
1168 case E_PQ_VIDEOSTANDARD_NTSC_44:
1169 u16SrcType = QM_RF_NTSC_44_Main;
1170 break;
1171 case E_PQ_VIDEOSTANDARD_PAL_60:
1172 u16SrcType = QM_RF_PAL_60_Main;
1173 break;
1174 case E_PQ_VIDEOSTANDARD_NTSC_M:
1175 u16SrcType = QM_RF_NTSC_M_Main;
1176 break;
1177 case E_PQ_VIDEOSTANDARD_SECAM:
1178 u16SrcType = QM_RF_SECAM_Main;
1179 break;
1180 case E_PQ_VIDEOSTANDARD_PAL_BGHI:
1181 default:
1182 u16SrcType = QM_RF_PAL_BGHI_Main;
1183 break;
1184 }
1185 }
1186 else // QM_FRONTEND_VIFIN(eWindow)
1187 {
1188 switch(eStandard)
1189 {
1190 case E_PQ_VIDEOSTANDARD_PAL_M:
1191 u16SrcType = QM_VIF_PAL_M_Main;
1192 break;
1193 case E_PQ_VIDEOSTANDARD_PAL_N:
1194 u16SrcType = QM_VIF_PAL_N_Main;
1195 break;
1196 case E_PQ_VIDEOSTANDARD_NTSC_44:
1197 u16SrcType = QM_VIF_NTSC_44_Main;
1198 break;
1199 case E_PQ_VIDEOSTANDARD_PAL_60:
1200 u16SrcType = QM_VIF_PAL_60_Main;
1201 break;
1202 case E_PQ_VIDEOSTANDARD_NTSC_M:
1203 u16SrcType = QM_VIF_NTSC_M_Main;
1204 break;
1205 case E_PQ_VIDEOSTANDARD_SECAM:
1206 u16SrcType = QM_VIF_SECAM_Main;
1207 break;
1208 case E_PQ_VIDEOSTANDARD_PAL_BGHI:
1209 default:
1210 u16SrcType = QM_VIF_PAL_BGHI_Main;
1211 break;
1212 }
1213 }
1214 #endif
1215 }
1216 else if (QM_IsSourceSV(enInputSourceType))
1217 {
1218 #if (PQ_QM_CVBS)
1219 eStandard = QM_GetATVStandard(eWindow);
1220 switch(eStandard)
1221 {
1222 case E_PQ_VIDEOSTANDARD_PAL_M:
1223 u16SrcType = QM_SV_PAL_M_Main;
1224 break;
1225 case E_PQ_VIDEOSTANDARD_PAL_N:
1226 u16SrcType = QM_SV_PAL_N_Main;
1227 break;
1228 case E_PQ_VIDEOSTANDARD_NTSC_44:
1229 u16SrcType = QM_SV_NTSC_44_Main;
1230 break;
1231 case E_PQ_VIDEOSTANDARD_PAL_60:
1232 u16SrcType = QM_SV_PAL_60_Main;
1233 break;
1234 case E_PQ_VIDEOSTANDARD_NTSC_M:
1235 u16SrcType = QM_SV_NTSC_M_Main;
1236 break;
1237 case E_PQ_VIDEOSTANDARD_SECAM:
1238 u16SrcType = QM_SV_SECAM_Main;
1239 break;
1240 case E_PQ_VIDEOSTANDARD_PAL_BGHI:
1241 default:
1242 u16SrcType = QM_SV_PAL_BGHI_Main;
1243 break;
1244 }
1245 #endif
1246 }
1247 else // AV
1248 {
1249 #if (PQ_QM_CVBS)
1250 eStandard = QM_GetATVStandard(eWindow);
1251 switch(eStandard)
1252 {
1253 case E_PQ_VIDEOSTANDARD_PAL_M:
1254 u16SrcType = QM_AV_PAL_M_Main;
1255 break;
1256 case E_PQ_VIDEOSTANDARD_PAL_N:
1257 u16SrcType = QM_AV_PAL_N_Main;
1258 break;
1259 case E_PQ_VIDEOSTANDARD_NTSC_44:
1260 u16SrcType = QM_AV_NTSC_44_Main;
1261 break;
1262 case E_PQ_VIDEOSTANDARD_PAL_60:
1263 u16SrcType = QM_AV_PAL_60_Main;
1264 break;
1265 case E_PQ_VIDEOSTANDARD_NTSC_M:
1266 u16SrcType = QM_AV_NTSC_M_Main;
1267 break;
1268 case E_PQ_VIDEOSTANDARD_SECAM:
1269 u16SrcType = QM_AV_SECAM_Main;
1270 break;
1271 case E_PQ_VIDEOSTANDARD_PAL_BGHI:
1272 default:
1273 u16SrcType = QM_AV_PAL_BGHI_Main;
1274 break;
1275 }
1276 #endif
1277 }
1278
1279 #ifdef PQ_CFD_INFO
1280 ST_PQ_CFD_ANALOG stCfdAnalog;
1281 memset(&stCfdAnalog, 0, sizeof(ST_PQ_CFD_ANALOG));
1282 stCfdAnalog.u32Version = CFD_ANALOG_VERSION;
1283 stCfdAnalog.u16Length = sizeof(ST_PQ_CFD_ANALOG);
1284 stCfdAnalog.u8Win = eWindow;
1285 if (Hal_PQ_get_cfd_info(u16SrcType, &stCfdAnalog.u8ColorFormat, &stCfdAnalog.u8ColorDataFormat, &stCfdAnalog.bIsFullRange, &stCfdAnalog.u8ColorPrimaries, &stCfdAnalog.u8TransferCharacteristics, &stCfdAnalog.u8MatrixCoefficients) == TRUE)
1286 {
1287 if (QM_IsSourceVGA(enInputSourceType))
1288 {
1289 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_VGA, &stCfdAnalog, sizeof(ST_PQ_CFD_ANALOG));
1290 }
1291 else if (QM_IsSourceATV(enInputSourceType))
1292 {
1293 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_TV, &stCfdAnalog, sizeof(ST_PQ_CFD_ANALOG));
1294 }
1295 else if (QM_IsSourceAV(enInputSourceType))
1296 {
1297 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_CVBS, &stCfdAnalog, sizeof(ST_PQ_CFD_ANALOG));
1298 }
1299 else if (QM_IsSourceSV(enInputSourceType))
1300 {
1301 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_SVIDEO, &stCfdAnalog, sizeof(ST_PQ_CFD_ANALOG));
1302 }
1303 else if (QM_IsSourceYPbPr(enInputSourceType))
1304 {
1305 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_YPBPR, &stCfdAnalog, sizeof(ST_PQ_CFD_ANALOG));
1306 }
1307 else if (QM_IsSourceScart(enInputSourceType))
1308 {
1309 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_SCART, &stCfdAnalog, sizeof(ST_PQ_CFD_ANALOG));
1310 }
1311 else if (QM_IsSourceDVI_HDMIPC(enInputSourceType, eWindow))
1312 {
1313 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_DVI, &stCfdAnalog, sizeof(ST_PQ_CFD_ANALOG));
1314 }
1315 }
1316 #endif
1317
1318 return u16SrcType;
1319 }
1320
1321 #ifdef UFO_XC_PQ_SUPPORT_REPEATER_COLOR_THROUGH_MODE
MDrv_PQ_SetColorThroughMode_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEn)1322 void MDrv_PQ_SetColorThroughMode_U2(void* pInstance, PQ_WIN eWindow, MS_BOOL bEn)
1323 {
1324 _gIsThroughMode = bEn;
1325 }
1326
MDrv_PQ_SetColorThroughMode(PQ_WIN eWindow,MS_BOOL bEn)1327 void MDrv_PQ_SetColorThroughMode(PQ_WIN eWindow, MS_BOOL bEn)
1328 {
1329 #ifdef TRACE_DBG
1330 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
1331 #endif
1332 if (pu32PQInst == NULL)
1333 {
1334 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
1335 return ;
1336 }
1337
1338 stPQ_SetColorThroughMode PQArgs;
1339 PQArgs.eWindow = eWindow;
1340 PQArgs.bEn = bEn;
1341 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_COLOR_THROUGH_MODE, (void*)&PQArgs) != 0)
1342 {
1343 printf("Obtain PQ engine fail\n");
1344 return;
1345 }
1346 else
1347 {
1348 return;
1349 }
1350 }
1351 #endif
1352
1353
QM_InputSourceToIndex_UFSC(void * pInstance,PQ_WIN eWindow,MS_U8 enInputSourceType)1354 MS_U16 QM_InputSourceToIndex_UFSC(void* pInstance,PQ_WIN eWindow, MS_U8 enInputSourceType)
1355 {
1356 MS_U16 u16SrcType = 0;
1357 #if defined(ENABLE_PQ_BIN_UFSC) && ENABLE_PQ_BIN_UFSC
1358 MS_U16 u16Input_HSize = QM_GetInputHSize(eWindow);
1359 MS_U16 u16Input_VSize = QM_GetInputVSize(eWindow);
1360 MS_BOOL bRGB444 = FALSE, bYUV422 = FALSE;
1361
1362 XC_ApiStatusEx stDrvStatusEx;
1363 memset(&stDrvStatusEx, 0, sizeof(XC_ApiStatusEx));
1364 stDrvStatusEx.u16ApiStatusEX_Length = sizeof(XC_ApiStatusEx);
1365 stDrvStatusEx.u32ApiStatusEx_Version = API_STATUS_EX_VERSION;
1366 MApi_XC_GetStatusEx(&stDrvStatusEx, MAIN_WINDOW);
1367 if (stDrvStatusEx.bMemYUVFmt)
1368 {
1369 if (stDrvStatusEx.bMemFmt422)
1370 {
1371 bYUV422 = TRUE;
1372 }
1373 }
1374 else
1375 {
1376 bRGB444 = TRUE;
1377 }
1378
1379 #if(ENABLE_PQ_UFSC_DLC)
1380 if(E_XC_3D_OUTPUT_MODE_NONE != MApi_XC_Get_3D_Output_Mode())
1381 {
1382 u16SrcType = QM_FSC_3D_UFSC; /// 3d
1383 }
1384 else
1385 #endif
1386 if(
1387 ((MDrv_PQBin_GetPanelIdx_UFSC(pInstance)==PQ_BIN_PNLTYPE_4K2K) && (MDrv_PQ_GetPQPathStatus(E_PQ_UFSC_4K_PATH, u16Input_HSize, u16Input_VSize))) ||
1388 (!(MDrv_PQBin_GetPanelIdx_UFSC(pInstance)==PQ_BIN_PNLTYPE_4K2K) )
1389 )
1390 {
1391 #if(ENABLE_PQ_UFSC_BYPASS)
1392 #if (PQ_QM_DTV)
1393 if((QM_IsSourceDTV(enInputSourceType)) && (QM_IsDTV_IFRAME(eWindow)))
1394 {
1395 u16SrcType = QM_4K2K_PQbypass_UFSC; //QM_4K2K_PQbypass_UFSC
1396 }
1397 else
1398 #endif
1399 #endif
1400 {
1401 if (bRGB444)
1402 {
1403 if( MApi_XC_GetDynamicScalingStatus())
1404 {
1405 u16SrcType = QM_4K2K_RGB444_DS_UFSC;//4K2K_RGB444_DS
1406 }
1407 else
1408 {
1409 u16SrcType = QM_4K2K_RGB444_UFSC; //4K2K_RGB444
1410 }
1411 }
1412 else if (bYUV422)
1413 {
1414 if( MApi_XC_GetDynamicScalingStatus())
1415 {
1416 u16SrcType = QM_4K2K_YUV422_DS_UFSC;//4K2K_YUV422_DS
1417 }
1418 else
1419 {
1420 u16SrcType = QM_4K2K_YUV422_UFSC; //4K2K_YUV422
1421 }
1422 }
1423 else
1424 {
1425 if( MApi_XC_GetDynamicScalingStatus())
1426 {
1427 u16SrcType = QM_4K2K_YUV444_DS_UFSC;//4K2K_YUV444_DS
1428 }
1429 else
1430 {
1431 u16SrcType = QM_4K2K_YUV444_UFSC; //4K2K_YUV444
1432 }
1433 }
1434 }
1435 }
1436 else
1437 {
1438 #if(ENABLE_PQ_UFSC_BYPASS)
1439 #if (PQ_QM_DTV)
1440 if((QM_IsSourceDTV(enInputSourceType)) && (QM_IsDTV_IFRAME(eWindow)))
1441 {
1442 u16SrcType = QM_FHD_PQBypass_UFSC; //QM_FHD_PQBypass_UFSC
1443 }
1444 else
1445 #endif
1446 #endif
1447 {
1448 if (bRGB444)
1449 {
1450 if( MApi_XC_GetDynamicScalingStatus())
1451 {
1452 u16SrcType = QM_FHD_RGB444_DS_UFSC; //FHD_RGB444_DS
1453 }
1454 else
1455 {
1456 u16SrcType = QM_FHD_RGB444_UFSC; //FHD_RGB444
1457 }
1458 }
1459 else if (bYUV422)
1460 {
1461 if( MApi_XC_GetDynamicScalingStatus())
1462 {
1463 u16SrcType = QM_FHD_YUV422_DS_UFSC; //FHD_YUV422_DS
1464 }
1465 else
1466 {
1467 u16SrcType = QM_FHD_YUV422_UFSC; //FHD_YUV422
1468 }
1469 }
1470 else
1471 {
1472 if( MApi_XC_GetDynamicScalingStatus())
1473 {
1474 u16SrcType = QM_FHD_YUV444_DS_UFSC; //FHD_YUV444_DS
1475 }
1476 else
1477 {
1478 u16SrcType = QM_FHD_YUV444_UFSC; //FHD_YUV444
1479 }
1480 }
1481 }
1482 }
1483 printf("[Load UFSC PQ] Source index=%d\n", u16SrcType);
1484 #endif
1485 return u16SrcType;
1486 }
1487 #if (ENABLE_PQ_BIN_CF)
QM_InputSourceToIndex_CF(void * pInstance,PQ_WIN eWindow,MS_U8 enInputSourceType)1488 MS_U16 QM_InputSourceToIndex_CF(void* pInstance,PQ_WIN eWindow, MS_U8 enInputSourceType)
1489 {
1490 MS_U16 u16SrcType = 0;
1491
1492 #if (CFD_STATUS_VERSION >=2)
1493 XC_CFD_STATUS stCfdStatus;
1494 memset(&stCfdStatus, 0, sizeof(XC_CFD_STATUS));
1495 stCfdStatus.u32Version=CFD_STATUS_VERSION;
1496 stCfdStatus.u16Length=sizeof(XC_CFD_STATUS);
1497 stCfdStatus.u8Win=eWindow;
1498
1499 XC_CFD_CONTROL_INFO stCfdCtrlInfo;
1500 memset(&stCfdCtrlInfo, 0, sizeof(XC_CFD_CONTROL_INFO));
1501 stCfdCtrlInfo.enCtrlType = E_XC_CFD_CTRL_TYPE_STATUS;
1502 stCfdCtrlInfo.pParam = &stCfdStatus;
1503 stCfdCtrlInfo.u32ParamLen = sizeof(XC_CFD_STATUS);
1504 MApi_XC_HDR_Control(E_XC_HDR_CTRL_CFD_CONTROL, &stCfdCtrlInfo);
1505
1506 u16SrcType=stCfdStatus.u8ColorType;
1507 printf("[Load CF PQ] Source index=%d\n", u16SrcType);
1508 #else
1509 printf("Wrong Color format type, Please check CFD_STATUS_VERSION\n");
1510 #endif
1511 return u16SrcType;
1512 }
1513 #endif
1514 #if PQ_GRULE_OSD_BW_ENABLE
_MDrv_PQ_LoadOSD_BWTable(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_OSD_BW_Idx)1515 static void _MDrv_PQ_LoadOSD_BWTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_OSD_BW_Idx)
1516 {
1517 MS_U16 i, u16IPIdx = 0, u16TabIdx = 0;
1518
1519 if(u16PQ_OSD_BW_Idx > PQ_GRULE_OSD_BW_NUM_Main)
1520 {
1521 MS_ASSERT(0);
1522 return;
1523 }
1524
1525 for(i = 0; i < PQ_GRULE_OSD_BW_IP_NUM_Main; i++)
1526 {
1527 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, i);
1528
1529 if(u16PQ_OSD_BW_Idx == PQ_GRULE_OSD_BW_NUM_Main) // see it as default
1530 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
1531 else
1532 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSD_BW_Idx, i);
1533
1534 PQGRULE_DBG(printf("[NR]SRC: %u, NR: %u, NRIPIdx:%u, IPIdx:%u, u8TabIdx:%u\n",
1535 _u16PQSrcType[eWindow], u16PQ_OSD_BW_Idx, i, u16IPIdx, u16IPIdx));
1536
1537 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
1538 }
1539 }
1540
1541
MDrv_PQ_LoadOSD_BWTable(void * pInstance,PQ_WIN eWindow,PQ_OSD_BW_FUNCTION_TYPE enOSD_BW_Type)1542 void MDrv_PQ_LoadOSD_BWTable(void* pInstance, PQ_WIN eWindow, PQ_OSD_BW_FUNCTION_TYPE enOSD_BW_Type)
1543 {
1544 PQGRULE_DBG(printf("[PQ_Load_OSD_BW_Table] "));
1545 MS_U16 u16PQ_NRIdx;
1546
1547 if(enOSD_BW_Type == PQ_OSD_BW_ON)
1548 {
1549 PQGRULE_DBG(printf("On\n"));
1550
1551 #if (PQ_OSD_BW_VER == 1)
1552 #if PQ_GRULE_DDR_SELECT_ENABLE
1553 if(bw_info.u32Miu1MemSize == 0)
1554 {
1555 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_1DDR_On_Main);
1556 _MDrv_PQ_LoadOSD_BWTable(pInstance, eWindow, u16PQ_NRIdx);
1557 }
1558 else
1559 {
1560 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_2DDR_On_Main);
1561 _MDrv_PQ_LoadOSD_BWTable(pInstance, eWindow, u16PQ_NRIdx);
1562 }
1563 #else
1564 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_Main);
1565 _MDrv_PQ_LoadOSD_BWTable(pInstance, eWindow, u16PQ_NRIdx);
1566 #endif
1567 #elif (PQ_OSD_BW_VER == 2)
1568 #if PQ_GRULE_DDR_SELECT_ENABLE
1569 if(bw_info.bDDR2 == FALSE) // DDR 3
1570 {
1571 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
1572 {
1573 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR3 mirror\n"));
1574 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR3_Mirror_Main);
1575 _MDrv_PQ_LoadOSD_BWTable(pInstance, eWindow, u16PQ_NRIdx);
1576 }
1577 else
1578 {
1579 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR3 non-mirror\n"));
1580 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR3_Main);
1581 _MDrv_PQ_LoadOSD_BWTable(pInstance, eWindow, u16PQ_NRIdx);
1582 }
1583 }
1584 else // DDR 2
1585 {
1586 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
1587 {
1588 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR2 mirror\n"));
1589 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR2_Mirror_Main);
1590 _MDrv_PQ_LoadOSD_BWTable(pInstance, eWindow, u16PQ_NRIdx);
1591 }
1592 else
1593 {
1594 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR2 non-mirror\n"));
1595 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR2_Main);
1596 _MDrv_PQ_LoadOSD_BWTable(pInstance, eWindow, u16PQ_NRIdx);
1597 }
1598 }
1599 #endif
1600 #endif
1601 }
1602 else
1603 {
1604 MS_ASSERT(0);
1605 }
1606 }
1607 #endif
1608
1609 #if PQ_GRULE_FILM_MODE_ENABLE
_MDrv_PQ_LoadFilmModeTable(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_FilmModeIdx)1610 static void _MDrv_PQ_LoadFilmModeTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_FilmModeIdx)
1611 {
1612 MS_U16 i, u16IPIdx = 0, u16TabIdx = 0;
1613 if(u16PQ_FilmModeIdx > PQ_GRULE_FILM_MODE_NUM_Main)
1614 {
1615 MS_ASSERT(0);
1616 return;
1617 }
1618
1619 for(i = 0; i < PQ_GRULE_FILM_MODE_IP_NUM_Main; i++)
1620 {
1621 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_FILM_MODE_Main, i);
1622
1623 if(u16PQ_FilmModeIdx == PQ_GRULE_FILM_MODE_NUM_Main) // see it as default
1624 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16TabIdx);
1625 else
1626 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_FILM_MODE_Main, u16PQ_FilmModeIdx, i);
1627
1628 PQGRULE_DBG(printf("[FM]SRC: %u, FM: %u, FMIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
1629 _u16PQSrcType[eWindow], u16PQ_FilmModeIdx, i, u16IPIdx, u16TabIdx));
1630 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
1631 }
1632 }
1633 #endif
1634
1635
MDrv_PQ_LoadFilmModeTable_U2(void * pInstance,PQ_WIN eWindow,PQ_FILM_MODE_FUNCTION_TYPE enFilmModeType)1636 void MDrv_PQ_LoadFilmModeTable_U2(void* pInstance,PQ_WIN eWindow, PQ_FILM_MODE_FUNCTION_TYPE enFilmModeType)
1637 {
1638 #if PQ_GRULE_FILM_MODE_ENABLE
1639 MS_U16 u16PQ_FilmModeIdx;
1640
1641 if(enFilmModeType == PQ_FilmMode_OFF)
1642 {
1643 u16PQ_FilmModeIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_FILM_MODE_Main, PQ_GRule_FILM_MODE_Off_Main);
1644 _MDrv_PQ_LoadFilmModeTable(pInstance, eWindow, u16PQ_FilmModeIdx);
1645
1646 }
1647 else if(enFilmModeType == PQ_FilmMode_ON)
1648 {
1649 u16PQ_FilmModeIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_FILM_MODE_Main, PQ_GRule_FILM_MODE_On_Main);
1650 _MDrv_PQ_LoadFilmModeTable(pInstance, eWindow, u16PQ_FilmModeIdx);
1651 }
1652 else
1653 {
1654 MS_ASSERT(0);
1655 }
1656 #else
1657 UNUSED(eWindow);
1658 UNUSED(enFilmModeType);
1659 #endif
1660 }
MDrv_PQ_LoadFilmModeTable(PQ_WIN eWindow,PQ_FILM_MODE_FUNCTION_TYPE enFilmModeType)1661 void MDrv_PQ_LoadFilmModeTable(PQ_WIN eWindow, PQ_FILM_MODE_FUNCTION_TYPE enFilmModeType)
1662 {
1663 #ifdef TRACE_DBG
1664 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
1665 #endif
1666 if (pu32PQInst == NULL)
1667 {
1668 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
1669 return ;
1670 }
1671
1672 stPQ_LoadFilmModeTable PQArgs;
1673 PQArgs.eWindow = eWindow;
1674 PQArgs.enFilmModeType = enFilmModeType;
1675
1676 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_FILMMODE_TABLE, (void*)&PQArgs) != 0)
1677 {
1678 printf("Obtain PQ engine fail\n");
1679 return ;
1680 }
1681 else
1682 {
1683 return ;
1684 }
1685 }
1686
1687 #if PQ_GRULE_DYNAMIC_CONTRAST_ENABLE
_MDrv_PQ_DynamicContrastTable(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_DynContrIdx)1688 static void _MDrv_PQ_DynamicContrastTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_DynContrIdx)
1689 {
1690 MS_U16 i, u16IPIdx = 0, u16TabIdx = 0;
1691 if(u16PQ_DynContrIdx > PQ_GRULE_DYNAMIC_CONTRAST_NUM_Main)
1692 {
1693 MS_ASSERT(0);
1694 return;
1695 }
1696
1697 for(i = 0; i < PQ_GRULE_DYNAMIC_CONTRAST_IP_NUM_Main; i++)
1698 {
1699 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_DYNAMIC_CONTRAST_Main, i);
1700 #if PQ_DLC_CTL_FOR_MVC4KX1K
1701 if((_gIsMVC4kx1k == TRUE) && (u16IPIdx == PQ_IP_VIP_DLC_Main))
1702 {
1703 printf("[Grule-DynamicContrast] cannot load DLC table for MVC4kx1k\n");
1704 continue;
1705 }
1706 #endif
1707 if(u16PQ_DynContrIdx == PQ_GRULE_DYNAMIC_CONTRAST_NUM_Main) // see it as default
1708 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16TabIdx);
1709 else
1710 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DYNAMIC_CONTRAST_Main, u16PQ_DynContrIdx, i);
1711
1712 PQGRULE_DBG(printf("[DC]SRC: %u, DC: %u, DCIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
1713 _u16PQSrcType[eWindow], u16PQ_DynContrIdx, i, u16IPIdx, u16TabIdx));
1714 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
1715 }
1716 }
1717 #endif
1718
MDrv_PQ_LoadDynamicContrastTable_U2(void * pInstance,PQ_WIN eWindow,PQ_DYNAMIC_CONTRAST_FUNCTION_TYPE enDynamicContrastType)1719 void MDrv_PQ_LoadDynamicContrastTable_U2(void* pInstance,PQ_WIN eWindow, PQ_DYNAMIC_CONTRAST_FUNCTION_TYPE enDynamicContrastType)
1720 {
1721 #if PQ_GRULE_DYNAMIC_CONTRAST_ENABLE
1722 MS_U16 u16PQ_DynContrIdx;
1723
1724 if(enDynamicContrastType == PQ_DynContr_OFF)
1725 {
1726 u16PQ_DynContrIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DYNAMIC_CONTRAST_Main, PQ_GRule_DYNAMIC_CONTRAST_Off_Main);
1727 _MDrv_PQ_DynamicContrastTable(pInstance, eWindow, u16PQ_DynContrIdx);
1728 }
1729 else if(enDynamicContrastType == PQ_DynContr_ON)
1730 {
1731 u16PQ_DynContrIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DYNAMIC_CONTRAST_Main, PQ_GRule_DYNAMIC_CONTRAST_On_Main);
1732 _MDrv_PQ_DynamicContrastTable(pInstance, eWindow, u16PQ_DynContrIdx);
1733 }
1734 else
1735 {
1736 MS_ASSERT(0);
1737 }
1738 #else
1739 UNUSED(eWindow);
1740 UNUSED(enDynamicContrastType);
1741 #endif
1742 }
MDrv_PQ_LoadDynamicContrastTable(PQ_WIN eWindow,PQ_DYNAMIC_CONTRAST_FUNCTION_TYPE enDynamicContrastType)1743 void MDrv_PQ_LoadDynamicContrastTable(PQ_WIN eWindow, PQ_DYNAMIC_CONTRAST_FUNCTION_TYPE enDynamicContrastType)
1744 {
1745 #ifdef TRACE_DBG
1746 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
1747 #endif
1748 if (pu32PQInst == NULL)
1749 {
1750 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
1751 return ;
1752 }
1753
1754 stPQ_LoadDynamicContrastTable PQArgs;
1755 PQArgs.eWindow =eWindow;
1756 PQArgs.enDynamicContrastType = enDynamicContrastType;
1757
1758 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_DYNAMIC_CONTRAST_TABLE, (void*)&PQArgs) != 0)
1759 {
1760 printf("Obtain PQ engine fail\n");
1761 return ;
1762 }
1763 else
1764 {
1765 return ;
1766 }
1767 }
1768
1769 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE || (ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE && PQ_ENABLE_PIP)
_MDrv_PQ_LoadCustomerNRTable(PQ_WIN eWindow,MS_U16 u16PQ_NRIdx)1770 static void _MDrv_PQ_LoadCustomerNRTable(PQ_WIN eWindow, MS_U16 u16PQ_NRIdx)
1771 {
1772 MS_U16 i, u16IPIdx = 0, u16TabIdx = 0;
1773
1774 // follow setgrulestatus, only load big pq or small pq, not both
1775 if ((eWindow == PQ_MAIN_WINDOW) && _bCustomerMainPQEn)
1776 {
1777 if(u16PQ_NRIdx > PQ_GRULE_NR_NUM_Main_Color)
1778 {
1779 MS_ASSERT(FALSE);
1780 return;
1781 }
1782
1783 for(i = 0; i < PQ_GRULE_NR_IP_NUM_Main_Color; i++)
1784 {
1785 u16IPIdx = MDrv_PQ_GetCustomerGRule_IPIndex(eWindow, PQ_GRule_NR_Main_Color, i);
1786
1787 if(u16PQ_NRIdx == PQ_GRULE_NR_NUM_Main_Color) // see it as default
1788 {
1789 u16TabIdx = MDrv_PQ_GetCustomerTableIndex(eWindow, u16IPIdx);
1790 }
1791 else
1792 {
1793 u16TabIdx = MDrv_PQ_GetGRule_CustomerTableIndex(eWindow, PQ_GRule_NR_Main_Color, u16PQ_NRIdx, i);
1794 }
1795 MDrv_PQ_LoadCustomerTable(eWindow, u16TabIdx, u16IPIdx);
1796 }
1797 }
1798 #if PQ_ENABLE_PIP
1799 else if ((eWindow == PQ_SUB_WINDOW) && _bCustomerSubPQEn)
1800 {
1801 if(u16PQ_NRIdx > PQ_GRULE_NR_NUM_Sub_Color)
1802 {
1803 MS_ASSERT(FALSE);
1804 return;
1805 }
1806
1807 for(i = 0; i < PQ_GRULE_NR_IP_NUM_Sub_Color; i++)
1808 {
1809 u16IPIdx = MDrv_PQ_GetCustomerGRule_IPIndex(eWindow, PQ_GRule_NR_Sub_Color, i);
1810
1811 if(u16PQ_NRIdx == PQ_GRULE_NR_NUM_Sub_Color) // see it as default
1812 {
1813 u16TabIdx = MDrv_PQ_GetCustomerTableIndex(eWindow, u16IPIdx);
1814 }
1815 else
1816 {
1817 u16TabIdx = MDrv_PQ_GetGRule_CustomerTableIndex(eWindow, PQ_GRule_NR_Sub_Color, u16PQ_NRIdx, i);
1818 }
1819 MDrv_PQ_LoadCustomerTable(eWindow, u16TabIdx, u16IPIdx);
1820 }
1821 }
1822 #endif
1823 else
1824 {
1825 PQGRULE_DBG(printf("[NR] CUSTOMER PQ Not support case \n"));
1826 }
1827
1828 }
1829 #endif
1830
_MDrv_PQ_LoadNRTable(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_NRIdx)1831 static void _MDrv_PQ_LoadNRTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_NRIdx)
1832 {
1833 MS_U16 i, u16IPIdx = 0, u16TabIdx = 0;
1834
1835 // follow setgrulestatus, only load big pq or small pq, not both
1836 if (eWindow == PQ_MAIN_WINDOW)
1837 {
1838 {
1839 if(u16PQ_NRIdx > PQ_GRULE_NR_NUM_Main)
1840 {
1841 MS_ASSERT(FALSE);
1842 return;
1843 }
1844
1845 for(i = 0; i < PQ_GRULE_NR_IP_NUM_Main; i++)
1846 {
1847 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_NR_Main, i);
1848
1849 if(u16PQ_NRIdx == PQ_GRULE_NR_NUM_Main) // see it as default
1850 {
1851 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
1852 }
1853 else
1854 {
1855 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_NR_Main, u16PQ_NRIdx, i);
1856 }
1857 PQGRULE_DBG(printf("[NR]SRC: %u, NR: %u, NRIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
1858 _u16PQSrcType[eWindow], u16PQ_NRIdx, i, u16IPIdx, u16TabIdx));
1859 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
1860 }
1861 }
1862 }
1863 #if PQ_ENABLE_PIP
1864 else if (eWindow == PQ_SUB_WINDOW)
1865 {
1866 {
1867 if(u16PQ_NRIdx > PQ_GRULE_NR_NUM_Sub)
1868 {
1869 MS_ASSERT(FALSE);
1870 return;
1871 }
1872
1873 for(i = 0; i < PQ_GRULE_NR_IP_NUM_Sub; i++)
1874 {
1875 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_NR_Sub, i);
1876
1877 if(u16PQ_NRIdx == PQ_GRULE_NR_NUM_Sub) // see it as default
1878 {
1879 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
1880 }
1881 else
1882 {
1883 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_NR_Sub, u16PQ_NRIdx, i);
1884 }
1885 PQGRULE_DBG(printf("[NR]SRC: %u, NR: %u, NRIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
1886 _u16PQSrcType[eWindow], u16PQ_NRIdx, i, u16IPIdx, u16TabIdx));
1887 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
1888 }
1889 }
1890
1891 }
1892 #endif
1893 else
1894 {
1895 PQGRULE_DBG(printf("[NR] Not support case \n"));
1896 }
1897
1898 }
1899
MDrv_PQ_LoadNRTable_U2(void * pInstance,PQ_WIN eWindow,PQ_3D_NR_FUNCTION_TYPE en3DNRType)1900 void MDrv_PQ_LoadNRTable_U2(void* pInstance,PQ_WIN eWindow, PQ_3D_NR_FUNCTION_TYPE en3DNRType)
1901 {
1902 PQGRULE_DBG(printf("[PQ_LoadNRTable] "));
1903 MS_U16 u16PQ_NRIdx = PQ_GRule_NR_Off_Main;
1904 MS_U16 u16GRuleType = PQ_GRule_NR_Main;
1905 MS_U16 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Main;
1906 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1907 MS_U16 u16CustomerPQ_NRIdx = PQ_GRule_NR_Off_Main;
1908 MS_U16 u16CustomerGRuleType = PQ_GRule_NR_Main_Color;
1909 MS_U16 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Main_Color;
1910 #endif
1911
1912 if (eWindow == PQ_MAIN_WINDOW)
1913 {
1914 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1915 u16CustomerGRuleType = PQ_GRule_NR_Main_Color + MDrv_PQ_GetGRule_GRuleNum_U2(pInstance, eWindow);
1916 #endif
1917 u16GRuleType = PQ_GRule_NR_Main;
1918
1919 if(en3DNRType == PQ_3D_NR_DEFAULT)
1920 {
1921 PQGRULE_DBG(printf("Default\n"));
1922 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
1923 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
1924 {
1925 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1926 u16CustomerPQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, u16CustomerGRuleType, PQ_GRule_Lvl_NR_Low_3D_Main_Color);
1927 #endif
1928 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, u16GRuleType, PQ_GRule_Lvl_NR_Low_3D_Main);
1929 }
1930 else
1931 #endif
1932 {
1933 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1934 u16CustomerPQ_NRIdx = PQ_GRULE_NR_NUM_Main_Color;
1935 #endif
1936 u16PQ_NRIdx = PQ_GRULE_NR_NUM_Main;
1937 }
1938 }
1939 else
1940 {
1941 if(en3DNRType == PQ_3D_NR_OFF)
1942 {
1943 PQGRULE_DBG(printf("Off\n"));
1944 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
1945 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
1946 {
1947 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1948 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Main_Color;
1949 #endif
1950 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Main;
1951 }
1952 else
1953 #endif
1954 {
1955 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1956 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Main_Color;
1957 #endif
1958 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Main;
1959 }
1960 }
1961 else if(en3DNRType == PQ_3D_NR_AUTO)
1962 {
1963 // Auto NR will be process in msAPI_DynamicNR_Handler(), hence we only need to pre-setup the PQ table.
1964 PQGRULE_DBG(printf("Auto\n"));
1965 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
1966 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
1967 {
1968 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1969 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main_Color;
1970 #endif
1971 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main;
1972 }
1973 else
1974 #endif
1975 {
1976 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1977 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Main_Color;
1978 #endif
1979 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Main;
1980 }
1981 }
1982 else if(en3DNRType == PQ_3D_NR_LOW)
1983 {
1984 PQGRULE_DBG(printf("Low\n"));
1985 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
1986 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
1987 {
1988 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1989 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main_Color;
1990 #endif
1991 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main;
1992 }
1993 else
1994 #endif
1995 {
1996 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
1997 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Main_Color;
1998 #endif
1999 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Main;
2000 }
2001 }
2002 else if(en3DNRType == PQ_3D_NR_MID)
2003 {
2004 PQGRULE_DBG(printf("Mid\n"));
2005 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2006 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2007 {
2008 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2009 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main_Color;
2010 #endif
2011 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main;
2012 }
2013 else
2014 #endif
2015 {
2016 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2017 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_Main_Color;
2018 #endif
2019 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_Main;
2020 }
2021 }
2022 else if(en3DNRType == PQ_3D_NR_HIGH)
2023 {
2024 PQGRULE_DBG(printf("High\n"));
2025 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2026 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2027 {
2028 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2029 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main_Color;
2030 #endif
2031 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main;
2032 }
2033 else
2034 #endif
2035 {
2036 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2037 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_High_Main_Color;
2038 #endif
2039 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_High_Main;
2040 }
2041 }
2042 #if (PQ_ENABLE_MULTI_LEVEL_AUTO_NR == 1)
2043 else if(en3DNRType == PQ_3D_NR_AUTO_LOW_L)
2044 {
2045 PQGRULE_DBG(printf("AUTO_LOW_L\n"));
2046 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2047 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2048 {
2049 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2050 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main_Color;
2051 #endif
2052 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main;
2053 }
2054 else
2055 #endif
2056 {
2057 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2058 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Low_L_Main_Color;
2059 #endif
2060 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Low_L_Main;
2061 }
2062 }
2063 else if(en3DNRType == PQ_3D_NR_AUTO_LOW_M)
2064 {
2065 PQGRULE_DBG(printf("AUTO_LOW_M\n"));
2066 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2067 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2068 {
2069 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2070 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main_Color;
2071 #endif
2072 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main;
2073 }
2074 else
2075 #endif
2076 {
2077 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2078 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Low_M_Main_Color;
2079 #endif
2080 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Low_M_Main;
2081 }
2082 }
2083 else if(en3DNRType == PQ_3D_NR_AUTO_LOW_H)
2084 {
2085 PQGRULE_DBG(printf("AUTO_LOW_H\n"));
2086 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2087 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2088 {
2089 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2090 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main_Color;
2091 #endif
2092 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_3D_Main;
2093 }
2094 else
2095 #endif
2096 {
2097 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2098 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Low_H_Main_Color;
2099 #endif
2100 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Low_H_Main;
2101 }
2102 }
2103 else if(en3DNRType == PQ_3D_NR_AUTO_MID_L)
2104 {
2105 PQGRULE_DBG(printf("AUTO_MID_L\n"));
2106 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2107 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2108 {
2109 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2110 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main_Color;
2111 #endif
2112 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main;
2113 }
2114 else
2115 #endif
2116 {
2117 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2118 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Middle_L_Main_Color;
2119 #endif
2120 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Middle_L_Main;
2121 }
2122 }
2123 else if(en3DNRType == PQ_3D_NR_AUTO_MID_M)
2124 {
2125 PQGRULE_DBG(printf("AUTO_MID_M\n"));
2126 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2127 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2128 {
2129 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2130 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main_Color;
2131 #endif
2132 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main;
2133 }
2134 else
2135 #endif
2136 {
2137 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2138 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Middle_M_Main_Color;
2139 #endif
2140 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Middle_M_Main;
2141 }
2142 }
2143 else if(en3DNRType == PQ_3D_NR_AUTO_MID_H)
2144 {
2145 PQGRULE_DBG(printf("AUTO_MID_H\n"));
2146 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2147 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2148 {
2149 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2150 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main_Color;
2151 #endif
2152 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_3D_Main;
2153 }
2154 else
2155 #endif
2156 {
2157 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2158 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Middle_H_Main_Color;
2159 #endif
2160 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_Middle_H_Main;
2161 }
2162 }
2163 else if(en3DNRType == PQ_3D_NR_AUTO_HIGH_L)
2164 {
2165 PQGRULE_DBG(printf("AUTO_HIGH_L\n"));
2166 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2167 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2168 {
2169 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2170 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main_Color;
2171 #endif
2172 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main;
2173 }
2174 else
2175 #endif
2176 {
2177 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2178 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_High_L_Main_Color;
2179 #endif
2180 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_High_L_Main;
2181 }
2182 }
2183 else if(en3DNRType == PQ_3D_NR_AUTO_HIGH_M)
2184 {
2185 PQGRULE_DBG(printf("AUTO_HIGH_M\n"));
2186 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2187 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2188 {
2189 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2190 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main_Color;
2191 #endif
2192 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main;
2193 }
2194 else
2195 #endif
2196 {
2197 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2198 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_High_M_Main_Color;
2199 #endif
2200 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_High_M_Main;
2201 }
2202 }
2203 else if(en3DNRType == PQ_3D_NR_AUTO_HIGH_H)
2204 {
2205 PQGRULE_DBG(printf("AUTO_HIGH_H\n"));
2206 #if (PQ_ENABLE_3D_STRENGTHEN_NR == 1)
2207 if(MApi_XC_Get_3D_Output_Mode() != E_XC_3D_OUTPUT_MODE_NONE)
2208 {
2209 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2210 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main_Color;
2211 #endif
2212 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_High_3D_Main;
2213 }
2214 else
2215 #endif
2216 {
2217 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2218 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_High_H_Main_Color;
2219 #endif
2220 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Auto_High_H_Main;
2221 }
2222 }
2223 #endif
2224 else
2225 {
2226 MS_ASSERT(FALSE);
2227 }
2228 // Third parameter of MDrv_PQ_GetGRule_LevelIndex should be level index, not group index.
2229 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, u16GRuleType, u16GRuleLevelIndex);
2230 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2231 u16CustomerPQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, u16CustomerGRuleType, u16CustomerGRuleLevelIndex);
2232 #endif
2233 }
2234 _MDrv_PQ_LoadNRTable(pInstance, eWindow, u16PQ_NRIdx);
2235 #if ENABLE_PQ_CUSTOMER_BIN_MAIN_GRULE
2236 _MDrv_PQ_LoadCustomerNRTable(eWindow, u16CustomerPQ_NRIdx);
2237 #endif
2238 }
2239 #if PQ_ENABLE_PIP
2240 else if (eWindow == PQ_SUB_WINDOW)
2241 {
2242 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2243 u16CustomerGRuleType = PQ_GRule_NR_Sub_Color + MDrv_PQ_GetGRule_GRuleNum_U2(pInstance, eWindow);
2244 #endif
2245 u16GRuleType = PQ_GRule_NR_Sub;
2246
2247 if(en3DNRType == PQ_3D_NR_DEFAULT)
2248 {
2249 PQGRULE_DBG(printf("Default\n"));
2250 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2251 u16CustomerPQ_NRIdx = PQ_GRULE_NR_NUM_Sub_Color;
2252 #endif
2253 u16PQ_NRIdx = PQ_GRULE_NR_NUM_Sub;
2254 }
2255 else
2256 {
2257 if(en3DNRType == PQ_3D_NR_OFF)
2258 {
2259 PQGRULE_DBG(printf("Off\n"));
2260 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2261 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Sub_Color;
2262 #endif
2263 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Off_Sub;
2264 }
2265 else if(en3DNRType == PQ_3D_NR_AUTO)
2266 {
2267 // Auto NR will be process in msAPI_DynamicNR_Handler(), hence we only need to pre-setup the PQ table.
2268 PQGRULE_DBG(printf("Auto\n"));
2269 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2270 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Sub_Color;
2271 #endif
2272 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Sub;
2273 }
2274 else if(en3DNRType == PQ_3D_NR_LOW)
2275 {
2276 PQGRULE_DBG(printf("Low\n"));
2277 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2278 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Sub_Color;
2279 #endif
2280 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Low_Sub;
2281 }
2282 else if(en3DNRType == PQ_3D_NR_MID)
2283 {
2284 PQGRULE_DBG(printf("Mid\n"));
2285 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2286 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_Sub_Color;
2287 #endif
2288 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_Middle_Sub;
2289 }
2290 else if(en3DNRType == PQ_3D_NR_HIGH)
2291 {
2292 PQGRULE_DBG(printf("High\n"));
2293 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2294 u16CustomerGRuleLevelIndex = PQ_GRule_Lvl_NR_High_Sub_Color;
2295 #endif
2296 u16GRuleLevelIndex = PQ_GRule_Lvl_NR_High_Sub;
2297 }
2298 else
2299 {
2300 MS_ASSERT(FALSE);
2301 }
2302 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, u16GRuleType, u16GRuleLevelIndex);
2303 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2304 u16CustomerPQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, u16CustomerGRuleType, u16CustomerGRuleLevelIndex);
2305 #endif
2306 }
2307 _MDrv_PQ_LoadNRTable(pInstance, eWindow, u16PQ_NRIdx);
2308 #if ENABLE_PQ_CUSTOMER_BIN_SUB_GRULE
2309 _MDrv_PQ_LoadCustomerNRTable(eWindow, u16CustomerPQ_NRIdx);
2310 #endif
2311 }
2312 #endif
2313 else
2314 {
2315 PQGRULE_DBG(printf("Not support case \n"));
2316 }
2317 }
MDrv_PQ_LoadNRTable(PQ_WIN eWindow,PQ_3D_NR_FUNCTION_TYPE en3DNRType)2318 void MDrv_PQ_LoadNRTable(PQ_WIN eWindow, PQ_3D_NR_FUNCTION_TYPE en3DNRType)
2319 {
2320 #ifdef TRACE_DBG
2321 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2322 #endif
2323 if (pu32PQInst == NULL)
2324 {
2325 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2326 return ;
2327 }
2328
2329 stPQ_LoadNRTable PQArgs;
2330 PQArgs.eWindow = eWindow;
2331 PQArgs.en3DNRType = en3DNRType;
2332
2333 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_NR_TABLE, (void*)&PQArgs) != 0)
2334 {
2335 printf("Obtain PQ engine fail\n");
2336 return ;
2337 }
2338 else
2339 {
2340 return ;
2341 }
2342 }
2343
2344 #if PQ_GRULE_MPEG_NR_ENABLE
_MDrv_PQ_LoadMPEGNRTable(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_NRIdx)2345 static void _MDrv_PQ_LoadMPEGNRTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_NRIdx)
2346 {
2347 MS_U16 i, u16IPIdx = 0, u16TabIdx = 0;
2348 if(u16PQ_NRIdx > PQ_GRULE_MPEG_NR_NUM_Main)
2349 {
2350 MS_ASSERT(0);
2351 return;
2352 }
2353
2354 for(i = 0; i < PQ_GRULE_MPEG_NR_IP_NUM_Main; i++)
2355 {
2356 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_MPEG_NR_Main, i);
2357
2358 if(u16PQ_NRIdx == PQ_GRULE_MPEG_NR_NUM_Main) // see it as default
2359 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
2360 else
2361 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_MPEG_NR_Main, u16PQ_NRIdx, i);
2362
2363 PQGRULE_DBG(printf("[MPEGNR]SRC: %u, NR: %u, NRIPIdx:%u, IPIdx:%u, u16TabIdx:%u\n",
2364 _u16PQSrcType[eWindow], u16PQ_NRIdx, i, u16IPIdx, u16TabIdx));
2365 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
2366 }
2367 }
2368 #endif
2369
MDrv_PQ_LoadMPEGNRTable_U2(void * pInstance,PQ_WIN eWindow,PQ_MPEG_NR_FUNCTION_TYPE enMPEGNRType)2370 void MDrv_PQ_LoadMPEGNRTable_U2(void* pInstance,PQ_WIN eWindow, PQ_MPEG_NR_FUNCTION_TYPE enMPEGNRType)
2371 {
2372 #if(PQ_GRULE_MPEG_NR_ENABLE)
2373 PQGRULE_DBG(printf("[PQ_LoadMPEGNRTable] "));
2374 MS_U16 u16PQ_NRIdx;
2375 if(eWindow == PQ_MAIN_WINDOW)
2376 {
2377 if(enMPEGNRType == PQ_MPEG_NR_OFF)
2378 {
2379 PQGRULE_DBG(printf("Off\n"));
2380 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_MPEG_NR_Main, PQ_GRule_MPEG_NR_Off_Main);
2381 _MDrv_PQ_LoadMPEGNRTable(pInstance, eWindow, u16PQ_NRIdx);
2382 }
2383 else if( enMPEGNRType == PQ_MPEG_NR_AUTO )
2384 {
2385 // Auto NR will be process in msAPI_DynamicNR_Handler(), hence we only need to pre-setup the PQ table.
2386 PQGRULE_DBG(printf("Auto\n"));
2387 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_MPEG_NR_Main, PQ_GRule_MPEG_NR_Low_Main);
2388 _MDrv_PQ_LoadMPEGNRTable(pInstance, eWindow, u16PQ_NRIdx);
2389 }
2390 else if(enMPEGNRType == PQ_MPEG_NR_LOW)
2391 {
2392 PQGRULE_DBG(printf("Low\n"));
2393 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_MPEG_NR_Main, PQ_GRule_MPEG_NR_Low_Main);
2394 _MDrv_PQ_LoadMPEGNRTable(pInstance, eWindow, u16PQ_NRIdx);
2395 }
2396 else if(enMPEGNRType == PQ_MPEG_NR_MID)
2397 {
2398 PQGRULE_DBG(printf("Mid\n"));
2399 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_MPEG_NR_Main, PQ_GRule_MPEG_NR_Middle_Main);
2400 _MDrv_PQ_LoadMPEGNRTable(pInstance, eWindow, u16PQ_NRIdx);
2401 }
2402 else if(enMPEGNRType == PQ_MPEG_NR_HIGH)
2403 {
2404 PQGRULE_DBG(printf("High\n"));
2405 u16PQ_NRIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_MPEG_NR_Main, PQ_GRule_MPEG_NR_High_Main);
2406 _MDrv_PQ_LoadMPEGNRTable(pInstance, eWindow, u16PQ_NRIdx);
2407 }
2408 else if(enMPEGNRType == PQ_MPEG_NR_DEFAULT)
2409 {
2410 PQGRULE_DBG(printf("Default\n"));
2411 _MDrv_PQ_LoadMPEGNRTable(pInstance, eWindow, PQ_GRULE_MPEG_NR_NUM_Main);
2412 }
2413 else
2414 {
2415 MS_ASSERT(0);
2416 }
2417 }
2418 #else
2419 UNUSED(eWindow);
2420 UNUSED(enMPEGNRType);
2421 #endif
2422 }
MDrv_PQ_LoadMPEGNRTable(PQ_WIN eWindow,PQ_MPEG_NR_FUNCTION_TYPE enMPEGNRType)2423 void MDrv_PQ_LoadMPEGNRTable(PQ_WIN eWindow, PQ_MPEG_NR_FUNCTION_TYPE enMPEGNRType)
2424 {
2425 #ifdef TRACE_DBG
2426 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2427 #endif
2428 if (pu32PQInst == NULL)
2429 {
2430 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2431 return ;
2432 }
2433
2434 stPQ_LoadMPEGNRTable PQArgs;
2435 PQArgs.eWindow = eWindow;
2436 PQArgs.enMPEGNRType = enMPEGNRType;
2437
2438 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_MPEG_NR_TABLE, (void*)&PQArgs) != 0)
2439 {
2440 printf("Obtain PQ engine fail\n");
2441 return ;
2442 }
2443 else
2444 {
2445 return ;
2446 }
2447 }
2448
2449 #if PQ_GRULE_ULTRAT_CLEAR_ENABLE
_MDrv_PQ_Load_ULTRACLEAR_Table(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_ULTRACLEAR_Idx)2450 void _MDrv_PQ_Load_ULTRACLEAR_Table(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_ULTRACLEAR_Idx)
2451 {
2452 MS_U16 i = 0, u16IPIdx = 0, u16TabIdx = 0;
2453
2454 if(u16PQ_ULTRACLEAR_Idx > PQ_GRULE_ULTRAT_CLEAR_NUM_Main)
2455 {
2456 MS_ASSERT(0);
2457 return;
2458 }
2459
2460 for(i = 0; i < PQ_GRULE_ULTRAT_CLEAR_IP_NUM_Main; i++)
2461 {
2462 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_ULTRAT_CLEAR_Main, i);
2463 #if PQ_LCE_CTL_FOR_MVC4KX1K
2464 if((_gIsMVC4kx1k == TRUE) && (u16IPIdx == PQ_IP_VIP_LCE_Main))
2465 {
2466 printf("[Grule-ULTRACLEAR] cannot load LCE table for MVC4kx1k\n");
2467 continue;
2468 }
2469 #endif
2470 if(u16PQ_ULTRACLEAR_Idx == PQ_GRULE_ULTRAT_CLEAR_NUM_Main) // see it as default
2471 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
2472 else
2473 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_ULTRAT_CLEAR_Main, u16PQ_ULTRACLEAR_Idx, i);
2474
2475 PQGRULE_DBG(printf("[UC]SRC: %u, UC: %u, UCIPIdx:%u, IPIdx:%u, u8TabIdx:%u\n",
2476 _u16PQSrcType[eWindow], u16PQ_ULTRACLEAR_Idx, i, u16IPIdx, u16IPIdx));
2477
2478 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
2479 }
2480 }
2481 #endif
2482
MDrv_PQ_Load_ULTRACLEAR_Table_U2(void * pInstance,PQ_WIN eWindow,PQ_FEATURE_SWITCH_TYPE enCtrlType)2483 void MDrv_PQ_Load_ULTRACLEAR_Table_U2(void* pInstance,PQ_WIN eWindow, PQ_FEATURE_SWITCH_TYPE enCtrlType)
2484 {
2485 MS_U16 u16PQ_TableIdx = 0;
2486 #if PQ_GRULE_ULTRAT_CLEAR_ENABLE
2487 PQGRULE_DBG(printf("[PQ_Load_ULTRACLEAR_Table] "));
2488 if(enCtrlType == PQ_FEATURE_SWITCH_ON)
2489 {
2490 PQGRULE_DBG(printf("On\n"));
2491 u16PQ_TableIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_ULTRAT_CLEAR_Main, PQ_GRule_ULTRAT_CLEAR_On_Main);
2492 _MDrv_PQ_Load_ULTRACLEAR_Table(pInstance, eWindow, u16PQ_TableIdx);
2493 }
2494 else
2495 {
2496 PQGRULE_DBG(printf("Off\n"));
2497 u16PQ_TableIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_ULTRAT_CLEAR_Main, PQ_GRule_ULTRAT_CLEAR_Off_Main);
2498 _MDrv_PQ_Load_ULTRACLEAR_Table(pInstance, eWindow, u16PQ_TableIdx);
2499 }
2500 #else
2501 UNUSED(u16PQ_TableIdx);
2502 UNUSED(eWindow);
2503 UNUSED(enCtrlType);
2504
2505 #endif
2506 }
MDrv_PQ_Load_ULTRACLEAR_Table(PQ_WIN eWindow,PQ_FEATURE_SWITCH_TYPE enCtrlType)2507 void MDrv_PQ_Load_ULTRACLEAR_Table(PQ_WIN eWindow, PQ_FEATURE_SWITCH_TYPE enCtrlType)
2508 {
2509 #ifdef TRACE_DBG
2510 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2511 #endif
2512 if (pu32PQInst == NULL)
2513 {
2514 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2515 return ;
2516 }
2517
2518 stPQ_Load_ULTRACLEAR_Table PQArgs;
2519 PQArgs.eWindow = eWindow;
2520 PQArgs.enCtrlType = enCtrlType;
2521
2522 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_ULTRACLEAR_TABLE, (void*)&PQArgs) != 0)
2523 {
2524 printf("Obtain PQ engine fail\n");
2525 return ;
2526 }
2527 else
2528 {
2529 return ;
2530 }
2531 }
2532
MDrv_PQ_Load_HDR_Table_U2(void * pInstance,PQ_WIN eWindow,PQ_HDR_MODE enHdrMode)2533 void MDrv_PQ_Load_HDR_Table_U2(void *pInstance,PQ_WIN eWindow, PQ_HDR_MODE enHdrMode)
2534 {
2535 #if PQ_GRULE_HDR_ENABLE
2536 if (enHdrMode == PQ_HDR_ON)
2537 {
2538 MDrv_PQ_SetGRuleStatus_U2(pInstance,eWindow, PQ_GRule_HDR_Main, PQ_GRule_HDR_On_Main);
2539 }
2540 #else
2541 UNUSED(eWindow);
2542 UNUSED(enHdrMode);
2543 #endif
2544 }
MDrv_PQ_Load_HDR_Table(PQ_WIN eWindow,PQ_HDR_MODE enHdrMode)2545 void MDrv_PQ_Load_HDR_Table(PQ_WIN eWindow, PQ_HDR_MODE enHdrMode)
2546 {
2547 #ifdef TRACE_DBG
2548 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2549 #endif
2550 if (pu32PQInst == NULL)
2551 {
2552 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2553 return ;
2554 }
2555
2556 stPQ_Load_HDR_Table PQArgs;
2557 PQArgs.eWindow = eWindow;
2558 PQArgs.enHdrMode = enHdrMode;
2559
2560 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_HDR_TABLE, (void*)&PQArgs) != 0)
2561 {
2562 printf("Obtain PQ engine fail\n");
2563 return ;
2564 }
2565 else
2566 {
2567 return ;
2568 }
2569 }
2570
MDrv_PQ_Load_XVYCC_Table_U2(void * pInstance,PQ_WIN eWindow,PQ_XVYCC_TYPE enXvyccType)2571 void MDrv_PQ_Load_XVYCC_Table_U2(void* pInstance,PQ_WIN eWindow, PQ_XVYCC_TYPE enXvyccType)
2572 {
2573 #ifdef PQ_CFD_INFO
2574 if (eWindow == PQ_MAIN_WINDOW)
2575 {
2576 ST_PQ_CFD_LINEAR_RGB stCfdLinearRgb;
2577 memset(&stCfdLinearRgb, 0, sizeof(ST_PQ_CFD_LINEAR_RGB));
2578 stCfdLinearRgb.u32Version = CFD_LINEAR_RGB_VERSION;
2579 stCfdLinearRgb.u16Length = sizeof(ST_PQ_CFD_LINEAR_RGB);
2580 stCfdLinearRgb.u8Win = eWindow;
2581
2582 if(enXvyccType == PQ_XVYCC_NORMAL)
2583 {
2584 stCfdLinearRgb.bEnable = TRUE;
2585 }
2586 else if(enXvyccType == PQ_XVYCC_ON_XVYCC)
2587 {
2588 stCfdLinearRgb.bEnable = TRUE;
2589 }
2590 else if(enXvyccType == PQ_XVYCC_ON_SRGB)
2591 {
2592 stCfdLinearRgb.bEnable = FALSE;
2593 }
2594
2595 MDrv_PQ_SendCfd(E_PQ_CFD_CTRL_SET_LINEAR_RGB, &stCfdLinearRgb, sizeof(ST_PQ_CFD_LINEAR_RGB));
2596 }
2597 #else
2598 #if PQ_GRULE_XVYCC_ENABLE
2599 if (!QM_IsSourceMultiMedia(MDrv_PQ_GetInputSourceType(eWindow)))
2600 {
2601 PQGRULE_DBG(printf("[PQ_Load_XVYCC_Table] "));
2602 if(enXvyccType == PQ_XVYCC_NORMAL)
2603 {
2604 PQGRULE_DBG(printf("Normal\n"));
2605 MDrv_PQ_SetGRuleStatus(eWindow, PQ_GRule_XVYCC_Main, PQ_GRule_XVYCC_Normal_Main);//PQ_GRule_XVYCC_Normal_Main
2606 }
2607 else if(enXvyccType == PQ_XVYCC_ON_XVYCC)
2608 {
2609 PQGRULE_DBG(printf("On xcYCC\n"));
2610 MDrv_PQ_SetGRuleStatus(eWindow, PQ_GRule_XVYCC_Main, PQ_GRule_XVYCC_On_xvYCC_Main);//PQ_GRule_XVYCC_On_xvYCC_Main
2611 }
2612 else if(enXvyccType == PQ_XVYCC_ON_SRGB)
2613 {
2614 PQGRULE_DBG(printf("On sRGB\n"));
2615 MDrv_PQ_SetGRuleStatus(eWindow, PQ_GRule_XVYCC_Main, PQ_GRule_XVYCC_On_sRGB_Main);//PQ_GRule_XVYCC_On_sRGB_Main
2616 }
2617 else
2618 {
2619 MS_ASSERT(0);
2620 }
2621 }
2622 #else
2623 UNUSED(eWindow);
2624 UNUSED(enXvyccType);
2625 #endif
2626 #endif
2627 }
MDrv_PQ_Load_XVYCC_Table(PQ_WIN eWindow,PQ_XVYCC_TYPE enXvyccType)2628 void MDrv_PQ_Load_XVYCC_Table(PQ_WIN eWindow, PQ_XVYCC_TYPE enXvyccType)
2629 {
2630 #ifdef TRACE_DBG
2631 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2632 #endif
2633 if (pu32PQInst == NULL)
2634 {
2635 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2636 return ;
2637 }
2638
2639 stPQ_Load_XVYCC_Table PQArgs;
2640 PQArgs.eWindow = eWindow;
2641 PQArgs.enXvyccType = enXvyccType;
2642
2643 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_XVYCC_TABLE, (void*)&PQArgs) != 0)
2644 {
2645 printf("Obtain PQ engine fail\n");
2646 return ;
2647 }
2648 else
2649 {
2650 return ;
2651 }
2652 }
2653
MDrv_PQ_GRULE_Get_Support_Status_U2(void * pInstance,PQ_SUPPORTED_TYPE enType)2654 MS_BOOL MDrv_PQ_GRULE_Get_Support_Status_U2(void* pInstance,PQ_SUPPORTED_TYPE enType)
2655 {
2656 MS_BOOL bStatus = FALSE;
2657 switch(enType)
2658 {
2659 case E_PQ_SUPPORTED_FILM:
2660 if(PQ_GRULE_FILM_MODE_ENABLE)
2661 bStatus = TRUE;
2662 break;
2663 case E_PQ_SUPPORTED_NR:
2664 if(PQ_GRULE_NR_ENABLE)
2665 bStatus = TRUE;
2666 break;
2667 case E_PQ_SUPPORTED_MPEG_NR:
2668 if(PQ_GRULE_MPEG_NR_ENABLE)
2669 bStatus = TRUE;
2670 break;
2671 case E_PQ_SUPPORTED_BLACK_LEVEL:
2672 bStatus = TRUE;
2673 break;
2674 case E_PQ_SUPPORTED_ULTRA_CLEAR:
2675 if(PQ_GRULE_ULTRAT_CLEAR_ENABLE)
2676 bStatus = TRUE;
2677 break;
2678 case E_PQ_SUPPORTED_HDR:
2679 if(PQ_GRULE_HDR_ENABLE )
2680 bStatus = TRUE;
2681 break;
2682 default:
2683 break;
2684 }
2685
2686 return bStatus;
2687
2688 }
MDrv_PQ_GRULE_Get_Support_Status(PQ_SUPPORTED_TYPE enType)2689 MS_BOOL MDrv_PQ_GRULE_Get_Support_Status(PQ_SUPPORTED_TYPE enType)
2690 {
2691 #ifdef TRACE_DBG
2692 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2693 #endif
2694 if (pu32PQInst == NULL)
2695 {
2696 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2697 return FALSE;
2698 }
2699
2700 stPQ_GRULE_Get_Support_Status PQArgs;
2701 PQArgs.enType = enType;
2702 PQArgs.bReturnValue = FALSE;
2703
2704 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GRULE_GET_SUPPORT_STATUS, (void*)&PQArgs) != 0)
2705 {
2706 printf("Obtain PQ engine fail\n");
2707 return FALSE;
2708 }
2709 else
2710 {
2711 return PQArgs.bReturnValue;
2712 }
2713 }
2714
2715 //////////////////////////////////////////////////////////////////
2716 // Load MADi/444To422/422To444 table
2717 //
2718 // parameter:
2719 // [IN] u8PQTabType
2720 // bMemFmt422: TRUE - 422
2721 // FALSE - 444
2722 // bFBL: TRUE - framebuffer-less mode
2723 // FALSE - framebuffer mode
2724 // [OUT] u8BitsPerPixel
2725 // bits per pixel for decided memory format
2726 //
2727 // return: deinterlace (MADi) mode
2728 //
MDrv_PQ_SetMemFormat_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_BOOL bFBL,MS_U8 * pu8BitsPerPixel)2729 PQ_DEINTERLACE_MODE MDrv_PQ_SetMemFormat_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bMemFmt422, MS_BOOL bFBL, MS_U8 *pu8BitsPerPixel)
2730 {
2731 MS_U16 u16TabIdx_MemFormat = 0;
2732 MS_U16 u16TabIdx_MADi = 0;
2733 MS_U16 u16TabIdx_MADi_Motion=0xFFFF;
2734 MS_U16 u16TabIdx_444To422 = 0;
2735 MS_U16 u16TabIdx_422To444 = 0;
2736 PQ_DEINTERLACE_MODE eDeInterlaceMode = PQ_DEINT_OFF;
2737 MS_U8 u8FrameCount = 4;
2738
2739 if(eWindow == PQ_MAIN_WINDOW)
2740 {
2741 MApi_XC_Set_OPWriteOffEnable(ENABLE, MAIN_WINDOW); //default
2742 }
2743 else
2744 {
2745 PQINFO_DBG(printf("No need to enable OP write with sub window, it would change main window setting \n"));
2746 }
2747
2748 PQBW_DBG(printf("==>In PQ : eWindow =%d\n", eWindow));
2749
2750 if(!bFBL)
2751 {
2752 // if MADi mode change from 25 <=> 27, cropping base address need to be recalculated.
2753 #if PQ_GRULE_OSD_BW_ENABLE
2754 if(((_stMode_Info[eWindow].u16input_hsize >= 1280) && (_stMode_Info[eWindow].u16input_vsize >= 720)) &&
2755 (_bOSD_On))
2756 {
2757 MDrv_PQ_GetMADiFromOSDBWGrule(eWindow, &u16TabIdx_MADi, &u16TabIdx_MADi_Motion);
2758 }
2759 else
2760 #endif
2761 {
2762 MDrv_PQ_GetMADiInGeneral_U2(pInstance, eWindow, &u16TabIdx_MADi, &u16TabIdx_MADi_Motion);
2763 #if PQ_GRULE_OSD_BW_ENABLE
2764 MDrv_PQ_Patch2Rto4RForFieldPackingMode_U2(pInstance, eWindow, u16TabIdx_MADi);
2765 #endif
2766 }
2767
2768 MDrv_PQ_GetMADiForRFBL_U2(pInstance, eWindow, bFBL, &u16TabIdx_MADi_Motion, &u16TabIdx_MADi);
2769 }
2770 else // FBL
2771 {
2772 MS_U8 u8FblMode = Hal_PQ_get_madi_fbl_mode(pInstance,bMemFmt422, _stMode_Info[eWindow].bInterlace);
2773 u16TabIdx_MADi = Hal_PQ_get_madi_idx(pInstance,(eWindow == PQ_MAIN_WINDOW) ? TRUE : FALSE, (MS_MADI_TYPE)u8FblMode);
2774 }
2775
2776 PQMADi_DBG(printf("Memory is %s mode \n", (bFBL)?("FBL"):("FB")));
2777 PQMADi_DBG(printf("get MADi idx = %u\n", u16TabIdx_MADi));
2778
2779 MDrv_PQ_GetMemFmtInGeneral_U2(pInstance, eWindow, bMemFmt422, &u16TabIdx_MemFormat, &u16TabIdx_444To422, &u16TabIdx_422To444);
2780
2781 PQTAB_DBG(printf("%s :u16TabIdx_444To422=%u\n", eWindow?"SubWin":"MainWin",u16TabIdx_444To422));
2782 PQTAB_DBG(printf("%s :u16TabIdx_422To444=%u\n", eWindow?"SubWin":"MainWin",u16TabIdx_422To444));
2783 PQMADi_DBG(printf("MemFmt is 422 : %s\n",(bMemFmt422)?("Yes"):("No")));
2784 PQMADi_DBG(printf("u16TabIdx_MemFormat is %u\n",u16TabIdx_MemFormat));
2785
2786 MDrv_PQ_GetBPPInfoFromMADi_U2(
2787 pInstance,
2788 eWindow,
2789 bMemFmt422,
2790 u16TabIdx_MADi,
2791 u16TabIdx_MemFormat,
2792 pu8BitsPerPixel,
2793 &eDeInterlaceMode,
2794 &u8FrameCount);
2795
2796 PQMADi_DBG(printf("BitPerPixel =%d, DIMode =%x\n", *pu8BitsPerPixel, eDeInterlaceMode));
2797
2798 _gbMemfmt422[eWindow] = bMemFmt422;
2799 _gu16SetMemfmt_Madi[eWindow] = u16TabIdx_MADi;
2800 _gu16SetMemfmt_Madi_Motion[eWindow] = u16TabIdx_MADi_Motion;
2801
2802 MDrv_PQ_ChangeMemConfigFor3D_U2(pInstance, eWindow, bMemFmt422, &u16TabIdx_MemFormat, &u16TabIdx_444To422, &u16TabIdx_422To444,
2803 pu8BitsPerPixel, &u16TabIdx_MADi_Motion, &u16TabIdx_MADi);
2804
2805 if(eWindow == PQ_MAIN_WINDOW)
2806 {
2807 #if(ENABLE_PQ_MLOAD)
2808 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
2809 #endif
2810 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, u16TabIdx_MemFormat, PQ_IP_MemFormat_Main);
2811
2812 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi, PQ_IP_MADi_Main);
2813 #if PQ_GRULE_OSD_BW_ENABLE
2814 if(0xFFFF != u16TabIdx_MADi_Motion)
2815 {
2816 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi_Motion, PQ_IP_MADi_Motion_Main);
2817 }
2818 #endif
2819 #if(ENABLE_PQ_MLOAD)
2820 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
2821 #endif
2822
2823 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_444To422, PQ_IP_444To422_Main);
2824 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_422To444, PQ_IP_422To444_Main);
2825 }
2826 #if PQ_ENABLE_PIP
2827 else
2828 {
2829 #if(ENABLE_PQ_MLOAD)
2830 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
2831 #endif
2832 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MemFormat, PQ_IP_MemFormat_Sub);
2833
2834 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi, PQ_IP_MADi_Sub);
2835 #if PQ_GRULE_OSD_BW_ENABLE
2836 if(0xFFFF != u16TabIdx_MADi_Motion)
2837 {
2838 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_MADi_Motion, PQ_IP_MADi_Motion_Sub);
2839 }
2840 #endif
2841 #if(ENABLE_PQ_MLOAD)
2842 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
2843 #endif
2844 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_444To422, PQ_IP_444To422_Sub);
2845 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx_422To444, PQ_IP_422To444_Sub);
2846
2847 //R W bank mapping mode patch for Qmap hasn't this item for sub
2848 if(_stMode_Info[eWindow].bInterlace)
2849 {
2850 MApi_XC_W2BYTEMSK(REG_SC_BK12_47_L, 0x4000 , 0xE000 );
2851 }
2852 else
2853 {
2854 MApi_XC_W2BYTEMSK(REG_SC_BK12_47_L, 0x2000 , 0xE000 );
2855 }
2856 }
2857 #endif
2858
2859 PQTAB_DBG(printf("u16TabIdx_MemFormat=%u\n", u16TabIdx_MemFormat));
2860 PQTAB_DBG(printf("%s, u16TabIdx_MADi=%u\n", eWindow?"SUB_WIN":"MAIN_WIN", u16TabIdx_MADi));
2861 PQTAB_DBG(printf("%s, u16TabIdx_MADi_Motion=%u\n", eWindow?"SUB_WIN":"MAIN_WIN", u16TabIdx_MADi_Motion));
2862 PQTAB_DBG(printf("%s :u16TabIdx_444To422=%u\n", eWindow?"SUB_WIN":"MAIN_WIN", u16TabIdx_444To422));
2863 PQTAB_DBG(printf("%s :u16TabIdx_422To444=%u\n", eWindow?"SUB_WIN":"MAIN_WIN", u16TabIdx_422To444));
2864
2865 #if (PQ_XRULE_DB_ENABLE == 1)
2866 MDrv_PQ_Set_DBRule(eWindow, u16TabIdx_MADi);
2867 #endif
2868
2869 MDrv_PQ_ForceBPPForDynamicMemFmt_U2(pInstance, eWindow, bMemFmt422, pu8BitsPerPixel);
2870 MDrv_PQ_SuggestFrameNum_U2(pInstance, eWindow, u16TabIdx_MADi, u8FrameCount);
2871
2872 if(_bDS_En)
2873 {
2874 _u16RW_Method = Hal_PQ_get_rw_method(pInstance,eWindow == PQ_MAIN_WINDOW ? TRUE : FALSE);
2875 Hal_PQ_set_rw_method(pInstance,eWindow == PQ_MAIN_WINDOW ? TRUE : FALSE, 0x4000);
2876 }
2877
2878 _bRWNumIsReset[eWindow] = TRUE;
2879
2880 return eDeInterlaceMode;
2881 }
MDrv_PQ_SetMemFormat(PQ_WIN eWindow,MS_BOOL bMemFmt422,MS_BOOL bFBL,MS_U8 * pu8BitsPerPixel)2882 PQ_DEINTERLACE_MODE MDrv_PQ_SetMemFormat(PQ_WIN eWindow, MS_BOOL bMemFmt422, MS_BOOL bFBL, MS_U8 *pu8BitsPerPixel)
2883 {
2884 if (pu32PQInst == NULL)
2885 {
2886 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
2887 {
2888 printf("UtopiaOpen PQ failed\n");
2889 return PQ_DEINT_OFF;
2890 }
2891 }
2892 stPQ_SetMemFormat PQArgs;
2893 PQArgs.eWindow = eWindow;
2894 PQArgs.bMemFmt422 = bMemFmt422;
2895 PQArgs.bFBL = bFBL;
2896 PQArgs.pu8BitsPerPixel = pu8BitsPerPixel;
2897 PQArgs.bReturnValue = PQ_DEINT_OFF;
2898
2899 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_MEMFORMAT, (void*)&PQArgs) != 0)
2900 {
2901 printf("Obtain PQ engine fail\n");
2902 return PQ_DEINT_OFF;
2903 }
2904 else
2905 {
2906 return PQArgs.bReturnValue;
2907 }
2908 }
2909
MDrv_PQ_ReduceBW_ForOSD_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bOSD_On)2910 void MDrv_PQ_ReduceBW_ForOSD_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bOSD_On)
2911 {
2912 #if PQ_GRULE_OSD_BW_ENABLE
2913 MS_U8 u8BitPerPixel = 0;
2914 {
2915 if((_stMode_Info[eWindow].u16input_hsize >= 1280) && (_stMode_Info[eWindow].u16input_vsize >= 720))
2916 {
2917 PQBW_DBG(printf("[PQ_ReduceBW_ForOSD]:%u\n", bOSD_On));
2918
2919 _bOSD_On = bOSD_On;
2920 bSetFrameCount = FALSE;
2921
2922 MDrv_PQ_SetMemFormat(
2923 eWindow,
2924 _gbMemfmt422[eWindow],
2925 _stMode_Info[eWindow].bFBL,
2926 &u8BitPerPixel);
2927 bSetFrameCount = TRUE;
2928
2929 }
2930 }
2931 #else
2932 UNUSED(eWindow);
2933 UNUSED(bOSD_On);
2934 #endif
2935
2936 return;
2937 }
MDrv_PQ_ReduceBW_ForOSD(PQ_WIN eWindow,MS_BOOL bOSD_On)2938 void MDrv_PQ_ReduceBW_ForOSD(PQ_WIN eWindow, MS_BOOL bOSD_On)
2939 {
2940 #ifdef TRACE_DBG
2941 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
2942 #endif
2943 if (pu32PQInst == NULL)
2944 {
2945 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
2946 return ;
2947 }
2948
2949 stPQ_ReduceBW_ForOSD PQArgs;
2950 PQArgs.eWindow = eWindow;
2951 PQArgs.bOSD_On = bOSD_On;
2952
2953 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_REDUCEBW_ForOSD, (void*)&PQArgs) != 0)
2954 {
2955 printf("Obtain PQ engine fail\n");
2956 return ;
2957 }
2958 else
2959 {
2960 return ;
2961 }
2962 }
2963
2964 #if PQ_GRULE_PTP_ENABLE
_MDrv_PQ_LoadPTPTable(void * pInstance,PQ_WIN eWindow,MS_U16 u16PQ_PTP_Idx)2965 static void _MDrv_PQ_LoadPTPTable(void* pInstance, PQ_WIN eWindow, MS_U16 u16PQ_PTP_Idx)
2966 {
2967 MS_U16 i, u16IPIdx=0, u16TabIdx=0;
2968
2969 if(eWindow == PQ_SUB_WINDOW)
2970 {
2971 return;
2972 }
2973
2974 if (u16PQ_PTP_Idx > PQ_GRULE_PTP_LVL_NUM_Main)
2975 {
2976 MS_ASSERT(0);
2977 return;
2978 }
2979
2980 for(i=0; i<PQ_GRULE_PTP_IP_NUM_Main; i++)
2981 {
2982 u16IPIdx = MDrv_PQ_GetGRule_IPIndex_U2(pInstance, eWindow, PQ_GRule_PTP_Main, i);
2983
2984 if (u16PQ_PTP_Idx == PQ_GRULE_PTP_NUM_Main) // see it as default
2985 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, u16IPIdx);
2986 else
2987 u16TabIdx = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_PTP_Main, u16PQ_PTP_Idx, i);
2988
2989 PQP2P_DBG(printf("[PTP]SRC: %u, u16PQ_PTP_Idx: %u, PIPIPIdx:%u, IPIdx:%u, u8TabIdx:%u\n",
2990 _u16PQSrcType[eWindow], u16PQ_PTP_Idx, i, u16IPIdx, u16TabIdx);)
2991
2992 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, u16IPIdx);
2993 }
2994 }
2995 #endif
2996
MDrv_PQ_LoadPTPTable_U2(void * pInstance,PQ_WIN eWindow,PQ_PTP_FUNCTION_TYPE enPTP_Type)2997 void MDrv_PQ_LoadPTPTable_U2(void* pInstance,PQ_WIN eWindow, PQ_PTP_FUNCTION_TYPE enPTP_Type)
2998 {
2999 #if PQ_GRULE_PTP_ENABLE
3000 PQGRULE_DBG(printf("[PQ_LoadPTPTable] "));
3001 MS_U16 u16PQ_PTPIdx;
3002
3003 if(eWindow == PQ_SUB_WINDOW)
3004 {
3005 return;
3006 }
3007
3008 if( enPTP_Type == PQ_PTP_PTP )
3009 {
3010 PQP2P_DBG(printf("PTP\n");)
3011 u16PQ_PTPIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_PTP_Main, PQ_GRule_Lvl_PTP_On_Main);
3012 _MDrv_PQ_LoadPTPTable(pInstance, eWindow, u16PQ_PTPIdx);
3013 #if (PQ_4K2K_P2P_H_OFFSET_LIMITIOM == 1)
3014 // 4k2k case, p2p should patch offset to 1, by designer
3015 if((QM_GetInputHSize(eWindow) == 3840) && (QM_GetInputVSize(eWindow) == 2160))
3016 {
3017 MApi_XC_W2BYTEMSK(REG_SC_BK20_1C_L, 0x01, 0xFF);
3018 //MDrv_PQ_LoadTable_U2(pInstance, eWindow, PQ_IP_VIP_Peaking_ON_Voff_Main, PQ_IP_VIP_Peaking_Main);
3019 }
3020 #endif
3021 }
3022 else
3023 {
3024 MS_ASSERT(0);
3025 }
3026 #else
3027 UNUSED(eWindow);
3028 UNUSED(enPTP_Type);
3029 #endif
3030 }
MDrv_PQ_LoadPTPTable(PQ_WIN eWindow,PQ_PTP_FUNCTION_TYPE enPTP_Type)3031 void MDrv_PQ_LoadPTPTable(PQ_WIN eWindow, PQ_PTP_FUNCTION_TYPE enPTP_Type)
3032 {
3033 #ifdef TRACE_DBG
3034 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3035 #endif
3036 if (pu32PQInst == NULL)
3037 {
3038 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3039 return ;
3040 }
3041
3042 stPQ_LoadPTPTable PQArgs;
3043 PQArgs.eWindow = eWindow;
3044 PQArgs.enPTP_Type = enPTP_Type;
3045
3046 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_LOAD_PTP_TABLE, (void*)&PQArgs) != 0)
3047 {
3048 printf("Obtain PQ engine fail\n");
3049 return ;
3050 }
3051 else
3052 {
3053 return ;
3054 }
3055 }
3056
3057 typedef struct {
3058 MS_U8 *pQuality_Map_Aray;
3059 #if (ENABLE_PQ_EX)
3060 MS_U8 *pQuality_Map_Aray_Ex;
3061 #endif
3062 MS_U8 *pGRule_Level[E_GRULE_NUM];
3063 } QMAP_TBL_INIT_INFO;
3064
3065 #define QMAP_TABLE_PANEL_NUMBER 1 // 1920, 1366 , 4K2K
3066 #if PQ_ENABLE_PIP
3067 #define QMAP_TABLE_DISPLAY_NUMBER PQ_DISPLAY_POP+1
3068 #else
3069 #define QMAP_TABLE_DISPLAY_NUMBER PQ_DISPLAY_ONE+1
3070 #endif
3071 QMAP_TBL_INIT_INFO QmapTblInitInfo_Main[QMAP_TABLE_PANEL_NUMBER][QMAP_TABLE_DISPLAY_NUMBER] = {
3072 { // 1920
3073 { // ONE
3074 (void*)QMAP_1920_Main,
3075 #if (ENABLE_PQ_EX)
3076 (void*)QMAP_1920_Main_Ex,
3077 #endif
3078 {
3079 #if (PQ_GRULE_NR_ENABLE)
3080 (void*)MST_GRule_1920_NR_Main,
3081 #endif
3082 #if (PQ_GRULE_OSD_BW_ENABLE == 1)
3083 (void*)MST_GRule_1920_OSD_BW_Main,
3084 #endif
3085 #if (PQ_GRULE_MPEG_NR_ENABLE)
3086 (void*)MST_GRule_1920_MPEG_NR_Main,
3087 #endif
3088 #if (PQ_GRULE_FILM_MODE_ENABLE)
3089 (void*)MST_GRule_1920_FILM_MODE_Main,
3090 #endif
3091 #if (PQ_GRULE_DYNAMIC_CONTRAST_ENABLE)
3092 (void*)MST_GRule_1920_DYNAMIC_CONTRAST_Main,
3093 #endif
3094 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
3095 (void*)MST_GRule_1920_DDR_SELECT_Main,
3096 #endif
3097 #if (PQ_GRULE_ULTRAT_CLEAR_ENABLE)
3098 (void*)MST_GRule_1920_ULTRAT_CLEAR_Main,
3099 #endif
3100 #if (PQ_GRULE_PTP_ENABLE == 1)
3101 (void*)MST_GRule_1920_PTP_Main,
3102 #endif
3103 #if (PQ_GRULE_XVYCC_ENABLE == 1 )
3104 (void*)MST_GRule_1920_XVYCC_Main,
3105 #endif
3106 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
3107 (void*)MST_GRule_1920_GAME_MODE_Main,
3108 #endif
3109 #if (PQ_GRULE_DS_PARAMETERS_ENABLE == 1)
3110 (void*)MST_GRule_1920_DS_PARAMETERS_Main,
3111 #endif
3112 #if (PQ_GRULE_HDR_ENABLE == 1)
3113 (void*)MST_GRule_1920_HDR_Main,
3114 #endif
3115 }
3116 },
3117 #if PQ_ENABLE_PIP
3118 { // PIP
3119 (void*)QMAP_1920_PIP_Main,
3120 #if (ENABLE_PQ_EX)
3121 (void*)QMAP_1920_PIP_Main_Ex,
3122 #endif
3123 {
3124 #if (PQ_GRULE_NR_ENABLE)
3125 (void*)MST_GRule_1920_PIP_NR_Main,
3126 #endif
3127 #if (PQ_GRULE_OSD_BW_ENABLE == 1)
3128 (void*)MST_GRule_1920_PIP_OSD_BW_Main,
3129 #endif
3130 #if (PQ_GRULE_MPEG_NR_ENABLE)
3131 (void*)MST_GRule_1920_PIP_MPEG_NR_Main,
3132 #endif
3133 #if (PQ_GRULE_FILM_MODE_ENABLE)
3134 (void*)MST_GRule_1920_PIP_FILM_MODE_Main,
3135 #endif
3136 #if (PQ_GRULE_DYNAMIC_CONTRAST_ENABLE)
3137 (void*)MST_GRule_1920_PIP_DYNAMIC_CONTRAST_Main,
3138 #endif
3139 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
3140 (void*)MST_GRule_1920_PIP_DDR_SELECT_Main,
3141 #endif
3142 #if (PQ_GRULE_ULTRAT_CLEAR_ENABLE)
3143 (void*)MST_GRule_1920_PIP_ULTRAT_CLEAR_Main,
3144 #endif
3145 #if (PQ_GRULE_PTP_ENABLE == 1)
3146 (void*)MST_GRule_1920_PIP_PTP_Main,
3147 #endif
3148 #if (PQ_GRULE_XVYCC_ENABLE == 1 )
3149 (void*)MST_GRule_1920_PIP_XVYCC_Main,
3150 #endif
3151 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
3152 (void*)MST_GRule_1920_PIP_GAME_MODE_Main,
3153 #endif
3154 #if (PQ_GRULE_DS_PARAMETERS_ENABLE == 1)
3155 (void*)MST_GRule_1920_PIP_DS_PARAMETERS_Main,
3156 #endif
3157 #if (PQ_GRULE_HDR_ENABLE == 1)
3158 (void*)MST_GRule_1920_PIP_HDR_Main,
3159 #endif
3160 }
3161 },
3162 { // POP
3163 (void*)QMAP_1920_POP_Main,
3164 #if (ENABLE_PQ_EX)
3165 (void*)QMAP_1920_POP_Main_Ex,
3166 #endif
3167 {
3168 #if (PQ_GRULE_NR_ENABLE)
3169 (void*)MST_GRule_1920_POP_NR_Main,
3170 #endif
3171 #if (PQ_GRULE_OSD_BW_ENABLE == 1)
3172 (void*)MST_GRule_1920_POP_OSD_BW_Main,
3173 #endif
3174 #if (PQ_GRULE_MPEG_NR_ENABLE)
3175 (void*)MST_GRule_1920_POP_MPEG_NR_Main,
3176 #endif
3177 #if (PQ_GRULE_FILM_MODE_ENABLE)
3178 (void*)MST_GRule_1920_POP_FILM_MODE_Main,
3179 #endif
3180 #if (PQ_GRULE_DYNAMIC_CONTRAST_ENABLE)
3181 (void*)MST_GRule_1920_POP_DYNAMIC_CONTRAST_Main,
3182 #endif
3183 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
3184 (void*)MST_GRule_1920_POP_DDR_SELECT_Main,
3185 #endif
3186 #if (PQ_GRULE_ULTRAT_CLEAR_ENABLE)
3187 (void*)MST_GRule_1920_POP_ULTRAT_CLEAR_Main,
3188 #endif
3189 #if (PQ_GRULE_PTP_ENABLE == 1)
3190 (void*)MST_GRule_1920_POP_PTP_Main,
3191 #endif
3192 #if (PQ_GRULE_XVYCC_ENABLE == 1 )
3193 (void*)MST_GRule_1920_POP_XVYCC_Main,
3194 #endif
3195 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
3196 (void*)MST_GRule_1920_POP_GAME_MODE_Main,
3197 #endif
3198 #if (PQ_GRULE_DS_PARAMETERS_ENABLE == 1)
3199 (void*)MST_GRule_1920_POP_DS_PARAMETERS_Main,
3200 #endif
3201 #if (PQ_GRULE_HDR_ENABLE == 1)
3202 (void*)MST_GRule_1920_POP_HDR_Main,
3203 #endif
3204 }
3205 },
3206 #endif
3207 },
3208
3209 };
3210
3211 #if PQ_ENABLE_PIP
3212 QMAP_TBL_INIT_INFO QmapTblInitInfo_Sub[QMAP_TABLE_PANEL_NUMBER][QMAP_TABLE_DISPLAY_NUMBER] = {
3213 { // 1920
3214 { // ONE
3215 (void*)QMAP_1920_Sub,
3216 #if (ENABLE_PQ_EX)
3217 (void*)QMAP_1920_Sub_Ex,
3218 #endif
3219 {
3220 #if (PQ_GRULE_NR_ENABLE)
3221 (void*)MST_GRule_1920_NR_Sub,
3222 #endif
3223 }
3224 },
3225 { // PIP
3226 (void*)QMAP_1920_PIP_Sub,
3227 #if (ENABLE_PQ_EX)
3228 (void*)QMAP_1920_PIP_Sub_Ex,
3229 #endif
3230 {
3231 #if (PQ_GRULE_NR_ENABLE)
3232 (void*)MST_GRule_1920_PIP_NR_Sub,
3233 #endif
3234 }
3235 },
3236 { // POP
3237 (void*)QMAP_1920_POP_Sub,
3238 #if (ENABLE_PQ_EX)
3239 (void*)QMAP_1920_POP_Sub_Ex,
3240 #endif
3241 {
3242 #if (PQ_GRULE_NR_ENABLE)
3243 (void*)MST_GRule_1920_POP_NR_Sub,
3244 #endif
3245 }
3246 },
3247 },
3248
3249 };
3250 #endif
3251
_MDrv_PQ_Get_PanelIndexByDisplayWidth(MS_U16 u16DisplayWidth)3252 static MS_U8 _MDrv_PQ_Get_PanelIndexByDisplayWidth(MS_U16 u16DisplayWidth)
3253 {
3254 MS_U8 u8PanelIndex = 0;
3255
3256 switch(u16DisplayWidth)
3257 {
3258 case 1920:
3259 default:
3260 u8PanelIndex = PQ_BIN_PNLTYPE_1920;
3261 break;
3262 }
3263 return u8PanelIndex;
3264 }
3265
_MDrv_PQ_Set_DisplayType_Main(void * pInstance,MS_U16 u16DisplayWidth,PQ_DISPLAY_TYPE enDisplaType,MS_BOOL bSkipCommTable)3266 static MS_BOOL _MDrv_PQ_Set_DisplayType_Main(void *pInstance,MS_U16 u16DisplayWidth, PQ_DISPLAY_TYPE enDisplaType, MS_BOOL bSkipCommTable)
3267 {
3268 MS_U8 u8PanelIndex = 0;
3269 PQTABLE_INFO PQTableInfo;
3270 PQTABLE_INFO PQTableInfoEx;
3271
3272 memset(&PQTableInfo, 0, sizeof(PQTABLE_INFO));
3273 memset(&PQTableInfoEx, 0, sizeof(PQTABLE_INFO));
3274
3275 u8PanelIndex = _MDrv_PQ_Get_PanelIndexByDisplayWidth(u16DisplayWidth);
3276
3277 PQTableInfo.pQuality_Map_Aray = (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pQuality_Map_Aray;
3278 #if (PQ_GRULE_NR_ENABLE)
3279 PQTableInfo.pGRule_Level[E_GRULE_NR] =
3280 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_NR];
3281 #endif
3282 #if (PQ_GRULE_MPEG_NR_ENABLE)
3283 PQTableInfo.pGRule_Level[E_GRULE_MPEG_NR] =
3284 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_MPEG_NR];
3285 #endif
3286 #if (PQ_GRULE_FILM_MODE_ENABLE)
3287 PQTableInfo.pGRule_Level[E_GRULE_FilmMode] =
3288 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_FilmMode];
3289 #endif
3290 #if (PQ_GRULE_DYNAMIC_CONTRAST_ENABLE)
3291 PQTableInfo.pGRule_Level[E_GRULE_DynContr] =
3292 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_DynContr];
3293 #endif
3294 #if (PQ_GRULE_ULTRAT_CLEAR_ENABLE)
3295 PQTableInfo.pGRule_Level[E_GRULE_ULTRACLEAR] =
3296 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_ULTRACLEAR];
3297 #endif
3298 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
3299 PQTableInfo.pGRule_Level[E_GRULE_DDR_SELECT] =
3300 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_DDR_SELECT];
3301 #endif
3302 #if (PQ_GRULE_OSD_BW_ENABLE == 1)
3303 PQTableInfo.pGRule_Level[E_GRULE_OSD_BW] =
3304 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_OSD_BW];
3305 #endif
3306 #if (PQ_GRULE_PTP_ENABLE == 1)
3307 PQTableInfo.pGRule_Level[E_GRULE_PTP] =
3308 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_PTP];
3309 #endif
3310 #if (PQ_GRULE_XVYCC_ENABLE == 1 )
3311 PQTableInfo.pGRule_Level[E_GRULE_XVYCC] =
3312 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_XVYCC];
3313 #endif
3314 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
3315 PQTableInfo.pGRule_Level[E_GRULE_GAME_MODE] =
3316 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_GAME_MODE];
3317 #endif
3318 #if (PQ_GRULE_DS_PARAMETERS_ENABLE == 1)
3319 PQTableInfo.pGRule_Level[E_GRULE_DS_PARAMETERS] =
3320 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_DS_PARAMETERS];
3321 #endif
3322 #if (PQ_GRULE_HDR_ENABLE == 1)
3323 PQTableInfo.pGRule_Level[E_GRule_HDR_Main] =
3324 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pGRule_Level[E_GRule_HDR_Main];
3325 #endif
3326
3327
3328 // table config parameter
3329 PQTableInfo.u8PQ_InputType_Num = QM_INPUTTYPE_NUM_Main;
3330 PQTableInfo.u8PQ_IP_Num = PQ_IP_NUM_Main;
3331 PQTableInfo.pIPTAB_Info = (void*)PQ_IPTAB_INFO_Main;
3332 PQTableInfo.pSkipRuleIP = (void*)MST_SkipRule_IP_Main;
3333
3334 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_HSD] = PQ_HSDRule_IP_NUM_Main;
3335 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_VSD] = PQ_VSDRule_IP_NUM_Main;
3336 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_HSP] = PQ_HSPRule_IP_NUM_Main;
3337 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_VSP] = PQ_VSPRule_IP_NUM_Main;
3338 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_CSC] = PQ_CSCRule_IP_NUM_Main;
3339 #if (PQ_XRULE_DB_ENABLE == 1)
3340 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_DB_NTSC] = PQ_DBRule_NTSC_IP_NUM_Main;
3341 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_DB_PAL] = PQ_DBRule_PAL_IP_NUM_Main;
3342 #endif
3343
3344 PQTableInfo.pXRule_IP_Index[E_XRULE_HSD] = (void*)MST_HSDRule_IP_Index_Main;
3345 PQTableInfo.pXRule_IP_Index[E_XRULE_VSD] = (void*)MST_VSDRule_IP_Index_Main;
3346 PQTableInfo.pXRule_IP_Index[E_XRULE_HSP] = (void*)MST_HSPRule_IP_Index_Main;
3347 PQTableInfo.pXRule_IP_Index[E_XRULE_VSP] = (void*)MST_VSPRule_IP_Index_Main;
3348 PQTableInfo.pXRule_IP_Index[E_XRULE_CSC] = (void*)MST_CSCRule_IP_Index_Main;
3349 #if (PQ_XRULE_DB_ENABLE == 1)
3350 PQTableInfo.pXRule_IP_Index[E_XRULE_DB_NTSC] = (void*)MST_DBRule_NTSC_IP_Index_Main;
3351 PQTableInfo.pXRule_IP_Index[E_XRULE_DB_PAL] = (void*)MST_DBRule_PAL_IP_Index_Main;
3352 #endif
3353
3354 PQTableInfo.pXRule_Array[E_XRULE_HSD] = (void*)MST_HSDRule_Array_Main;
3355 PQTableInfo.pXRule_Array[E_XRULE_VSD] = (void*)MST_VSDRule_Array_Main;
3356 PQTableInfo.pXRule_Array[E_XRULE_HSP] = (void*)MST_HSPRule_Array_Main;
3357 PQTableInfo.pXRule_Array[E_XRULE_VSP] = (void*)MST_VSPRule_Array_Main;
3358 PQTableInfo.pXRule_Array[E_XRULE_CSC] = (void*)MST_CSCRule_Array_Main;
3359 #if (PQ_XRULE_DB_ENABLE == 1)
3360 PQTableInfo.pXRule_Array[E_XRULE_DB_NTSC] = (void*)MST_DBRule_NTSC_Array_Main;
3361 PQTableInfo.pXRule_Array[E_XRULE_DB_PAL] = (void*)MST_DBRule_PAL_Array_Main;
3362 #endif
3363
3364 PQTableInfo.u8PQ_GRule_Num[E_GRULE_NR] = PQ_GRULE_NR_NUM_Main;
3365 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_NR] = PQ_GRULE_NR_IP_NUM_Main;
3366 PQTableInfo.pGRule_IP_Index[E_GRULE_NR] = (void*)MST_GRule_NR_IP_Index_Main;
3367 PQTableInfo.pGRule_Array[E_GRULE_NR] = (void*)MST_GRule_NR_Main;
3368 #if (PQ_GRULE_MPEG_NR_ENABLE)
3369 PQTableInfo.u8PQ_GRule_Num[E_GRULE_MPEG_NR] = PQ_GRULE_MPEG_NR_NUM_Main;
3370 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_MPEG_NR] = PQ_GRULE_MPEG_NR_IP_NUM_Main;
3371 PQTableInfo.pGRule_IP_Index[E_GRULE_MPEG_NR] = (void*)MST_GRule_MPEG_NR_IP_Index_Main;
3372 PQTableInfo.pGRule_Array[E_GRULE_MPEG_NR] = (void*)MST_GRule_MPEG_NR_Main;
3373 #endif
3374
3375 #if (PQ_GRULE_FILM_MODE_ENABLE)
3376 PQTableInfo.u8PQ_GRule_Num[E_GRULE_FilmMode] = PQ_GRULE_FILM_MODE_NUM_Main;
3377 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_FilmMode] = PQ_GRULE_FILM_MODE_IP_NUM_Main;
3378 PQTableInfo.pGRule_IP_Index[E_GRULE_FilmMode] = (void*)MST_GRule_FILM_MODE_IP_Index_Main;
3379 PQTableInfo.pGRule_Array[E_GRULE_FilmMode] = (void*)MST_GRule_FILM_MODE_Main;
3380 #endif
3381
3382 #if (PQ_GRULE_DYNAMIC_CONTRAST_ENABLE)
3383 PQTableInfo.u8PQ_GRule_Num[E_GRULE_DynContr] = PQ_GRULE_DYNAMIC_CONTRAST_NUM_Main;
3384 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_DynContr] = PQ_GRULE_DYNAMIC_CONTRAST_IP_NUM_Main;
3385 PQTableInfo.pGRule_IP_Index[E_GRULE_DynContr] = (void*)MST_GRule_DYNAMIC_CONTRAST_IP_Index_Main;
3386 PQTableInfo.pGRule_Array[E_GRULE_DynContr] = (void*)MST_GRule_DYNAMIC_CONTRAST_Main;
3387 #endif
3388
3389 #if (PQ_GRULE_ULTRAT_CLEAR_ENABLE)
3390 PQTableInfo.u8PQ_GRule_Num[E_GRULE_ULTRACLEAR] = PQ_GRULE_ULTRAT_CLEAR_NUM_Main;
3391 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_ULTRACLEAR] = PQ_GRULE_ULTRAT_CLEAR_IP_NUM_Main;
3392 PQTableInfo.pGRule_IP_Index[E_GRULE_ULTRACLEAR] = (void*)MST_GRule_ULTRAT_CLEAR_IP_Index_Main;
3393 PQTableInfo.pGRule_Array[E_GRULE_ULTRACLEAR] = (void*)MST_GRule_ULTRAT_CLEAR_Main;
3394 #endif
3395
3396 #if (PQ_GRULE_DDR_SELECT_ENABLE == 1)
3397 PQTableInfo.u8PQ_GRule_Num[E_GRULE_DDR_SELECT] = PQ_GRULE_DDR_SELECT_NUM_Main;
3398 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_DDR_SELECT] = PQ_GRULE_DDR_SELECT_IP_NUM_Main;
3399 PQTableInfo.pGRule_IP_Index[E_GRULE_DDR_SELECT] = (void*)MST_GRule_DDR_SELECT_IP_Index_Main;
3400 PQTableInfo.pGRule_Array[E_GRULE_DDR_SELECT] = (void*)MST_GRule_DDR_SELECT_Main;
3401 #endif
3402
3403 #if (PQ_GRULE_OSD_BW_ENABLE == 1)
3404 PQTableInfo.u8PQ_GRule_Num[E_GRULE_OSD_BW] = PQ_GRULE_OSD_BW_NUM_Main;
3405 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_OSD_BW] = PQ_GRULE_OSD_BW_IP_NUM_Main;
3406 PQTableInfo.pGRule_IP_Index[E_GRULE_OSD_BW] = (void*)MST_GRule_OSD_BW_IP_Index_Main;
3407 PQTableInfo.pGRule_Array[E_GRULE_OSD_BW] = (void*)MST_GRule_OSD_BW_Main;
3408 #endif
3409
3410 #if (PQ_GRULE_PTP_ENABLE == 1)
3411 PQTableInfo.u8PQ_GRule_Num[E_GRULE_PTP] = PQ_GRULE_PTP_NUM_Main;
3412 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_PTP] = PQ_GRULE_PTP_IP_NUM_Main;
3413 PQTableInfo.pGRule_IP_Index[E_GRULE_PTP] = (void*)MST_GRule_PTP_IP_Index_Main;
3414 PQTableInfo.pGRule_Array[E_GRULE_PTP] = (void*)MST_GRule_PTP_Main;
3415 #endif
3416
3417 #if (PQ_GRULE_XVYCC_ENABLE == 1 )
3418 PQTableInfo.u8PQ_GRule_Num[E_GRULE_XVYCC] = PQ_GRULE_XVYCC_NUM_Main;
3419 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_XVYCC] = PQ_GRULE_XVYCC_IP_NUM_Main;
3420 PQTableInfo.pGRule_IP_Index[E_GRULE_XVYCC] = (void*)MST_GRule_XVYCC_IP_Index_Main;
3421 PQTableInfo.pGRule_Array[E_GRULE_XVYCC] = (void*)MST_GRule_XVYCC_Main;
3422 #endif
3423
3424 #if (PQ_GRULE_GAME_MODE_ENABLE == 1)
3425 PQTableInfo.u8PQ_GRule_Num[E_GRULE_GAME_MODE] = PQ_GRULE_GAME_MODE_NUM_Main;
3426 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_GAME_MODE] = PQ_GRULE_GAME_MODE_IP_NUM_Main;
3427 PQTableInfo.pGRule_IP_Index[E_GRULE_GAME_MODE] = (void*)MST_GRule_GAME_MODE_IP_Index_Main;
3428 PQTableInfo.pGRule_Array[E_GRULE_GAME_MODE] = (void*)MST_GRule_GAME_MODE_Main;
3429 #endif
3430 #if (PQ_GRULE_DS_PARAMETERS_ENABLE == 1)
3431 PQTableInfo.u8PQ_GRule_Num[E_GRULE_DS_PARAMETERS] = PQ_GRULE_DS_PARAMETERS_NUM_Main;
3432 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_DS_PARAMETERS] = PQ_GRULE_DS_PARAMETERS_IP_NUM_Main;
3433 PQTableInfo.pGRule_IP_Index[E_GRULE_DS_PARAMETERS] = (void*)MST_GRule_DS_PARAMETERS_IP_Index_Main;
3434 PQTableInfo.pGRule_Array[E_GRULE_DS_PARAMETERS] = (void*)MST_GRule_DS_PARAMETERS_Main;
3435 #endif
3436 #if (PQ_GRULE_HDR_ENABLE == 1)
3437 PQTableInfo.u8PQ_GRule_Num[E_GRule_HDR_Main] = PQ_GRULE_HDR_NUM_Main;
3438 PQTableInfo.u8PQ_GRule_IPNum[E_GRule_HDR_Main] = PQ_GRULE_HDR_IP_NUM_Main;
3439 PQTableInfo.pGRule_IP_Index[E_GRule_HDR_Main] = (void*)MST_GRule_HDR_IP_Index_Main;
3440 PQTableInfo.pGRule_Array[E_GRule_HDR_Main] = (void*)MST_GRule_HDR_Main;
3441 #endif
3442
3443 MDrv_PQ_AddTable_(MAIN,pInstance, &PQTableInfo);
3444 if(!bSkipCommTable)
3445 {
3446 MDrv_PQ_LoadCommTable_(MAIN,pInstance);
3447 }
3448
3449 #if (ENABLE_PQ_EX)
3450 // table config parameter
3451 PQTableInfoEx = PQTableInfo;
3452
3453 PQTableInfoEx.u8PQ_InputType_Num = QM_INPUTTYPE_NUM_Main_Ex;
3454 PQTableInfoEx.u8PQ_IP_Num = PQ_IP_NUM_Main_Ex;
3455 PQTableInfoEx.pIPTAB_Info = (void*)PQ_IPTAB_INFO_Main_Ex;
3456 PQTableInfoEx.pSkipRuleIP = (void*)MST_SkipRule_IP_Main_Ex;
3457
3458 PQTableInfoEx.pQuality_Map_Aray =
3459 (void*)QmapTblInitInfo_Main[u8PanelIndex][enDisplaType].pQuality_Map_Aray_Ex;
3460
3461 MDrv_PQ_AddTable_(MAINEX,pInstance, &PQTableInfoEx);
3462 if(!bSkipCommTable)
3463 {
3464 MDrv_PQ_LoadCommTable_(MAINEX,pInstance);
3465 }
3466 if((MS_U16)QM_INPUTTYPE_NUM_Main != (MS_U16)QM_INPUTTYPE_NUM_Main_Ex)
3467 {
3468 //printf("PQ INPUTTYPE NUM MISMATCH: MAIN != EX");
3469 //MS_ASSERT(0);
3470 }
3471 #endif
3472 return TRUE;
3473 }
3474
_MDrv_PQ_Set_DisplayType_Sub(void * pInstance,MS_U16 u16DisplayWidth,PQ_DISPLAY_TYPE enDisplaType,MS_BOOL bSkipCommTable)3475 static MS_BOOL _MDrv_PQ_Set_DisplayType_Sub(void *pInstance,MS_U16 u16DisplayWidth, PQ_DISPLAY_TYPE enDisplaType, MS_BOOL bSkipCommTable)
3476 {
3477 #if PQ_ENABLE_PIP
3478 MS_U8 u8PanelIndex = 0;
3479
3480 PQTABLE_INFO PQTableInfo;
3481 PQTABLE_INFO PQTableInfoEx;
3482
3483 memset(&PQTableInfo, 0, sizeof(PQTABLE_INFO));
3484 memset(&PQTableInfoEx, 0, sizeof(PQTABLE_INFO));
3485
3486 u8PanelIndex = _MDrv_PQ_Get_PanelIndexByDisplayWidth(u16DisplayWidth);
3487
3488 PQTableInfo.pQuality_Map_Aray =
3489 (void*)QmapTblInitInfo_Sub[u8PanelIndex][enDisplaType].pQuality_Map_Aray;
3490 #if (PQ_GRULE_NR_ENABLE)
3491 PQTableInfo.pGRule_Level[E_GRULE_NR] =
3492 (void*)QmapTblInitInfo_Sub[u8PanelIndex][enDisplaType].pGRule_Level[E_GRULE_NR];
3493
3494 #endif
3495
3496 // table config parameter
3497 PQTableInfo.u8PQ_InputType_Num = QM_INPUTTYPE_NUM_Sub;
3498 PQTableInfo.u8PQ_IP_Num = PQ_IP_NUM_Sub;
3499 PQTableInfo.pIPTAB_Info = (void*)PQ_IPTAB_INFO_Sub;
3500 PQTableInfo.pSkipRuleIP = (void*)MST_SkipRule_IP_Sub;
3501
3502 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_HSD] = PQ_HSDRule_IP_NUM_Sub;
3503 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_VSD] = PQ_VSDRule_IP_NUM_Sub;
3504 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_HSP] = PQ_HSPRule_IP_NUM_Sub;
3505 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_VSP] = PQ_VSPRule_IP_NUM_Sub;
3506 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_CSC] = PQ_CSCRule_IP_NUM_Sub;
3507 #if (PQ_XRULE_DB_ENABLE == 1)
3508 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_DB_NTSC] = PQ_DBRule_NTSC_IP_NUM_Sub;
3509 PQTableInfo.u8PQ_XRule_IP_Num[E_XRULE_DB_PAL] = PQ_DBRule_PAL_IP_NUM_Sub;
3510 #endif
3511
3512 PQTableInfo.pXRule_IP_Index[E_XRULE_HSD] = (void*)MST_HSDRule_IP_Index_Sub;
3513 PQTableInfo.pXRule_IP_Index[E_XRULE_VSD] = (void*)MST_VSDRule_IP_Index_Sub;
3514 PQTableInfo.pXRule_IP_Index[E_XRULE_HSP] = (void*)MST_HSPRule_IP_Index_Sub;
3515 PQTableInfo.pXRule_IP_Index[E_XRULE_VSP] = (void*)MST_VSPRule_IP_Index_Sub;
3516 PQTableInfo.pXRule_IP_Index[E_XRULE_CSC] = (void*)MST_CSCRule_IP_Index_Sub;
3517 #if (PQ_XRULE_DB_ENABLE == 1)
3518 PQTableInfo.pXRule_IP_Index[E_XRULE_DB_NTSC] = (void*)MST_DBRule_NTSC_IP_Index_Sub;
3519 PQTableInfo.pXRule_IP_Index[E_XRULE_DB_PAL] = (void*)MST_DBRule_PAL_IP_Index_Sub;
3520 #endif
3521
3522 PQTableInfo.pXRule_Array[E_XRULE_HSD] = (void*)MST_HSDRule_Array_Sub;
3523 PQTableInfo.pXRule_Array[E_XRULE_VSD] = (void*)MST_VSDRule_Array_Sub;
3524 PQTableInfo.pXRule_Array[E_XRULE_HSP] = (void*)MST_HSPRule_Array_Sub;
3525 PQTableInfo.pXRule_Array[E_XRULE_VSP] = (void*)MST_VSPRule_Array_Sub;
3526 PQTableInfo.pXRule_Array[E_XRULE_CSC] = (void*)MST_CSCRule_Array_Sub;
3527 #if (PQ_XRULE_DB_ENABLE == 1)
3528 PQTableInfo.pXRule_Array[E_XRULE_DB_NTSC] = (void*)MST_DBRule_NTSC_Array_Sub;
3529 PQTableInfo.pXRule_Array[E_XRULE_DB_PAL] = (void*)MST_DBRule_PAL_Array_Sub;
3530 #endif
3531
3532 PQTableInfo.u8PQ_GRule_Num[E_GRULE_NR] = PQ_GRULE_NR_NUM_Sub;
3533 PQTableInfo.u8PQ_GRule_IPNum[E_GRULE_NR] = PQ_GRULE_NR_IP_NUM_Sub;
3534 PQTableInfo.pGRule_IP_Index[E_GRULE_NR] = (void*)MST_GRule_NR_IP_Index_Sub;
3535 PQTableInfo.pGRule_Array[E_GRULE_NR] = (void*)MST_GRule_NR_Sub;
3536
3537 MDrv_PQ_AddTable_(SUB,pInstance, &PQTableInfo);
3538 if(!bSkipCommTable)
3539 {
3540 MDrv_PQ_LoadCommTable_(SUB,pInstance);
3541 }
3542
3543 #if (ENABLE_PQ_EX)
3544 // table config parameter
3545 PQTableInfoEx = PQTableInfo;
3546
3547 PQTableInfoEx.u8PQ_InputType_Num = QM_INPUTTYPE_NUM_Sub_Ex;
3548 PQTableInfoEx.u8PQ_IP_Num = PQ_IP_NUM_Sub_Ex;
3549 PQTableInfoEx.pIPTAB_Info = (void*)PQ_IPTAB_INFO_Sub_Ex;
3550 PQTableInfoEx.pSkipRuleIP = (void*)MST_SkipRule_IP_Sub_Ex;
3551
3552 PQTableInfoEx.pQuality_Map_Aray =
3553 (void*)QmapTblInitInfo_Sub[u8PanelIndex][enDisplaType].pQuality_Map_Aray_Ex;
3554
3555 MDrv_PQ_AddTable_(SUBEX,pInstance, &PQTableInfoEx);
3556 if(!bSkipCommTable)
3557 {
3558 MDrv_PQ_LoadCommTable_(SUBEX,pInstance);
3559 }
3560 #endif
3561 #endif
3562 return TRUE;
3563 }
3564
MDrv_PQ_Init_DisplayType_U2(void * pInstance,MS_U16 u16DisplayWidth,PQ_DISPLAY_TYPE enDisplaType)3565 void MDrv_PQ_Init_DisplayType_U2(void* pInstance,MS_U16 u16DisplayWidth, PQ_DISPLAY_TYPE enDisplaType)
3566 {
3567 PQINFO_DBG(printf("%s: enDisplaType=%u, u16DisplayWidth=%u\n", __FUNCTION__, enDisplaType, u16DisplayWidth));
3568
3569 if(gbPQBinEnable)
3570 {
3571 MDrv_PQBin_SetPanelID(pInstance,_MDrv_PQ_Get_PanelIndexByDisplayWidth(u16DisplayWidth));
3572 MDrv_PQBin_SetDisplayType(pInstance,enDisplaType == PQ_DISPLAY_ONE ? PQ_BIN_DISPLAY_ONE :
3573 enDisplaType == PQ_DISPLAY_PIP ? PQ_BIN_DISPLAY_PIP :
3574 PQ_BIN_DISPLAY_POP);
3575 }
3576 else
3577 {
3578 MS_BOOL bSkipCommTable = PQ_SKIPCOMMTB_ENABLE;
3579
3580 _MDrv_PQ_Set_DisplayType_Sub(pInstance,u16DisplayWidth, enDisplaType, bSkipCommTable);
3581 _MDrv_PQ_Set_DisplayType_Main(pInstance,u16DisplayWidth, enDisplaType, bSkipCommTable);
3582 gu16DisplayWidth = u16DisplayWidth;
3583 }
3584 #if (PQ_ENABLE_PIP)
3585 genDisplayType = PQ_DISPLAY_ONE;
3586 #endif
3587 }
MDrv_PQ_Init_DisplayType(MS_U16 u16DisplayWidth,PQ_DISPLAY_TYPE enDisplaType)3588 void MDrv_PQ_Init_DisplayType(MS_U16 u16DisplayWidth, PQ_DISPLAY_TYPE enDisplaType)
3589 {
3590 #ifdef TRACE_DBG
3591 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3592 #endif
3593 if (pu32PQInst == NULL)
3594 {
3595 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3596 return ;
3597 }
3598
3599 stPQ_Init_DisplayType PQArgs;
3600 PQArgs.u16DisplayWidth = u16DisplayWidth;
3601 PQArgs.enDisplaType = enDisplaType;
3602
3603 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_INIT_DISPLAY_TYPE, (void*)&PQArgs) != 0)
3604 {
3605 printf("Obtain PQ engine fail\n");
3606 return ;
3607 }
3608 else
3609 {
3610 return ;
3611 }
3612 }
3613
MDrv_PQ_Set_DisplayType_U2(void * pInstance,MS_U16 u16DisplayWidth,PQ_DISPLAY_TYPE enDisplaType)3614 void MDrv_PQ_Set_DisplayType_U2(void* pInstance,MS_U16 u16DisplayWidth, PQ_DISPLAY_TYPE enDisplaType)
3615 {
3616 if(enDisplaType != PQ_DISPLAY_ONE)
3617 {
3618 _gbSubWin_En = TRUE;
3619 }
3620 else
3621 {
3622 _gbSubWin_En = FALSE;
3623 }
3624
3625 _enPQDisplayType = enDisplaType;
3626
3627 // QMAP(one, pip, pop) should be the same.
3628 // we need to handle the differnce between one/pip/pop by Grule, not by summary page.
3629 // because Qmap is complicatedly related with VD, ADC sampling. It's not simply dumping table.
3630 // eg. single-->pop, we will load 1920_pop page, but VD won't be re-set again according to
3631 // new VD sampling setting in Pop Page. So, conflict.
3632 {
3633 enDisplaType = PQ_DISPLAY_ONE;
3634 }
3635
3636 #if (PQ_ENABLE_PIP)
3637 PQINFO_DBG(printf("%s: enDisplaType=%u, u16DisplayWidth=%u\n", __FUNCTION__, enDisplaType, u16DisplayWidth));
3638
3639 if(gbPQBinEnable)
3640 {
3641 MDrv_PQBin_SetPanelID(pInstance,_MDrv_PQ_Get_PanelIndexByDisplayWidth(u16DisplayWidth));
3642 MDrv_PQBin_SetDisplayType(pInstance,enDisplaType == PQ_DISPLAY_ONE ? PQ_BIN_DISPLAY_ONE :
3643 enDisplaType == PQ_DISPLAY_PIP ? PQ_BIN_DISPLAY_PIP :
3644 PQ_BIN_DISPLAY_POP);
3645 }
3646 else
3647 {
3648 MS_BOOL bSkipCommTable = TRUE;
3649
3650 if((genDisplayType != enDisplaType) || (gu16DisplayWidth != u16DisplayWidth))
3651 {
3652 _MDrv_PQ_Set_DisplayType_Sub(pInstance,u16DisplayWidth, enDisplaType, bSkipCommTable);
3653 _MDrv_PQ_Set_DisplayType_Main(pInstance,u16DisplayWidth, enDisplaType, bSkipCommTable);
3654 genDisplayType = enDisplaType;
3655 gu16DisplayWidth = u16DisplayWidth;
3656 }
3657 }
3658
3659 #else
3660 if(gbPQBinEnable)
3661 {
3662 UNUSED(u16DisplayWidth);
3663 UNUSED(enDisplaType);
3664 }
3665 else
3666 {
3667 MS_BOOL bSkipCommTable = TRUE;
3668
3669 if((gu16DisplayWidth != u16DisplayWidth))
3670 {
3671 _MDrv_PQ_Set_DisplayType_Main(pInstance,u16DisplayWidth, enDisplaType, bSkipCommTable);
3672 gu16DisplayWidth = u16DisplayWidth;
3673 }
3674 }
3675
3676 #endif
3677 }
MDrv_PQ_Set_DisplayType(MS_U16 u16DisplayWidth,PQ_DISPLAY_TYPE enDisplaType)3678 void MDrv_PQ_Set_DisplayType(MS_U16 u16DisplayWidth, PQ_DISPLAY_TYPE enDisplaType)
3679 {
3680 #ifdef TRACE_DBG
3681 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3682 #endif
3683 if (pu32PQInst == NULL)
3684 {
3685 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3686 return ;
3687 }
3688
3689 stPQ_Set_DisplayType PQArgs;
3690 PQArgs.u16DisplayWidth = u16DisplayWidth;
3691 PQArgs.enDisplaType = enDisplaType;
3692
3693 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_DISPLAY_TYPE, (void*)&PQArgs) != 0)
3694 {
3695 printf("Obtain PQ engine fail\n");
3696 return ;
3697 }
3698 else
3699 {
3700 return ;
3701 }
3702 }
3703
MDrv_PQDS_Update_PanelID(void * pInstance,MS_U16 u16DisplayWidth)3704 void MDrv_PQDS_Update_PanelID(void *pInstance, MS_U16 u16DisplayWidth)
3705 {
3706 if(u16DisplayWidth <= 1366)
3707 {
3708 MDrv_PQBin_SetPanelID(pInstance,_MDrv_PQ_Get_PanelIndexByDisplayWidth(1366));
3709 }
3710 else if (u16DisplayWidth == 1920)
3711 {
3712 MDrv_PQBin_SetPanelID(pInstance,_MDrv_PQ_Get_PanelIndexByDisplayWidth(1920));
3713 }
3714 else if (u16DisplayWidth == 3840)
3715 {
3716 MDrv_PQBin_SetPanelID(pInstance,_MDrv_PQ_Get_PanelIndexByDisplayWidth(3840));
3717 }
3718 else
3719 {
3720 MDrv_PQBin_SetPanelID(pInstance,_MDrv_PQ_Get_PanelIndexByDisplayWidth(1920));
3721 }
3722
3723 }
3724
MDrv_PQ_GetMADiFromOSDBWGrule_U2(void * pInstance,PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi,MS_U16 * pu16TabIdx_MADi_Motion)3725 MS_BOOL MDrv_PQ_GetMADiFromOSDBWGrule_U2(void* pInstance,PQ_WIN eWindow,
3726 MS_U16 *pu16TabIdx_MADi,
3727 MS_U16 *pu16TabIdx_MADi_Motion)
3728 {
3729 #if PQ_GRULE_OSD_BW_ENABLE
3730 MS_U16 u16PQ_OSDBWIdx = 0;
3731
3732 if(eWindow == PQ_MAIN_WINDOW)
3733 {
3734 #if (PQ_OSD_BW_VER == 1)
3735 #if PQ_GRULE_DDR_SELECT_ENABLE
3736 {
3737 if(bw_info.u32Miu1MemSize ==0) // 1 DDR
3738 {
3739 u16PQ_OSDBWIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_1DDR_On_Main);
3740 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 0); // only MADi ip
3741 }
3742 else // 2 DDR
3743 {
3744 u16PQ_OSDBWIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_2DDR_On_Main);
3745 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 0); // only MADi ip
3746 }
3747 }
3748 #else //DDR select disable
3749 {
3750 u16PQ_OSDBWIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_Main);
3751 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 0); // only MADi ip
3752 }
3753 #endif
3754 #elif (PQ_OSD_BW_VER == 2)
3755 #if PQ_GRULE_DDR_SELECT_ENABLE
3756 if(bw_info.bDDR2 == FALSE) // DDR 3
3757 {
3758 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
3759 {
3760 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR3 mirror\n"));
3761 u16PQ_OSDBWIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR3_Mirror_Main);
3762 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 0); // only MADi ip
3763 }
3764 else
3765 {
3766 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR3 non-mirror\n"));
3767 u16PQ_OSDBWIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR3_Main);
3768 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 0); // only MADi ip
3769 }
3770 }
3771 else // DDR 2
3772 {
3773 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
3774 {
3775 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR2 mirror\n"));
3776 u16PQ_OSDBWIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR2_Mirror_Main);
3777 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 0); // only MADi ip
3778 }
3779 else
3780 {
3781 PQMADi_DBG(printf("MDrv_PQ_GetMADiFromGrule_OSDBW_Ver2: DDR2 non-mirror\n"));
3782 u16PQ_OSDBWIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_OSD_BW_Main, PQ_GRule_Lvl_OSD_BW_On_DDR2_Main);
3783 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 0); // only MADi ip
3784 }
3785 }
3786 #endif
3787 #endif
3788
3789 #if (PQ_GRULE_OSD_BW_IP_NUM_Main > 1)
3790 *pu16TabIdx_MADi_Motion = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_OSD_BW_Main, u16PQ_OSDBWIdx, 1); // Add MADi_Motion ip
3791 #else
3792 UNUSED(pu16TabIdx_MADi_Motion);
3793 #endif
3794 }
3795 else
3796 {
3797 // TODO: Should sub window need to consider the OSD BW ??
3798 }
3799 #else
3800 UNUSED(eWindow);
3801 UNUSED(pu16TabIdx_MADi_Motion);
3802 UNUSED(pu16TabIdx_MADi);
3803 #endif
3804
3805 return TRUE;
3806 }
MDrv_PQ_GetMADiFromOSDBWGrule(PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi,MS_U16 * pu16TabIdx_MADi_Motion)3807 MS_BOOL MDrv_PQ_GetMADiFromOSDBWGrule(PQ_WIN eWindow,
3808 MS_U16 *pu16TabIdx_MADi,
3809 MS_U16 *pu16TabIdx_MADi_Motion)
3810 {
3811 #ifdef TRACE_DBG
3812 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3813 #endif
3814 if (pu32PQInst == NULL)
3815 {
3816 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3817 return FALSE;
3818 }
3819
3820 stPQ_GetMADiFromOSDBWGrule PQArgs;
3821 PQArgs.eWindow = eWindow;
3822 PQArgs.pu16TabIdx_MADi = pu16TabIdx_MADi;
3823 PQArgs.pu16TabIdx_MADi_Motion = pu16TabIdx_MADi_Motion;
3824 PQArgs.bReturnValue = FALSE;
3825
3826 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_MADI_FROM_OSDBW_GRULE, (void*)&PQArgs) != 0)
3827 {
3828 printf("Obtain PQ engine fail\n");
3829 return FALSE;
3830 }
3831 else
3832 {
3833 return PQArgs.bReturnValue;
3834 }
3835 }
3836
MDrv_PQ_GetMADiInGeneral_U2(void * pInstance,PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi,MS_U16 * pu16TabIdx_MADi_Motion)3837 MS_BOOL MDrv_PQ_GetMADiInGeneral_U2(void* pInstance,PQ_WIN eWindow, MS_U16 *pu16TabIdx_MADi, MS_U16 *pu16TabIdx_MADi_Motion)
3838 {
3839 UNUSED(pu16TabIdx_MADi_Motion);
3840 UNUSED(pu16TabIdx_MADi);
3841 #if PQ_GRULE_DDR_SELECT_ENABLE
3842 if(eWindow == PQ_MAIN_WINDOW)
3843 {
3844 MS_U16 u16PQ_DDRSELIdx = 0;
3845 #if (PQ_DDR_SELECT_VER == 1)
3846 if(bw_info.u32Miu1MemSize==0) // 1 DDR
3847 {
3848 PQMADi_DBG(printf("MDrv_PQ_GetMADiInGeneral: 1 DDR \n"));
3849 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_1DDR_Main);
3850 }
3851 else // 2 DDR
3852 {
3853 PQMADi_DBG(printf("MDrv_PQ_GetMADiInGeneral: 2 DDR \n"));
3854 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_2DDR_Main);
3855 }
3856 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 0); // only MADi ip
3857 #elif (PQ_DDR_SELECT_VER == 2)
3858 if(bw_info.bDDR2 == FALSE) // DDR 3
3859 {
3860 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
3861 {
3862 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR3 mirror\n"));
3863 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR3_Mirror_Main);
3864 }
3865 else
3866 {
3867 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR3 non-mirror\n"));
3868 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR3_Main);
3869 }
3870 }
3871 else // DDR 2
3872 {
3873 if(MApi_XC_GetMirrorModeTypeEx(MAIN_WINDOW) != MIRROR_NORMAL)
3874 {
3875 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR2 mirror\n"));
3876 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR2_Mirror_Main);
3877 }
3878 else
3879 {
3880 PQMADi_DBG(printf("MDrv_PQ_GetDDRMirrorSelectInfo: DDR2 non-mirror\n"));
3881 u16PQ_DDRSELIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_DDR_SELECT_Main, PQ_GRule_Lvl_DDR_SELECT_DDR2_Main);
3882 }
3883 }
3884 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 0);
3885 *pu16TabIdx_MADi_Motion = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_DDR_SELECT_Main, u16PQ_DDRSELIdx, 1);
3886 #endif
3887 }
3888 else
3889 {
3890 #if (ENABLE_LITE_SN == 0)
3891 *pu16TabIdx_MADi = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_Sub);
3892 #endif
3893 }
3894 #else //DDR select disable
3895 if(eWindow == PQ_MAIN_WINDOW)
3896 {
3897 *pu16TabIdx_MADi = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_Main);
3898 #if PQ_GRULE_OSD_BW_ENABLE
3899 *pu16TabIdx_MADi_Motion = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_Motion_Main); //y MADi_motion ip
3900 #endif
3901 }
3902 #if PQ_ENABLE_PIP
3903 else
3904 {
3905 *pu16TabIdx_MADi = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_Sub);
3906 #if PQ_GRULE_OSD_BW_ENABLE
3907 *pu16TabIdx_MADi_Motion = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_MADi_Motion_Sub); // MADi_motion ip
3908 #endif
3909 }
3910 #endif
3911 //printf("$$[%s]:%d, %s, u16TabIdx_MADi=%u\n", __FUNCTION__, __LINE__, eWindow?"SUB":"MAIN", u16TabIdx_MADi);
3912
3913 #endif
3914
3915 #if PQ_GRULE_SLZ_ENABLE
3916 MS_U16 u16PQ_SLZIdx = 0;
3917 MS_BOOL bSeamlessZappingEnable;
3918
3919 if(MApi_XC_GetSeamlessZappingStatus(eWindow, &bSeamlessZappingEnable) == E_APIXC_RET_OK)
3920 {
3921 if(bSeamlessZappingEnable)
3922 {
3923 if(eWindow == PQ_MAIN_WINDOW)
3924 {
3925 u16PQ_SLZIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_SLZ_Main, PQ_GRule_Lvl_SLZ_On_Main);
3926 PQMADi_DBG(printf("MDrv_PQ_GetMADiInGeneral: Main LSZ =%u\n", u16PQ_SLZIdx));
3927 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Main, u16PQ_SLZIdx, 0); //y MADi ip
3928 *pu16TabIdx_MADi_Motion = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Main, u16PQ_SLZIdx, 1); //y MADi_motion ip
3929 }
3930 #if PQ_ENABLE_PIP
3931 else
3932 {
3933 u16PQ_SLZIdx = MDrv_PQ_GetGRule_LevelIndex_U2(pInstance, eWindow, PQ_GRule_SLZ_Sub, PQ_GRule_Lvl_SLZ_On_Sub);
3934 PQMADi_DBG(printf("MDrv_PQ_GetMADiInGeneral: Sub LSZ =%u\n", u16PQ_SLZIdx));
3935 *pu16TabIdx_MADi = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Sub, u16PQ_SLZIdx, 0); // MADi ip
3936 *pu16TabIdx_MADi_Motion = MDrv_PQ_GetGRule_TableIndex(eWindow, PQ_GRule_SLZ_Sub, u16PQ_SLZIdx, 1); // MADi_motion ip
3937 }
3938 #endif
3939 }
3940 else
3941 {
3942 //it's not slz case
3943 }
3944 }
3945 else
3946 {
3947 printf("MApi_XC_GetStatusEx () version is incorrect at %s %d, the code's purpose is not fulfilled.\n",__FILE__,(int)__LINE__);
3948 }
3949 #else
3950 UNUSED(pu16TabIdx_MADi_Motion);
3951
3952 #endif
3953
3954 return TRUE;
3955 }
MDrv_PQ_GetMADiInGeneral(PQ_WIN eWindow,MS_U16 * pu16TabIdx_MADi,MS_U16 * pu16TabIdx_MADi_Motion)3956 MS_BOOL MDrv_PQ_GetMADiInGeneral(PQ_WIN eWindow, MS_U16 *pu16TabIdx_MADi, MS_U16 *pu16TabIdx_MADi_Motion)
3957 {
3958 #ifdef TRACE_DBG
3959 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
3960 #endif
3961 if (pu32PQInst == NULL)
3962 {
3963 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
3964 return FALSE;
3965 }
3966
3967 stPQ_GetMADiInGeneral PQArgs;
3968 PQArgs.eWindow = eWindow;
3969 PQArgs.pu16TabIdx_MADi = pu16TabIdx_MADi;
3970 PQArgs.pu16TabIdx_MADi_Motion = pu16TabIdx_MADi_Motion;
3971 PQArgs.bReturnValue = FALSE;
3972
3973 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_GET_MADI_IN_GENERAL, (void*)&PQArgs) != 0)
3974 {
3975 printf("Obtain PQ engine fail\n");
3976 return FALSE;
3977 }
3978 else
3979 {
3980 return PQArgs.bReturnValue;
3981 }
3982 }
3983
MDrv_PQ_Check_PointToPoint_Condition_U2(void * pInstance,XC_SETWIN_INFO * pstXC_SetWin_Info,PQ_WIN eWindow)3984 MS_BOOL MDrv_PQ_Check_PointToPoint_Condition_U2(void* pInstance,XC_SETWIN_INFO *pstXC_SetWin_Info,PQ_WIN eWindow)
3985 {
3986 UNUSED(eWindow);
3987 MS_BOOL bRet = FALSE;
3988
3989 #if PQ_GRULE_PTP_ENABLE
3990 // HDMI RGB, HDMI YUV444, DVI, VGA.
3991 // all in progressive mode
3992 PQP2P_DBG(printf("----HDMI source=%u, HDMIPacket=%u, RGB=%u, YUV444=%u, VGA=%u, interlace=%u\n",
3993 (IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)),
3994 (_stHDMI_Info[eWindow].bIsHDMI == TRUE),
3995 (QM_HDMIPC_COLORRGB(PQ_MAIN_WINDOW)),
3996 (QM_HDMIPC_COLORYUV444(PQ_MAIN_WINDOW)),
3997 (IsSrcTypeVga(pstXC_SetWin_Info->enInputSourceType)),
3998 (pstXC_SetWin_Info->bInterlace)
3999 );)
4000 //at this time, the PQ input source has not been inited. so we use XC_SETWIN_INFO to check
4001 //we cannot do the PTP when timing size is bigger than panel size
4002 if((((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == TRUE) && (QM_HDMIPC_COLORRGB(PQ_MAIN_WINDOW))) ||
4003 ((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == TRUE) && (QM_HDMIPC_COLORYUV444(PQ_MAIN_WINDOW))) ||
4004 ((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == FALSE) && (QM_HDMIPC_COLORYUV444(PQ_MAIN_WINDOW))) ||
4005 ((IsSrcTypeHDMI(pstXC_SetWin_Info->enInputSourceType)) && (_stHDMI_Info[eWindow].bIsHDMI == FALSE) && (QM_HDMIPC_COLORRGB(PQ_MAIN_WINDOW))) ||
4006 (IsSrcTypeVga(pstXC_SetWin_Info->enInputSourceType))) &&
4007 (!pstXC_SetWin_Info->bInterlace) &&
4008 ((g_IPanel.Width() >= pstXC_SetWin_Info->stCropWin.width) && (g_IPanel.Height() >= pstXC_SetWin_Info->stCropWin.height) &&
4009 (eWindow == PQ_MAIN_WINDOW))
4010 )
4011 {
4012 bRet = TRUE;
4013 }
4014 #else
4015 UNUSED(pstXC_SetWin_Info);
4016 #endif
4017
4018 PQP2P_DBG(printf("[MDrv_PQ_Check_PointToPoint_Condition] %u\n",bRet);)
4019
4020 return bRet;
4021 }
MDrv_PQ_Check_PointToPoint_Condition(XC_SETWIN_INFO * pstXC_SetWin_Info,PQ_WIN eWindow)4022 MS_BOOL MDrv_PQ_Check_PointToPoint_Condition(XC_SETWIN_INFO *pstXC_SetWin_Info,PQ_WIN eWindow)
4023 {
4024 #ifdef TRACE_DBG
4025 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4026 #endif
4027 if (pu32PQInst == NULL)
4028 {
4029 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4030 return FALSE;
4031 }
4032
4033 stPQ_Check_PointToPoint_Condition PQArgs;
4034 PQArgs.pstXC_SetWin_Info = pstXC_SetWin_Info;
4035 PQArgs.eWindow = eWindow;
4036 PQArgs.bReturnValue = FALSE;
4037
4038 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_CHECK_POINT2POINT_CONDITION, (void*)&PQArgs) != 0)
4039 {
4040 printf("Obtain PQ engine fail\n");
4041 return FALSE;
4042 }
4043 else
4044 {
4045 return PQArgs.bReturnValue;
4046 }
4047 }
4048
MDrv_PQ_SetPostCCSOnOff_U2(void * pInstance,PQ_WIN eWindow,MS_BOOL bEnable)4049 MS_BOOL MDrv_PQ_SetPostCCSOnOff_U2(void* pInstance,PQ_WIN eWindow, MS_BOOL bEnable)
4050 {
4051 if (eWindow >= PQ_MAX_WINDOW)
4052 return FALSE;
4053
4054 if (bEnable)
4055 {
4056 MS_U16 u16TabIdx =0;
4057 u16TabIdx = MDrv_PQ_GetTableIndex_U2(pInstance,eWindow, PQ_IP_PostCCS_Main);
4058 #if(ENABLE_PQ_MLOAD)
4059 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
4060 #endif
4061 MDrv_PQ_LoadTable_U2(pInstance, eWindow, u16TabIdx, PQ_IP_PostCCS_Main);
4062 #if(ENABLE_PQ_MLOAD)
4063 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
4064 #endif
4065 }
4066 else
4067 {
4068 #if(ENABLE_PQ_MLOAD)
4069 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
4070 #endif
4071 MDrv_PQ_LoadTable_U2(pInstance, eWindow, PQ_IP_PostCCS_OFF_Main, PQ_IP_PostCCS_Main);
4072 #if(ENABLE_PQ_MLOAD)
4073 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
4074 #endif
4075 }
4076 return TRUE;
4077 }
MDrv_PQ_SetPostCCSOnOff(PQ_WIN eWindow,MS_BOOL bEnable)4078 MS_BOOL MDrv_PQ_SetPostCCSOnOff(PQ_WIN eWindow, MS_BOOL bEnable)
4079 {
4080 #ifdef TRACE_DBG
4081 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4082 #endif
4083 if (pu32PQInst == NULL)
4084 {
4085 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4086 return FALSE;
4087 }
4088
4089 stPQ_SetPostCCSOnOff PQArgs;
4090 PQArgs.eWindow = eWindow;
4091 PQArgs.bEnable = bEnable;
4092 PQArgs.bReturnValue = FALSE;
4093
4094 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_POSTCCS_ONOFF, (void*)&PQArgs) != 0)
4095 {
4096 printf("Obtain PQ engine fail\n");
4097 return FALSE;
4098 }
4099 else
4100 {
4101 return PQArgs.bReturnValue;
4102 }
4103 }
4104
MDrv_PQ_AdaptiveTuning_U2(void * pInstance)4105 void MDrv_PQ_AdaptiveTuning_U2(void* pInstance)
4106 {
4107 Hal_PQ_AdaptiveTuning(pInstance);
4108 }
MDrv_PQ_AdaptiveTuning(void)4109 void MDrv_PQ_AdaptiveTuning(void)
4110 {
4111 #ifdef TRACE_DBG
4112 //printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4113 #endif
4114 if (pu32PQInst == NULL)
4115 {
4116 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4117 {
4118 printf("UtopiaOpen PQ failed\n");
4119 return ;
4120 }
4121 }
4122
4123 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_ADAPTIVE_TUNING, NULL) != 0)
4124 {
4125 printf("Obtain PQ engine fail\n");
4126 return ;
4127 }
4128 else
4129 {
4130 return ;
4131 }
4132 }
4133 #ifdef UFO_XC_PQ_SUPPORT_SWDRIVING_MULTI_DEVICES
MDrv_PQ_EX_AdaptiveTuning(PQ_DEVICE_ID * pDeviceId)4134 void MDrv_PQ_EX_AdaptiveTuning(PQ_DEVICE_ID *pDeviceId)
4135 {
4136 if (pDeviceId->u32Id == 1)
4137 {
4138 //need add a PQ_device_1 instance
4139 return ;
4140 }
4141
4142 if (pu32PQInst == NULL)
4143 {
4144 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4145 {
4146 printf("UtopiaOpen PQ failed\n");
4147 return ;
4148 }
4149 }
4150
4151 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_ADAPTIVE_TUNING, NULL) != 0)
4152 {
4153 printf("Obtain PQ engine fail\n");
4154 return ;
4155 }
4156 else
4157 {
4158 return ;
4159 }
4160 }
4161 #endif
MDrv_PQ_FilmMode_AnyCandence_Enable_U2(void * pInstance,MS_BOOL bEnable)4162 void MDrv_PQ_FilmMode_AnyCandence_Enable_U2(void* pInstance,MS_BOOL bEnable)
4163 {
4164 Hal_PQ_FilmMode_AnyCandence_Enable(pInstance,bEnable);
4165 }
MDrv_PQ_FilmMode_AnyCandence_Enable(MS_BOOL bEnable)4166 void MDrv_PQ_FilmMode_AnyCandence_Enable(MS_BOOL bEnable)
4167 {
4168 #ifdef TRACE_DBG
4169 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4170 #endif
4171 if (pu32PQInst == NULL)
4172 {
4173 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4174 return ;
4175 }
4176
4177 stPQ_FilmMode_AnyCandence_Enable PQArgs;
4178 PQArgs.bEnable = bEnable;
4179
4180 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_FILMMODE_ANYCANDENCE_ENABLE, (void*)&PQArgs) != 0)
4181 {
4182 printf("Obtain PQ engine fail\n");
4183 return ;
4184 }
4185 else
4186 {
4187 return ;
4188 }
4189 }
4190
MDrv_PQ_SetH264_OnOff_U2(void * pInstance,MS_BOOL bEn)4191 MS_BOOL MDrv_PQ_SetH264_OnOff_U2(void* pInstance,MS_BOOL bEn)
4192 {
4193 _gIsH264 = bEn;
4194 return TRUE;
4195 }
MDrv_PQ_SetH264_OnOff(MS_BOOL bEn)4196 MS_BOOL MDrv_PQ_SetH264_OnOff(MS_BOOL bEn)
4197 {
4198 #ifdef TRACE_DBG
4199 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4200 #endif
4201 if (pu32PQInst == NULL)
4202 {
4203 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4204 {
4205 printf("UtopiaOpen PQ failed\n");
4206 return FALSE;
4207 }
4208 }
4209
4210 stPQ_SetH264_OnOff PQArgs;
4211 PQArgs.bEn = bEn;
4212 PQArgs.bReturnValue = FALSE;
4213
4214 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SETH264_ONOFF, (void*)&PQArgs) != 0)
4215 {
4216 printf("Obtain PQ engine fail\n");
4217 return FALSE;
4218 }
4219 else
4220 {
4221 return PQArgs.bReturnValue;
4222 }
4223 }
4224
MDrv_PQ_SetG3D_OnOff_U2(void * pInstance,MS_BOOL bEn)4225 MS_BOOL MDrv_PQ_SetG3D_OnOff_U2(void* pInstance,MS_BOOL bEn)
4226 {
4227 _gbIsG3D = bEn;
4228 return TRUE;
4229 }
MDrv_PQ_SetG3D_OnOff(MS_BOOL bEn)4230 MS_BOOL MDrv_PQ_SetG3D_OnOff(MS_BOOL bEn)
4231 {
4232 #ifdef TRACE_DBG
4233 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4234 #endif
4235 if (pu32PQInst == NULL)
4236 {
4237 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4238 return FALSE;
4239 }
4240
4241 stPQ_SetG3D_OnOff PQArgs;
4242 PQArgs.bEn = bEn;
4243 PQArgs.bReturnValue = FALSE;
4244
4245 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SETG3D_ONOFF, (void*)&PQArgs) != 0)
4246 {
4247 printf("Obtain PQ engine fail\n");
4248 return FALSE;
4249 }
4250 else
4251 {
4252 return PQArgs.bReturnValue;
4253 }
4254 }
4255
MDrv_PQ_SetMVC4kx1k_OnOff_U2(void * pInstance,MS_BOOL bEn)4256 MS_BOOL MDrv_PQ_SetMVC4kx1k_OnOff_U2(void* pInstance,MS_BOOL bEn)
4257 {
4258 _gIsMVC4kx1k = bEn;
4259 return TRUE;
4260 }
MDrv_PQ_SetMVC4kx1k_OnOff(MS_BOOL bEn)4261 MS_BOOL MDrv_PQ_SetMVC4kx1k_OnOff(MS_BOOL bEn)
4262 {
4263 #ifdef TRACE_DBG
4264 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4265 #endif
4266 if (pu32PQInst == NULL)
4267 {
4268 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4269 return FALSE;
4270 }
4271
4272 stPQ_SetMVC4kx1k_OnOff PQArgs;
4273 PQArgs.bEn = bEn;
4274 PQArgs.bReturnValue = FALSE;
4275
4276 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SETMVC4KX1K_ONOFF, (void*)&PQArgs) != 0)
4277 {
4278 printf("Obtain PQ engine fail\n");
4279 return FALSE;
4280 }
4281 else
4282 {
4283 return PQArgs.bReturnValue;
4284 }
4285 }
4286
MDrv_PQ_SetNetworkMM_OnOff_U2(void * pInstance,MS_BOOL bEn)4287 MS_BOOL MDrv_PQ_SetNetworkMM_OnOff_U2(void* pInstance,MS_BOOL bEn)
4288 {
4289 _gIsNetworkMM = bEn;
4290 return TRUE;
4291 }
MDrv_PQ_SetNetworkMM_OnOff(MS_BOOL bEn)4292 MS_BOOL MDrv_PQ_SetNetworkMM_OnOff(MS_BOOL bEn)
4293 {
4294 #ifdef TRACE_DBG
4295 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4296 #endif
4297 if (pu32PQInst == NULL)
4298 {
4299 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4300 {
4301 printf("UtopiaOpen PQ failed\n");
4302 return FALSE;
4303 }
4304 }
4305
4306 stPQ_SetNetworkMM_OnOff PQArgs;
4307 PQArgs.bEn = bEn;
4308 PQArgs.bReturnValue = FALSE;
4309
4310 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_NETWORKMM_ONOFF, (void*)&PQArgs) != 0)
4311 {
4312 printf("Obtain PQ engine fail\n");
4313 return FALSE;
4314 }
4315 else
4316 {
4317 return PQArgs.bReturnValue;
4318 }
4319 }
4320
MDrv_PQ_SetMM_OnOff_U2(void * pInstance,MS_BOOL bEn)4321 MS_BOOL MDrv_PQ_SetMM_OnOff_U2(void* pInstance,MS_BOOL bEn)
4322 {
4323 _gIsMMplayer = bEn;
4324 return TRUE;
4325 }
MDrv_PQ_SetMM_OnOff(MS_BOOL bEn)4326 MS_BOOL MDrv_PQ_SetMM_OnOff(MS_BOOL bEn)
4327 {
4328 #ifdef TRACE_DBG
4329 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4330 #endif
4331 if (pu32PQInst == NULL)
4332 {
4333 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4334 return FALSE;
4335 }
4336
4337 stPQ_SetMM_OnOff PQArgs;
4338 PQArgs.bEn = bEn;
4339 PQArgs.bReturnValue = FALSE;
4340
4341 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SETMM_ONOFF, (void*)&PQArgs) != 0)
4342 {
4343 printf("Obtain PQ engine fail\n");
4344 return FALSE;
4345 }
4346 else
4347 {
4348 return PQArgs.bReturnValue;
4349 }
4350 }
4351
MDrv_PQ_SetRmvb_OnOff_U2(void * pInstance,MS_BOOL bEn,PQ_WIN ePQWindow)4352 MS_BOOL MDrv_PQ_SetRmvb_OnOff_U2(void* pInstance,MS_BOOL bEn, PQ_WIN ePQWindow)
4353 {
4354 _gIsRmvb[ePQWindow] = bEn;
4355 return TRUE;
4356 }
MDrv_PQ_SetRmvb_OnOff(MS_BOOL bEn,PQ_WIN ePQWindow)4357 MS_BOOL MDrv_PQ_SetRmvb_OnOff(MS_BOOL bEn, PQ_WIN ePQWindow)
4358 {
4359 #ifdef TRACE_DBG
4360 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4361 #endif
4362 if (pu32PQInst == NULL)
4363 {
4364 if(UtopiaOpen(MODULE_PQ , &pu32PQInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4365 {
4366 printf("UtopiaOpen PQ failed\n");
4367 return FALSE;
4368 }
4369 }
4370
4371 stPQ_SetRmvb_OnOff PQArgs;
4372 PQArgs.bEn = bEn;
4373 PQArgs.ePQWindow = ePQWindow;
4374 PQArgs.bReturnValue = FALSE;
4375
4376 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_RMVB_ONOFF, (void*)&PQArgs) != 0)
4377 {
4378 printf("Obtain PQ engine fail\n");
4379 return FALSE;
4380 }
4381 else
4382 {
4383 return PQArgs.bReturnValue;
4384 }
4385 }
4386
MDrv_PQ_Set1KTravelingEnable_U2(void * pInstance,MS_BOOL bEn)4387 MS_BOOL MDrv_PQ_Set1KTravelingEnable_U2(void* pInstance,MS_BOOL bEn)
4388 {
4389 _gIs1KTraveling = bEn;
4390 return TRUE;
4391 }
4392
MDrv_PQ_Set1KTravelingEnable(MS_BOOL bEn)4393 MS_BOOL MDrv_PQ_Set1KTravelingEnable(MS_BOOL bEn)
4394 {
4395 #ifdef TRACE_DBG
4396 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4397 #endif
4398 if (pu32PQInst == NULL)
4399 {
4400 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4401 return FALSE;
4402 }
4403
4404 stPQ_Set1KTravelingEnable PQArgs;
4405 PQArgs.bEn = bEn;
4406 PQArgs.bReturnValue = FALSE;
4407
4408 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_1KTRAVELINGENABLE, (void*)&PQArgs) != 0)
4409 {
4410 printf("Obtain PQ engine fail\n");
4411 return FALSE;
4412 }
4413 else
4414 {
4415 return PQArgs.bReturnValue;
4416 }
4417 }
4418
MDrv_PQ_SetVIPBypass_OnOff_U2(void * pInstance,MS_BOOL bEnable,PQ_WIN eWindow)4419 MS_BOOL MDrv_PQ_SetVIPBypass_OnOff_U2(void* pInstance,MS_BOOL bEnable, PQ_WIN eWindow)
4420 {
4421 if (eWindow == PQ_MAIN_WINDOW)
4422 {
4423 #if PQ_VIP_CTL
4424 #if(ENABLE_PQ_MLOAD)
4425 MDrv_PQ_Set_MLoadEn(eWindow, TRUE);
4426 #endif
4427 if(bEnable)
4428 {
4429 #if PQ_VIP_OFF_MINUS16
4430 if(MDrv_PQ_IsForceVideoInputMode_U2(pInstance, PQ_MAIN_WINDOW) == TRUE
4431 || MApi_XC_IsYUVSpace(MAIN_WINDOW) == TRUE)
4432 {
4433 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_VIP_OFF_Minus16_Main, PQ_IP_VIP_Main);
4434 }
4435 else
4436 {
4437 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_VIP_OFF_Main, PQ_IP_VIP_Main);
4438 }
4439 #else
4440 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_VIP_OFF_Main, PQ_IP_VIP_Main);
4441 #endif
4442 }
4443 else
4444 {
4445 MDrv_PQ_LoadTable_U2(pInstance, PQ_MAIN_WINDOW, PQ_IP_VIP_ON_Main, PQ_IP_VIP_Main);
4446 }
4447 #if(ENABLE_PQ_MLOAD)
4448 MDrv_PQ_Set_MLoadEn(eWindow, FALSE);
4449 #endif
4450 #endif
4451 }
4452 else if (eWindow == PQ_SUB_WINDOW)
4453 {
4454 //none
4455 }
4456 else
4457 {
4458 printf("Invalid window type, please check ! \n");
4459 return FALSE;
4460 }
4461
4462 return TRUE;
4463 }
MDrv_PQ_SetVIPBypass_OnOff(MS_BOOL bEnable,PQ_WIN eWindow)4464 MS_BOOL MDrv_PQ_SetVIPBypass_OnOff(MS_BOOL bEnable, PQ_WIN eWindow)
4465 {
4466 #ifdef TRACE_DBG
4467 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4468 #endif
4469 if (pu32PQInst == NULL)
4470 {
4471 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4472 return FALSE;
4473 }
4474
4475 stPQ_SetVIPBypass_OnOff PQArgs;
4476 PQArgs.bEnable = bEnable;
4477 PQArgs.eWindow = eWindow;
4478 PQArgs.bReturnValue = FALSE;
4479
4480 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_VIPBYPASS_ONOFF, (void*)&PQArgs) != 0)
4481 {
4482 printf("Obtain PQ engine fail\n");
4483 return FALSE;
4484 }
4485 else
4486 {
4487 return PQArgs.bReturnValue;
4488 }
4489 }
4490
MDrv_PQ_SetPeaking_OnOff_U2(void * pInstance,MS_BOOL bEnable,PQ_WIN eWindow)4491 MS_BOOL MDrv_PQ_SetPeaking_OnOff_U2(void* pInstance,MS_BOOL bEnable, PQ_WIN eWindow)
4492 {
4493 if (eWindow == PQ_MAIN_WINDOW)
4494 {
4495 MApi_XC_W2BYTEMSK(REG_SC_BK19_10_L, bEnable, 0x0001);
4496 }
4497 else if (eWindow == PQ_SUB_WINDOW)
4498 {
4499 MApi_XC_W2BYTEMSK(REG_SC_BK19_14_L, bEnable, 0x0001);
4500 }
4501 else
4502 {
4503 printf("Invalid window type, please check ! \n");
4504 return FALSE;
4505 }
4506 return TRUE;
4507 }
MDrv_PQ_SetPeaking_OnOff(MS_BOOL bEnable,PQ_WIN eWindow)4508 MS_BOOL MDrv_PQ_SetPeaking_OnOff(MS_BOOL bEnable, PQ_WIN eWindow)
4509 {
4510 #ifdef TRACE_DBG
4511 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4512 #endif
4513 if (pu32PQInst == NULL)
4514 {
4515 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4516 return FALSE;
4517 }
4518
4519 stPQ_SetPeaking_OnOff PQArgs;
4520 PQArgs.bEnable = bEnable;
4521 PQArgs.eWindow = eWindow;
4522 PQArgs.bReturnValue = FALSE;
4523
4524 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_PEAKING_ONOFF, (void*)&PQArgs) != 0)
4525 {
4526 printf("Obtain PQ engine fail\n");
4527 return FALSE;
4528 }
4529 else
4530 {
4531 return PQArgs.bReturnValue;
4532 }
4533 }
4534
MDrv_PQ_SetFakeOutEnable_U2(void * pInstance,MS_BOOL bEnable)4535 MS_BOOL MDrv_PQ_SetFakeOutEnable_U2(void* pInstance,MS_BOOL bEnable)
4536 {
4537 return Hal_PQ_SetFakeOutEnable(pInstance,bEnable);
4538 }
MDrv_PQ_SetFakeOutEnable(MS_BOOL bEnable)4539 MS_BOOL MDrv_PQ_SetFakeOutEnable(MS_BOOL bEnable)
4540 {
4541 #ifdef TRACE_DBG
4542 printf("\33[1;33m[MARCOS](%s %d)\33[m\n", __FUNCTION__, __LINE__);
4543 #endif
4544 if (pu32PQInst == NULL)
4545 {
4546 printf("[%s,%5d]No instance existed, please get an instance by calling MDrv_PQ_Init() first\n",__FUNCTION__,__LINE__);
4547 return FALSE;
4548 }
4549
4550 stPQ_SetFakeOutEnable PQArgs;
4551 PQArgs.bEnable = bEnable;
4552 PQArgs.bReturnValue = FALSE;
4553
4554 if(UtopiaIoctl(pu32PQInst, E_PQ_CMD_SET_FAKE_OUT_ENABLE, (void*)&PQArgs) != 0)
4555 {
4556 printf("Obtain PQ engine fail\n");
4557 return FALSE;
4558 }
4559 else
4560 {
4561 return PQArgs.bReturnValue;
4562 }
4563 }
4564
4565 EXPORT_SYMBOL(MDrv_PQ_AdaptiveTuning);
4566