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 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file apiXC_Adc_EX.c
98 /// brief Scaler API layer Interface
99 /// author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 #ifndef _API_XC_ADC_EX_C_
103 #define _API_XC_ADC_EX_C_
104
105 //-------------------------------------------------------------------------------------------------
106 // Include Files
107 //-------------------------------------------------------------------------------------------------
108 // Common Definition
109
110 #if !defined(MSOS_TYPE_LINUX_KERNEL)
111 #include "string.h"
112 #else
113 #include <linux/string.h>
114 #endif
115
116 #include "MsCommon.h"
117 #include "utopia.h"
118 #include "utopia_dapi.h"
119 #include "mhal_xc_chip_config.h"
120 #include "drvXC_IOPort.h"
121 #include "apiXC.h"
122
123 #include "apiXC_Adc.h"
124 #include "apiXC_Auto.h"
125 #include "drv_sc_display.h"
126 #include "drv_sc_isr.h"
127 #include "apiXC_PCMonitor.h"
128 #include "apiXC_ModeParse.h"
129 #include "drvXC_HDMI_if.h"
130 #include "mvideo_context.h"
131 #if (LD_ENABLE==1)
132 #include "mdrv_ld.h"
133 #include "mdrv_ldalgo.h"
134 #endif
135 #include "mdrv_sc_3d.h"
136 #include "drv_sc_menuload.h"
137 #include "drvXC_ADC_Internal.h"
138 #include "drv_sc_ip.h"
139 #include "mhal_sc.h"
140 #if FRC_INSIDE
141 #include "mdrv_frc.h"
142 #include "mhal_frc.h"
143 #endif
144 #include "XC_private.h"
145 #include "apiXC_v2.h"
146
147 #include "xc_hwreg_utility2.h"
148
149
150 // Common
151 #include "apiXC_EX.h"
152 #include "apiXC_Adc_v2.h"
153 #include "apiXC_Adc_EX.h"
154 #include "apiXC_Auto_v2.h"
155 #include "apiXC_Auto_EX.h"
156 #include "apiXC_PCMonitor_v2.h"
157 #include "apiXC_PCMonitor_EX.h"
158 #include "apiXC_ModeParse_v2.h"
159 #include "apiXC_ModeParse_EX.h"
160 #include "drvXC_HDMI_if_v2.h"
161 #include "drvXC_HDMI_if_EX.h"
162
163 // Driver
164 //#include "drvXC_ADC_Internal_ex.h"
165
166 // Internal Definition
167
168 //-------------------------------------------------------------------------------------------------
169 // Driver Compiler Options
170 //-------------------------------------------------------------------------------------------------
171
172
173 //-------------------------------------------------------------------------------------------------
174 // Local Defines
175 //-------------------------------------------------------------------------------------------------
176 //#define TRACE_ADC_INPUT(x) //x
177
178 #ifndef UNUSED
179 #define UNUSED(x) ((x)=(x))
180 #endif
181
182 #define _XC_SELECT_INSTANCE(u32Id) ((u32Id == 0)? pu32XCInst : pu32XCInst_1)
183 #define _XC_ST_CHECK_SIZE(st, st_ex) if(sizeof(st) != sizeof(st_ex)) \
184 { \
185 printf("\033[1;35[%s][%d] XC_EX check size fail.\033[0m\n",__FUNCTION__,__LINE__); \
186 }
187
188 //-------------------------------------------------------------------------------------------------
189 // Local Structurs
190 //-------------------------------------------------------------------------------------------------
191
192
193 //-------------------------------------------------------------------------------------------------
194 // Global Variables
195 //-------------------------------------------------------------------------------------------------
196
197 //-------------------------------------------------------------------------------------------------
198 // Local Variables
199 //-------------------------------------------------------------------------------------------------
200
201 //-------------------------------------------------------------------------------------------------
202 // Debug Functions
203 //-------------------------------------------------------------------------------------------------
204
205 //-------------------------------------------------------------------------------------------------
206 // Local Functions
207 //-------------------------------------------------------------------------------------------------
208
209 //-------------------------------------------------------------------------------------------------
210 // Function and Variable
211 //-------------------------------------------------------------------------------------------------
MApi_XC_ADC_EX_SetCVBSOut(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_DEST_TYPE enOutputType,XC_EX_INPUT_SOURCE_TYPE enInputPortType,MS_BOOL isDigitalSource)212 void MApi_XC_ADC_EX_SetCVBSOut(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_DEST_TYPE enOutputType , XC_EX_INPUT_SOURCE_TYPE enInputPortType, MS_BOOL isDigitalSource)
213 {
214 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
215 {
216 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
217 return;
218 }
219
220 stXC_ADC_SETCVBSOUT XCArgs;
221 XCArgs.bEnable = bEnable;
222 XCArgs.enOutputType = enOutputType;
223 XCArgs.enInputPortType = enInputPortType;
224 XCArgs.isDigitalSource = isDigitalSource;
225
226 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETCVBSOUT, (void*)&XCArgs) != 0)
227 {
228 printf("Obtain XC engine fail\n");
229 return;
230 }
231 else
232 {
233 return;
234 }
235 }
MApi_XC_ADC_EX_IsCVBSOutEnabled(XC_DEVICE_ID * pDeviceId,XC_EX_DEST_TYPE enOutputType)236 MS_BOOL MApi_XC_ADC_EX_IsCVBSOutEnabled(XC_DEVICE_ID *pDeviceId, XC_EX_DEST_TYPE enOutputType)
237 {
238 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
239 {
240 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
241 return FALSE;
242 }
243
244 stXC_ADC_ISCVBSOUTENABLED XCArgs;
245 XCArgs.enOutputType = enOutputType;
246 XCArgs.bReturnValue = FALSE;
247
248 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_ISCVBSOUTENABLED, (void*)&XCArgs) != 0)
249 {
250 printf("Obtain XC engine fail\n");
251 return FALSE;
252 }
253 else
254 {
255 return XCArgs.bReturnValue;
256 }
257 }
258
MApi_XC_ADC_EX_SetPcClock(XC_DEVICE_ID * pDeviceId,MS_U16 u16Clock)259 void MApi_XC_ADC_EX_SetPcClock(XC_DEVICE_ID *pDeviceId, MS_U16 u16Clock)
260 {
261 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
262 {
263 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
264 return;
265 }
266
267 stXC_ADC_SETPCCLOCK XCArgs;
268 XCArgs.u16Value = u16Clock;
269
270 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETPCCLOCK, (void*)&XCArgs) != 0)
271 {
272 printf("Obtain XC engine fail\n");
273 return;
274 }
275 else
276 {
277 return;
278 }
279 }
280
MApi_XC_ADC_EX_SetPhase(XC_DEVICE_ID * pDeviceId,MS_U8 u8Value)281 void MApi_XC_ADC_EX_SetPhase(XC_DEVICE_ID *pDeviceId, MS_U8 u8Value)
282 {
283 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
284 {
285 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
286 return;
287 }
288
289 stXC_ADC_SETPHASE XCArgs;
290 XCArgs.u8Value = u8Value;
291
292 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETPHASE, (void*)&XCArgs) != 0)
293 {
294 printf("Obtain XC engine fail\n");
295 return;
296 }
297 else
298 {
299 return;
300 }
301 }
302
MApi_XC_ADC_EX_SetPhaseEx(XC_DEVICE_ID * pDeviceId,MS_U16 u16Value)303 void MApi_XC_ADC_EX_SetPhaseEx(XC_DEVICE_ID *pDeviceId, MS_U16 u16Value)
304 {
305 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
306 {
307 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
308 return;
309 }
310
311 stXC_ADC_SETPHASEEX XCArgs;
312 XCArgs.u16Value = u16Value;
313
314 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETPHASEEX, (void*)&XCArgs) != 0)
315 {
316 printf("Obtain XC engine fail\n");
317 return;
318 }
319 else
320 {
321 return;
322 }
323 }
324
MApi_XC_ADC_EX_GetPhaseRange(XC_DEVICE_ID * pDeviceId)325 MS_U16 MApi_XC_ADC_EX_GetPhaseRange( XC_DEVICE_ID *pDeviceId )
326 {
327 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
328 {
329 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
330 return 0;
331 }
332
333 stXC_ADC_GETPHASERANGE XCArgs;
334 XCArgs.u16ReturnValue = 0;
335
336 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETPHASERANGE, (void*)&XCArgs) != 0)
337 {
338 printf("Obtain XC engine fail\n");
339 return 0;
340 }
341 else
342 {
343 return XCArgs.u16ReturnValue;
344 }
345 }
346
MApi_XC_ADC_EX_GetPhase(XC_DEVICE_ID * pDeviceId)347 MS_U8 MApi_XC_ADC_EX_GetPhase( XC_DEVICE_ID *pDeviceId )
348 {
349 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
350 {
351 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
352 return 0;
353 }
354
355 stXC_ADC_GETPHASE XCArgs;
356 XCArgs.u8ReturnValue = 0;
357
358 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETPHASE, (void*)&XCArgs) != 0)
359 {
360 printf("Obtain XC engine fail\n");
361 return 0;
362 }
363 else
364 {
365 return XCArgs.u8ReturnValue;
366 }
367
368 }
MApi_XC_ADC_EX_GetPhaseEx(XC_DEVICE_ID * pDeviceId)369 MS_U16 MApi_XC_ADC_EX_GetPhaseEx( XC_DEVICE_ID *pDeviceId )
370 {
371 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
372 {
373 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
374 return 0;
375 }
376
377 stXC_ADC_GETPHASEEX XCArgs;
378 XCArgs.u16ReturnValue = 0;
379
380 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETPHASEEX, (void*)&XCArgs) != 0)
381 {
382 printf("Obtain XC engine fail\n");
383 return 0;
384 }
385 else
386 {
387 return XCArgs.u16ReturnValue;
388 }
389 }
390
MApi_XC_ADC_EX_IsScartRGB(XC_DEVICE_ID * pDeviceId)391 MS_BOOL MApi_XC_ADC_EX_IsScartRGB(XC_DEVICE_ID *pDeviceId)
392 {
393 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
394 {
395 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
396 return FALSE;
397 }
398
399 stXC_ADC_ISSCARTRGB XCArgs;
400 XCArgs.bReturnValue = FALSE;
401
402 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_ISSCARTRGB, (void*)&XCArgs) != 0)
403 {
404 printf("Obtain XC engine fail\n");
405 return FALSE;
406 }
407 else
408 {
409 return XCArgs.bReturnValue;
410 }
411 }
MApi_XC_ADC_EX_GetPcClock(XC_DEVICE_ID * pDeviceId)412 MS_U16 MApi_XC_ADC_EX_GetPcClock(XC_DEVICE_ID *pDeviceId )
413 {
414 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
415 {
416 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
417 return 0;
418 }
419
420 stXC_ADC_GETPCCLOCK XCArgs;
421 XCArgs.u16ReturnValue = 0;
422
423 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETPCCLOCK, (void*)&XCArgs) != 0)
424 {
425 printf("Obtain XC engine fail\n");
426 return 0;
427 }
428 else
429 {
430 return XCArgs.u16ReturnValue;
431 }
432 }
433
MApi_XC_ADC_EX_GetSoGLevelRange(XC_DEVICE_ID * pDeviceId,MS_U32 * u32min,MS_U32 * u32max,MS_U32 * u32Recommend_value)434 void MApi_XC_ADC_EX_GetSoGLevelRange(XC_DEVICE_ID *pDeviceId, MS_U32 *u32min, MS_U32 *u32max, MS_U32 *u32Recommend_value)
435 {
436 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
437 {
438 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
439 return;
440 }
441
442 stXC_ADC_GETSOGLEVELRANGE XCArgs;
443 XCArgs.u32min = u32min;
444 XCArgs.u32max = u32max;
445 XCArgs.u32Recommend_value = u32Recommend_value;
446
447 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETSOGLEVELRANGE, (void*)&XCArgs) != 0)
448 {
449 printf("Obtain XC engine fail\n");
450 return;
451 }
452 else
453 {
454 return;
455 }
456 }
457
MApi_XC_ADC_EX_SetSoGLevel(XC_DEVICE_ID * pDeviceId,MS_U32 u32Value)458 void MApi_XC_ADC_EX_SetSoGLevel(XC_DEVICE_ID *pDeviceId, MS_U32 u32Value)
459 {
460 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
461 {
462 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
463 return;
464 }
465
466 stXC_ADC_SETSOGLEVEL XCArgs;
467 XCArgs.u32Value = u32Value;
468
469 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETSOGLEVEL, (void*)&XCArgs) != 0)
470 {
471 printf("Obtain XC engine fail\n");
472 return;
473 }
474 else
475 {
476 return;
477 }
478 }
479
480 // power
MApi_XC_ADC_EX_PowerOff(XC_DEVICE_ID * pDeviceId)481 void MApi_XC_ADC_EX_PowerOff(XC_DEVICE_ID *pDeviceId)
482 {
483 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
484 {
485 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
486 return;
487 }
488
489 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_POWEROFF, NULL) != 0)
490 {
491 printf("Obtain XC engine fail\n");
492 return;
493 }
494 else
495 {
496 return;
497 }
498 }
499
500 // ADC calibration
MApi_XC_ADC_EX_GetDefaultGainOffset(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE eSource,XC_ADC_EX_AdcGainOffsetSetting * pstADCSetting)501 void MApi_XC_ADC_EX_GetDefaultGainOffset(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE eSource , XC_ADC_EX_AdcGainOffsetSetting* pstADCSetting)
502 {
503 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
504 {
505 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
506 return;
507 }
508
509 _XC_ST_CHECK_SIZE(APIXC_AdcGainOffsetSetting,XC_ADC_EX_AdcGainOffsetSetting);
510 stXC_ADC_GETDEFAULTGAINOFFSET XCArgs;
511 XCArgs.enSource = eSource;
512 XCArgs.pstADCSetting = (APIXC_AdcGainOffsetSetting*)pstADCSetting;
513
514 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETDEFAULTGAINOFFSET, (void*)&XCArgs) != 0)
515 {
516 printf("Obtain XC engine fail\n");
517 return;
518 }
519 else
520 {
521 return;
522 }
523 }
524
MApi_XC_ADC_EX_GetMaximalOffsetValue(XC_DEVICE_ID * pDeviceId)525 MS_U16 MApi_XC_ADC_EX_GetMaximalOffsetValue(XC_DEVICE_ID *pDeviceId)
526 {
527 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
528 {
529 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
530 return 0;
531 }
532
533 stXC_ADC_GETMAXIMALOFFSETVALUE XCArgs;
534 XCArgs.u16ReturnValue = 0;
535
536 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETMAXIMALOFFSETVALUE, (void*)&XCArgs) != 0)
537 {
538 printf("Obtain XC engine fail\n");
539 return 0;
540 }
541 else
542 {
543 return XCArgs.u16ReturnValue;
544 }
545 }
546
MApi_XC_ADC_EX_GetMaximalGainValue(XC_DEVICE_ID * pDeviceId)547 MS_U16 MApi_XC_ADC_EX_GetMaximalGainValue(XC_DEVICE_ID *pDeviceId)
548 {
549 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
550 {
551 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
552 return 0;
553 }
554
555 stXC_ADC_GETMAXIMALGAINVALUE XCArgs;
556 XCArgs.u16ReturnValue = 0;
557
558 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETMAXIMALGAINVALUE, (void*)&XCArgs) != 0)
559 {
560 printf("Obtain XC engine fail\n");
561 return 0;
562 }
563 else
564 {
565 return XCArgs.u16ReturnValue;
566 }
567 }
568
MApi_XC_ADC_EX_GetCenterGain(XC_DEVICE_ID * pDeviceId)569 MS_U16 MApi_XC_ADC_EX_GetCenterGain(XC_DEVICE_ID *pDeviceId)
570 {
571 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
572 {
573 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
574 return 0;
575 }
576
577 stXC_ADC_GETCENTERGAIN XCArgs;
578 XCArgs.u16ReturnValue = 0;
579
580 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETCENTERGAIN, (void*)&XCArgs) != 0)
581 {
582 printf("Obtain XC engine fail\n");
583 return 0;
584 }
585 else
586 {
587 return XCArgs.u16ReturnValue;
588 }
589 }
590
MApi_XC_ADC_EX_GetCenterOffset(XC_DEVICE_ID * pDeviceId)591 MS_U16 MApi_XC_ADC_EX_GetCenterOffset(XC_DEVICE_ID *pDeviceId)
592 {
593 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
594 {
595 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
596 return 0;
597 }
598
599 stXC_ADC_GETCENTEROFFSET XCArgs;
600 XCArgs.u16ReturnValue = 0;
601
602 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_GETCENTEROFFSET, (void*)&XCArgs) != 0)
603 {
604 printf("Obtain XC engine fail\n");
605 return 0;
606 }
607 else
608 {
609 return XCArgs.u16ReturnValue;
610 }
611 }
612
613 // Set Gain & Offset
MApi_XC_ADC_EX_SetGain(XC_DEVICE_ID * pDeviceId,MS_U8 u8color,MS_U16 u16value)614 void MApi_XC_ADC_EX_SetGain(XC_DEVICE_ID *pDeviceId, MS_U8 u8color, MS_U16 u16value)
615 {
616 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
617 {
618 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
619 return;
620 }
621
622 stXC_ADC_SETGAIN XCArgs;
623 XCArgs.u8Color = u8color;
624 XCArgs.u16Value = u16value;
625
626 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETGAIN, (void*)&XCArgs) != 0)
627 {
628 printf("Obtain XC engine fail\n");
629 return;
630 }
631 else
632 {
633 return;
634 }
635 }
636
MApi_XC_ADC_EX_SetOffset(XC_DEVICE_ID * pDeviceId,MS_U8 u8color,MS_U16 u16value)637 void MApi_XC_ADC_EX_SetOffset(XC_DEVICE_ID *pDeviceId, MS_U8 u8color, MS_U16 u16value)
638 {
639 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
640 {
641 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
642 return;
643 }
644
645 stXC_ADC_SETOFFSET XCArgs;
646 XCArgs.u8Color = u8color;
647 XCArgs.u16Value = u16value;
648
649 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETOFFSET, (void*)&XCArgs) != 0)
650 {
651 printf("Obtain XC engine fail\n");
652 return;
653 }
654 else
655 {
656 return;
657 }
658 }
659
MApi_XC_ADC_EX_AdjustGainOffset(XC_DEVICE_ID * pDeviceId,XC_ADC_EX_AdcGainOffsetSetting * pstADCSetting)660 void MApi_XC_ADC_EX_AdjustGainOffset(XC_DEVICE_ID *pDeviceId, XC_ADC_EX_AdcGainOffsetSetting* pstADCSetting)
661 {
662 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
663 {
664 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
665 return;
666 }
667
668 _XC_ST_CHECK_SIZE(APIXC_AdcGainOffsetSetting,XC_ADC_EX_AdcGainOffsetSetting);
669 stXC_ADC_ADJUSTGAINOFFSET XCArgs;
670 XCArgs.pstADCSetting = (APIXC_AdcGainOffsetSetting*)pstADCSetting;
671
672 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_ADJUSTGAINOFFSET, (void*)&XCArgs) != 0)
673 {
674 printf("Obtain XC engine fail\n");
675 return;
676 }
677 else
678 {
679 return;
680 }
681 }
682
MApi_XC_ADC_EX_Source_Calibrate(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE enInputSourceType)683 void MApi_XC_ADC_EX_Source_Calibrate(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE enInputSourceType)
684 {
685 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
686 {
687 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
688 return;
689 }
690
691 stXC_ADC_SOURCE_CALIBRATE XCArgs;
692 XCArgs.enInputSourceType = enInputSourceType;
693
694 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SOURCE_CALIBRATE, (void*)&XCArgs) != 0)
695 {
696 printf("Obtain XC engine fail\n");
697 return;
698 }
699 else
700 {
701 return;
702 }
703 }
704
MApi_XC_ADC_EX_SetSoGCal(XC_DEVICE_ID * pDeviceId)705 void MApi_XC_ADC_EX_SetSoGCal(XC_DEVICE_ID *pDeviceId)
706 {
707 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
708 {
709 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
710 return;
711 }
712
713 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETSOGCAL, NULL) != 0)
714 {
715 printf("Obtain XC engine fail\n");
716 return;
717 }
718 else
719 {
720 return;
721 }
722 }
723
724 //Set SCART RGB PIPE Delay
MApi_XC_ADC_EX_SetRGB_PIPE_Delay(XC_DEVICE_ID * pDeviceId,MS_U8 u8Value)725 void MApi_XC_ADC_EX_SetRGB_PIPE_Delay(XC_DEVICE_ID *pDeviceId, MS_U8 u8Value)
726 {
727 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
728 {
729 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
730 return;
731 }
732
733 stXC_ADC_SETRGB_PIPE_DELAY XCArgs;
734 XCArgs.u8Value = u8Value;
735
736 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETRGB_PIPE_DELAY, (void*)&XCArgs) != 0)
737 {
738 printf("Obtain XC engine fail\n");
739 return;
740 }
741 else
742 {
743 return;
744 }
745 }
746
747 //Set Scart RGB Sync on green clamp delay value
MApi_XC_ADC_EX_ScartRGB_SOG_ClampDelay(XC_DEVICE_ID * pDeviceId,MS_U16 u16Clpdly,MS_U16 u16Caldur)748 void MApi_XC_ADC_EX_ScartRGB_SOG_ClampDelay(XC_DEVICE_ID *pDeviceId, MS_U16 u16Clpdly, MS_U16 u16Caldur)
749 {
750 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
751 {
752 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
753 return;
754 }
755
756 stXC_ADC_SCARTRGB_SOG_CLAMPDELAY XCArgs;
757 XCArgs.u16Clpdly = u16Clpdly;
758 XCArgs.u16Caldur = u16Caldur;
759
760 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SCARTRGB_SOG_CLAMPDELAY, (void*)&XCArgs) != 0)
761 {
762 printf("Obtain XC engine fail\n");
763 return;
764 }
765 else
766 {
767 return;
768 }
769 }
770
MApi_XC_ADC_EX_Set_YPbPrLooseLPF(XC_DEVICE_ID * pDeviceId,MS_BOOL benable)771 void MApi_XC_ADC_EX_Set_YPbPrLooseLPF(XC_DEVICE_ID *pDeviceId, MS_BOOL benable)
772 {
773 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
774 {
775 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
776 return;
777 }
778
779 stXC_ADC_SET_YPBPRLOOSELPF XCArgs;
780 XCArgs.bEnable = benable;
781
782 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SET_YPBPRLOOSELPF, (void*)&XCArgs) != 0)
783 {
784 printf("Obtain XC engine fail\n");
785 return;
786 }
787 else
788 {
789 return;
790 }
791 }
792
MApi_XC_ADC_EX_Set_SOGBW(XC_DEVICE_ID * pDeviceId,MS_U16 u16value)793 void MApi_XC_ADC_EX_Set_SOGBW(XC_DEVICE_ID *pDeviceId, MS_U16 u16value)
794 {
795 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
796 {
797 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
798 return;
799 }
800
801 stXC_ADC_SET_SOGBW XCArgs;
802 XCArgs.u16Value = u16value;
803
804 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SET_SOGBW, (void*)&XCArgs) != 0)
805 {
806 printf("Obtain XC engine fail\n");
807 return;
808 }
809 else
810 {
811 return;
812 }
813 }
814
815 // Set Clamp Duration
MApi_XC_ADC_EX_SetClampDuration(XC_DEVICE_ID * pDeviceId,MS_U16 u16Value)816 void MApi_XC_ADC_EX_SetClampDuration(XC_DEVICE_ID *pDeviceId, MS_U16 u16Value)
817 {
818 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
819 {
820 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
821 return;
822 }
823
824 stXC_ADC_SETCLAMPDURATION XCArgs;
825 XCArgs.u16Value = u16Value;
826
827 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_SETCLAMPDURATION, (void*)&XCArgs) != 0)
828 {
829 printf("Obtain XC engine fail\n");
830 return;
831 }
832 else
833 {
834 return;
835 }
836 }
837
MApi_XC_ADC_EX_EnableHWCalibration(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)838 MS_BOOL MApi_XC_ADC_EX_EnableHWCalibration(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
839 {
840 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
841 {
842 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
843 return FALSE;
844 }
845
846 stXC_ADC_ENABLEHWCALIBRATION XCArgs;
847 XCArgs.bEnable = bEnable;
848 XCArgs.bReturnValue = FALSE;
849
850 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_ADC_CMD_ENABLEHWCALIBRATION, (void*)&XCArgs) != 0)
851 {
852 printf("Obtain XC engine fail\n");
853 return FALSE;
854 }
855 else
856 {
857 return XCArgs.bReturnValue;
858 }
859 }
860
861 //XC_Auto
MApi_XC_Auto_EX_Geometry(XC_DEVICE_ID * pDeviceId,XC_Auto_EX_TuneType enAutoTuneType,XC_Auto_EX_Signal_Info * ActiveInfo,XC_Auto_EX_Signal_Info * StandardInfo,XC_EX_SCALER_WIN eWindow)862 MS_BOOL MApi_XC_Auto_EX_Geometry(XC_DEVICE_ID *pDeviceId, XC_Auto_EX_TuneType enAutoTuneType, XC_Auto_EX_Signal_Info *ActiveInfo, XC_Auto_EX_Signal_Info *StandardInfo, XC_EX_SCALER_WIN eWindow)
863 {
864 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
865 {
866 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
867 return FALSE;
868 }
869
870 _XC_ST_CHECK_SIZE(XC_Auto_Signal_Info,XC_Auto_EX_Signal_Info);
871 stXC_AUTO_GEOMETRY XCArgs;
872 XCArgs.enAutoTuneType = enAutoTuneType;
873 XCArgs.ActiveInfo = (XC_Auto_Signal_Info*)ActiveInfo;
874 XCArgs.StandardInfo = (XC_Auto_Signal_Info*)StandardInfo;
875 XCArgs.eWindow = eWindow;
876 XCArgs.bReturnValue = FALSE;
877
878 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_GEOMETRY, (void*)&XCArgs) != 0)
879 {
880 printf("Obtain XC engine fail\n");
881 return FALSE;
882 }
883 else
884 {
885 return XCArgs.bReturnValue;
886 }
887 }
888
MApi_XC_Auto_EX_Geometry_Ex(XC_DEVICE_ID * pDeviceId,XC_Auto_EX_TuneType enAutoTuneType,XC_Auto_EX_Signal_Info_Ex * ActiveInfo,XC_Auto_EX_Signal_Info_Ex * StandardInfo,XC_EX_SCALER_WIN eWindow)889 MS_BOOL MApi_XC_Auto_EX_Geometry_Ex(XC_DEVICE_ID *pDeviceId, XC_Auto_EX_TuneType enAutoTuneType, XC_Auto_EX_Signal_Info_Ex *ActiveInfo, XC_Auto_EX_Signal_Info_Ex *StandardInfo, XC_EX_SCALER_WIN eWindow)
890 {
891 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
892 {
893 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
894 return FALSE;
895 }
896
897 _XC_ST_CHECK_SIZE(XC_Auto_Signal_Info_Ex,XC_Auto_EX_Signal_Info_Ex);
898 stXC_AUTO_GEOMETRY_EX XCArgs;
899 XCArgs.enAutoTuneType = enAutoTuneType;
900 XCArgs.ActiveInfo = (XC_Auto_Signal_Info_Ex*)ActiveInfo;
901 XCArgs.StandardInfo = (XC_Auto_Signal_Info_Ex*)StandardInfo;
902 XCArgs.eWindow = eWindow;
903 XCArgs.bReturnValue = FALSE;
904
905 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_GEOMETRY_EX, (void*)&XCArgs) != 0)
906 {
907 printf("Obtain XC engine fail\n");
908 return FALSE;
909 }
910 else
911 {
912 return XCArgs.bReturnValue;
913 }
914 }
915
MApi_XC_Auto_EX_StopAutoGeometry(XC_DEVICE_ID * pDeviceId)916 MS_BOOL MApi_XC_Auto_EX_StopAutoGeometry(XC_DEVICE_ID *pDeviceId)
917 {
918 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
919 {
920 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
921 return FALSE;
922 }
923
924 stXC_AUTO_STOPAUTOGEOMETRY XCArgs;
925 XCArgs.bReturnValue = FALSE;
926
927 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_STOPAUTOGEOMETRY, (void*)&XCArgs) != 0)
928 {
929 printf("Obtain XC engine fail\n");
930 return FALSE;
931 }
932 else
933 {
934 return XCArgs.bReturnValue;
935 }
936 }
937
MApi_XC_Auto_EX_GainOffset(XC_DEVICE_ID * pDeviceId,XC_Auto_EX_CalibrationType type,XC_Auto_EX_TuneType enAutoTuneType,XC_ADC_EX_AdcGainOffsetSetting * pstADCSetting,XC_EX_SCALER_WIN eWindow)938 MS_BOOL MApi_XC_Auto_EX_GainOffset(XC_DEVICE_ID *pDeviceId, XC_Auto_EX_CalibrationType type, XC_Auto_EX_TuneType enAutoTuneType, XC_ADC_EX_AdcGainOffsetSetting *pstADCSetting, XC_EX_SCALER_WIN eWindow)
939 {
940 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
941 {
942 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
943 return FALSE;
944 }
945
946 _XC_ST_CHECK_SIZE(APIXC_AdcGainOffsetSetting,XC_ADC_EX_AdcGainOffsetSetting);
947 stXC_AUTO_GAINOFFSET XCArgs;
948 XCArgs.type = type;
949 XCArgs.enAutoTuneType = enAutoTuneType;
950 XCArgs.pstADCSetting = (APIXC_AdcGainOffsetSetting*)pstADCSetting;
951 XCArgs.eWindow = eWindow;
952 XCArgs.bReturnValue = FALSE;
953
954 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_GAINOFFSET, (void*)&XCArgs) != 0)
955 {
956 printf("Obtain XC engine fail\n");
957 return FALSE;
958 }
959 else
960 {
961 return XCArgs.bReturnValue;
962 }
963 }
964
MApi_XC_Auto_EX_GetHWFixedGainOffset(XC_DEVICE_ID * pDeviceId,XC_Auto_EX_TuneType enAutoTuneType,XC_ADC_EX_AdcGainOffsetSetting * pstADCSetting)965 MS_BOOL MApi_XC_Auto_EX_GetHWFixedGainOffset(XC_DEVICE_ID *pDeviceId, XC_Auto_EX_TuneType enAutoTuneType, XC_ADC_EX_AdcGainOffsetSetting *pstADCSetting)
966 {
967 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
968 {
969 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
970 return FALSE;
971 }
972
973 _XC_ST_CHECK_SIZE(APIXC_AdcGainOffsetSetting,XC_ADC_EX_AdcGainOffsetSetting);
974 stXC_AUTO_GETHWFIXEDGAINOFFSET XCArgs;
975 XCArgs.enAutoTuneType = enAutoTuneType;
976 XCArgs.pstADCSetting = (APIXC_AdcGainOffsetSetting*)pstADCSetting;
977 XCArgs.bReturnValue = FALSE;
978
979 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_GETHWFIXEDGAINOFFSET, (void*)&XCArgs) != 0)
980 {
981 printf("Obtain XC engine fail\n");
982 return FALSE;
983 }
984 else
985 {
986 return XCArgs.bReturnValue;
987 }
988
989 }
990
MApi_XC_Auto_EX_SetValidData(XC_DEVICE_ID * pDeviceId,MS_U8 Value)991 MS_BOOL MApi_XC_Auto_EX_SetValidData(XC_DEVICE_ID *pDeviceId, MS_U8 Value)
992 {
993 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
994 {
995 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
996 return FALSE;
997 }
998
999 stXC_AUTO_SETVALIDDATA XCArgs;
1000 XCArgs.Value = Value;
1001 XCArgs.bReturnValue = FALSE;
1002
1003 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_SETVALIDDATA, (void*)&XCArgs) != 0)
1004 {
1005 printf("Obtain XC engine fail\n");
1006 return FALSE;
1007 }
1008 else
1009 {
1010 return XCArgs.bReturnValue;
1011 }
1012 }
1013
MApi_XC_Auto_EX_AutoOffset(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,MS_BOOL bIsYPbPrFlag)1014 void MApi_XC_Auto_EX_AutoOffset(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, MS_BOOL bIsYPbPrFlag)
1015 {
1016 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1017 {
1018 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1019 return;
1020 }
1021
1022 stXC_AUTO_AUTOOFFSET XCArgs;
1023 XCArgs.bEnable = bEnable;
1024 XCArgs.bIsYPbPrFlag = bIsYPbPrFlag;
1025
1026 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_AUTOOFFSET, (void*)&XCArgs) != 0)
1027 {
1028 printf("Obtain XC engine fail\n");
1029 return;
1030 }
1031 else
1032 {
1033 return;
1034 }
1035 }
1036
MApi_XC_Auto_EX_DetectWidth(XC_DEVICE_ID * pDeviceId,XC_Auto_EX_Signal_Info_Ex * pSignalInfo,XC_EX_SCALER_WIN eWindow)1037 MS_BOOL MApi_XC_Auto_EX_DetectWidth(XC_DEVICE_ID *pDeviceId, XC_Auto_EX_Signal_Info_Ex *pSignalInfo , XC_EX_SCALER_WIN eWindow)
1038 {
1039 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1040 {
1041 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1042 return FALSE;
1043 }
1044
1045 _XC_ST_CHECK_SIZE(XC_Auto_Signal_Info_Ex,XC_Auto_EX_Signal_Info_Ex);
1046 stXC_AUTO_DETECTWIDTH XCArgs;
1047 XCArgs.pSignalInfo = (XC_Auto_Signal_Info_Ex*)pSignalInfo;
1048 XCArgs.eWindow = eWindow;
1049 XCArgs.bReturnValue = FALSE;
1050
1051 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_DETECTWIDTH, (void*)&XCArgs) != 0)
1052 {
1053 printf("Obtain XC engine fail\n");
1054 return FALSE;
1055 }
1056 else
1057 {
1058 return XCArgs.bReturnValue;
1059 }
1060 }
1061
MApi_XC_Auto_EX_SetCalibrationMode(XC_DEVICE_ID * pDeviceId,XC_Auto_EX_CalibrationMode eMode)1062 MS_BOOL MApi_XC_Auto_EX_SetCalibrationMode(XC_DEVICE_ID *pDeviceId, XC_Auto_EX_CalibrationMode eMode)
1063 {
1064 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1065 {
1066 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1067 return FALSE;
1068 }
1069
1070 stXC_AUTO_SETCALIBRATIONMODE XCArgs;
1071 XCArgs.eMode = eMode;
1072 XCArgs.bReturnValue = FALSE;
1073
1074 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_SETCALIBRATIONMODE, (void*)&XCArgs) != 0)
1075 {
1076 printf("Obtain XC engine fail\n");
1077 return FALSE;
1078 }
1079 else
1080 {
1081 return XCArgs.bReturnValue;
1082 }
1083 }
1084
MApi_XC_Auto_EX_GetCalibrationMode(XC_DEVICE_ID * pDeviceId,XC_Auto_EX_CalibrationMode * eMode)1085 void MApi_XC_Auto_EX_GetCalibrationMode(XC_DEVICE_ID *pDeviceId, XC_Auto_EX_CalibrationMode *eMode)
1086 {
1087 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1088 {
1089 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1090 return;
1091 }
1092
1093 _XC_ST_CHECK_SIZE(XC_Auto_CalibrationMode,XC_Auto_EX_CalibrationMode);
1094 stXC_AUTO_GETCALIBRATIONMODE XCArgs;
1095 XCArgs.eMode = (XC_Auto_CalibrationMode*)eMode;
1096
1097 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_AUTO_CMD_GETCALIBRATIONMODE, (void*)&XCArgs) != 0)
1098 {
1099 printf("Obtain XC engine fail\n");
1100 return;
1101 }
1102 else
1103 {
1104 return;
1105 }
1106 }
1107
1108 //XC_Monitor
MApi_XC_PCMonitor_EX_Init(XC_DEVICE_ID * pDeviceId,MS_U8 u8MaxWindowNum)1109 MS_BOOL MApi_XC_PCMonitor_EX_Init(XC_DEVICE_ID *pDeviceId, MS_U8 u8MaxWindowNum)
1110 {
1111 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1112 {
1113 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1114 return FALSE;
1115 }
1116
1117 stXC_PCMONITOR_INIT XCArgs;
1118 XCArgs.u8MaxWindowNum = u8MaxWindowNum;
1119 XCArgs.bReturnValue = FALSE;
1120
1121 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_INIT, (void*)&XCArgs) != 0)
1122 {
1123 printf("Obtain XC engine fail\n");
1124 return FALSE;
1125 }
1126 else
1127 {
1128 return XCArgs.bReturnValue;
1129 }
1130 }
MApi_XC_PCMonitor_EX_Restart(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1131 void MApi_XC_PCMonitor_EX_Restart(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1132 {
1133 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1134 {
1135 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1136 return;
1137 }
1138
1139 stXC_PCMONITOR_RESTART XCArgs;
1140 XCArgs.eWindow = eWindow;
1141
1142 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_RESTART, (void*)&XCArgs) != 0)
1143 {
1144 printf("Obtain XC engine fail\n");
1145 return;
1146 }
1147 else
1148 {
1149 return;
1150 }
1151 }
MApi_XC_PCMonitor_EX_SetTimingCount(XC_DEVICE_ID * pDeviceId,MS_U16 u16TimingStableCounter,MS_U16 u16TimingNosyncCounter)1152 void MApi_XC_PCMonitor_EX_SetTimingCount(XC_DEVICE_ID *pDeviceId, MS_U16 u16TimingStableCounter, MS_U16 u16TimingNosyncCounter)
1153 {
1154 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1155 {
1156 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1157 return;
1158 }
1159
1160 stXC_PCMONITOR_SETTIMINGCOUNT XCArgs;
1161 XCArgs.u16TimingStableCounter = u16TimingStableCounter;
1162 XCArgs.u16TimingNosyncCounter = u16TimingNosyncCounter;
1163
1164 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_SETTIMINGCOUNT, (void*)&XCArgs) != 0)
1165 {
1166 printf("Obtain XC engine fail\n");
1167 return;
1168 }
1169 else
1170 {
1171 return;
1172 }
1173 }
1174
MApi_XC_PCMonitor_EX(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE src,XC_EX_SCALER_WIN eWindow)1175 XC_PCMONITOR_EX_STATUS MApi_XC_PCMonitor_EX(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE src, XC_EX_SCALER_WIN eWindow)
1176 {
1177 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1178 {
1179 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1180 return E_XC_PCMONITOR_STABLE_NOSYNC;
1181 }
1182
1183 stXC_PCMONITOR XCArgs;
1184 XCArgs.eCurrentSrc = src;
1185 XCArgs.eWindow = eWindow;
1186 XCArgs.eReturnValue = E_XC_PCMONITOR_STABLE_NOSYNC;
1187
1188 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD, (void*)&XCArgs) != 0)
1189 {
1190 printf("Obtain XC engine fail\n");
1191 return E_XC_PCMONITOR_STABLE_NOSYNC;
1192 }
1193 else
1194 {
1195 return XCArgs.eReturnValue;
1196 }
1197 }
1198
1199 // get input timing information
MApi_XC_PCMonitor_EX_GetCurrentState(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1200 XC_PCMONITOR_EX_STATUS MApi_XC_PCMonitor_EX_GetCurrentState(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1201 {
1202 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1203 {
1204 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1205 return E_XC_PCMONITOR_STABLE_NOSYNC;
1206 }
1207
1208 stXC_PCMONITOR_GETCURRENTSTATE XCArgs;
1209 XCArgs.eWindow = eWindow;
1210 XCArgs.eReturnValue = E_XC_PCMONITOR_STABLE_NOSYNC;
1211
1212 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GETCURRENTSTATE, (void*)&XCArgs) != 0)
1213 {
1214 printf("Obtain XC engine fail\n");
1215 return E_XC_PCMONITOR_STABLE_NOSYNC;
1216 }
1217 else
1218 {
1219 return XCArgs.eReturnValue;
1220 }
1221 }
1222
MApi_XC_PCMonitor_EX_GetSyncStatus(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1223 MS_U8 MApi_XC_PCMonitor_EX_GetSyncStatus(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1224 {
1225 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1226 {
1227 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1228 return 0;
1229 }
1230
1231 stXC_PCMONITOR_GETSYNCSTATUS XCArgs;
1232 XCArgs.eWindow = eWindow;
1233 XCArgs.u8ReturnValue = 0;
1234
1235 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GETSYNCSTATUS, (void*)&XCArgs) != 0)
1236 {
1237 printf("Obtain XC engine fail\n");
1238 return 0;
1239 }
1240 else
1241 {
1242 return XCArgs.u8ReturnValue;
1243 }
1244 }
1245
MApi_XC_PCMonitor_EX_Get_HFreqx10(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1246 MS_U16 MApi_XC_PCMonitor_EX_Get_HFreqx10(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1247 {
1248 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1249 {
1250 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1251 return 0;
1252 }
1253
1254 stXC_PCMONITOR_GET_HFREQX10 XCArgs;
1255 XCArgs.eWindow = eWindow;
1256 XCArgs.u16ReturnValue = 0;
1257
1258 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GET_HFREQX10, (void*)&XCArgs) != 0)
1259 {
1260 printf("Obtain XC engine fail\n");
1261 return 0;
1262 }
1263 else
1264 {
1265 return XCArgs.u16ReturnValue;
1266 }
1267 }
1268
MApi_XC_PCMonitor_EX_Get_HFreqx1K(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1269 MS_U32 MApi_XC_PCMonitor_EX_Get_HFreqx1K(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1270 {
1271 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1272 {
1273 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1274 return 0;
1275 }
1276
1277 stXC_PCMONITOR_GET_HFREQX1K XCArgs;
1278 XCArgs.eWindow = eWindow;
1279 XCArgs.u32ReturnValue = 0;
1280
1281 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GET_HFREQX1K, (void*)&XCArgs) != 0)
1282 {
1283 printf("Obtain XC engine fail\n");
1284 return 0;
1285 }
1286 else
1287 {
1288 return XCArgs.u32ReturnValue;
1289 }
1290 }
1291
MApi_XC_PCMonitor_EX_Get_VFreqx10(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1292 MS_U16 MApi_XC_PCMonitor_EX_Get_VFreqx10(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1293 {
1294 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1295 {
1296 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1297 return 0;
1298 }
1299
1300 stXC_PCMONITOR_GET_VFREQX10 XCArgs;
1301 XCArgs.eWindow = eWindow;
1302 XCArgs.u16ReturnValue = 0;
1303
1304 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GET_VFREQX10, (void*)&XCArgs) != 0)
1305 {
1306 printf("Obtain XC engine fail\n");
1307 return 0;
1308 }
1309 else
1310 {
1311 return XCArgs.u16ReturnValue;
1312 }
1313 }
1314
1315
MApi_XC_PCMonitor_EX_Get_VFreqx1K(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1316 MS_U32 MApi_XC_PCMonitor_EX_Get_VFreqx1K(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1317 {
1318 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1319 {
1320 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1321 return 0;
1322 }
1323
1324 stXC_PCMONITOR_GET_VFREQX1K XCArgs;
1325 XCArgs.eWindow = eWindow;
1326 XCArgs.u32ReturnValue = 0;
1327
1328 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GET_VFREQX1K, (void*)&XCArgs) != 0)
1329 {
1330 printf("Obtain XC engine fail\n");
1331 return 0;
1332 }
1333 else
1334 {
1335 return XCArgs.u32ReturnValue;
1336 }
1337 }
1338
MApi_XC_PCMonitor_EX_Get_Vtotal(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1339 MS_U16 MApi_XC_PCMonitor_EX_Get_Vtotal(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1340 {
1341 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1342 {
1343 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1344 return 0;
1345 }
1346
1347 stXC_PCMONITOR_GET_VTOTAL XCArgs;
1348 XCArgs.eWindow = eWindow;
1349 XCArgs.u16ReturnValue = 0;
1350
1351 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GET_VTOTAL, (void*)&XCArgs) != 0)
1352 {
1353 printf("Obtain XC engine fail\n");
1354 return 0;
1355 }
1356 else
1357 {
1358 return XCArgs.u16ReturnValue;
1359 }
1360 }
1361
MApi_XC_PCMonitor_EX_Get_Dvi_Hdmi_De_Info(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow,XC_EX_WINDOW_TYPE * msWin)1362 void MApi_XC_PCMonitor_EX_Get_Dvi_Hdmi_De_Info(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow,XC_EX_WINDOW_TYPE* msWin)
1363 {
1364 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1365 {
1366 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1367 return;
1368 }
1369
1370 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE,XC_EX_WINDOW_TYPE);
1371 stXC_PCMONITOR_GET_DVI_HDMI_DE_INFO XCArgs;
1372 XCArgs.eWindow = eWindow;
1373 XCArgs.msWin = (MS_WINDOW_TYPE*)msWin;
1374
1375 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_GET_DVI_HDMI_DE_INFO, (void*)&XCArgs) != 0)
1376 {
1377 printf("Obtain XC engine fail\n");
1378 return;
1379 }
1380 else
1381 {
1382 return;
1383 }
1384 }
1385
MApi_XC_PCMonitor_EX_SyncLoss(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)1386 MS_BOOL MApi_XC_PCMonitor_EX_SyncLoss(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
1387 {
1388 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1389 {
1390 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1391 return FALSE;
1392 }
1393
1394 stXC_PCMONITOR_SYNCLOSS XCArgs;
1395 XCArgs.eWindow = eWindow;
1396 XCArgs.bReturnValue = FALSE;
1397
1398 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_SYNCLOSS, (void*)&XCArgs) != 0)
1399 {
1400 printf("Obtain XC engine fail\n");
1401 return FALSE;
1402 }
1403 else
1404 {
1405 return XCArgs.bReturnValue;
1406 }
1407 }
1408
MApi_XC_PCMonitor_EX_InvalidTimingDetect(XC_DEVICE_ID * pDeviceId,MS_BOOL bPollingOnly,XC_EX_SCALER_WIN eWindow)1409 MS_BOOL MApi_XC_PCMonitor_EX_InvalidTimingDetect(XC_DEVICE_ID *pDeviceId, MS_BOOL bPollingOnly, XC_EX_SCALER_WIN eWindow)
1410 {
1411 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1412 {
1413 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1414 return FALSE;
1415 }
1416
1417 stXC_PCMONITOR_INVALIDTIMINGDETECT XCArgs;
1418 XCArgs.bPollingOnly = bPollingOnly;
1419 XCArgs.eWindow = eWindow;
1420 XCArgs.bReturnValue = FALSE;
1421
1422 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_INVALIDTIMINGDETECT, (void*)&XCArgs) != 0)
1423 {
1424 printf("Obtain XC engine fail\n");
1425 return FALSE;
1426 }
1427 else
1428 {
1429 return XCArgs.bReturnValue;
1430 }
1431 }
1432
MApi_XC_PCMonitor_EX_SetTimingCountEx(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE eCurrentSrc,MS_U16 u16TimingStableCounter,MS_U16 u16TimingNosyncCounter)1433 XC_EX_RETURN_VALUE MApi_XC_PCMonitor_EX_SetTimingCountEx( XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE eCurrentSrc, MS_U16 u16TimingStableCounter, MS_U16 u16TimingNosyncCounter)
1434 {
1435 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1436 {
1437 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1438 return E_APIXC_RET_FAIL;
1439 }
1440
1441 stXC_PCMONITOR_SETTIMINGCOUNTEX XCArgs;
1442 XCArgs.eCurrentSrc = eCurrentSrc;
1443 XCArgs.u16TimingStableCounter = u16TimingStableCounter;
1444 XCArgs.u16TimingNosyncCounter = u16TimingNosyncCounter;
1445 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
1446
1447 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_PCMONITOR_CMD_SETTIMINGCOUNTEX, (void*)&XCArgs) != 0)
1448 {
1449 printf("Obtain XC engine fail\n");
1450 return E_APIXC_RET_FAIL;
1451 }
1452 else
1453 {
1454 return XCArgs.eReturnValue;
1455 }
1456 }
1457
1458
1459 //XC_ModeParse
MApi_XC_ModeParse_EX_Init(XC_DEVICE_ID * pDeviceId)1460 MS_BOOL MApi_XC_ModeParse_EX_Init(XC_DEVICE_ID *pDeviceId)
1461 {
1462 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1463 {
1464 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1465 return FALSE;
1466 }
1467
1468 stXC_MODEPARSE_INIT XCArgs;
1469 XCArgs.bReturnValue = FALSE;
1470
1471 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_MODEPARSE_CMD_INIT, (void*)&XCArgs) != 0)
1472 {
1473 printf("Obtain XC engine fail\n");
1474 return FALSE;
1475 }
1476 else
1477 {
1478 return XCArgs.bReturnValue;
1479 }
1480 }
1481
MApi_XC_ModeParse_EX_MatchMode(XC_DEVICE_ID * pDeviceId,XC_MODEPARSE_EX_PCADC_MODETABLE_TYPE * ModeDB,MS_U8 u16NumberOfItems,XC_MODEPARSE_EX_INPUT_INFO * psInputInfo)1482 XC_MODEPARSE_EX_RESULT MApi_XC_ModeParse_EX_MatchMode(XC_DEVICE_ID *pDeviceId, XC_MODEPARSE_EX_PCADC_MODETABLE_TYPE* ModeDB, MS_U8 u16NumberOfItems , XC_MODEPARSE_EX_INPUT_INFO *psInputInfo)
1483 {
1484 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1485 {
1486 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1487 return XC_MODEPARSE_NOT_PARSED;
1488 }
1489
1490 _XC_ST_CHECK_SIZE(MS_PCADC_MODETABLE_TYPE,XC_MODEPARSE_EX_PCADC_MODETABLE_TYPE);
1491 _XC_ST_CHECK_SIZE(XC_MODEPARSE_INPUT_INFO,XC_MODEPARSE_EX_INPUT_INFO);
1492 stXC_MODEPARSE_MATCHMODE XCArgs;
1493 XCArgs.ModeDB = (MS_PCADC_MODETABLE_TYPE*)ModeDB;
1494 XCArgs.u8NumberOfItems = u16NumberOfItems;
1495 XCArgs.psInputInfo = (XC_MODEPARSE_INPUT_INFO*)psInputInfo;
1496 XCArgs.eReturnValue = XC_MODEPARSE_NOT_PARSED;
1497
1498 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_MODEPARSE_CMD_MATCHMODE, (void*)&XCArgs) != 0)
1499 {
1500 printf("Obtain XC engine fail\n");
1501 return XC_MODEPARSE_NOT_PARSED;
1502 }
1503 else
1504 {
1505 return XCArgs.eReturnValue;
1506 }
1507 }
1508
MApi_XC_ModeParse_EX_MatchModeEx(XC_DEVICE_ID * pDeviceId,XC_MODEPARSE_EX_PCADC_MODETABLE_TYPE_EX * ModeDB,MS_U8 u16NumberOfItems,XC_MODEPARSE_EX_INPUT_INFO * psInputInfo)1509 XC_MODEPARSE_EX_RESULT MApi_XC_ModeParse_EX_MatchModeEx(XC_DEVICE_ID *pDeviceId, XC_MODEPARSE_EX_PCADC_MODETABLE_TYPE_EX* ModeDB, MS_U8 u16NumberOfItems , XC_MODEPARSE_EX_INPUT_INFO *psInputInfo)
1510 {
1511 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1512 {
1513 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1514 return XC_MODEPARSE_NOT_PARSED;
1515 }
1516
1517 _XC_ST_CHECK_SIZE(MS_PCADC_MODETABLE_TYPE_EX,XC_MODEPARSE_EX_PCADC_MODETABLE_TYPE_EX);
1518 _XC_ST_CHECK_SIZE(XC_MODEPARSE_INPUT_INFO,XC_MODEPARSE_EX_INPUT_INFO);
1519 stXC_MODEPARSE_MATCHMODEEX XCArgs;
1520 XCArgs.ModeDB = (MS_PCADC_MODETABLE_TYPE_EX*)ModeDB;
1521 XCArgs.u8NumberOfItems = u16NumberOfItems;
1522 XCArgs.psInputInfo = (XC_MODEPARSE_INPUT_INFO*)psInputInfo;
1523 XCArgs.eReturnValue = XC_MODEPARSE_NOT_PARSED;
1524
1525 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_MODEPARSE_CMD_MATCHMODEEX, (void*)&XCArgs) != 0)
1526 {
1527 printf("Obtain XC engine fail\n");
1528 return XC_MODEPARSE_NOT_PARSED;
1529 }
1530 else
1531 {
1532 return XCArgs.eReturnValue;
1533 }
1534
1535 }
1536
1537 //drvXC_HDMI_if_EX.h
MDrv_HDMI_EX_GetLibVer(const MSIF_Version ** ppVersion)1538 HDMI_EX_RET_VALUE MDrv_HDMI_EX_GetLibVer(const MSIF_Version **ppVersion)
1539 {
1540 if (pu32XCInst == NULL)
1541 {
1542 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1543 return E_HDMI_RET_FAIL;
1544 }
1545
1546 stHDMI_GETLIBVER XCArgs;
1547 XCArgs.ppVersion = ppVersion;
1548 XCArgs.eReturnValue = E_HDMI_RET_FAIL;
1549
1550 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GETLIBVER, (void*)&XCArgs) != 0)
1551 {
1552 printf("Obtain XC engine fail\n");
1553 return E_HDMI_RET_FAIL;
1554 }
1555 else
1556 {
1557 return XCArgs.eReturnValue;
1558 }
1559 }
MDrv_HDMI_EX_GetInfo(HDMI_EX_INFO * pInfo)1560 HDMI_EX_RET_VALUE MDrv_HDMI_EX_GetInfo(HDMI_EX_INFO *pInfo)
1561 {
1562 if (pu32XCInst == NULL)
1563 {
1564 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1565 return E_HDMI_RET_FAIL;
1566 }
1567
1568 _XC_ST_CHECK_SIZE(MS_HDMI_INFO,HDMI_EX_INFO);
1569 stHDMI_GETINFO XCArgs;
1570 XCArgs.pInfo = (MS_HDMI_INFO*)pInfo;
1571 XCArgs.eReturnValue = E_HDMI_RET_FAIL;
1572
1573 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GETINFO, (void*)&XCArgs) != 0)
1574 {
1575 printf("Obtain XC engine fail\n");
1576 return E_HDMI_RET_FAIL;
1577 }
1578 else
1579 {
1580 return XCArgs.eReturnValue;
1581 }
1582 }
MDrv_HDMI_EX_GetStatus(HDMI_EX_Status * pStatus)1583 HDMI_EX_RET_VALUE MDrv_HDMI_EX_GetStatus(HDMI_EX_Status *pStatus)
1584 {
1585 if (pu32XCInst == NULL)
1586 {
1587 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1588 return E_HDMI_RET_FAIL;
1589 }
1590
1591 _XC_ST_CHECK_SIZE(MS_HDMI_Status,HDMI_EX_Status);
1592 stHDMI_GETSTATUS XCArgs;
1593 XCArgs.pStatus = (MS_HDMI_Status*)pStatus;
1594 XCArgs.eReturnValue = E_HDMI_RET_FAIL;
1595
1596 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GETSTATUS, (void*)&XCArgs) != 0)
1597 {
1598 printf("Obtain XC engine fail\n");
1599 return E_HDMI_RET_FAIL;
1600 }
1601 else
1602 {
1603 return XCArgs.eReturnValue;
1604 }
1605 }
1606
MDrv_HDMI_EX_Get_AVIInfoActiveInfoPresent(void)1607 MS_BOOL MDrv_HDMI_EX_Get_AVIInfoActiveInfoPresent(void)
1608 {
1609 if (pu32XCInst == NULL)
1610 {
1611 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1612 return FALSE;
1613 }
1614
1615 stHDMI_GET_AVIIINFO_ACTIVEINFOPRESENT XCArgs;
1616 XCArgs.bReturnValue = FALSE;
1617
1618 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AVIINFO_ACTIVEINFOPRESENT, (void*)&XCArgs) != 0)
1619 {
1620 printf("Obtain XC engine fail\n");
1621 return FALSE;
1622 }
1623 else
1624 {
1625 return XCArgs.bReturnValue;
1626 }
1627 }
1628
MDrv_HDMI_EX_Func_Caps(void)1629 MS_U16 MDrv_HDMI_EX_Func_Caps(void)
1630 {
1631 if (pu32XCInst == NULL)
1632 {
1633 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1634 return 0;
1635 }
1636
1637 stHDMI_FUNC_CAPS XCArgs;
1638 XCArgs.u16ReturnValue = 0;
1639
1640 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_FUNC_CAPS, (void*)&XCArgs) != 0)
1641 {
1642 printf("Obtain XC engine fail\n");
1643 return 0;
1644 }
1645 else
1646 {
1647 return XCArgs.u16ReturnValue;
1648 }
1649 }
1650
MDrv_HDMI_EX_init(XC_DEVICE_ID * pDeviceId)1651 void MDrv_HDMI_EX_init( XC_DEVICE_ID *pDeviceId )
1652 {
1653 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1654 {
1655 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1656 return;
1657 }
1658
1659 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDMI_IF_CMD_INIT, NULL) != 0)
1660 {
1661 printf("Obtain XC engine fail\n");
1662 return;
1663 }
1664 else
1665 {
1666 return;
1667 }
1668 }
1669
MDrv_HDMI_EX_Exit(XC_DEVICE_ID * pDeviceId)1670 void MDrv_HDMI_EX_Exit( XC_DEVICE_ID *pDeviceId )
1671 {
1672 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1673 {
1674 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1675 return;
1676 }
1677
1678 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDMI_IF_CMD_EXIT, NULL) != 0)
1679 {
1680 printf("Obtain XC engine fail\n");
1681 return;
1682 }
1683 else
1684 {
1685 return;
1686 }
1687 }
1688
MDrv_HDMI_EX_pkt_reset(XC_DEVICE_ID * pDeviceId,HDMI_EX_REST breset)1689 void MDrv_HDMI_EX_pkt_reset( XC_DEVICE_ID *pDeviceId, HDMI_EX_REST breset )
1690 {
1691 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1692 {
1693 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1694 return;
1695 }
1696
1697 stHDMI_PKT_RESET XCArgs;
1698 XCArgs.breset = breset;
1699
1700 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDMI_IF_CMD_PKT_RESET, (void*)&XCArgs) != 0)
1701 {
1702 printf("Obtain XC engine fail\n");
1703 return;
1704 }
1705 else
1706 {
1707 return;
1708 }
1709 }
1710
MDrv_HDMI_EX_pullhpd(MS_BOOL bHighLow,E_MUX_INPUTPORT enInputPortType,MS_BOOL bInverse)1711 void MDrv_HDMI_EX_pullhpd( MS_BOOL bHighLow, E_MUX_INPUTPORT enInputPortType, MS_BOOL bInverse)
1712 {
1713 if (pu32XCInst == NULL)
1714 {
1715 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1716 return;
1717 }
1718
1719 stHDMI_PULLHPD XCArgs;
1720 XCArgs.bHighLow = bHighLow;
1721 XCArgs.enInputPortType = enInputPortType;
1722 XCArgs.bInverse = bInverse;
1723
1724 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_PULLHPD, (void*)&XCArgs) != 0)
1725 {
1726 printf("Obtain XC engine fail\n");
1727 return;
1728 }
1729 else
1730 {
1731 return;
1732 }
1733 }
1734
MDrv_HDMI_EX_GC_Info(HDMI_EX_GControl_INFO gcontrol)1735 MS_U16 MDrv_HDMI_EX_GC_Info(HDMI_EX_GControl_INFO gcontrol)
1736 {
1737 if (pu32XCInst == NULL)
1738 {
1739 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1740 return 0;
1741 }
1742
1743 stHDMI_GC_INFO XCArgs;
1744 XCArgs.gcontrol = gcontrol;
1745 XCArgs.u16ReturnValue = 0;
1746
1747 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GC_INFO, (void*)&XCArgs) != 0)
1748 {
1749 printf("Obtain XC engine fail\n");
1750 return 0;
1751 }
1752 else
1753 {
1754 return XCArgs.u16ReturnValue;
1755 }
1756 }
1757
MDrv_HDMI_EX_Packet_Received(MS_BOOL bEnable)1758 HDMI_EX_PACKET_VALUE MDrv_HDMI_EX_Packet_Received(MS_BOOL bEnable)
1759 {
1760 _XC_ST_CHECK_SIZE(MS_HDMI_PACKET_VALUE_t,HDMI_EX_PACKET_VALUE);
1761 stHDMI_PACKET_RECEIVED XCArgs;
1762 HDMI_EX_PACKET_VALUE stPacketValue = {0};
1763 XCArgs.bEnable = bEnable;
1764
1765 if (pu32XCInst == NULL)
1766 {
1767 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1768 }
1769
1770 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_PACKET_RECEIVED, (void*)&XCArgs) != 0)
1771 {
1772 printf("Obtain XC engine fail\n");
1773 }
1774 else
1775 {
1776
1777 }
1778
1779 return stPacketValue;
1780 }
1781
MDrv_HDMI_EX_Get_ColorFormat(void)1782 HDMI_EX_COLOR_FORMAT MDrv_HDMI_EX_Get_ColorFormat(void)
1783 {
1784 if (pu32XCInst == NULL)
1785 {
1786 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1787 return MS_HDMI_COLOR_UNKNOWN;
1788 }
1789
1790 stHDMI_GET_COLORFORMAT XCArgs;
1791 XCArgs.eReturnValue = MS_HDMI_COLOR_UNKNOWN;
1792
1793 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_COLORFORMAT, (void*)&XCArgs) != 0)
1794 {
1795 printf("Obtain XC engine fail\n");
1796 return MS_HDMI_COLOR_UNKNOWN;
1797 }
1798 else
1799 {
1800 return XCArgs.eReturnValue;
1801 }
1802 }
1803
MDrv_HDMI_EX_Get_ColorRange(void)1804 HDMI_EX_COLOR_RANGE MDrv_HDMI_EX_Get_ColorRange(void)
1805 {
1806 if (pu32XCInst == NULL)
1807 {
1808 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1809 return E_HDMI_COLOR_RANGE_RESERVED;
1810 }
1811
1812 stHDMI_GET_COLORRANGE XCArgs;
1813 XCArgs.eReturnValue = E_HDMI_COLOR_RANGE_RESERVED;
1814
1815 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_COLORRANGE, (void*)&XCArgs) != 0)
1816 {
1817 printf("Obtain XC engine fail\n");
1818 return E_HDMI_COLOR_RANGE_RESERVED;
1819 }
1820 else
1821 {
1822 return XCArgs.eReturnValue;
1823 }
1824 }
1825
MDrv_HDMI_EX_Get_Content_Type(void)1826 HDMI_EX_CONTENT_TYPE MDrv_HDMI_EX_Get_Content_Type(void)
1827 {
1828 if (pu32XCInst == NULL)
1829 {
1830 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1831 return MS_HDMI_CONTENT_NoData;
1832 }
1833
1834 stHDMI_GET_CONTENT_TYPE XCArgs;
1835 XCArgs.enReturnValue = MS_HDMI_CONTENT_NoData;
1836
1837 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_CONTENT_TYPE, (void*)&XCArgs) != 0)
1838 {
1839 printf("Obtain XC engine fail\n");
1840 return MS_HDMI_CONTENT_NoData;
1841 }
1842 else
1843 {
1844 return XCArgs.enReturnValue;
1845 }
1846 }
1847
MDrv_HDMI_EX_Get_ExtColorimetry(void)1848 HDMI_EX_EXT_COLORIMETRY_FORMAT MDrv_HDMI_EX_Get_ExtColorimetry(void)
1849 {
1850 if (pu32XCInst == NULL)
1851 {
1852 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1853 return MS_HDMI_EXT_COLOR_UNKNOWN;
1854 }
1855
1856 stHDMI_GET_EXT_COLORIMETRY XCArgs;
1857 XCArgs.enReturnValue = MS_HDMI_EXT_COLOR_UNKNOWN;
1858
1859 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_EXTCOLORIMETRY, (void*)&XCArgs) != 0)
1860 {
1861 printf("Obtain XC engine fail\n");
1862 return MS_HDMI_EXT_COLOR_UNKNOWN;
1863 }
1864 else
1865 {
1866 return XCArgs.enReturnValue;
1867 }
1868 }
1869
MDrv_HDMI_EX_Set_EQ(XC_DEVICE_ID * pDeviceId,HDMI_EX_EQ enEq,MS_U8 u8EQValue)1870 void MDrv_HDMI_EX_Set_EQ(XC_DEVICE_ID *pDeviceId, HDMI_EX_EQ enEq, MS_U8 u8EQValue)
1871 {
1872 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1873 {
1874 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1875 return;
1876 }
1877
1878 stHDMI_SET_EQ XCArgs;
1879 XCArgs.enEq = enEq;
1880 XCArgs.u8EQValue = u8EQValue;
1881
1882 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDMI_IF_CMD_SET_EQ, (void*)&XCArgs) != 0)
1883 {
1884 printf("Obtain XC engine fail\n");
1885 return;
1886 }
1887 else
1888 {
1889 return;
1890 }
1891 }
1892
MDrv_HDMI_EX_Set_EQ_To_Port(XC_DEVICE_ID * pDeviceId,HDMI_EX_EQ enEq,MS_U8 u8EQValue,E_MUX_INPUTPORT enInputPortType)1893 MS_BOOL MDrv_HDMI_EX_Set_EQ_To_Port(XC_DEVICE_ID *pDeviceId, HDMI_EX_EQ enEq, MS_U8 u8EQValue, E_MUX_INPUTPORT enInputPortType)
1894 {
1895 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
1896 {
1897 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
1898 return FALSE;
1899 }
1900
1901 stHDMI_SET_EQ_TO_PORT XCArgs;
1902 XCArgs.enEq = enEq;
1903 XCArgs.u8EQValue = u8EQValue;
1904 XCArgs.enInputPortType = enInputPortType;
1905 XCArgs.bReturnValue = FALSE;
1906
1907 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDMI_IF_CMD_SET_EQ_TO_PORT, (void*)&XCArgs) != 0)
1908 {
1909 printf("Obtain XC engine fail\n");
1910 return FALSE;
1911 }
1912 else
1913 {
1914 return XCArgs.bReturnValue;
1915 }
1916 }
1917
MDrv_HDMI_EX_Audio_MUTE_Enable(MS_U16 u16MuteEvent,MS_U16 u16MuteMask)1918 void MDrv_HDMI_EX_Audio_MUTE_Enable(MS_U16 u16MuteEvent, MS_U16 u16MuteMask)
1919 {
1920 if (pu32XCInst == NULL)
1921 {
1922 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1923 return;
1924 }
1925
1926 stHDMI_AUDIO_MUTE_ENABLE XCArgs;
1927 XCArgs.u16MuteEvent = u16MuteEvent;
1928 XCArgs.u16MuteMask = u16MuteMask;
1929
1930 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_MUTE_ENABLE, (void*)&XCArgs) != 0)
1931 {
1932 printf("Obtain XC engine fail\n");
1933 return;
1934 }
1935 else
1936 {
1937 return;
1938 }
1939 }
MDrv_HDMI_EX_Audio_Status_Clear(void)1940 void MDrv_HDMI_EX_Audio_Status_Clear(void)
1941 {
1942 if (pu32XCInst == NULL)
1943 {
1944 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1945 return;
1946 }
1947
1948 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_STATUS_CLEAR, NULL) != 0)
1949 {
1950 printf("Obtain XC engine fail\n");
1951 return;
1952 }
1953 else
1954 {
1955 return;
1956 }
1957 }
1958
MDrv_HDMI_EX_Get_AspectRatio(MS_BOOL bEn_PAR,MS_BOOL bEn_AFAR)1959 HDMI_EX_AR_TYPE MDrv_HDMI_EX_Get_AspectRatio(MS_BOOL bEn_PAR, MS_BOOL bEn_AFAR)
1960 {
1961 if (pu32XCInst == NULL)
1962 {
1963 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1964 return HDMI_AF_AR_Reserve_0;
1965 }
1966
1967 stHDMI_GET_ASPECTRATIO XCArgs;
1968 XCArgs.bEn_PAR = bEn_PAR;
1969 XCArgs.bEn_AFAR = bEn_AFAR;
1970 XCArgs.eReturnValue = HDMI_AF_AR_Reserve_0;
1971
1972 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_ASPECTRATIO, (void*)&XCArgs) != 0)
1973 {
1974 printf("Obtain XC engine fail\n");
1975 return HDMI_AF_AR_Reserve_0;
1976 }
1977 else
1978 {
1979 return XCArgs.eReturnValue;
1980 }
1981 }
1982
MDrv_HDMI_EX_Get_ActiveFormat_AspectRatio(MS_BOOL bEn_AFAR)1983 HDMI_EX_AR_TYPE MDrv_HDMI_EX_Get_ActiveFormat_AspectRatio(MS_BOOL bEn_AFAR)
1984 {
1985 if (pu32XCInst == NULL)
1986 {
1987 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
1988 return HDMI_AF_AR_Reserve_0;
1989 }
1990
1991 stHDMI_GET_ACTIVEFORMAT_ASPECTRATIO XCArgs;
1992 XCArgs.bEn_AFAR = bEn_AFAR;
1993 XCArgs.eReturnValue = HDMI_AF_AR_Reserve_0;
1994
1995 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_ACTIVEFORMAT_ASPECTRATIO, (void*)&XCArgs) != 0)
1996 {
1997 printf("Obtain XC engine fail\n");
1998 return HDMI_AF_AR_Reserve_0;
1999 }
2000 else
2001 {
2002 return XCArgs.eReturnValue;
2003 }
2004 }
2005
MDrv_HDMI_EX_Get_AVIInfoFrameVer(void)2006 HDMI_EX_AVI_INFOFRAME_VERSION MDrv_HDMI_EX_Get_AVIInfoFrameVer(void)
2007 {
2008 if (pu32XCInst == NULL)
2009 {
2010 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2011 return E_AVI_INFOFRAME_VERSION_NON;
2012 }
2013
2014 stHDMI_GET_AVIINFOFRAMEVER XCArgs;
2015 XCArgs.eReturnValue = E_AVI_INFOFRAME_VERSION_NON;
2016
2017 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_AVIINFOFRAMEVER, (void*)&XCArgs) != 0)
2018 {
2019 printf("Obtain XC engine fail\n");
2020 return E_AVI_INFOFRAME_VERSION_NON;
2021 }
2022 else
2023 {
2024 return XCArgs.eReturnValue;
2025 }
2026 }
2027
MDrv_HDMI_EX_err_status_update(MS_U8 u8value,MS_BOOL bread)2028 MS_U8 MDrv_HDMI_EX_err_status_update(MS_U8 u8value, MS_BOOL bread)
2029 {
2030 if (pu32XCInst == NULL)
2031 {
2032 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2033 return 0;
2034 }
2035
2036 stHDMI_ERR_STATUS_UPDATE XCArgs;
2037 XCArgs.u8value = u8value;
2038 XCArgs.bread = bread;
2039 XCArgs.u8ReturnValue = 0;
2040
2041 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_ERR_STATUS_UPDATE, (void*)&XCArgs) != 0)
2042 {
2043 printf("Obtain XC engine fail\n");
2044 return 0;
2045 }
2046 else
2047 {
2048 return XCArgs.u8ReturnValue;
2049 }
2050 }
2051
MDrv_HDMI_EX_Get_PollingStatus(HDMI_POLLING_STATUS_t ** pStatus)2052 void MDrv_HDMI_EX_Get_PollingStatus(HDMI_POLLING_STATUS_t **pStatus)
2053 {
2054 if (pu32XCInst == NULL)
2055 {
2056 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2057 return;
2058 }
2059
2060 stHDMI_GET_POLLINGSTATUS XCArgs;
2061 XCArgs.pStatus = NULL;
2062
2063 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_POLLINGSTATUS, (void*)&XCArgs) != 0)
2064 {
2065 printf("Obtain XC engine fail\n");
2066 return;
2067 }
2068 else
2069 {
2070 return;
2071 }
2072 }
2073
MDrv_HDMI_EX_IsHDMI_Mode(void)2074 MS_BOOL MDrv_HDMI_EX_IsHDMI_Mode(void)
2075 {
2076 if (pu32XCInst == NULL)
2077 {
2078 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2079 return FALSE;
2080 }
2081
2082 stHDMI_ISHDMI_MODE XCArgs;
2083 XCArgs.bReturnValue = FALSE;
2084
2085 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_ISHDMI_MODE, (void*)&XCArgs) != 0)
2086 {
2087 printf("Obtain XC engine fail\n");
2088 return FALSE;
2089 }
2090 else
2091 {
2092 return XCArgs.bReturnValue;
2093 }
2094 }
2095
MDrv_HDMI_EX_Get_MID_info(MS_U8 * pu8ManufactorData)2096 void MDrv_HDMI_EX_Get_MID_info(MS_U8 * pu8ManufactorData)
2097 {
2098 if (pu32XCInst == NULL)
2099 {
2100 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2101 return;
2102 }
2103
2104 stHDMI_GET_MID_INFO XCArgs;
2105 XCArgs.pu8ManufactorData = pu8ManufactorData;
2106
2107 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_MID_INFO, (void*)&XCArgs) != 0)
2108 {
2109 printf("Obtain XC engine fail\n");
2110 return;
2111 }
2112 else
2113 {
2114 return;
2115 }
2116 }
2117
MDrv_HDMI_EX_get_packet_value(HDMI_EX_PACKET_STATE u8state,MS_U8 u8byte_idx,MS_U8 * pValue)2118 MS_BOOL MDrv_HDMI_EX_get_packet_value(HDMI_EX_PACKET_STATE u8state, MS_U8 u8byte_idx, MS_U8 *pValue)
2119 {
2120 if (pu32XCInst == NULL)
2121 {
2122 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2123 return FALSE;
2124 }
2125
2126 stHDMI_GET_PACKET_VALUE XCArgs;
2127 XCArgs.u8state = u8state;
2128 XCArgs.u8byte_idx = u8byte_idx;
2129 XCArgs.pValue = pValue;
2130 XCArgs.bReturnValue = FALSE;
2131
2132 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_PACKET_VALUE, (void*)&XCArgs) != 0)
2133 {
2134 printf("Obtain XC engine fail\n");
2135 return FALSE;
2136 }
2137 else
2138 {
2139 return XCArgs.bReturnValue;
2140 }
2141 }
2142
2143 //DVI
MDrv_DVI_EX_ChannelPhaseStatus(HDMI_EX_DVI_CHANNEL_TYPE u8Channel)2144 MS_U16 MDrv_DVI_EX_ChannelPhaseStatus( HDMI_EX_DVI_CHANNEL_TYPE u8Channel)
2145 {
2146 if (pu32XCInst == NULL)
2147 {
2148 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2149 return 0;
2150 }
2151
2152 stDVI_CHANNELPHASESTATUS XCArgs;
2153 XCArgs.u8Channel = u8Channel;
2154 XCArgs.u16ReturnValue = 0;
2155
2156 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_CHANNELPHASESTATUS, (void*)&XCArgs) != 0)
2157 {
2158 printf("Obtain XC engine fail\n");
2159 return 0;
2160 }
2161 else
2162 {
2163 return XCArgs.u16ReturnValue;
2164 }
2165 }
2166
MDrv_DVI_EX_SoftwareReset(MS_U16 u16Reset)2167 void MDrv_DVI_EX_SoftwareReset( MS_U16 u16Reset)
2168 {
2169 if (pu32XCInst == NULL)
2170 {
2171 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2172 return;
2173 }
2174
2175 stDVI_SOFTWARERESET XCArgs;
2176 XCArgs.u16Reset = u16Reset;
2177
2178 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_SOFTWARERESET, (void*)&XCArgs) != 0)
2179 {
2180 printf("Obtain XC engine fail\n");
2181 return;
2182 }
2183 else
2184 {
2185 return;
2186 }
2187 }
2188
mdrv_dvi_ex_reset(XC_DEVICE_ID * pDeviceId)2189 void mdrv_dvi_ex_reset(XC_DEVICE_ID *pDeviceId)
2190 {
2191 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2192 {
2193 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2194 return;
2195 }
2196
2197 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_DVI_IF_CMD_RESET, NULL) != 0)
2198 {
2199 printf("Obtain XC engine fail\n");
2200 return;
2201 }
2202 else
2203 {
2204 return;
2205 }
2206 }
2207
MDrv_DVI_EX_ClkPullLow(MS_BOOL bPullLow,E_MUX_INPUTPORT enInputPortType)2208 void MDrv_DVI_EX_ClkPullLow(MS_BOOL bPullLow, E_MUX_INPUTPORT enInputPortType)
2209 {
2210 if (pu32XCInst == NULL)
2211 {
2212 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2213 return;
2214 }
2215
2216 stDVI_CLKPULLLOW XCArgs;
2217 XCArgs.bPullLow = bPullLow;
2218 XCArgs.enInputPortType = enInputPortType;
2219
2220 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_CLKPULLLOW, (void*)&XCArgs) != 0)
2221 {
2222 printf("Obtain XC engine fail\n");
2223 return;
2224 }
2225 else
2226 {
2227 return;
2228 }
2229 }
2230
MDrv_DVI_EX_SwitchSrc(E_MUX_INPUTPORT enInputPortType)2231 void MDrv_DVI_EX_SwitchSrc(E_MUX_INPUTPORT enInputPortType)
2232 {
2233 if (pu32XCInst == NULL)
2234 {
2235 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2236 return;
2237 }
2238
2239 stDVI_SWITCHSRC XCArgs;
2240 XCArgs.enInputPortType = enInputPortType;
2241
2242 if(UtopiaIoctl(pu32XCInst, E_XC_DVI_IF_CMD_SWITCHSRC, (void*)&XCArgs) != 0)
2243 {
2244 printf("Obtain XC engine fail\n");
2245 return;
2246 }
2247 else
2248 {
2249 return;
2250 }
2251 }
2252
MDrv_HDMI_EX_SetForClockLessThan70Mhz(E_MUX_INPUTPORT InputSourceType)2253 MS_BOOL MDrv_HDMI_EX_SetForClockLessThan70Mhz( E_MUX_INPUTPORT InputSourceType )
2254 {
2255 if (pu32XCInst == NULL)
2256 {
2257 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2258 return FALSE;
2259 }
2260
2261 stHDMI_SETFORCLOCKLESSTHAN70MHZ XCArgs;
2262 XCArgs.enInputPortType = InputSourceType;
2263 XCArgs.bReturnValue = FALSE;
2264
2265 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SETFORCLOCKLESSTHAN70MHZ, (void*)&XCArgs) != 0)
2266 {
2267 printf("Obtain XC engine fail\n");
2268 return FALSE;
2269 }
2270 else
2271 {
2272 return XCArgs.bReturnValue;
2273 }
2274 }
2275
MDrv_HDMI_EX_dvi_adjust(MS_BOOL bClockLessThan70MHz)2276 void MDrv_HDMI_EX_dvi_adjust( MS_BOOL bClockLessThan70MHz)
2277 {
2278 if (pu32XCInst == NULL)
2279 {
2280 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2281 return;
2282 }
2283
2284 stHDMI_DVI_ADJUST XCArgs;
2285 XCArgs.bClockLessThan70MHz = bClockLessThan70MHz;
2286
2287 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_DVI_ADJUST, (void*)&XCArgs) != 0)
2288 {
2289 printf("Obtain XC engine fail\n");
2290 return;
2291 }
2292 else
2293 {
2294 return;
2295 }
2296 }
2297
MDrv_HDMI_EX_SetUpdatePhaseLineCount(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE enInputSourceType)2298 void MDrv_HDMI_EX_SetUpdatePhaseLineCount(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE enInputSourceType)
2299 {
2300 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2301 {
2302 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2303 return;
2304 }
2305
2306 stHDMI_SETUPDATEPHASELINECOUNT XCArgs;
2307 XCArgs.enInputSourceType = enInputSourceType;
2308
2309 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDMI_IF_CMD_SETUPDATEPHASELINECOUNT, (void*)&XCArgs) != 0)
2310 {
2311 printf("Obtain XC engine fail\n");
2312 return;
2313 }
2314 else
2315 {
2316 return;
2317 }
2318 }
2319
2320 //HDCP
MDrv_HDCP_EX_Enable(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)2321 void MDrv_HDCP_EX_Enable(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
2322 {
2323 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2324 {
2325 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2326 return;
2327 }
2328
2329 stHDCP_ENABLE XCArgs;
2330 XCArgs.bEnable = bEnable;
2331
2332 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDCP_IF_CMD_ENABLE, (void*)&XCArgs) != 0)
2333 {
2334 printf("Obtain XC engine fail\n");
2335 return;
2336 }
2337 else
2338 {
2339 return;
2340 }
2341 }
2342
MDrv_HDMI_EX_SetHdcpEnable(E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable)2343 MS_BOOL MDrv_HDMI_EX_SetHdcpEnable(E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable)
2344 {
2345 if (pu32XCInst == NULL)
2346 {
2347 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2348 return FALSE;
2349 }
2350
2351 stHDMI_SET_HDCPENABLE XCArgs;
2352 XCArgs.enInputPortType = enInputPortType;
2353 XCArgs.bEnable = bEnable;
2354 XCArgs.bReturnValue = FALSE;
2355
2356 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_SET_HDCP_ENABLE, (void*)&XCArgs) != 0)
2357 {
2358 printf("Obtain XC engine fail\n");
2359 return FALSE;
2360 }
2361 else
2362 {
2363 return XCArgs.bReturnValue;
2364 }
2365 }
2366
MDrv_HDCP_EX_ClearStatus(XC_DEVICE_ID * pDeviceId)2367 void MDrv_HDCP_EX_ClearStatus( XC_DEVICE_ID *pDeviceId )
2368 {
2369 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2370 {
2371 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2372 return;
2373 }
2374
2375 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDCP_IF_CMD_CLEARSTATUS, NULL) != 0)
2376 {
2377 printf("Obtain XC engine fail\n");
2378 return;
2379 }
2380 else
2381 {
2382 return;
2383 }
2384 }
2385
MDrv_HDCP_EX_initproductionkey(MS_U8 * pu8HdcpKeyData)2386 void MDrv_HDCP_EX_initproductionkey( MS_U8 * pu8HdcpKeyData )
2387 {
2388 if (pu32XCInst == NULL)
2389 {
2390 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2391 return;
2392 }
2393
2394 stHDCP_INITPRODUCTIONKEY XCArgs;
2395 XCArgs.pu8HdcpKeyData = pu8HdcpKeyData;
2396
2397 if(UtopiaIoctl(pu32XCInst, E_XC_HDCP_IF_CMD_INITPRODUCTIONKEY, (void*)&XCArgs) != 0)
2398 {
2399 printf("Obtain XC engine fail\n");
2400 return;
2401 }
2402 else
2403 {
2404 return;
2405 }
2406 }
2407
MDrv_HDCP_EX_GetStatus(XC_DEVICE_ID * pDeviceId)2408 HDCP_EX_STATUS_INFO* MDrv_HDCP_EX_GetStatus(XC_DEVICE_ID *pDeviceId)
2409 {
2410 stHDCP_GETSTATUS XCArgs = {0};
2411 static HDCP_EX_STATUS_INFO stHDCPStatus = {0};
2412
2413 XCArgs.usHDCPStatus = 0;
2414
2415 if(_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2416 {
2417 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2418 }
2419
2420 _XC_ST_CHECK_SIZE(MS_HDCP_STATUS_INFO_t, HDCP_EX_STATUS_INFO);
2421
2422 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_HDCP_IF_CMD_GETSTATUS, (void*)&XCArgs) != 0)
2423 {
2424 printf("Obtain XC engine fail\n");
2425
2426 }
2427 else
2428 {
2429
2430 }
2431
2432 return &stHDCPStatus;
2433 }
2434
MDrv_HDCP_EX_Vsync_end_en(MS_BOOL bStable)2435 void MDrv_HDCP_EX_Vsync_end_en(MS_BOOL bStable)
2436 {
2437 if (pu32XCInst == NULL)
2438 {
2439 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2440 return;
2441 }
2442
2443 stHDCP_VSYNC_END_EN XCArgs;
2444 XCArgs.bStable = bStable;
2445
2446 if(UtopiaIoctl(pu32XCInst, E_XC_HDCP_IF_CMD_VSYNC_END_EN, (void*)&XCArgs) != 0)
2447 {
2448 printf("Obtain XC engine fail\n");
2449 return;
2450 }
2451 else
2452 {
2453 return;
2454 }
2455 }
2456
2457 //Audio
MDrv_HDMI_EX_audio_output(MS_BOOL bEnable)2458 void MDrv_HDMI_EX_audio_output( MS_BOOL bEnable )
2459 {
2460 if (pu32XCInst == NULL)
2461 {
2462 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2463 return;
2464 }
2465
2466 stHDMI_AUDIO_OUTPUT XCArgs;
2467 XCArgs.bEnable = bEnable;
2468
2469 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_OUTPUT, (void*)&XCArgs) != 0)
2470 {
2471 printf("Obtain XC engine fail\n");
2472 return;
2473 }
2474 else
2475 {
2476 return;
2477 }
2478 }
2479
MDrv_HDMI_EX_audio_cp_hdr_info(void)2480 MS_U8 MDrv_HDMI_EX_audio_cp_hdr_info(void)
2481 {
2482 if (pu32XCInst == NULL)
2483 {
2484 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2485 return 0;
2486 }
2487
2488 stHDMI_AUDIO_CP_HDR_INFO XCArgs;
2489 XCArgs.u8ReturnValue = 0;
2490
2491 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_CP_HDR_INFO, (void*)&XCArgs) != 0)
2492 {
2493 printf("Obtain XC engine fail\n");
2494 return 0;
2495 }
2496 else
2497 {
2498 return XCArgs.u8ReturnValue;
2499 }
2500 }
2501
MDrv_HDMI_EX_audio_channel_status(MS_U8 u8byte)2502 MS_U8 MDrv_HDMI_EX_audio_channel_status(MS_U8 u8byte)
2503 {
2504 if (pu32XCInst == NULL)
2505 {
2506 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2507 return 0;
2508 }
2509
2510 stHDMI_AUDIO_CHANNEL_STATUS XCArgs;
2511 XCArgs.u8byte = u8byte;
2512 XCArgs.u8ReturnValue = 0;
2513
2514 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AUDIO_CHANNEL_STATUS, (void*)&XCArgs) != 0)
2515 {
2516 printf("Obtain XC engine fail\n");
2517 return 0;
2518 }
2519 else
2520 {
2521 return XCArgs.u8ReturnValue;
2522 }
2523 }
2524
2525 // DDC Ram
MDrv_HDMI_EX_READ_DDCRAM(XC_EX_DDCRAM_PROG_INFO * pstDDCRam_Info,MS_U32 u32SizeOfInfo)2526 void MDrv_HDMI_EX_READ_DDCRAM(XC_EX_DDCRAM_PROG_INFO *pstDDCRam_Info, MS_U32 u32SizeOfInfo)
2527 {
2528 if (pu32XCInst == NULL)
2529 {
2530 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2531 return;
2532 }
2533
2534 _XC_ST_CHECK_SIZE(XC_DDCRAM_PROG_INFO,XC_EX_DDCRAM_PROG_INFO);
2535 stHDMI_READ_DDCRAM XCArgs;
2536 XCArgs.pstDDCRam_Info = (XC_DDCRAM_PROG_INFO*)pstDDCRam_Info;
2537 XCArgs.u32SizeOfInfo = u32SizeOfInfo;
2538
2539 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_READ_DDCRAM, (void*)&XCArgs) != 0)
2540 {
2541 printf("Obtain XC engine fail\n");
2542 return;
2543 }
2544 else
2545 {
2546 return;
2547 }
2548 }
2549
MDrv_HDMI_EX_PROG_DDCRAM(XC_EX_DDCRAM_PROG_INFO * pstDDCRam_Info,MS_U32 u32SizeOfInfo)2550 void MDrv_HDMI_EX_PROG_DDCRAM(XC_EX_DDCRAM_PROG_INFO *pstDDCRam_Info, MS_U32 u32SizeOfInfo)
2551 {
2552 if (pu32XCInst == NULL)
2553 {
2554 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2555 return;
2556 }
2557
2558 _XC_ST_CHECK_SIZE(XC_DDCRAM_PROG_INFO,XC_EX_DDCRAM_PROG_INFO);
2559 stHDMI_PROG_DDCRAM XCArgs;
2560 XCArgs.pstDDCRam_Info = (XC_DDCRAM_PROG_INFO*)pstDDCRam_Info;
2561 XCArgs.u32SizeOfInfo = u32SizeOfInfo;
2562
2563 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_PROG_DDCRAM, (void*)&XCArgs) != 0)
2564 {
2565 printf("Obtain XC engine fail\n");
2566 return;
2567 }
2568 else
2569 {
2570 return;
2571 }
2572 }
2573
MDrv_HDMI_EX_Get_Pixel_Repetition(void)2574 MS_U8 MDrv_HDMI_EX_Get_Pixel_Repetition(void)
2575 {
2576 if (pu32XCInst == NULL)
2577 {
2578 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2579 return 0;
2580 }
2581
2582 stHDMI_GET_PIXEL_REPETITION XCArgs;
2583 XCArgs.u8ReturnValue = 0;
2584
2585 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_PIXEL_REPETITION, (void*)&XCArgs) != 0)
2586 {
2587 printf("Obtain XC engine fail\n");
2588 return 0;
2589 }
2590 else
2591 {
2592 return XCArgs.u8ReturnValue;
2593 }
2594 }
2595
2596 //#if defined(CHIP_T8) || defined(CHIP_J2) // HDMI 1.4 new feature
MDrv_HDMI_EX_3D_4Kx2K_Process(void)2597 void MDrv_HDMI_EX_3D_4Kx2K_Process(void)
2598 {
2599 if (pu32XCInst == NULL)
2600 {
2601 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2602 return;
2603 }
2604
2605 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_3D_4KX2K_PROCESS, NULL) != 0)
2606 {
2607 printf("Obtain XC engine fail\n");
2608 return;
2609 }
2610 else
2611 {
2612 return;
2613 }
2614 }
2615
MDrv_HDMI_EX_AVG_ScaleringDown(MS_BOOL btrue)2616 void MDrv_HDMI_EX_AVG_ScaleringDown(MS_BOOL btrue)
2617 {
2618 if (pu32XCInst == NULL)
2619 {
2620 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2621 return;
2622 }
2623
2624 stHDMI_AVG_SCALERINGDOWN XCArgs;
2625 XCArgs.bTrue = btrue;
2626
2627 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_AVG_SCALERINGDOWN, (void*)&XCArgs) != 0)
2628 {
2629 printf("Obtain XC engine fail\n");
2630 return;
2631 }
2632 else
2633 {
2634 return;
2635 }
2636 }
2637
MDrv_HDMI_EX_Check4K2K(void)2638 MS_BOOL MDrv_HDMI_EX_Check4K2K(void)
2639 {
2640 if (pu32XCInst == NULL)
2641 {
2642 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2643 return FALSE;
2644 }
2645
2646 stHDMI_CHECK_4K2K XCArgs;
2647 XCArgs.bReturnValue = FALSE;
2648
2649 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_CHECK_4K2K, NULL) != 0)
2650 {
2651 printf("Obtain XC engine fail\n");
2652 return FALSE;
2653 }
2654 else
2655 {
2656 return XCArgs.bReturnValue;
2657 }
2658 }
2659
MDrv_HDMI_EX_Check_Additional_Format(void)2660 HDMI_EX_ADDITIONAL_VIDEO_FORMAT MDrv_HDMI_EX_Check_Additional_Format(void)
2661 {
2662 if (pu32XCInst == NULL)
2663 {
2664 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2665 return E_HDMI_NA;
2666 }
2667
2668 stHDMI_CHECK_ADDITIONAL_FORMAT XCArgs;
2669 XCArgs.eReturnValue = E_HDMI_NA;
2670
2671 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_CHECK_ADDITIONAL_FORMAT, (void*)&XCArgs) != 0)
2672 {
2673 printf("Obtain XC engine fail\n");
2674 return E_HDMI_NA;
2675 }
2676 else
2677 {
2678 return XCArgs.eReturnValue;
2679 }
2680 }
2681
MDrv_HDMI_EX_Get_3D_Structure(void)2682 XC_EX_3D_INPUT_MODE MDrv_HDMI_EX_Get_3D_Structure(void)
2683 {
2684 if (pu32XCInst == NULL)
2685 {
2686 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2687 return E_XC_3D_INPUT_MODE_NONE;
2688 }
2689
2690 stHDMI_GET_3D_STRUCTURE XCArgs;
2691 XCArgs.eReturnValue = E_XC_3D_INPUT_MODE_NONE;
2692
2693 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_3D_STRUCTURE, (void*)&XCArgs) != 0)
2694 {
2695 printf("Obtain XC engine fail\n");
2696 return E_XC_3D_INPUT_MODE_NONE;
2697 }
2698 else
2699 {
2700 return XCArgs.eReturnValue;
2701 }
2702 }
2703
MDrv_HDMI_EX_Get_3D_Ext_Data(void)2704 HDMI_EX_3D_EXT_DATA MDrv_HDMI_EX_Get_3D_Ext_Data(void)
2705 {
2706 if (pu32XCInst == NULL)
2707 {
2708 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2709 return E_3D_EXT_DATA_MODE_MAX;
2710 }
2711
2712 stHDMI_GET_3D_EXT_DATA XCArgs;
2713 XCArgs.eReturnValue = E_3D_EXT_DATA_MODE_MAX;
2714
2715 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_CMD_GET_3D_EXT_DATA, (void*)&XCArgs) != 0)
2716 {
2717 printf("Obtain XC engine fail\n");
2718 return E_3D_EXT_DATA_MODE_MAX;
2719 }
2720 else
2721 {
2722 return XCArgs.eReturnValue;
2723 }
2724 }
2725
MDrv_HDMI_EX_Get_3D_Meta_Field(HDMI_EX_3D_META_FIELD * pdata)2726 void MDrv_HDMI_EX_Get_3D_Meta_Field(HDMI_EX_3D_META_FIELD *pdata)
2727 {
2728 if (pu32XCInst == NULL)
2729 {
2730 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2731 return;
2732 }
2733
2734 _XC_ST_CHECK_SIZE(sHDMI_3D_META_FIELD,HDMI_EX_3D_META_FIELD);
2735 stHDMI_GET_3D_META_FIELD XCArgs;
2736 XCArgs.pdata = (sHDMI_3D_META_FIELD*)pdata;
2737
2738 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_3D_META_FIELD, (void*)&XCArgs) != 0)
2739 {
2740 printf("Obtain XC engine fail\n");
2741 return;
2742 }
2743 else
2744 {
2745 return;
2746 }
2747 }
2748
MDrv_HDMI_EX_Get_VIC_Code(void)2749 MS_U8 MDrv_HDMI_EX_Get_VIC_Code(void)
2750 {
2751 if (pu32XCInst == NULL)
2752 {
2753 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2754 return 0;
2755 }
2756
2757 stHDMI_GET_VIC_CODE XCArgs;
2758 XCArgs.u8ReturnValue = 0;
2759
2760 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_VIC_CODE, (void*)&XCArgs) != 0)
2761 {
2762 printf("Obtain XC engine fail\n");
2763 return 0;
2764 }
2765 else
2766 {
2767 return XCArgs.u8ReturnValue;
2768 }
2769 }
2770
MDrv_HDMI_EX_Get_4Kx2K_VIC_Code(void)2771 HDMI_EX_VIC_4Kx2K_CODE MDrv_HDMI_EX_Get_4Kx2K_VIC_Code(void)
2772 {
2773 if (pu32XCInst == NULL)
2774 {
2775 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2776 return E_VIC_NA;
2777 }
2778
2779 stHDMI_GET_4KX2K_VIC_CODE XCArgs;
2780 XCArgs.eReturnValue = E_VIC_NA;
2781
2782 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_GET_4KX2K_VIC_CODE, (void*)&XCArgs) != 0)
2783 {
2784 printf("Obtain XC engine fail\n");
2785 return E_VIC_NA;
2786 }
2787 else
2788 {
2789 return XCArgs.eReturnValue;
2790 }
2791 }
2792
2793 // HDMI ARC pin control
MDrv_HDMI_EX_ARC_PINControl(E_MUX_INPUTPORT enInputPortType,MS_BOOL bEnable,MS_BOOL bDrivingHigh)2794 void MDrv_HDMI_EX_ARC_PINControl(E_MUX_INPUTPORT enInputPortType, MS_BOOL bEnable, MS_BOOL bDrivingHigh)
2795 {
2796 if (pu32XCInst == NULL)
2797 {
2798 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2799 return;
2800 }
2801
2802 stHDMI_ARC_PINCONTROL XCArgs;
2803 XCArgs.enInputPortType = enInputPortType;
2804 XCArgs.bEnable = bEnable;
2805 XCArgs.bDrivingHigh = bDrivingHigh;
2806
2807 if(UtopiaIoctl(pu32XCInst, E_XC_HDMI_IF_CMD_ARC_PINCONTROL, (void*)&XCArgs) != 0)
2808 {
2809 printf("Obtain XC engine fail\n");
2810 return;
2811 }
2812 else
2813 {
2814 return;
2815 }
2816 }
2817
2818 //API XC
MApi_XC_EX_GetLibVer(const MSIF_Version ** ppVersion)2819 XC_EX_RETURN_VALUE MApi_XC_EX_GetLibVer(const MSIF_Version **ppVersion)
2820 {
2821 return MApi_XC_GetLibVer(ppVersion);
2822
2823 if (pu32XCInst == NULL)
2824 {
2825 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
2826 return E_APIXC_RET_FAIL;
2827 }
2828
2829 stXC_GET_LIB_VER XCArgs;
2830 XCArgs.ppVersion = ppVersion;
2831 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
2832
2833 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_LIB_VERSION, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2834 {
2835 printf("Obtain XC engine fail\n");
2836 return E_APIXC_RET_FAIL;
2837 }
2838 else
2839 {
2840 return XCArgs.eReturnValue;
2841 }
2842 }
2843
MApi_XC_EX_GetInfo(XC_DEVICE_ID * pDeviceId)2844 const XC_EX_ApiInfo * MApi_XC_EX_GetInfo(XC_DEVICE_ID *pDeviceId)
2845 {
2846 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2847 {
2848 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2849 return NULL;
2850 }
2851
2852 stXC_CMD_GET_INFO XCArgs;
2853 static XC_ApiInfo Getinfo;
2854
2855 XCArgs.stReturnValue = &Getinfo;
2856
2857 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2858 {
2859 printf("Obtain XC engine fail\n");
2860 return (XC_EX_ApiInfo*)XCArgs.stReturnValue;
2861 }
2862 else
2863 {
2864 return (XC_EX_ApiInfo*)XCArgs.stReturnValue;
2865 }
2866 }
2867
MApi_XC_EX_GetStatus(XC_DEVICE_ID * pDeviceId,XC_EX_ApiStatus * pDrvStatus,XC_EX_SCALER_WIN eWindow)2868 MS_BOOL MApi_XC_EX_GetStatus(XC_DEVICE_ID *pDeviceId, XC_EX_ApiStatus *pDrvStatus, XC_EX_SCALER_WIN eWindow)
2869 {
2870 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2871 {
2872 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2873 return FALSE;
2874 }
2875
2876 _XC_ST_CHECK_SIZE(XC_ApiStatus,XC_EX_ApiStatus);
2877 stXC_GET_STATUS XCArgs;
2878 XCArgs.pDrvStatus = (XC_ApiStatus*)pDrvStatus;
2879 XCArgs.eWindow = eWindow;
2880 XCArgs.bReturnValue = FALSE;
2881
2882 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2883 {
2884 printf("Obtain XC engine fail\n");
2885 return FALSE;
2886 }
2887 else
2888 {
2889 return XCArgs.bReturnValue;
2890 }
2891 }
2892
MApi_XC_EX_GetStatusEx(XC_DEVICE_ID * pDeviceId,XC_EX_ApiStatusEx * pDrvStatusEx,XC_EX_SCALER_WIN eWindow)2893 MS_U16 MApi_XC_EX_GetStatusEx(XC_DEVICE_ID *pDeviceId, XC_EX_ApiStatusEx *pDrvStatusEx, XC_EX_SCALER_WIN eWindow)
2894 {
2895 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2896 {
2897 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2898 return 0;
2899 }
2900
2901 _XC_ST_CHECK_SIZE(XC_ApiStatusEx,XC_EX_ApiStatusEx);
2902 stXC_GET_STATUS_EX XCArgs;
2903 XCArgs.pDrvStatusEx = (XC_ApiStatusEx*)pDrvStatusEx;
2904 XCArgs.eWindow = eWindow;
2905 XCArgs.u16ReturnValue = 0;
2906
2907 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_STATUS_EX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2908 {
2909 printf("Obtain XC engine fail\n");
2910 return 0;
2911 }
2912 else
2913 {
2914 return XCArgs.u16ReturnValue;
2915 }
2916 }
2917
MApi_XC_EX_SetDbgLevel(MS_U16 u16DbgSwitch)2918 MS_BOOL MApi_XC_EX_SetDbgLevel(MS_U16 u16DbgSwitch)
2919 {
2920 if (pu32XCInst == NULL)
2921 {
2922 XC_INSTANT_ATTRIBUTE stXCInstantAttribute;
2923 INIT_XC_INSTANT_ATTR(stXCInstantAttribute);
2924 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
2925 {
2926 printf("UtopiaOpen XC failed\n");
2927 return E_APIXC_RET_FAIL;
2928 }
2929 }
2930
2931 stXC_SET_DBG_LEVEL XCArgs;
2932 XCArgs.u16DbgSwitch = u16DbgSwitch;
2933 XCArgs.bReturnValue = FALSE;
2934
2935 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_DBG_LEVEL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2936 {
2937 printf("Obtain XC engine fail\n");
2938 return FALSE;
2939 }
2940 else
2941 {
2942 return XCArgs.bReturnValue;
2943 }
2944 }
2945
MApi_XC_EX_FPLLDbgMode(XC_DEVICE_ID * pDeviceId,XC_EX_FPLL_DBG_MODE DbgMode,XC_EX_FPLL_DBG_FLAG DbgFlag,MS_U32 u32Data)2946 void MApi_XC_EX_FPLLDbgMode(XC_DEVICE_ID *pDeviceId, XC_EX_FPLL_DBG_MODE DbgMode, XC_EX_FPLL_DBG_FLAG DbgFlag, MS_U32 u32Data)
2947 {
2948 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2949 {
2950 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2951 return;
2952 }
2953
2954 stXC_SET_FPLL_CUSTOMERMODE XCArgs;
2955 XCArgs.eMode = DbgMode;
2956 XCArgs.eFlag = DbgFlag;
2957 XCArgs.u32Data = u32Data;
2958
2959 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FPLL_CUSTOMERMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2960 {
2961 printf("Obtain XC engine fail\n");
2962 return;
2963 }
2964 else
2965 {
2966 return;
2967 }
2968 }
2969
MApi_XC_EX_FPLLCustomerMode(XC_DEVICE_ID * pDeviceId,XC_EX_FPLL_MODE eMode,XC_EX_FPLL_FLAG eFlag,MS_U32 u32Data)2970 void MApi_XC_EX_FPLLCustomerMode(XC_DEVICE_ID *pDeviceId, XC_EX_FPLL_MODE eMode, XC_EX_FPLL_FLAG eFlag, MS_U32 u32Data)
2971 {
2972 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2973 {
2974 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2975 return;
2976 }
2977
2978 stXC_SET_FPLL_CUSTOMERMODE XCArgs;
2979 XCArgs.eMode = eMode;
2980 XCArgs.eFlag = eFlag;
2981 XCArgs.u32Data = u32Data;
2982
2983 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FPLL_CUSTOMERMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
2984 {
2985 printf("Obtain XC engine fail\n");
2986 return;
2987 }
2988 else
2989 {
2990 return;
2991 }
2992 }
2993
MDrv_XC_EX_SetIOMapBase(XC_DEVICE_ID * pDeviceId)2994 MS_BOOL MDrv_XC_EX_SetIOMapBase(XC_DEVICE_ID *pDeviceId)
2995 {
2996 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
2997 {
2998 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
2999 return FALSE;
3000 }
3001
3002 stXC_CMD_SET_IOMAPBASE XCArgs;
3003 XCArgs.bReturnValue = FALSE;
3004
3005 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_IOMAPBASE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3006 {
3007 printf("Obtain XC engine fail\n");
3008 return FALSE;
3009 }
3010 else
3011 {
3012 return XCArgs.bReturnValue;
3013 }
3014 }
3015
MApi_XC_EX_Init(XC_DEVICE_ID * pDeviceId,XC_EX_INITDATA * pXC_InitData,MS_U32 u32InitDataLen)3016 MS_BOOL MApi_XC_EX_Init(XC_DEVICE_ID *pDeviceId, XC_EX_INITDATA *pXC_InitData, MS_U32 u32InitDataLen)
3017 {
3018 XC_INSTANT_ATTRIBUTE stXCInstantAttribute;
3019 INIT_XC_INSTANT_ATTR(stXCInstantAttribute);
3020 if (pDeviceId->u32Id == 0 && pu32XCInst == NULL)
3021 {
3022 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
3023 {
3024 printf("UtopiaOpen XC failed\n");
3025 return E_APIXC_RET_FAIL;
3026 }
3027 }
3028 else if (pDeviceId->u32Id == 1 && pu32XCInst_1 == NULL)
3029 {
3030 stXCInstantAttribute.u32DeviceID= 1;
3031 if(UtopiaOpen(MODULE_XC, &pu32XCInst_1, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
3032 {
3033 printf("UtopiaOpen XC failed\n");
3034 return E_APIXC_RET_FAIL;
3035 }
3036 }
3037 else if(pDeviceId->u32Id > 1)
3038 {
3039 printf("Device Id over 2\n");
3040 return E_APIXC_RET_FAIL;
3041 }
3042
3043 _XC_ST_CHECK_SIZE(XC_INITDATA,XC_EX_INITDATA);
3044 stXC_INIT XCArgs;
3045 XCArgs.pXC_InitData = (XC_INITDATA*)pXC_InitData;
3046 XCArgs.u32InitDataLen = u32InitDataLen;
3047 XCArgs.bReturnValue = FALSE;
3048
3049 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3050 {
3051 printf("Obtain XC engine fail\n");
3052 return FALSE;
3053 }
3054 else
3055 {
3056 return XCArgs.bReturnValue;
3057 }
3058 }
3059
MApi_XC_EX_GetConfig(XC_DEVICE_ID * pDeviceId,XC_EX_INITDATA * pXC_EX_InitData)3060 XC_EX_RETURN_VALUE MApi_XC_EX_GetConfig(XC_DEVICE_ID *pDeviceId, XC_EX_INITDATA *pXC_EX_InitData)
3061 {
3062 XC_INSTANT_ATTRIBUTE stXCInstantAttribute;
3063 INIT_XC_INSTANT_ATTR(stXCInstantAttribute);
3064 if (pDeviceId->u32Id == 0 && pu32XCInst == NULL)
3065 {
3066 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
3067 {
3068 printf("UtopiaOpen XC failed\n");
3069 return E_APIXC_RET_FAIL;
3070 }
3071 }
3072 else if (pDeviceId->u32Id == 1 && pu32XCInst_1 == NULL)
3073 {
3074 stXCInstantAttribute.u32DeviceID= 1;
3075 if(UtopiaOpen(MODULE_XC, &pu32XCInst_1, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
3076 {
3077 printf("UtopiaOpen XC failed\n");
3078 return E_APIXC_RET_FAIL;
3079 }
3080 }
3081 else if(pDeviceId->u32Id > 1)
3082 {
3083 printf("Device Id over 2\n");
3084 return E_APIXC_RET_FAIL;
3085 }
3086
3087 _XC_ST_CHECK_SIZE(XC_INITDATA, XC_EX_INITDATA);
3088 stXC_GET_CONFIG XCArgs;
3089 XCArgs.pXC_InitData = (XC_INITDATA*)pXC_EX_InitData;
3090 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
3091
3092 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_CONFIG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3093 {
3094 printf("XC engine GET_CONFIG Ioctl fail\n");
3095 return E_APIXC_RET_FAIL;
3096 }
3097 else
3098 {
3099 return XCArgs.eReturnValue;
3100 }
3101 }
3102
MApi_XC_EX_Init_MISC(XC_DEVICE_ID * pDeviceId,XC_EX_INITMISC * pXC_Init_Misc,MS_U32 u32InitMiscDataLen)3103 XC_EX_RETURN_VALUE MApi_XC_EX_Init_MISC(XC_DEVICE_ID *pDeviceId, XC_EX_INITMISC *pXC_Init_Misc, MS_U32 u32InitMiscDataLen)
3104 {
3105 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3106 {
3107 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3108 return E_APIXC_RET_FAIL;
3109 }
3110
3111 _XC_ST_CHECK_SIZE(XC_INITMISC,XC_EX_INITMISC);
3112 stXC_INIT_MISC XCArgs;
3113 XCArgs.pXC_Init_Misc = (XC_INITMISC*)pXC_Init_Misc;
3114 XCArgs.u32InitMiscDataLen = u32InitMiscDataLen;
3115 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
3116
3117 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_INIT_MISC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3118 {
3119 printf("Obtain XC engine fail\n");
3120 return E_APIXC_RET_FAIL;
3121 }
3122 else
3123 {
3124 return XCArgs.eReturnValue;
3125 }
3126 }
3127
MApi_XC_EX_GetMISCStatus(XC_DEVICE_ID * pDeviceId,XC_EX_INITMISC * pXC_Init_Misc)3128 XC_EX_RETURN_VALUE MApi_XC_EX_GetMISCStatus(XC_DEVICE_ID *pDeviceId, XC_EX_INITMISC *pXC_Init_Misc)
3129 {
3130 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3131 {
3132 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3133 return E_APIXC_RET_FAIL;
3134 }
3135
3136 _XC_ST_CHECK_SIZE(XC_INITMISC,XC_EX_INITMISC);
3137 stXC_GET_MISC_STATUS XCArgs;
3138 XCArgs.pXC_Init_Misc = (XC_INITMISC*)pXC_Init_Misc;
3139 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
3140
3141 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_MISC_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3142 {
3143 printf("Obtain XC engine fail\n");
3144 return E_APIXC_RET_FAIL;
3145 }
3146 else
3147 {
3148 return XCArgs.eReturnValue;
3149 }
3150 }
3151
MApi_XC_EX_GetCapability(MS_U32 u32Id)3152 MS_U32 MApi_XC_EX_GetCapability(MS_U32 u32Id)
3153 {
3154 if (pu32XCInst == NULL)
3155 {
3156 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3157 {
3158 printf("UtopiaOpen XC failed\n");
3159 return E_APIXC_RET_FAIL;
3160 }
3161 }
3162
3163 stXC_GET_CAPABILITY XCArgs;
3164 XCArgs.u32Id = u32Id;
3165 XCArgs.u32ReturnValue = 0;
3166
3167 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_CAPABILITY, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3168 {
3169 printf("Obtain XC engine fail\n");
3170 return 0;
3171 }
3172 else
3173 {
3174 return XCArgs.u32ReturnValue;
3175 }
3176 }
3177
MApi_XC_EX_GetChipCaps(XC_EX_CAPS eCapType,MS_U32 * pRet,MS_U32 ret_size)3178 XC_EX_RETURN_VALUE MApi_XC_EX_GetChipCaps(XC_EX_CAPS eCapType, MS_U32* pRet, MS_U32 ret_size)
3179 {
3180 if (pu32XCInst == NULL)
3181 {
3182 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
3183 return E_APIXC_RET_FAIL;
3184 }
3185
3186 stXC_GET_CHIP_CAPS XCArgs;
3187 XCArgs.eCapType = eCapType;
3188 XCArgs.pRet = pRet;
3189 XCArgs.ret_size = ret_size;
3190 XCArgs.eReturnValue = 0;
3191
3192 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_CHIPCAPS, (void*)&XCArgs) != 0)
3193 {
3194 printf("Obtain XC engine fail\n");
3195 return E_APIXC_RET_FAIL;
3196 }
3197 else
3198 {
3199 return XCArgs.eReturnValue;
3200 }
3201 }
3202
MApi_XC_EX_Exit(XC_DEVICE_ID * pDeviceId)3203 MS_BOOL MApi_XC_EX_Exit(XC_DEVICE_ID *pDeviceId)
3204 {
3205 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3206 {
3207 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3208 return FALSE;
3209 }
3210
3211 stXC_EXIT XCArgs;
3212 XCArgs.bReturnValue = FALSE;
3213
3214 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_EXIT, (void*)&XCArgs) != 0)
3215 {
3216 printf("Obtain XC engine fail\n");
3217 return FALSE;
3218 }
3219 else
3220 {
3221 return XCArgs.bReturnValue;
3222 }
3223 }
3224
MApi_XC_EX_SetDynamicScaling(XC_DEVICE_ID * pDeviceId,XC_EX_DynamicScaling_Info * pstDSInfo,MS_U32 u32DSInfoLen,XC_EX_SCALER_WIN eWindow)3225 MS_BOOL MApi_XC_EX_SetDynamicScaling(XC_DEVICE_ID *pDeviceId, XC_EX_DynamicScaling_Info *pstDSInfo, MS_U32 u32DSInfoLen, XC_EX_SCALER_WIN eWindow)
3226 {
3227 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3228 {
3229 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3230 return FALSE;
3231 }
3232
3233 _XC_ST_CHECK_SIZE(XC_DynamicScaling_Info,XC_EX_DynamicScaling_Info);
3234 stXC_SET_DYNAMIC_SCALING XCArgs;
3235 XCArgs.pstDSInfo = (XC_DynamicScaling_Info*)pstDSInfo;
3236 XCArgs.u32DSInfoLen = u32DSInfoLen;
3237 XCArgs.eWindow = eWindow;
3238 XCArgs.bReturnValue = FALSE;
3239
3240 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_DYNAMIC_SCALING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3241 {
3242 printf("Obtain XC engine fail\n");
3243 return FALSE;
3244 }
3245 else
3246 {
3247 return XCArgs.bReturnValue;
3248 }
3249 }
3250
MApi_XC_EX_GetDynamicScalingStatus(XC_DEVICE_ID * pDeviceId)3251 MS_BOOL MApi_XC_EX_GetDynamicScalingStatus(XC_DEVICE_ID *pDeviceId)
3252 {
3253 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3254 {
3255 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3256 return FALSE;
3257 }
3258
3259 stXC_GET_DS_STATUS XCArgs;
3260 XCArgs.bReturnValue = FALSE;
3261
3262 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DS_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3263 {
3264 printf("Obtain XC engine fail\n");
3265 return FALSE;
3266 }
3267 else
3268 {
3269 return XCArgs.bReturnValue;
3270 }
3271 }
3272
MApi_XC_EX_Get_DNRBaseOffset(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)3273 MS_PHY MApi_XC_EX_Get_DNRBaseOffset(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
3274 {
3275 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3276 {
3277 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3278 return 0;
3279 }
3280
3281 stXC_GET_DNR_BASEOFFSET XCArgs;
3282 XCArgs.eWindow = eWindow;
3283 XCArgs.u32ReturnValue = 0;
3284
3285 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DNR_BASEOFFSET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3286 {
3287 printf("Obtain XC engine fail\n");
3288 return 0;
3289 }
3290 else
3291 {
3292 return XCArgs.u32ReturnValue;
3293 }
3294 }
3295
MApi_XC_EX_Get_FrameNumFactor(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)3296 MS_U8 MApi_XC_EX_Get_FrameNumFactor(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
3297 {
3298 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3299 {
3300 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3301 return 0;
3302 }
3303
3304 stXC_GET_FRAMENUM_FACTOR XCArgs;
3305 XCArgs.eWindow = eWindow;
3306 XCArgs.u8ReturnValue = 0;
3307
3308 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_FRAMENUM_FACTOR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3309 {
3310 printf("Obtain XC engine fail\n");
3311 return 0;
3312 }
3313 else
3314 {
3315 return XCArgs.u8ReturnValue;
3316 }
3317 }
3318
MApi_XC_EX_SetWindow(XC_DEVICE_ID * pDeviceId,XC_EX_SETWIN_INFO * pstXC_SetWin_Info,MS_U32 u32InitDataLen,XC_EX_SCALER_WIN eWindow)3319 MS_BOOL MApi_XC_EX_SetWindow(XC_DEVICE_ID *pDeviceId, XC_EX_SETWIN_INFO *pstXC_SetWin_Info, MS_U32 u32InitDataLen, XC_EX_SCALER_WIN eWindow)
3320 {
3321 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3322 {
3323 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3324 return FALSE;
3325 }
3326
3327 _XC_ST_CHECK_SIZE(XC_SETWIN_INFO,XC_EX_SETWIN_INFO);
3328 stXC_SET_WINDOW XCArgs;
3329 XCArgs.pstXC_SetWin_Info = (XC_SETWIN_INFO*)pstXC_SetWin_Info;
3330 XCArgs.u32InitDataLen = u32InitDataLen;
3331 XCArgs.eWindow = eWindow;
3332 XCArgs.bReturnValue = FALSE;
3333
3334 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3335 {
3336 printf("Obtain XC engine fail\n");
3337 return FALSE;
3338 }
3339 else
3340 {
3341 return XCArgs.bReturnValue;
3342 }
3343 }
3344
MApi_XC_EX_SetDualWindow(XC_DEVICE_ID * pDeviceId,XC_EX_SETWIN_INFO * pstXC_SetWin_Info_Main,XC_EX_SETWIN_INFO * pstXC_SetWin_Info_Sub)3345 MS_BOOL MApi_XC_EX_SetDualWindow(XC_DEVICE_ID *pDeviceId, XC_EX_SETWIN_INFO *pstXC_SetWin_Info_Main, XC_EX_SETWIN_INFO *pstXC_SetWin_Info_Sub)
3346 {
3347 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3348 {
3349 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3350 return FALSE;
3351 }
3352
3353 _XC_ST_CHECK_SIZE(XC_SETWIN_INFO,XC_EX_SETWIN_INFO);
3354 stXC_SET_DUALWINDOW XCArgs;
3355 XCArgs.pstXC_SetWin_Info_Main = (XC_SETWIN_INFO*)pstXC_SetWin_Info_Main;
3356 XCArgs.pstXC_SetWin_Info_Sub = (XC_SETWIN_INFO*)pstXC_SetWin_Info_Sub;
3357 XCArgs.bReturnValue = FALSE;
3358
3359 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_DUALWINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3360 {
3361 printf("Obtain XC engine fail\n");
3362 return FALSE;
3363 }
3364 else
3365 {
3366 return XCArgs.bReturnValue;
3367 }
3368 }
3369
MApi_XC_EX_SetTravelingWindow(XC_DEVICE_ID * pDeviceId,XC_EX_SETWIN_INFO * pstXC_SetWin_Info,MS_U32 u32InitDataLen,XC_EX_SCALER_WIN eWindow)3370 MS_BOOL MApi_XC_EX_SetTravelingWindow(XC_DEVICE_ID *pDeviceId, XC_EX_SETWIN_INFO *pstXC_SetWin_Info, MS_U32 u32InitDataLen, XC_EX_SCALER_WIN eWindow)
3371 {
3372 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3373 {
3374 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3375 return FALSE;
3376 }
3377
3378 _XC_ST_CHECK_SIZE(XC_SETWIN_INFO,XC_EX_SETWIN_INFO);
3379 stXC_SET_TRAVELING_WINDOW XCArgs;
3380 XCArgs.pstXC_SetWin_Info = (XC_SETWIN_INFO*)pstXC_SetWin_Info;
3381 XCArgs.u32InitDataLen = u32InitDataLen;
3382 XCArgs.eWindow = eWindow;
3383 XCArgs.bReturnValue = FALSE;
3384
3385 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_TRAVELING_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3386 {
3387 printf("Obtain XC engine fail\n");
3388 return FALSE;
3389 }
3390 else
3391 {
3392 return XCArgs.bReturnValue;
3393 }
3394 }
3395
MApi_XC_EX_SetInputSource(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE enInputSourceType,XC_EX_SCALER_WIN eWindow)3396 void MApi_XC_EX_SetInputSource( XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE enInputSourceType, XC_EX_SCALER_WIN eWindow )
3397 {
3398 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3399 {
3400 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3401 return;
3402 }
3403
3404 stXC_SET_INPUTSOURCE XCArgs;
3405 XCArgs.enInputSourceType = enInputSourceType;
3406 XCArgs.eWindow = eWindow;
3407
3408 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_INPUTSOURCE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3409 {
3410 printf("Obtain XC engine fail\n");
3411 return;
3412 }
3413 else
3414 {
3415 return;
3416 }
3417 }
3418
MApi_XC_EX_IsYUVSpace(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)3419 MS_BOOL MApi_XC_EX_IsYUVSpace(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
3420 {
3421 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3422 {
3423 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3424 return FALSE;
3425 }
3426
3427 stXC_CHECK_YUVSPACE XCArgs;
3428 XCArgs.eWindow = eWindow;
3429 XCArgs.bReturnValue = FALSE;
3430
3431 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_YUVSPACE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3432 {
3433 printf("Obtain XC engine fail\n");
3434 return FALSE;
3435 }
3436 else
3437 {
3438 return XCArgs.bReturnValue;
3439 }
3440 }
3441
MApi_XC_EX_IsMemoryFormat422(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)3442 MS_BOOL MApi_XC_EX_IsMemoryFormat422(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
3443 {
3444 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3445 {
3446 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3447 return FALSE;
3448 }
3449
3450 stXC_CHECK_MEMORYFORMAT422 XCArgs;
3451 XCArgs.eWindow = eWindow;
3452 XCArgs.bReturnValue = FALSE;
3453
3454 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_MEMORYFORMAT422, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3455 {
3456 printf("Obtain XC engine fail\n");
3457 return FALSE;
3458 }
3459 else
3460 {
3461 return XCArgs.bReturnValue;
3462 }
3463 }
3464
MApi_XC_EX_EnableForceRGBin(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)3465 void MApi_XC_EX_EnableForceRGBin(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
3466 {
3467 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3468 {
3469 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3470 return;
3471 }
3472
3473 stXC_SET_FORCE_RGBIN XCArgs;
3474 XCArgs.bEnable = bEnable;
3475 XCArgs.eWindow = eWindow;
3476
3477 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FORCE_RGBIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3478 {
3479 printf("Obtain XC engine fail\n");
3480 return;
3481 }
3482 else
3483 {
3484 return;
3485 }
3486 }
3487
MApi_XC_EX_EnableMirrorModeEx(XC_DEVICE_ID * pDeviceId,XC_EX_MirrorMode eMirrorMode,XC_EX_SCALER_WIN eWindow)3488 MS_BOOL MApi_XC_EX_EnableMirrorModeEx( XC_DEVICE_ID *pDeviceId, XC_EX_MirrorMode eMirrorMode, XC_EX_SCALER_WIN eWindow)
3489 {
3490 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3491 {
3492 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3493 return FALSE;
3494 }
3495
3496 stXC_SET_MIRRORMODE_EX XCArgs;
3497 XCArgs.eMirrorMode = eMirrorMode;
3498 XCArgs.eWindow = eWindow;
3499 XCArgs.bReturnValue = FALSE;
3500
3501 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MIRRORMODE_EX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3502 {
3503 printf("Obtain XC engine fail\n");
3504 return FALSE;
3505 }
3506 else
3507 {
3508 return XCArgs.bReturnValue;
3509 }
3510 }
3511
MApi_XC_EX_GetMirrorModeTypeEx(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)3512 XC_EX_MirrorMode MApi_XC_EX_GetMirrorModeTypeEx(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
3513 {
3514 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3515 {
3516 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3517 return MIRROR_MAX;
3518 }
3519
3520 stXC_GET_MIRRORMODE_TYPEEX XCArgs;
3521 XCArgs.eWindow = eWindow;
3522 XCArgs.eReturnValue = MIRROR_MAX;
3523
3524 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_MIRRORMODE_TYPEEX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3525 {
3526 printf("Obtain XC engine fail\n");
3527 return MIRROR_MAX;
3528 }
3529 else
3530 {
3531 return XCArgs.eReturnValue;
3532 }
3533 }
3534
MApi_XC_EX_GetSyncStatus(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE eCurrentSrc,XC_EX_IP_SYNC_STATUS * sXC_Sync_Status,XC_EX_SCALER_WIN eWindow)3535 void MApi_XC_EX_GetSyncStatus(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE eCurrentSrc , XC_EX_IP_SYNC_STATUS *sXC_Sync_Status, XC_EX_SCALER_WIN eWindow)
3536 {
3537 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3538 {
3539 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3540 return;
3541 }
3542
3543 _XC_ST_CHECK_SIZE(XC_IP_SYNC_STATUS,XC_EX_IP_SYNC_STATUS);
3544 stXC_GET_SYNC_STATUS XCArgs;
3545 XCArgs.eCurrentSrc = eCurrentSrc;
3546 XCArgs.sXC_Sync_Status = (XC_IP_SYNC_STATUS*)sXC_Sync_Status;
3547 XCArgs.eWindow = eWindow;
3548
3549 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_SYNC_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3550 {
3551 printf("Obtain XC engine fail\n");
3552 return;
3553 }
3554 else
3555 {
3556 return;
3557 }
3558 }
3559
MApi_XC_EX_WaitOutputVSync(XC_DEVICE_ID * pDeviceId,MS_U8 u8NumVSyncs,MS_U16 u16Timeout,XC_EX_SCALER_WIN eWindow)3560 MS_U8 MApi_XC_EX_WaitOutputVSync(XC_DEVICE_ID *pDeviceId, MS_U8 u8NumVSyncs, MS_U16 u16Timeout, XC_EX_SCALER_WIN eWindow)
3561 {
3562 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3563 {
3564 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3565 return 0;
3566 }
3567
3568 stXC_SET_WAIT_OUTPUT_VSYNC XCArgs;
3569 XCArgs.u8NumVSyncs = u8NumVSyncs;
3570 XCArgs.u16Timeout = u16Timeout;
3571 XCArgs.eWindow = eWindow;
3572 XCArgs.u8ReturnValue = 0xFF;
3573
3574 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_WAIT_OUTPUT_VSYNC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3575 {
3576 printf("Obtain XC engine fail\n");
3577 return 0xFF;
3578 }
3579 else
3580 {
3581 return XCArgs.u8ReturnValue;
3582 }
3583 }
3584
MApi_XC_EX_WaitInputVSync(XC_DEVICE_ID * pDeviceId,MS_U8 u8NumVSyncs,MS_U16 u16Timeout,XC_EX_SCALER_WIN eWindow)3585 MS_U8 MApi_XC_EX_WaitInputVSync(XC_DEVICE_ID *pDeviceId,MS_U8 u8NumVSyncs, MS_U16 u16Timeout, XC_EX_SCALER_WIN eWindow)
3586 {
3587 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3588 {
3589 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3590 return 0;
3591 }
3592
3593 stXC_SET_WAIT_INPUT_VSYNC XCArgs;
3594 XCArgs.u8NumVSyncs = u8NumVSyncs;
3595 XCArgs.u16Timeout = u16Timeout;
3596 XCArgs.eWindow = eWindow;
3597 XCArgs.u8ReturnValue = 0xFF;
3598
3599 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_WAIT_INPUT_VSYNC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3600 {
3601 printf("Obtain XC engine fail\n");
3602 return 0xFF;
3603 }
3604 else
3605 {
3606 return XCArgs.u8ReturnValue;
3607 }
3608 }
3609
MApi_XC_EX_SetHdmiSyncMode(XC_EX_HDMI_SYNC_TYPE esynctype)3610 void MApi_XC_EX_SetHdmiSyncMode(XC_EX_HDMI_SYNC_TYPE esynctype)
3611 {
3612 if (pu32XCInst == NULL)
3613 {
3614 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
3615 return;
3616 }
3617
3618 stXC_SET_HDMI_SYNCMODE XCArgs;
3619 XCArgs.eSynctype = esynctype;
3620
3621 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_SET_HDMI_SYNCMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3622 {
3623 printf("Obtain XC engine fail\n");
3624 return;
3625 }
3626 else
3627 {
3628 return;
3629 }
3630 }
3631
MApi_XC_EX_GetHdmiSyncMode(void)3632 XC_EX_HDMI_SYNC_TYPE MApi_XC_EX_GetHdmiSyncMode(void)
3633 {
3634 if (pu32XCInst == NULL)
3635 {
3636 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
3637 return HDMI_SYNC_DE;
3638 }
3639
3640 stXC_GET_HDMI_SYNCMODE XCArgs;
3641 XCArgs.eReturnValue = HDMI_SYNC_DE;
3642
3643 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_GET_HDMI_SYNCMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3644 {
3645 printf("Obtain XC engine fail\n");
3646 return HDMI_SYNC_DE;
3647 }
3648 else
3649 {
3650 return XCArgs.eReturnValue;
3651 }
3652 }
3653
MApi_XC_EX_SetRepWindow(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_WINDOW_TYPE Window,MS_U8 u8Color)3654 void MApi_XC_EX_SetRepWindow(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_WINDOW_TYPE Window, MS_U8 u8Color)
3655 {
3656 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3657 {
3658 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3659 return;
3660 }
3661
3662 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE,XC_EX_WINDOW_TYPE);
3663 stXC_SET_REPORT_WINDOW XCArgs;
3664 XCArgs.bEnable = bEnable;
3665 XCArgs.Window = *((MS_WINDOW_TYPE*)&Window);
3666 XCArgs.u8Color = u8Color;
3667
3668 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_REPORT_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3669 {
3670 printf("Obtain XC engine fail\n");
3671 return;
3672 }
3673 else
3674 {
3675 return;
3676 }
3677 }
3678
MApi_XC_EX_Set_OPWriteOffEnable(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)3679 void MApi_XC_EX_Set_OPWriteOffEnable(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
3680 {
3681 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3682 {
3683 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3684 return;
3685 }
3686
3687 stXC_SET_OPWRITEOFF_ENABLE XCArgs;
3688 XCArgs.bEnable = bEnable;
3689 XCArgs.eWindow = eWindow;
3690
3691 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OPWRITEOFF_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3692 {
3693 printf("Obtain XC engine fail\n");
3694 return;
3695 }
3696 else
3697 {
3698 return;
3699 }
3700 }
3701
MApi_XC_EX_ForceSet_OPWriteOffEnable(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)3702 void MApi_XC_EX_ForceSet_OPWriteOffEnable(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable , XC_EX_SCALER_WIN eWindow)
3703 {
3704 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3705 {
3706 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3707 return;
3708 }
3709
3710 stXC_FORCESET_OPWRITEOFF_ENABLE XCArgs;
3711 XCArgs.bEnable = bEnable;
3712 XCArgs.eWindow = eWindow;
3713
3714 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_FORCESET_OPWRITEOFF_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3715 {
3716 printf("Obtain XC engine fail\n");
3717 return;
3718 }
3719 else
3720 {
3721 return;
3722 }
3723 }
3724
MApi_XC_EX_SetDispWinToReg(XC_DEVICE_ID * pDeviceId,XC_EX_WINDOW_TYPE * pstDspwin,XC_EX_SCALER_WIN eWindow)3725 void MApi_XC_EX_SetDispWinToReg(XC_DEVICE_ID *pDeviceId, XC_EX_WINDOW_TYPE *pstDspwin, XC_EX_SCALER_WIN eWindow)
3726 {
3727 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3728 {
3729 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3730 return;
3731 }
3732
3733 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE,XC_EX_WINDOW_TYPE);
3734 stXC_SET_DISPLAY_WIN_TO_REG XCArgs;
3735 XCArgs.pstDspwin = (MS_WINDOW_TYPE*)pstDspwin;
3736 XCArgs.eWindow = eWindow;
3737
3738 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_DISPLAY_WIN_TO_REG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3739 {
3740 printf("Obtain XC engine fail\n");
3741 return;
3742 }
3743 else
3744 {
3745 return;
3746 }
3747 }
3748
MApi_XC_EX_GetDispWinFromReg(XC_DEVICE_ID * pDeviceId,XC_EX_WINDOW_TYPE * pstDspwin,XC_EX_SCALER_WIN eWindow)3749 void MApi_XC_EX_GetDispWinFromReg(XC_DEVICE_ID *pDeviceId, XC_EX_WINDOW_TYPE *pstDspwin, XC_EX_SCALER_WIN eWindow)
3750 {
3751 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3752 {
3753 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3754 return;
3755 }
3756
3757 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE,XC_EX_WINDOW_TYPE);
3758 stXC_GET_DISPLAY_WIN_FROM_REG XCArgs;
3759 XCArgs.pstDspwin = (MS_WINDOW_TYPE*)pstDspwin;
3760 XCArgs.eWindow = eWindow;
3761
3762 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DISPLAY_WIN_FROM_REG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3763 {
3764 printf("Obtain XC engine fail\n");
3765 return;
3766 }
3767 else
3768 {
3769 return;
3770 }
3771 }
3772
MApi_XC_EX_FreezeImg(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)3773 void MApi_XC_EX_FreezeImg(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
3774 {
3775 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3776 {
3777 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3778 return;
3779 }
3780
3781 stXC_SET_FREEZEIMG XCArgs;
3782 XCArgs.bEnable = bEnable;
3783 XCArgs.eWindow = eWindow;
3784
3785 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FREEZEIMG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3786 {
3787 printf("Obtain XC engine fail\n");
3788 return;
3789 }
3790 else
3791 {
3792 return;
3793 }
3794 }
3795
MApi_XC_EX_IsFreezeImg(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)3796 MS_BOOL MApi_XC_EX_IsFreezeImg(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
3797 {
3798 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3799 {
3800 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3801 return FALSE;
3802 }
3803
3804 stXC_CHECK_FREEZEIMG XCArgs;
3805 XCArgs.eWindow = eWindow;
3806 XCArgs.bReturnValue = FALSE;
3807
3808 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_FREEZEIMG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3809 {
3810 printf("Obtain XC engine fail\n");
3811 return FALSE;
3812 }
3813 else
3814 {
3815 return XCArgs.bReturnValue;
3816 }
3817 }
3818
MApi_XC_EX_GenerateBlackVideoForBothWin(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)3819 void MApi_XC_EX_GenerateBlackVideoForBothWin( XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
3820 {
3821 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3822 {
3823 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3824 return;
3825 }
3826
3827 stXC_SET_BOTHWINDOW_BLACKVIDEO XCArgs;
3828 XCArgs.bEnable = bEnable;
3829
3830 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BOTHWINDOW_BLACKVIDEO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3831 {
3832 printf("Obtain XC engine fail\n");
3833 return;
3834 }
3835 else
3836 {
3837 return;
3838 }
3839 }
3840
MApi_XC_EX_Set_BLSK(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)3841 void MApi_XC_EX_Set_BLSK(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
3842 {
3843 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3844 {
3845 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3846 return;
3847 }
3848
3849 stXC_SET_BLACKSCREEN XCArgs;
3850 XCArgs.bEnable = bEnable;
3851
3852 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BLACKSCREEN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3853 {
3854 printf("Obtain XC engine fail\n");
3855 return;
3856 }
3857 else
3858 {
3859 return;
3860 }
3861 }
3862
MApi_XC_EX_GenerateBlackVideo(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)3863 void MApi_XC_EX_GenerateBlackVideo(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
3864 {
3865 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3866 {
3867 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3868 return;
3869 }
3870
3871 stXC_SET_BLACKVIDEO XCArgs;
3872 XCArgs.bEnable = bEnable;
3873 XCArgs.eWindow = eWindow;
3874
3875 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BLACKVIDEO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3876 {
3877 printf("Obtain XC engine fail\n");
3878 return;
3879 }
3880 else
3881 {
3882 return;
3883 }
3884 }
3885
MApi_XC_EX_IsBlackVideoEnable(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)3886 MS_BOOL MApi_XC_EX_IsBlackVideoEnable(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
3887 {
3888 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3889 {
3890 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3891 return FALSE;
3892 }
3893
3894 stXC_CHECK_BLACKVIDEO_ENABLE XCArgs;
3895 XCArgs.eWindow = eWindow;
3896 XCArgs.bReturnValue = FALSE;
3897
3898 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_BLACKVIDEO_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3899 {
3900 printf("Obtain XC engine fail\n");
3901 return FALSE;
3902 }
3903 else
3904 {
3905 return XCArgs.bReturnValue;
3906 }
3907 }
3908
MApi_XC_EX_EnableFrameBufferLess(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)3909 void MApi_XC_EX_EnableFrameBufferLess(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
3910 {
3911 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3912 {
3913 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3914 return;
3915 }
3916
3917 stXC_SET_FRAMEBUFFERLESS XCArgs;
3918 XCArgs.bEnable = bEnable;
3919
3920 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRAMEBUFFERLESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3921 {
3922 printf("Obtain XC engine fail\n");
3923 return;
3924 }
3925 else
3926 {
3927 return;
3928 }
3929 }
3930
MApi_XC_EX_IsCurrentFrameBufferLessMode(XC_DEVICE_ID * pDeviceId)3931 MS_BOOL MApi_XC_EX_IsCurrentFrameBufferLessMode(XC_DEVICE_ID *pDeviceId)
3932 {
3933 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3934 {
3935 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3936 return FALSE;
3937 }
3938
3939 stXC_CHECK_FRAMEBUFFERLESS XCArgs;
3940 XCArgs.bReturnValue = FALSE;
3941
3942 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_FRAMEBUFFERLESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3943 {
3944 printf("Obtain XC engine fail\n");
3945 return FALSE;
3946 }
3947 else
3948 {
3949 return XCArgs.bReturnValue;
3950 }
3951 }
3952
MApi_XC_EX_EnableRequest_FrameBufferLess(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)3953 void MApi_XC_EX_EnableRequest_FrameBufferLess(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
3954 {
3955 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3956 {
3957 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3958 return;
3959 }
3960
3961 stXC_SET_REQUEST_FRAMEBUFFERLESS XCArgs;
3962 XCArgs.bEnable = bEnable;
3963
3964 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_REQUEST_FRAMEBUFFERLESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3965 {
3966 printf("Obtain XC engine fail\n");
3967 return;
3968 }
3969 else
3970 {
3971 return;
3972 }
3973 }
3974
MApi_XC_EX_IsCurrentRequest_FrameBufferLessMode(XC_DEVICE_ID * pDeviceId)3975 MS_BOOL MApi_XC_EX_IsCurrentRequest_FrameBufferLessMode(XC_DEVICE_ID *pDeviceId)
3976 {
3977 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
3978 {
3979 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
3980 return FALSE;
3981 }
3982
3983 stXC_CHECK_REQUEST_FRAMEBUFFERLESS XCArgs;
3984 XCArgs.bReturnValue = FALSE;
3985
3986 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_REQUEST_FRAMEBUFFERLESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
3987 {
3988 printf("Obtain XC engine fail\n");
3989 return FALSE;
3990 }
3991 else
3992 {
3993 return XCArgs.bReturnValue;
3994 }
3995 }
3996
MApi_XC_EX_Get_3D_HW_Version(XC_DEVICE_ID * pDeviceId)3997 MS_U16 MApi_XC_EX_Get_3D_HW_Version(XC_DEVICE_ID *pDeviceId)
3998 {
3999 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4000 {
4001 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4002 return 0;
4003 }
4004
4005 stXC_GET_3D_HWVERSION XCArgs;
4006 XCArgs.u16ReturnValue = 0;
4007
4008 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_HWVERSION, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4009 {
4010 printf("Obtain XC engine fail\n");
4011 return 0;
4012 }
4013 else
4014 {
4015 return XCArgs.u16ReturnValue;
4016 }
4017 }
4018
MApi_XC_EX_Get_3D_IsSupportedHW2DTo3D(XC_DEVICE_ID * pDeviceId)4019 MS_BOOL MApi_XC_EX_Get_3D_IsSupportedHW2DTo3D(XC_DEVICE_ID *pDeviceId)
4020 {
4021 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4022 {
4023 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4024 return FALSE;
4025 }
4026
4027 stXC_CHECK_3D_SUPPORT_HW2DTO3D XCArgs;
4028 XCArgs.bReturnValue = FALSE;
4029
4030 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_3D_SUPPORT_HW2DTO3D, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4031 {
4032 printf("Obtain XC engine fail\n");
4033 return FALSE;
4034 }
4035 else
4036 {
4037 return XCArgs.bReturnValue;
4038 }
4039 }
4040
MApi_XC_EX_Set_3D_Mode(XC_DEVICE_ID * pDeviceId,XC_EX_3D_INPUT_MODE e3dInputMode,XC_EX_3D_OUTPUT_MODE e3dOutputMode,XC_EX_3D_PANEL_TYPE e3dPanelType,XC_EX_SCALER_WIN eWindow)4041 MS_BOOL MApi_XC_EX_Set_3D_Mode(XC_DEVICE_ID *pDeviceId,
4042 XC_EX_3D_INPUT_MODE e3dInputMode,
4043 XC_EX_3D_OUTPUT_MODE e3dOutputMode,
4044 XC_EX_3D_PANEL_TYPE e3dPanelType,
4045 XC_EX_SCALER_WIN eWindow)
4046 {
4047 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4048 {
4049 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4050 return FALSE;
4051 }
4052
4053 stXC_SET_3D_MODE XCArgs;
4054 XCArgs.e3dInputMode = e3dInputMode;
4055 XCArgs.e3dOutputMode = e3dOutputMode;
4056 XCArgs.e3dPanelType = e3dPanelType;
4057 XCArgs.eWindow = eWindow;
4058 XCArgs.bReturnValue = FALSE;
4059
4060 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4061 {
4062 printf("Obtain XC engine fail\n");
4063 return FALSE;
4064 }
4065 else
4066 {
4067 return XCArgs.bReturnValue;
4068 }
4069 }
4070
MApi_XC_EX_Set_3D_MainWin_FirstMode(XC_DEVICE_ID * pDeviceId,MS_BOOL bMainFirst)4071 MS_BOOL MApi_XC_EX_Set_3D_MainWin_FirstMode(XC_DEVICE_ID *pDeviceId, MS_BOOL bMainFirst)
4072 {
4073 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4074 {
4075 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4076 return FALSE;
4077 }
4078
4079 stXC_SET_3D_MAINWIN_FIRST XCArgs;
4080 XCArgs.bMainFirst = bMainFirst;
4081 XCArgs.bReturnValue = FALSE;
4082
4083 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_MAINWIN_FIRST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4084 {
4085 printf("Obtain XC engine fail\n");
4086 return FALSE;
4087 }
4088 else
4089 {
4090 return XCArgs.bReturnValue;
4091 }
4092 }
4093
MApi_XC_EX_Set_3D_LR_Frame_Exchg(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)4094 MS_BOOL MApi_XC_EX_Set_3D_LR_Frame_Exchg(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
4095 {
4096 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4097 {
4098 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4099 return FALSE;
4100 }
4101
4102 stXC_SET_3D_LR_EXCHANGE XCArgs;
4103 XCArgs.eWindow = eWindow;
4104 XCArgs.bReturnValue = FALSE;
4105
4106 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_LR_EXCHANGE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4107 {
4108 printf("Obtain XC engine fail\n");
4109 return FALSE;
4110 }
4111 else
4112 {
4113 return XCArgs.bReturnValue;
4114 }
4115 }
4116
MApi_XC_EX_3D_Is_LR_Frame_Exchged(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)4117 MS_BOOL MApi_XC_EX_3D_Is_LR_Frame_Exchged(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
4118 {
4119 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4120 {
4121 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4122 return FALSE;
4123 }
4124
4125 stXC_CHECK_3D_LR_EXCHANGED XCArgs;
4126 XCArgs.eWindow = eWindow;
4127 XCArgs.bReturnValue = FALSE;
4128
4129 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_3D_LR_EXCHANGED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4130 {
4131 printf("Obtain XC engine fail\n");
4132 return FALSE;
4133 }
4134 else
4135 {
4136 return XCArgs.bReturnValue;
4137 }
4138 }
4139
MApi_XC_EX_Get_3D_Input_Mode(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)4140 XC_EX_3D_INPUT_MODE MApi_XC_EX_Get_3D_Input_Mode(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
4141 {
4142 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4143 {
4144 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4145 return E_XC_3D_INPUT_MODE_NONE;
4146 }
4147
4148 stXC_GET_3D_INPUT_MODE XCArgs;
4149 XCArgs.eWindow = eWindow;
4150 XCArgs.eReturnValue = E_XC_3D_INPUT_MODE_NONE;
4151
4152 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_INPUT_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4153 {
4154 printf("Obtain XC engine fail\n");
4155 return E_XC_3D_INPUT_MODE_NONE;
4156 }
4157 else
4158 {
4159 return XCArgs.eReturnValue;
4160 }
4161 }
4162
MApi_XC_EX_Get_3D_Output_Mode(XC_DEVICE_ID * pDeviceId)4163 XC_EX_3D_OUTPUT_MODE MApi_XC_EX_Get_3D_Output_Mode(XC_DEVICE_ID *pDeviceId)
4164 {
4165 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4166 {
4167 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4168 return E_XC_3D_OUTPUT_MODE_NONE;
4169 }
4170
4171 stXC_GET_3D_OUTPUT_MODE XCArgs;
4172 XCArgs.eReturnValue = E_XC_3D_OUTPUT_MODE_NONE;
4173
4174 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_OUTPUT_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4175 {
4176 printf("Obtain XC engine fail\n");
4177 return E_XC_3D_OUTPUT_MODE_NONE;
4178 }
4179 else
4180 {
4181 return XCArgs.eReturnValue;
4182 }
4183 }
4184
4185 #ifdef UFO_XC_GET_3D_FORMAT
MApi_XC_EX_Get3DFormat(XC_DEVICE_ID * pDeviceId,XC_EX_3D_ATTRIBUTE_TYPE e3DAttrType,void * para,void * p3DFormat)4186 MS_BOOL MApi_XC_EX_Get3DFormat(XC_DEVICE_ID *pDeviceId, XC_EX_3D_ATTRIBUTE_TYPE e3DAttrType, void* para, void* p3DFormat)
4187 {
4188 if(_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4189 {
4190 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4191 return FALSE;
4192 }
4193
4194 stXC_GET3DFORMAT XCArgs;
4195 XCArgs.e3DAttrType = e3DAttrType;
4196 XCArgs.para = para;
4197 XCArgs.p3DFormat = p3DFormat;
4198 XCArgs.bReturnValue = FALSE;
4199
4200 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET3DFORMAT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4201 {
4202 printf("\n %s : %d, Obtain XC engine fail \n ",__FUNCTION__,__LINE__);
4203 return E_XC_EX_3D_OUTPUT_MODE_NONE;
4204 }
4205 else
4206 {
4207 return XCArgs.bReturnValue;
4208 }
4209
4210 }
4211 #endif
4212
MApi_XC_EX_Get_3D_Panel_Type(XC_DEVICE_ID * pDeviceId)4213 XC_EX_3D_PANEL_TYPE MApi_XC_EX_Get_3D_Panel_Type(XC_DEVICE_ID *pDeviceId)
4214 {
4215 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4216 {
4217 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4218 return E_XC_3D_PANEL_MAX;
4219 }
4220
4221 stXC_GET_3D_PANELTYPE XCArgs;
4222 XCArgs.eReturnValue = E_XC_3D_PANEL_MAX;
4223
4224 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_PANELTYPE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4225 {
4226 printf("Obtain XC engine fail\n");
4227 return E_XC_3D_PANEL_MAX;
4228 }
4229 else
4230 {
4231 return XCArgs.eReturnValue;
4232 }
4233 }
4234
MApi_XC_EX_Get_3D_MainWin_First(XC_DEVICE_ID * pDeviceId)4235 MS_BOOL MApi_XC_EX_Get_3D_MainWin_First(XC_DEVICE_ID *pDeviceId)
4236 {
4237 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4238 {
4239 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4240 return FALSE;
4241 }
4242
4243 stXC_GET_3D_MAINWIN_FIRST XCArgs;
4244 XCArgs.bReturnValue = FALSE;
4245
4246 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_MAINWIN_FIRST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4247 {
4248 printf("Obtain XC engine fail\n");
4249 return FALSE;
4250 }
4251 else
4252 {
4253 return XCArgs.bReturnValue;
4254 }
4255 }
4256
MApi_XC_EX_3DMainSub_IPSync(XC_DEVICE_ID * pDeviceId)4257 MS_BOOL MApi_XC_EX_3DMainSub_IPSync(XC_DEVICE_ID *pDeviceId)
4258 {
4259 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4260 {
4261 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4262 return FALSE;
4263 }
4264
4265 stXC_CHECK_3D_MAINSUB_IPSYNC XCArgs;
4266 XCArgs.bReturnValue = FALSE;
4267
4268 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_3D_MAINSUB_IPSYNC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4269 {
4270 printf("Obtain XC engine fail\n");
4271 return FALSE;
4272 }
4273 else
4274 {
4275 return XCArgs.bReturnValue;
4276 }
4277 }
4278
MApi_XC_EX_Set_3D_VerVideoOffset(XC_DEVICE_ID * pDeviceId,MS_U16 u163DVerVideoOffset)4279 MS_BOOL MApi_XC_EX_Set_3D_VerVideoOffset(XC_DEVICE_ID *pDeviceId, MS_U16 u163DVerVideoOffset)
4280 {
4281 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4282 {
4283 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4284 return FALSE;
4285 }
4286
4287 stXC_SET_3D_VERTICALVIDEO_OFFSET XCArgs;
4288 XCArgs.u163DVerVideoOffset = u163DVerVideoOffset;
4289 XCArgs.bReturnValue = FALSE;
4290
4291 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_VERTICALVIDEO_OFFSET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4292 {
4293 printf("Obtain XC engine fail\n");
4294 return FALSE;
4295 }
4296 else
4297 {
4298 return XCArgs.bReturnValue;
4299 }
4300 }
4301
MApi_XC_EX_Get_3D_VerVideoOffset(XC_DEVICE_ID * pDeviceId)4302 MS_U16 MApi_XC_EX_Get_3D_VerVideoOffset(XC_DEVICE_ID *pDeviceId)
4303 {
4304 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4305 {
4306 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4307 return 0;
4308 }
4309
4310 stXC_GET_3D_VERTICALVIDEO_OFFSET XCArgs;
4311 XCArgs.u16ReturnValue = FALSE;
4312
4313 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_VERTICALVIDEO_OFFSET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4314 {
4315 printf("Obtain XC engine fail\n");
4316 return FALSE;
4317 }
4318 else
4319 {
4320 return XCArgs.u16ReturnValue;
4321 }
4322 }
4323
MApi_XC_EX_Is3DFormatSupported(XC_DEVICE_ID * pDeviceId,XC_EX_3D_INPUT_MODE e3dInputMode,XC_EX_3D_OUTPUT_MODE e3dOutputMode)4324 MS_BOOL MApi_XC_EX_Is3DFormatSupported(XC_DEVICE_ID *pDeviceId,
4325 XC_EX_3D_INPUT_MODE e3dInputMode,
4326 XC_EX_3D_OUTPUT_MODE e3dOutputMode)
4327 {
4328 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4329 {
4330 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4331 return FALSE;
4332 }
4333
4334 stXC_CHECK_3D_FORMAT_SUPPORTED XCArgs;
4335 XCArgs.e3dInputMode = e3dInputMode;
4336 XCArgs.e3dOutputMode = e3dOutputMode;
4337 XCArgs.bReturnValue = FALSE;
4338
4339 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_3D_FORMAT_SUPPORTED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4340 {
4341 printf("Obtain XC engine fail\n");
4342 return FALSE;
4343 }
4344 else
4345 {
4346 return XCArgs.bReturnValue;
4347 }
4348 }
4349
MApi_XC_EX_Set_3D_HShift(XC_DEVICE_ID * pDeviceId,MS_U16 u16HShift)4350 MS_BOOL MApi_XC_EX_Set_3D_HShift(XC_DEVICE_ID *pDeviceId, MS_U16 u16HShift)
4351 {
4352 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4353 {
4354 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4355 return FALSE;
4356 }
4357
4358 stXC_SET_3D_HORIZONTAL_SHIFT XCArgs;
4359 XCArgs.u16HShift = u16HShift;
4360 XCArgs.bReturnValue = FALSE;
4361
4362 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_HORIZONTAL_SHIFT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4363 {
4364 printf("Obtain XC engine fail\n");
4365 return FALSE;
4366 }
4367 else
4368 {
4369 return XCArgs.bReturnValue;
4370 }
4371 }
4372
MApi_XC_EX_Enable_3D_LR_Sbs2Line(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)4373 MS_BOOL MApi_XC_EX_Enable_3D_LR_Sbs2Line(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
4374 {
4375 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4376 {
4377 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4378 return FALSE;
4379 }
4380
4381 stXC_SET_3D_LR_SBS2LINE XCArgs;
4382 XCArgs.bEnable = bEnable;
4383 XCArgs.bReturnValue = FALSE;
4384
4385 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_LR_SBS2LINE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4386 {
4387 printf("Obtain XC engine fail\n");
4388 return FALSE;
4389 }
4390 else
4391 {
4392 return XCArgs.bReturnValue;
4393 }
4394 }
4395
MApi_XC_EX_Get_3D_HShift(XC_DEVICE_ID * pDeviceId)4396 MS_U16 MApi_XC_EX_Get_3D_HShift(XC_DEVICE_ID *pDeviceId)
4397 {
4398 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4399 {
4400 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4401 return 0;
4402 }
4403
4404 stXC_GET_3D_HORIZONTAL_SHIFT XCArgs;
4405 XCArgs.u16ReturnValue = 0;
4406
4407 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_HORIZONTAL_SHIFT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4408 {
4409 printf("Obtain XC engine fail\n");
4410 return 0;
4411 }
4412 else
4413 {
4414 return XCArgs.u16ReturnValue;
4415 }
4416 }
4417
MApi_XC_EX_Set_3D_HW2DTo3D_Buffer(XC_DEVICE_ID * pDeviceId,MS_PHY u32HW2DTO3D_DD_Buf,MS_PHY u32HW2DTO3D_DR_Buf)4418 MS_BOOL MApi_XC_EX_Set_3D_HW2DTo3D_Buffer(XC_DEVICE_ID *pDeviceId, MS_PHY u32HW2DTO3D_DD_Buf, MS_PHY u32HW2DTO3D_DR_Buf)
4419 {
4420 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4421 {
4422 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4423 return FALSE;
4424 }
4425
4426 stXC_SET_3D_HW2DTO3D_BUFFER XCArgs;
4427 XCArgs.u32HW2DTO3D_DD_Buf = u32HW2DTO3D_DD_Buf;
4428 XCArgs.u32HW2DTO3D_DR_Buf = u32HW2DTO3D_DR_Buf;
4429 XCArgs.bReturnValue = FALSE;
4430
4431 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_HW2DTO3D_BUFFER, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4432 {
4433 printf("Obtain XC engine fail\n");
4434 return FALSE;
4435 }
4436 else
4437 {
4438 return XCArgs.bReturnValue;
4439 }
4440 }
4441
MApi_XC_EX_Set_3D_HW2DTo3D_Parameters(XC_DEVICE_ID * pDeviceId,XC_EX_3D_HW2DTO3D_PARA st3DHw2DTo3DPara)4442 MS_BOOL MApi_XC_EX_Set_3D_HW2DTo3D_Parameters(XC_DEVICE_ID *pDeviceId, XC_EX_3D_HW2DTO3D_PARA st3DHw2DTo3DPara)
4443 {
4444 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4445 {
4446 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4447 return FALSE;
4448 }
4449
4450 _XC_ST_CHECK_SIZE(MS_XC_3D_HW2DTO3D_PARA,XC_EX_3D_HW2DTO3D_PARA);
4451 stXC_SET_3D_HW2DTO3D_PARAMETERS XCArgs;
4452 XCArgs.st3DHw2DTo3DPara = *((MS_XC_3D_HW2DTO3D_PARA*)&st3DHw2DTo3DPara);
4453 XCArgs.bReturnValue = FALSE;
4454
4455 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_HW2DTO3D_PARAMETERS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4456 {
4457 printf("Obtain XC engine fail\n");
4458 return FALSE;
4459 }
4460 else
4461 {
4462 return XCArgs.bReturnValue;
4463 }
4464 }
4465
MApi_XC_EX_Get_3D_HW2DTo3D_Parameters(XC_DEVICE_ID * pDeviceId,XC_EX_3D_HW2DTO3D_PARA * pst3DHw2DTo3DPara)4466 MS_BOOL MApi_XC_EX_Get_3D_HW2DTo3D_Parameters(XC_DEVICE_ID *pDeviceId, XC_EX_3D_HW2DTO3D_PARA *pst3DHw2DTo3DPara)
4467 {
4468 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4469 {
4470 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4471 return FALSE;
4472 }
4473
4474 _XC_ST_CHECK_SIZE(MS_XC_3D_HW2DTO3D_PARA,XC_EX_3D_HW2DTO3D_PARA);
4475 stXC_GET_3D_HW2DTO3D_PARAMETERS XCArgs;
4476 XCArgs.pst3DHw2DTo3DPara = (MS_XC_3D_HW2DTO3D_PARA*)pst3DHw2DTo3DPara;
4477 XCArgs.bReturnValue = FALSE;
4478
4479 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_HW2DTO3D_PARAMETERS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4480 {
4481 printf("Obtain XC engine fail\n");
4482 return FALSE;
4483 }
4484 else
4485 {
4486 return XCArgs.bReturnValue;
4487 }
4488 }
4489
MApi_XC_EX_Set_3D_Detect3DFormat_Parameters(XC_DEVICE_ID * pDeviceId,XC_EX_3D_DETECT3DFORMAT_PARA * pstDetect3DFormatPara)4490 MS_BOOL MApi_XC_EX_Set_3D_Detect3DFormat_Parameters(XC_DEVICE_ID *pDeviceId, XC_EX_3D_DETECT3DFORMAT_PARA *pstDetect3DFormatPara)
4491 {
4492 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4493 {
4494 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4495 return FALSE;
4496 }
4497
4498 _XC_ST_CHECK_SIZE(MS_XC_3D_DETECT3DFORMAT_PARA,XC_EX_3D_DETECT3DFORMAT_PARA);
4499 stXC_SET_3D_DETECT_3DFORMAT_PARAMETERS XCArgs;
4500 XCArgs.pstDetect3DFormatPara = (MS_XC_3D_DETECT3DFORMAT_PARA*)pstDetect3DFormatPara;
4501 XCArgs.bReturnValue = FALSE;
4502
4503 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_DETECT_3DFORMAT_PARAMETERS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4504 {
4505 printf("Obtain XC engine fail\n");
4506 return FALSE;
4507 }
4508 else
4509 {
4510 return XCArgs.bReturnValue;
4511 }
4512 }
4513
MApi_XC_EX_Get_3D_Detect3DFormat_Parameters(XC_DEVICE_ID * pDeviceId,XC_EX_3D_DETECT3DFORMAT_PARA * pstDetect3DFormatPara)4514 MS_BOOL MApi_XC_EX_Get_3D_Detect3DFormat_Parameters(XC_DEVICE_ID *pDeviceId, XC_EX_3D_DETECT3DFORMAT_PARA *pstDetect3DFormatPara)
4515 {
4516 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4517 {
4518 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4519 return FALSE;
4520 }
4521
4522 _XC_ST_CHECK_SIZE(MS_XC_3D_DETECT3DFORMAT_PARA,XC_EX_3D_DETECT3DFORMAT_PARA);
4523 stXC_GET_3D_DETECT_3DFORMAT_PARAMETERS XCArgs;
4524 XCArgs.pstDetect3DFormatPara = (MS_XC_3D_DETECT3DFORMAT_PARA*)pstDetect3DFormatPara;
4525 XCArgs.bReturnValue = FALSE;
4526
4527 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_DETECT_3DFORMAT_PARAMETERS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4528 {
4529 printf("Obtain XC engine fail\n");
4530 return FALSE;
4531 }
4532 else
4533 {
4534 return XCArgs.bReturnValue;
4535 }
4536 }
4537
MApi_XC_EX_Detect3DFormatByContent(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)4538 XC_EX_3D_INPUT_MODE MApi_XC_EX_Detect3DFormatByContent(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
4539 {
4540 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4541 {
4542 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4543 return FALSE;
4544 }
4545
4546 stXC_GET_3D_FORMAT_DETECTED_BY_CONTENT XCArgs;
4547 XCArgs.eWindow = eWindow;
4548 XCArgs.eReturnValue = FALSE;
4549
4550 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_FORMAT_DETECTED_BY_CONTENT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4551 {
4552 printf("Obtain XC engine fail\n");
4553 return FALSE;
4554 }
4555 else
4556 {
4557 return XCArgs.eReturnValue;
4558 }
4559 }
4560
MApi_XC_EX_DetectNL(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow,XC_EX_DETECTNL_PARA * pstDetectNLatticePara)4561 MS_BOOL MApi_XC_EX_DetectNL(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow, XC_EX_DETECTNL_PARA* pstDetectNLatticePara)
4562 {
4563 _XC_ST_CHECK_SIZE(ST_DETECTNL_PARA,XC_EX_DETECTNL_PARA);
4564 stXC_SET_NINELATTICE XCArgs;
4565 XCArgs.eWindow = eWindow;
4566 XCArgs.pstDetectNLatticePara = (ST_DETECTNL_PARA*)pstDetectNLatticePara;
4567 XCArgs.bReturnValue = FALSE;
4568
4569 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_NINELATTICE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4570 {
4571 printf("Obtain XC engine fail\n");
4572 return FALSE;
4573 }
4574 else
4575 {
4576 return XCArgs.bReturnValue;
4577 }
4578 }
4579
MApi_XC_EX_3D_PostPQSetting(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)4580 MS_BOOL MApi_XC_EX_3D_PostPQSetting(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
4581 {
4582 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4583 {
4584 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4585 return FALSE;
4586 }
4587
4588 stXC_SET_3D_POST_PQSETTING XCArgs;
4589 XCArgs.eWindow = eWindow;
4590 XCArgs.bReturnValue = FALSE;
4591
4592 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_POST_PQSETTING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4593 {
4594 printf("Obtain XC engine fail\n");
4595 return FALSE;
4596 }
4597 else
4598 {
4599 return XCArgs.bReturnValue;
4600 }
4601 }
4602
MApi_XC_EX_Set_3D_FPInfo(XC_DEVICE_ID * pDeviceId,XC_EX_3D_FPINFO_PARA * pstFPInfoPara)4603 MS_BOOL MApi_XC_EX_Set_3D_FPInfo(XC_DEVICE_ID *pDeviceId, XC_EX_3D_FPINFO_PARA *pstFPInfoPara)
4604 {
4605 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4606 {
4607 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4608 return FALSE;
4609 }
4610
4611 _XC_ST_CHECK_SIZE(MS_XC_3D_FPINFO_PARA,XC_EX_3D_FPINFO_PARA);
4612 stXC_SET_3D_FRAMEPACKING_INFO XCArgs;
4613 XCArgs.pstFPInfoPara = (MS_XC_3D_FPINFO_PARA*)pstFPInfoPara;
4614 XCArgs.bReturnValue = FALSE;
4615
4616 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_FRAMEPACKING_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4617 {
4618 printf("Obtain XC engine fail\n");
4619 return FALSE;
4620 }
4621 else
4622 {
4623 return XCArgs.bReturnValue;
4624 }
4625 }
4626
MApi_XC_EX_EnableAutoDetect3D(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_3D_AUTODETECT_METHOD enDetectMethod)4627 MS_BOOL MApi_XC_EX_EnableAutoDetect3D(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_3D_AUTODETECT_METHOD enDetectMethod)
4628 {
4629 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4630 {
4631 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4632 return FALSE;
4633 }
4634
4635 stXC_SET_3D_AUTODETECT XCArgs;
4636 XCArgs.bEnable = bEnable;
4637 XCArgs.enDetectMethod = enDetectMethod;
4638 XCArgs.bReturnValue = FALSE;
4639
4640 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_AUTODETECT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4641 {
4642 printf("Obtain XC engine fail\n");
4643 return FALSE;
4644 }
4645 else
4646 {
4647 return XCArgs.bReturnValue;
4648 }
4649 }
MApi_XC_EX_GetAutoDetect3DFlag(XC_DEVICE_ID * pDeviceId,XC_EX_3D_AUTODETECT_METHOD * penDetectMethod,MS_BOOL * pbEnable)4650 MS_BOOL MApi_XC_EX_GetAutoDetect3DFlag(XC_DEVICE_ID *pDeviceId, XC_EX_3D_AUTODETECT_METHOD *penDetectMethod, MS_BOOL *pbEnable)
4651 {
4652 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4653 {
4654 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4655 return FALSE;
4656 }
4657
4658 stXC_GET_3D_AUTODETECT_3DFLAG XCArgs;
4659 XCArgs.penDetectMethod = (E_XC_3D_AUTODETECT_METHOD*)penDetectMethod;
4660 XCArgs.pbEnable = pbEnable;
4661 XCArgs.bReturnValue = FALSE;
4662
4663 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_3D_AUTODETECT_3DFLAG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4664 {
4665 printf("Obtain XC engine fail\n");
4666 return FALSE;
4667 }
4668 else
4669 {
4670 return XCArgs.bReturnValue;
4671 }
4672 }
4673
MApi_XC_EX_Set_3D_SubWinClk(XC_DEVICE_ID * pDeviceId)4674 MS_BOOL MApi_XC_EX_Set_3D_SubWinClk(XC_DEVICE_ID *pDeviceId)
4675 {
4676 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4677 {
4678 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4679 return FALSE;
4680 }
4681
4682 stXC_SET_3D_SUBWINCLOCK XCArgs;
4683 XCArgs.bReturnValue = FALSE;
4684
4685 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_SUBWINCLOCK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4686 {
4687 printf("Obtain XC engine fail\n");
4688 return FALSE;
4689 }
4690 else
4691 {
4692 return XCArgs.bReturnValue;
4693 }
4694 }
4695
MApi_XC_EX_3D_Is_LR_Sbs2Line(XC_DEVICE_ID * pDeviceId)4696 MS_BOOL MApi_XC_EX_3D_Is_LR_Sbs2Line(XC_DEVICE_ID *pDeviceId)
4697 {
4698 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4699 {
4700 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4701 return FALSE;
4702 }
4703
4704 stXC_CHECK_3D_LR_SBS2LINE XCArgs;
4705 XCArgs.bReturnValue = FALSE;
4706
4707 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_3D_LR_SBS2LINE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4708 {
4709 printf("Obtain XC engine fail\n");
4710 return FALSE;
4711 }
4712 else
4713 {
4714 return XCArgs.bReturnValue;
4715 }
4716 }
4717
MApi_SC_EX_3D_Is_Skip_Default_LR_Flag(XC_DEVICE_ID * pDeviceId)4718 MS_BOOL MApi_SC_EX_3D_Is_Skip_Default_LR_Flag(XC_DEVICE_ID *pDeviceId)
4719 {
4720 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4721 {
4722 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4723 return FALSE;
4724 }
4725
4726 stXC_CHECK_3D_SKIP_DEFAULT_LR_FLAG XCArgs;
4727 XCArgs.bReturnValue = FALSE;
4728
4729 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_3D_SKIP_DEFAULT_LR_FLAG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4730 {
4731 printf("Obtain XC engine fail\n");
4732 return FALSE;
4733 }
4734 else
4735 {
4736 return XCArgs.bReturnValue;
4737 }
4738 }
4739
MApi_XC_EX_3D_Enable_Skip_Default_LR_Flag(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)4740 MS_BOOL MApi_XC_EX_3D_Enable_Skip_Default_LR_Flag(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
4741 {
4742 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4743 {
4744 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4745 return FALSE;
4746 }
4747
4748 stXC_SET_3D_SKIP_DEFAULT_LR_FLAG XCArgs;
4749 XCArgs.bEnable = bEnable;
4750 XCArgs.bReturnValue = FALSE;
4751
4752 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_3D_SKIP_DEFAULT_LR_FLAG, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4753 {
4754 printf("Obtain XC engine fail\n");
4755 return FALSE;
4756 }
4757 else
4758 {
4759 return XCArgs.bReturnValue;
4760 }
4761 }
4762
4763 typedef void (*pExFunc)(INPUT_SOURCE_TYPE_t , E_MUX_INPUTPORT* , MS_U8* );
MApi_XC_EX_Mux_Init(XC_DEVICE_ID * pDeviceId,void (* input_source_to_input_port)(XC_EX_INPUT_SOURCE_TYPE src_ids,E_MUX_INPUTPORT * port_ids,MS_U8 * u8port_count))4764 void MApi_XC_EX_Mux_Init(XC_DEVICE_ID *pDeviceId, void (*input_source_to_input_port)(XC_EX_INPUT_SOURCE_TYPE src_ids , E_MUX_INPUTPORT* port_ids , MS_U8* u8port_count ) )
4765 {
4766 XC_INSTANT_ATTRIBUTE stXCInstantAttribute;
4767 INIT_XC_INSTANT_ATTR(stXCInstantAttribute);
4768
4769 if (pDeviceId->u32Id == 0 && pu32XCInst == NULL)
4770 {
4771 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
4772 {
4773 printf("UtopiaOpen XC failed\n");
4774 return;
4775 }
4776 }
4777 else if (pDeviceId->u32Id == 1 && pu32XCInst_1 == NULL)
4778 {
4779 stXCInstantAttribute.u32DeviceID = 1;
4780 if(UtopiaOpen(MODULE_XC, &pu32XCInst_1, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
4781 {
4782 printf("UtopiaOpen XC failed\n");
4783 return;
4784 }
4785 }
4786 else if(pDeviceId->u32Id > 1)
4787 {
4788 printf("Device Id over 2\n");
4789 return;
4790 }
4791
4792 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4793 {
4794 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4795 return;
4796 }
4797
4798 stXC_SET_MUX_INIT XCArgs;
4799 XCArgs.input_source_to_input_port = (pExFunc)input_source_to_input_port;
4800
4801 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4802 {
4803 printf("Obtain XC engine fail\n");
4804 return;
4805 }
4806 else
4807 {
4808 return;
4809 }
4810 }
4811
MApi_XC_EX_Mux_SourceMonitor(XC_DEVICE_ID * pDeviceId,MS_BOOL bRealTimeMonitorOnly)4812 void MApi_XC_EX_Mux_SourceMonitor(XC_DEVICE_ID *pDeviceId, MS_BOOL bRealTimeMonitorOnly)
4813 {
4814 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4815 {
4816 //printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4817 return;
4818 }
4819
4820 stXC_SET_MUX_SOURCE_MONITOR XCArgs;
4821 XCArgs.bRealTimeMonitorOnly = bRealTimeMonitorOnly;
4822
4823 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_SOURCE_MONITOR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4824 {
4825 printf("Obtain XC engine fail\n");
4826 return;
4827 }
4828 else
4829 {
4830 return;
4831 }
4832 }
4833
MApi_XC_EX_Mux_CreatePath(XC_DEVICE_ID * pDeviceId,XC_EX_MUX_PATH_INFO * Path_Info,MS_U32 u32InitDataLen)4834 MS_S16 MApi_XC_EX_Mux_CreatePath(XC_DEVICE_ID *pDeviceId, XC_EX_MUX_PATH_INFO* Path_Info, MS_U32 u32InitDataLen)
4835 {
4836 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4837 {
4838 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4839 return 0;
4840 }
4841
4842 _XC_ST_CHECK_SIZE(XC_MUX_PATH_INFO,XC_EX_MUX_PATH_INFO);
4843 stXC_SET_MUX_CREATE_PATH XCArgs;
4844 XCArgs.Path_Info = (XC_MUX_PATH_INFO*)Path_Info;
4845 XCArgs.u32InitDataLen = u32InitDataLen;
4846 XCArgs.s16ReturnValue = -1;
4847
4848 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_CREATE_PATH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4849 {
4850 printf("Obtain XC engine fail\n");
4851 return -1;
4852 }
4853 else
4854 {
4855 return XCArgs.s16ReturnValue;
4856 }
4857 }
4858
MApi_XC_EX_Mux_DeletePath(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE src,XC_EX_DEST_TYPE dest)4859 MS_S16 MApi_XC_EX_Mux_DeletePath(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE src, XC_EX_DEST_TYPE dest)
4860 {
4861 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4862 {
4863 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4864 return 0;
4865 }
4866
4867 stXC_SET_MUX_DELETE_PATH XCArgs;
4868 XCArgs.src = src;
4869 XCArgs.dest = dest;
4870 XCArgs.s16ReturnValue = -1;
4871
4872 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_DELETE_PATH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4873 {
4874 printf("Obtain XC engine fail\n");
4875 return -1;
4876 }
4877 else
4878 {
4879 return XCArgs.s16ReturnValue;
4880 }
4881 }
4882
MApi_XC_EX_Mux_EnablePath(XC_DEVICE_ID * pDeviceId,MS_U16 PathId)4883 MS_S16 MApi_XC_EX_Mux_EnablePath(XC_DEVICE_ID *pDeviceId, MS_U16 PathId)
4884 {
4885 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4886 {
4887 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4888 return 0;
4889 }
4890
4891 stXC_SET_MUX_ENABLE_PATH XCArgs;
4892 XCArgs.PathId = PathId;
4893 XCArgs.s16ReturnValue = -1;
4894
4895 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_ENABLE_PATH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4896 {
4897 printf("Obtain XC engine fail\n");
4898 return -1;
4899 }
4900 else
4901 {
4902 return XCArgs.s16ReturnValue;
4903 }
4904 }
4905
MApi_XC_EX_Mux_TriggerPathSyncEvent(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE src,void * para)4906 void MApi_XC_EX_Mux_TriggerPathSyncEvent(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE src , void* para)
4907 {
4908 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4909 {
4910 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4911 return;
4912 }
4913
4914 stXC_SET_MUX_TRIGGER_PATH_SYNC_EVENT XCArgs;
4915 XCArgs.src = src;
4916 XCArgs.para = para;
4917
4918 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_TRIGGER_PATH_SYNC_EVENT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4919 {
4920 printf("Obtain XC engine fail\n");
4921 return;
4922 }
4923 else
4924 {
4925 return;
4926 }
4927 }
4928
MApi_XC_EX_Mux_TriggerDestOnOffEvent(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE src,void * para)4929 void MApi_XC_EX_Mux_TriggerDestOnOffEvent(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE src , void* para)
4930 {
4931 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4932 {
4933 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4934 return;
4935 }
4936
4937 stXC_SET_MUX_TRIGGER_DEST_ONOFF_EVENT XCArgs;
4938 XCArgs.src = src;
4939 XCArgs.para = para;
4940
4941 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_TRIGGER_DEST_ONOFF_EVENT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4942 {
4943 printf("Obtain XC engine fail\n");
4944 return;
4945 }
4946 else
4947 {
4948 return;
4949 }
4950 }
4951
MApi_XC_EX_Mux_OnOffPeriodicHandler(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE src,MS_BOOL bEnable)4952 MS_S16 MApi_XC_EX_Mux_OnOffPeriodicHandler(XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE src, MS_BOOL bEnable)
4953 {
4954 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4955 {
4956 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4957 return 0;
4958 }
4959
4960 stXC_SET_MUX_ONOFF_PERIODIC_HANDLER XCArgs;
4961 XCArgs.src = src;
4962 XCArgs.bEnable = bEnable;
4963 XCArgs.s16ReturnValue = -1;
4964
4965 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_ONOFF_PERIODIC_HANDLER, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4966 {
4967 printf("Obtain XC engine fail\n");
4968 return -1;
4969 }
4970 else
4971 {
4972 return XCArgs.s16ReturnValue;
4973 }
4974 }
4975
MApi_XC_EX_Mux_GetPathInfo(XC_DEVICE_ID * pDeviceId,XC_EX_MUX_PATH_INFO * Paths)4976 MS_U8 MApi_XC_EX_Mux_GetPathInfo(XC_DEVICE_ID *pDeviceId, XC_EX_MUX_PATH_INFO* Paths)
4977 {
4978 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
4979 {
4980 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
4981 return 0;
4982 }
4983
4984 _XC_ST_CHECK_SIZE(XC_MUX_PATH_INFO,XC_EX_MUX_PATH_INFO);
4985 stXC_GET_MUX_PATHINFO XCArgs;
4986 XCArgs.Paths = (XC_MUX_PATH_INFO*)Paths;
4987 XCArgs.u8ReturnValue = 0;
4988
4989 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_MUX_PATHINFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
4990 {
4991 printf("Obtain XC engine fail\n");
4992 return 0;
4993 }
4994 else
4995 {
4996 return XCArgs.u8ReturnValue;
4997 }
4998 } // Return current all path info. Max path number is MAX_DATA_PATH_SUPPORTED
4999
MApi_XC_EX_Mux_SetSupportMhlPathInfo(XC_DEVICE_ID * pDeviceId,MS_U8 u8MhlSupportInfo)5000 XC_EX_RETURN_VALUE MApi_XC_EX_Mux_SetSupportMhlPathInfo(XC_DEVICE_ID *pDeviceId, MS_U8 u8MhlSupportInfo)
5001 {
5002 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5003 {
5004 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5005 return E_APIXC_RET_FAIL;
5006 }
5007
5008 stXC_SET_MUX_SUPPORT_MHL_PATHINFO XCArgs;
5009 XCArgs.u8MhlSupportInfo = u8MhlSupportInfo;
5010 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
5011
5012 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_SUPPORT_MHL_PATHINFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5013 {
5014 printf("Obtain XC engine fail\n");
5015 return E_APIXC_RET_FAIL;
5016 }
5017 else
5018 {
5019 return XCArgs.eReturnValue;
5020 }
5021 }
5022
MApi_XC_EX_Mux_SetMhlHotPlugInverseInfo(XC_DEVICE_ID * pDeviceId,MS_BOOL bIsMhlHotPlugInverse)5023 XC_EX_RETURN_VALUE MApi_XC_EX_Mux_SetMhlHotPlugInverseInfo(XC_DEVICE_ID *pDeviceId, MS_BOOL bIsMhlHotPlugInverse)
5024 {
5025 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5026 {
5027 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5028 return E_APIXC_RET_FAIL;
5029 }
5030
5031 stXC_SET_MUX_MHL_HOTPLUG_INVERSE_INFO XCArgs;
5032 XCArgs.bIsMhlHotPlugInverse = bIsMhlHotPlugInverse;
5033 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
5034
5035 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MUX_MHL_HOTPLUG_INVERSE_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5036 {
5037 printf("Obtain XC engine fail\n");
5038 return E_APIXC_RET_FAIL;
5039 }
5040 else
5041 {
5042 return XCArgs.eReturnValue;
5043 }
5044 }
5045
MApi_XC_EX_Mux_GetHDMIPort(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE src)5046 E_MUX_INPUTPORT MApi_XC_EX_Mux_GetHDMIPort( XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE src )
5047 {
5048 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5049 {
5050 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5051 return INPUT_PORT_NONE_PORT;
5052 }
5053
5054 stXC_GET_MUX_HDMIPORT XCArgs;
5055 XCArgs.src = src;
5056 XCArgs.eReturnValue = INPUT_PORT_NONE_PORT;
5057
5058 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_MUX_HDMIPORT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5059 {
5060 printf("Obtain XC engine fail\n");
5061 return INPUT_PORT_NONE_PORT;
5062 }
5063 else
5064 {
5065 return XCArgs.eReturnValue;
5066 }
5067 }
5068
MApi_XC_EX_MUX_MapInputSourceToVDYMuxPORT(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE u8InputSourceType)5069 MS_U8 MApi_XC_EX_MUX_MapInputSourceToVDYMuxPORT( XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE u8InputSourceType )
5070 {
5071 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5072 {
5073 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5074 return 0;
5075 }
5076
5077 stXC_GET_MUX_INPUTSOURCE2VDYMUXPORT XCArgs;
5078 XCArgs.u8InputSourceType = u8InputSourceType;
5079 XCArgs.u8ReturnValue = 0;
5080
5081 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_MUX_INPUTSOURCE2VDYMUXPORT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5082 {
5083 printf("Obtain XC engine fail\n");
5084 return 0;
5085 }
5086 else
5087 {
5088 return XCArgs.u8ReturnValue;
5089 }
5090 }
5091
MApi_XC_EX_Set_NR(XC_DEVICE_ID * pDeviceId,MS_BOOL bEn,XC_EX_SCALER_WIN eWindow)5092 void MApi_XC_EX_Set_NR(XC_DEVICE_ID *pDeviceId, MS_BOOL bEn, XC_EX_SCALER_WIN eWindow)
5093 {
5094 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5095 {
5096 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5097 return;
5098 }
5099
5100 stXC_SET_NR XCArgs;
5101 XCArgs.bEn = bEn;
5102 XCArgs.eWindow = eWindow;
5103
5104 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_NR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5105 {
5106 printf("Obtain XC engine fail\n");
5107 return;
5108 }
5109 else
5110 {
5111 return;
5112 }
5113 }
5114
MApi_XC_EX_FilmMode_P(XC_DEVICE_ID * pDeviceId)5115 void MApi_XC_EX_FilmMode_P(XC_DEVICE_ID *pDeviceId)
5116 {
5117 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5118 {
5119 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5120 return;
5121 }
5122
5123 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FILM_MODE_PATCH, NULL) != UTOPIA_STATUS_SUCCESS)
5124 {
5125 printf("Obtain XC engine fail\n");
5126 return;
5127 }
5128 else
5129 {
5130 return;
5131 }
5132 }
5133
MApi_XC_EX_GetUCEnabled(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5134 MS_BOOL MApi_XC_EX_GetUCEnabled(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5135 {
5136 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5137 {
5138 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5139 return FALSE;
5140 }
5141
5142 stXC_CHECK_UC_ENABLED XCArgs;
5143 XCArgs.eWindow = eWindow;
5144 XCArgs.bReturnValue = FALSE;
5145
5146 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_UC_ENABLED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5147 {
5148 printf("Obtain XC engine fail\n");
5149 return FALSE;
5150 }
5151 else
5152 {
5153 return XCArgs.bReturnValue;
5154 }
5155 }
5156
MApi_XC_EX_GenSpecificTiming(XC_DEVICE_ID * pDeviceId,XC_EX_Internal_TimingType timingtype)5157 void MApi_XC_EX_GenSpecificTiming(XC_DEVICE_ID *pDeviceId, XC_EX_Internal_TimingType timingtype)
5158 {
5159 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5160 {
5161 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5162 return;
5163 }
5164
5165 stXC_SET_GENERATE_SPECIFIC_TIMING XCArgs;
5166 XCArgs.timingtype = timingtype;
5167
5168 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_GENERATE_SPECIFIC_TIMING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5169 {
5170 printf("Obtain XC engine fail\n");
5171 return;
5172 }
5173 else
5174 {
5175 return;
5176 }
5177 }
5178
MApi_XC_EX_GetDEBypassMode(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5179 MS_BOOL MApi_XC_EX_GetDEBypassMode(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5180 {
5181 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5182 {
5183 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5184 return FALSE;
5185 }
5186
5187 stXC_GET_DE_BYPASS_MODE XCArgs;
5188 XCArgs.eWindow = eWindow;
5189 XCArgs.bReturnValue = FALSE;
5190
5191 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DE_BYPASS_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5192 {
5193 printf("Obtain XC engine fail\n");
5194 return FALSE;
5195 }
5196 else
5197 {
5198 return XCArgs.bReturnValue;
5199 }
5200 }
5201
MApi_XC_EX_GetDEWindow(XC_DEVICE_ID * pDeviceId,XC_EX_WINDOW_TYPE * psWin,XC_EX_SCALER_WIN eWindow)5202 void MApi_XC_EX_GetDEWindow(XC_DEVICE_ID *pDeviceId, XC_EX_WINDOW_TYPE *psWin, XC_EX_SCALER_WIN eWindow)
5203 {
5204 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5205 {
5206 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5207 return;
5208 }
5209
5210 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE,XC_EX_WINDOW_TYPE);
5211 stXC_GET_DE_WINDOW XCArgs;
5212 XCArgs.psWin = (MS_WINDOW_TYPE*)psWin;
5213 XCArgs.eWindow = eWindow;
5214
5215 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DE_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5216 {
5217 printf("Obtain XC engine fail\n");
5218 return;
5219 }
5220 else
5221 {
5222 return;
5223 }
5224 }
5225
MApi_XC_EX_GetDEWidthHeightInDEByPassMode(XC_DEVICE_ID * pDeviceId,MS_U16 * pu16Width,MS_U16 * pu16Height,XC_EX_SCALER_WIN eWindow)5226 void MApi_XC_EX_GetDEWidthHeightInDEByPassMode(XC_DEVICE_ID *pDeviceId, MS_U16* pu16Width,MS_U16* pu16Height ,XC_EX_SCALER_WIN eWindow)
5227 {
5228 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5229 {
5230 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5231 return;
5232 }
5233
5234 stXC_GET_DE_WIN_WIDTH_HEIGHT_IN_DE_BYPASS_MODE XCArgs;
5235 XCArgs.pu16Width = pu16Width;
5236 XCArgs.pu16Height = pu16Height;
5237 XCArgs.eWindow = eWindow;
5238
5239 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DE_WIN_WIDTH_HEIGHT_IN_DE_BYPASS_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5240 {
5241 printf("Obtain XC engine fail\n");
5242 return;
5243 }
5244 else
5245 {
5246 return;
5247 }
5248 }
5249
MApi_XC_EX_GetCaptureWindow(XC_DEVICE_ID * pDeviceId,XC_EX_WINDOW_TYPE * capture_win,XC_EX_SCALER_WIN eWindow)5250 void MApi_XC_EX_GetCaptureWindow(XC_DEVICE_ID *pDeviceId, XC_EX_WINDOW_TYPE* capture_win, XC_EX_SCALER_WIN eWindow)
5251 {
5252 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5253 {
5254 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5255 return;
5256 }
5257
5258 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE,XC_EX_WINDOW_TYPE);
5259 stXC_GET_CAPTURE_WINDOW XCArgs;
5260 XCArgs.capture_win = (MS_WINDOW_TYPE*)capture_win;
5261 XCArgs.eWindow = eWindow;
5262
5263 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_CAPTURE_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5264 {
5265 printf("Obtain XC engine fail\n");
5266 return;
5267 }
5268 else
5269 {
5270 return;
5271 }
5272 }
5273
MApi_XC_EX_SetCaptureWindowVstart(XC_DEVICE_ID * pDeviceId,MS_U16 u16Vstart,XC_EX_SCALER_WIN eWindow)5274 void MApi_XC_EX_SetCaptureWindowVstart(XC_DEVICE_ID *pDeviceId, MS_U16 u16Vstart , XC_EX_SCALER_WIN eWindow)
5275 {
5276 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5277 {
5278 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5279 return;
5280 }
5281
5282 stXC_SET_CAPTURE_WINDOW_VSTART XCArgs;
5283 XCArgs.u16Vstart = u16Vstart;
5284 XCArgs.eWindow = eWindow;
5285
5286 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CAPTURE_WINDOW_VSTART, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5287 {
5288 printf("Obtain XC engine fail\n");
5289 return;
5290 }
5291 else
5292 {
5293 return;
5294 }
5295 }
5296
MApi_XC_EX_SetCaptureWindowHstart(XC_DEVICE_ID * pDeviceId,MS_U16 u16Hstart,XC_EX_SCALER_WIN eWindow)5297 void MApi_XC_EX_SetCaptureWindowHstart(XC_DEVICE_ID *pDeviceId, MS_U16 u16Hstart , XC_EX_SCALER_WIN eWindow)
5298 {
5299 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5300 {
5301 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5302 return;
5303 }
5304
5305 stXC_SET_CAPTURE_WINDOW_HSTART XCArgs;
5306 XCArgs.u16Hstart = u16Hstart;
5307 XCArgs.eWindow = eWindow;
5308
5309 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CAPTURE_WINDOW_HSTART, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5310 {
5311 printf("Obtain XC engine fail\n");
5312 return;
5313 }
5314 else
5315 {
5316 return;
5317 }
5318 }
5319
MApi_XC_EX_SetCaptureWindowVsize(XC_DEVICE_ID * pDeviceId,MS_U16 u16Vsize,XC_EX_SCALER_WIN eWindow)5320 void MApi_XC_EX_SetCaptureWindowVsize(XC_DEVICE_ID *pDeviceId, MS_U16 u16Vsize , XC_EX_SCALER_WIN eWindow)
5321 {
5322 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5323 {
5324 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5325 return;
5326 }
5327
5328 stXC_SET_CAPTURE_WINDOW_VSIZE XCArgs;
5329 XCArgs.u16Vsize = u16Vsize;
5330 XCArgs.eWindow = eWindow;
5331
5332 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CAPTURE_WINDOW_VSIZE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5333 {
5334 printf("Obtain XC engine fail\n");
5335 return;
5336 }
5337 else
5338 {
5339 return;
5340 }
5341 }
5342
MApi_XC_EX_SetCaptureWindowHsize(XC_DEVICE_ID * pDeviceId,MS_U16 u16Hsize,XC_EX_SCALER_WIN eWindow)5343 void MApi_XC_EX_SetCaptureWindowHsize(XC_DEVICE_ID *pDeviceId, MS_U16 u16Hsize , XC_EX_SCALER_WIN eWindow)
5344 {
5345 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5346 {
5347 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5348 return;
5349 }
5350
5351 stXC_SET_CAPTURE_WINDOW_HSIZE XCArgs;
5352 XCArgs.u16Hsize = u16Hsize;
5353 XCArgs.eWindow = eWindow;
5354
5355 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CAPTURE_WINDOW_HSIZE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5356 {
5357 printf("Obtain XC engine fail\n");
5358 return;
5359 }
5360 else
5361 {
5362 return;
5363 }
5364 }
5365
MApi_XC_EX_SoftwareReset(XC_DEVICE_ID * pDeviceId,MS_U8 u8Reset,XC_EX_SCALER_WIN eWindow)5366 void MApi_XC_EX_SoftwareReset(XC_DEVICE_ID *pDeviceId, MS_U8 u8Reset, XC_EX_SCALER_WIN eWindow)
5367 {
5368 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5369 {
5370 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5371 return;
5372 }
5373
5374 stXC_SET_SOFTWARE_RESET XCArgs;
5375 XCArgs.u8Reset = u8Reset;
5376 XCArgs.eWindow = eWindow;
5377
5378 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SOFTWARE_RESET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5379 {
5380 printf("Obtain XC engine fail\n");
5381 return;
5382 }
5383 else
5384 {
5385 return;
5386 }
5387 }
5388
MApi_XC_EX_CalculateHFreqx10(XC_DEVICE_ID * pDeviceId,MS_U16 u16HPeriod)5389 MS_U16 MApi_XC_EX_CalculateHFreqx10(XC_DEVICE_ID *pDeviceId, MS_U16 u16HPeriod)
5390 {
5391 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5392 {
5393 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5394 return 0;
5395 }
5396
5397 stXC_GET_HFREQX10 XCArgs;
5398 XCArgs.u16HPeriod = u16HPeriod;
5399 XCArgs.u16ReturnValue = 0;
5400
5401 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_HFREQX10, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5402 {
5403 printf("Obtain XC engine fail\n");
5404 return 0;
5405 }
5406 else
5407 {
5408 return XCArgs.u16ReturnValue;
5409 }
5410 }
5411
MApi_XC_EX_CalculateHFreqx1K(XC_DEVICE_ID * pDeviceId,MS_U16 u16HPeriod)5412 MS_U32 MApi_XC_EX_CalculateHFreqx1K(XC_DEVICE_ID *pDeviceId, MS_U16 u16HPeriod)
5413 {
5414 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5415 {
5416 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5417 return 0;
5418 }
5419
5420
5421 stXC_GET_HFREQX1K XCArgs;
5422 XCArgs.u16HPeriod = u16HPeriod;
5423 XCArgs.u32ReturnValue = 0;
5424
5425 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_HFREQX1K, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5426 {
5427 printf("Obtain XC engine fail\n");
5428 return 0;
5429 }
5430 else
5431 {
5432 return XCArgs.u32ReturnValue;
5433 }
5434 }
5435
MApi_XC_EX_CalculateVFreqx10(XC_DEVICE_ID * pDeviceId,MS_U16 u16HFreq,MS_U16 u16VTotal)5436 MS_U16 MApi_XC_EX_CalculateVFreqx10(XC_DEVICE_ID *pDeviceId, MS_U16 u16HFreq, MS_U16 u16VTotal)
5437 {
5438 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5439 {
5440 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5441 return 0;
5442 }
5443
5444 stXC_GET_VFREQX10 XCArgs;
5445 XCArgs.u16HFreq = u16HFreq;
5446 XCArgs.u16VTotal = u16VTotal;
5447 XCArgs.u16ReturnValue = 0;
5448
5449 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_VFREQX10, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5450 {
5451 printf("Obtain XC engine fail\n");
5452 return 0;
5453 }
5454 else
5455 {
5456 return XCArgs.u16ReturnValue;
5457 }
5458 }
5459
MApi_XC_EX_CalculateVFreqx1K(XC_DEVICE_ID * pDeviceId,MS_U32 u16HFreq,MS_U16 u16VTotal)5460 MS_U32 MApi_XC_EX_CalculateVFreqx1K(XC_DEVICE_ID *pDeviceId, MS_U32 u16HFreq, MS_U16 u16VTotal)
5461 {
5462 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5463 {
5464 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5465 return 0;
5466 }
5467
5468 stXC_GET_VFREQX1K XCArgs;
5469 XCArgs.u32HFreqx1K = u16HFreq;
5470 XCArgs.u16VTotal = u16VTotal;
5471 XCArgs.u32ReturnValue = 0;
5472
5473 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_VFREQX1K, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5474 {
5475 printf("Obtain XC engine fail\n");
5476 return 0;
5477 }
5478 else
5479 {
5480 return XCArgs.u32ReturnValue;
5481 }
5482 }
5483
MApi_XC_EX_GetAccurateVFreqx1K(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5484 MS_U32 MApi_XC_EX_GetAccurateVFreqx1K(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5485 {
5486 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5487 {
5488 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5489 return 0;
5490 }
5491
5492 stXC_GET_ACCURATE_VFREQX1k XCArgs;
5493 XCArgs.eWindow = eWindow;
5494 XCArgs.u32ReturnValue = 0;
5495
5496 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_ACCURATE_VFREQX1k, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5497 {
5498 printf("Obtain XC engine fail\n");
5499 return 0;
5500 }
5501 else
5502 {
5503 return XCArgs.u32ReturnValue;
5504 }
5505 }
5506
MApi_XC_EX_InterruptAttach(XC_DEVICE_ID * pDeviceId,SC_EX_INT_SRC enIntNum,SC_EX_InterruptCb pIntCb,void * pParam)5507 MS_BOOL MApi_XC_EX_InterruptAttach(XC_DEVICE_ID *pDeviceId, SC_EX_INT_SRC enIntNum, SC_EX_InterruptCb pIntCb, void * pParam)
5508 {
5509 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5510 {
5511 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5512 return FALSE;
5513 }
5514
5515 stXC_SET_INTERRUPT_ATTACH XCArgs;
5516 XCArgs.eIntNum = enIntNum;
5517 XCArgs.pIntCb = (SC_InterruptCb)pIntCb;
5518 XCArgs.pParam = pParam;
5519 XCArgs.bReturnValue = FALSE;
5520
5521 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_INTERRUPT_ATTACH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5522 {
5523 printf("Obtain XC engine fail\n");
5524 return FALSE;
5525 }
5526 else
5527 {
5528 return XCArgs.bReturnValue;
5529 }
5530 }
5531
MApi_XC_EX_InterruptDeAttach(XC_DEVICE_ID * pDeviceId,SC_EX_INT_SRC enIntNum,SC_EX_InterruptCb pIntCb,void * pParam)5532 MS_BOOL MApi_XC_EX_InterruptDeAttach(XC_DEVICE_ID *pDeviceId, SC_EX_INT_SRC enIntNum, SC_EX_InterruptCb pIntCb, void * pParam)
5533 {
5534 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5535 {
5536 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5537 return FALSE;
5538 }
5539
5540 stXC_SET_INTERRUPT_DEATTACH XCArgs;
5541 XCArgs.eIntNum = enIntNum;
5542 XCArgs.pIntCb = (SC_InterruptCb)pIntCb;
5543 XCArgs.pParam = pParam;
5544 XCArgs.bReturnValue = FALSE;
5545
5546 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_INTERRUPT_DEATTACH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5547 {
5548 printf("Obtain XC engine fail\n");
5549 return FALSE;
5550 }
5551 else
5552 {
5553 return XCArgs.bReturnValue;
5554 }
5555 }
5556
MApi_XC_EX_DisableInputSource(XC_DEVICE_ID * pDeviceId,MS_BOOL bDisable,XC_EX_SCALER_WIN eWidnow)5557 void MApi_XC_EX_DisableInputSource(XC_DEVICE_ID *pDeviceId, MS_BOOL bDisable, XC_EX_SCALER_WIN eWidnow)
5558 {
5559 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5560 {
5561 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5562 return;
5563 }
5564
5565 stXC_SET_DISABLE_INPUTSOURCE XCArgs;
5566 XCArgs.bDisable = bDisable;
5567 XCArgs.eWindow = eWidnow;
5568
5569 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_DISABLE_INPUTSOURCE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5570 {
5571 printf("Obtain XC engine fail\n");
5572 return;
5573 }
5574 else
5575 {
5576 return;
5577 }
5578 }
5579
MApi_XC_EX_IsInputSourceDisabled(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5580 MS_BOOL MApi_XC_EX_IsInputSourceDisabled(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5581 {
5582 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5583 {
5584 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5585 return FALSE;
5586 }
5587
5588 stXC_CHECK_INPUTSOURCE_DISABLED XCArgs;
5589 XCArgs.eWindow = eWindow;
5590 XCArgs.bReturnValue = FALSE;
5591
5592 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_INPUTSOURCE_DISABLED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5593 {
5594 printf("Obtain XC engine fail\n");
5595 return FALSE;
5596 }
5597 else
5598 {
5599 return XCArgs.bReturnValue;
5600 }
5601 }
5602
MApi_XC_EX_ChangePanelType(XC_DEVICE_ID * pDeviceId,XC_EX_PANEL_INFO * pstPanelInfo)5603 void MApi_XC_EX_ChangePanelType(XC_DEVICE_ID *pDeviceId, XC_EX_PANEL_INFO *pstPanelInfo)
5604 {
5605 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5606 {
5607 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5608 return;
5609 }
5610
5611 _XC_ST_CHECK_SIZE(XC_PANEL_INFO,XC_EX_PANEL_INFO);
5612 stXC_SET_CHANGE_PANELTYPE XCArgs;
5613 XCArgs.pstPanelInfo = (XC_PANEL_INFO*)pstPanelInfo;
5614
5615 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CHANGE_PANELTYPE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5616 {
5617 printf("Obtain XC engine fail\n");
5618 return;
5619 }
5620 else
5621 {
5622 return;
5623 }
5624 }
5625
MApi_XC_EX_GetCurrentReadBank(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5626 MS_U16 MApi_XC_EX_GetCurrentReadBank(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5627 {
5628 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5629 {
5630 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5631 return 0;
5632 }
5633
5634 stXC_GET_CURRENT_READBANK XCArgs;
5635 XCArgs.eWindow = eWindow;
5636 XCArgs.u16ReturnValue = 0;
5637
5638 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_CURRENT_READBANK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5639 {
5640 printf("Obtain XC engine fail\n");
5641 return 0;
5642 }
5643 else
5644 {
5645 return XCArgs.u16ReturnValue;
5646 }
5647 }
5648
MApi_XC_EX_GetCurrentWriteBank(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5649 MS_U16 MApi_XC_EX_GetCurrentWriteBank(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5650 {
5651 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5652 {
5653 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5654 return 0;
5655 }
5656
5657 stXC_GET_CURRENT_WRITEBANK XCArgs;
5658 XCArgs.eWindow = eWindow;
5659 XCArgs.u16ReturnValue = 0;
5660
5661 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_CURRENT_WRITEBANK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5662 {
5663 printf("Obtain XC engine fail\n");
5664 return 0;
5665 }
5666 else
5667 {
5668 return XCArgs.u16ReturnValue;
5669 }
5670 }
5671
MApi_XC_EX_SetAutoPreScaling(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)5672 void MApi_XC_EX_SetAutoPreScaling(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
5673 {
5674 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5675 {
5676 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5677 return;
5678 }
5679
5680 stXC_SET_AUTO_PRESCALING XCArgs;
5681 XCArgs.bEnable = bEnable;
5682 XCArgs.eWindow = eWindow;
5683
5684 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_AUTO_PRESCALING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5685 {
5686 printf("Obtain XC engine fail\n");
5687 return;
5688 }
5689 else
5690 {
5691 return;
5692 }
5693 }
5694
MApi_XC_EX_GetVSyncWidth(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5695 MS_U8 MApi_XC_EX_GetVSyncWidth(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5696 {
5697 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5698 {
5699 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5700 return 0;
5701 }
5702
5703 stXC_GET_VSYNC_WIDTH XCArgs;
5704 XCArgs.eWindow = eWindow;
5705 XCArgs.u8ReturnValue = 0;
5706
5707 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_VSYNC_WIDTH, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5708 {
5709 printf("Obtain XC engine fail\n");
5710 return 0;
5711 }
5712 else
5713 {
5714 return XCArgs.u8ReturnValue;
5715 }
5716 }
5717
MApi_XC_EX_set_GOP_Enable(XC_DEVICE_ID * pDeviceId,MS_U8 MaxGOP,MS_U8 UseNum,MS_U8 u8MuxNum,MS_BOOL bEnable)5718 MS_BOOL MApi_XC_EX_set_GOP_Enable(XC_DEVICE_ID *pDeviceId, MS_U8 MaxGOP, MS_U8 UseNum, MS_U8 u8MuxNum, MS_BOOL bEnable)
5719 {
5720 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5721 {
5722 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5723 return FALSE;
5724 }
5725
5726 stXC_SET_GOP_ENABLE XCArgs;
5727 XCArgs.MaxGOP = MaxGOP;
5728 XCArgs.UseNum = UseNum;
5729 XCArgs.u8MuxNum = u8MuxNum;
5730 XCArgs.bEnable = bEnable;
5731 XCArgs.bReturnValue = FALSE;
5732
5733 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_GOP_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5734 {
5735 printf("Obtain XC engine fail\n");
5736 return FALSE;
5737 }
5738 else
5739 {
5740 return XCArgs.bReturnValue;
5741 }
5742 }
5743
MApi_XC_EX_ip_sel_for_gop(XC_DEVICE_ID * pDeviceId,MS_U8 u8MuxNum,XC_EX_IPSEL_GOP ipSelGop)5744 void MApi_XC_EX_ip_sel_for_gop(XC_DEVICE_ID *pDeviceId, MS_U8 u8MuxNum , XC_EX_IPSEL_GOP ipSelGop)
5745 {
5746 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5747 {
5748 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5749 return;
5750 }
5751
5752 stXC_SET_SELECT_IP_FOR_GOP XCArgs;
5753 XCArgs.u8MuxNum = u8MuxNum;
5754 XCArgs.ipSelGop = ipSelGop;
5755
5756 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SELECT_IP_FOR_GOP, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5757 {
5758 printf("Obtain XC engine fail\n");
5759 return;
5760 }
5761 else
5762 {
5763 return;
5764 }
5765 }
5766
MApi_XC_EX_SetVOPNBL(XC_DEVICE_ID * pDeviceId)5767 void MApi_XC_EX_SetVOPNBL(XC_DEVICE_ID *pDeviceId)
5768 {
5769 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5770 {
5771 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5772 return;
5773 }
5774
5775 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_VOP_NEW_BLENDING_LEVEL, NULL) != UTOPIA_STATUS_SUCCESS)
5776 {
5777 printf("Obtain XC engine fail\n");
5778 return;
5779 }
5780 else
5781 {
5782 return;
5783 }
5784 }
5785
MApi_XC_EX_GetDstInfo(XC_DEVICE_ID * pDeviceId,XC_EX_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo,XC_EX_GOP_XCDST_TYPE XCDstType)5786 MS_BOOL MApi_XC_EX_GetDstInfo(XC_DEVICE_ID *pDeviceId, XC_EX_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo, XC_EX_GOP_XCDST_TYPE XCDstType)
5787 {
5788 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5789 {
5790 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5791 return FALSE;
5792 }
5793
5794 _XC_ST_CHECK_SIZE(MS_XC_DST_DispInfo,XC_EX_DST_DispInfo);
5795 stXC_GET_DESTINATION_INFO XCArgs;
5796 XCArgs.pDstInfo = (MS_XC_DST_DispInfo*)pDstInfo;
5797 XCArgs.u32SizeofDstInfo = u32SizeofDstInfo;
5798 XCArgs.XCDstType = XCDstType;
5799 XCArgs.bReturnValue = FALSE;
5800
5801 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DESTINATION_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5802 {
5803 printf("Obtain XC engine fail\n");
5804 return FALSE;
5805 }
5806 else
5807 {
5808 return XCArgs.bReturnValue;
5809 }
5810 }
5811
MApi_XC_EX_set_FD_Mask(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)5812 void MApi_XC_EX_set_FD_Mask(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
5813 {
5814 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5815 {
5816 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5817 return;
5818 }
5819
5820 stXC_SET_FDMASK_BYWIN XCArgs;
5821 XCArgs.bEnable = bEnable;
5822 XCArgs.eWindow = MAIN_WINDOW;
5823
5824 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5825 {
5826 printf("Obtain XC engine fail\n");
5827 return;
5828 }
5829 else
5830 {
5831 return;
5832 }
5833 }
5834
MApi_XC_EX_Get_FD_Mask(XC_DEVICE_ID * pDeviceId)5835 MS_BOOL MApi_XC_EX_Get_FD_Mask(XC_DEVICE_ID *pDeviceId)
5836 {
5837 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5838 {
5839 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5840 return FALSE;
5841 }
5842
5843 stXC_GET_FDMASK_BYWIN XCArgs;
5844 XCArgs.eWindow = MAIN_WINDOW;
5845 XCArgs.bReturnValue = FALSE;
5846
5847 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5848 {
5849 printf("Obtain XC engine fail\n");
5850 return FALSE;
5851 }
5852 else
5853 {
5854 return XCArgs.bReturnValue;
5855 }
5856 }
5857
MApi_XC_EX_set_FD_Mask_byWin(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)5858 void MApi_XC_EX_set_FD_Mask_byWin(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
5859 {
5860 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5861 {
5862 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5863 return;
5864 }
5865
5866 stXC_SET_FDMASK_BYWIN XCArgs;
5867 XCArgs.bEnable = bEnable;
5868 XCArgs.eWindow = eWindow;
5869
5870 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5871 {
5872 printf("Obtain XC engine fail\n");
5873 return;
5874 }
5875 else
5876 {
5877 return;
5878 }
5879 }
5880
MApi_XC_EX_Get_FD_Mask_byWin(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5881 MS_BOOL MApi_XC_EX_Get_FD_Mask_byWin(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5882 {
5883 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5884 {
5885 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5886 return FALSE;
5887 }
5888
5889 stXC_GET_FDMASK_BYWIN XCArgs;
5890 XCArgs.eWindow = eWindow;
5891 XCArgs.bReturnValue = FALSE;
5892
5893 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_FDMASK_BYWIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5894 {
5895 printf("Obtain XC engine fail\n");
5896 return FALSE;
5897 }
5898 else
5899 {
5900 return XCArgs.bReturnValue;
5901 }
5902 }
5903
MApi_XC_EX_Get_FD_Mask_Status(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5904 MS_BOOL MApi_XC_EX_Get_FD_Mask_Status(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5905 {
5906 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5907 {
5908 printf("[%s,%5d]No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__);
5909 return FALSE;
5910 }
5911
5912 stXC_GET_FDMASK_STATUS XCArgs;
5913 XCArgs.eWindow = eWindow;
5914 XCArgs.bReturnValue = FALSE;
5915
5916 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_FDMASK_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5917 {
5918 printf("Obtain XC engine fail\n");
5919 return FALSE;
5920 }
5921 else
5922 {
5923 return XCArgs.bReturnValue;
5924 }
5925 }
5926
MApi_XC_EX_SetIP1TestPattern(XC_DEVICE_ID * pDeviceId,MS_U8 u8Enable,MS_U16 u6Pattern_type,XC_EX_SCALER_WIN eWindow)5927 void MApi_XC_EX_SetIP1TestPattern(XC_DEVICE_ID *pDeviceId, MS_U8 u8Enable, MS_U16 u6Pattern_type, XC_EX_SCALER_WIN eWindow)
5928 {
5929 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5930 {
5931 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5932 return;
5933 }
5934
5935 stXC_SET_IP1_TESTPATTERN XCArgs;
5936 XCArgs.u8Enable = u8Enable;
5937 XCArgs.u6Pattern_type = u6Pattern_type;
5938 XCArgs.eWindow = eWindow;
5939
5940 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_IP1_TESTPATTERN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5941 {
5942 printf("Obtain XC engine fail\n");
5943 return;
5944 }
5945 else
5946 {
5947 return;
5948 }
5949 }
5950
MApi_XC_EX_InitIPForInternalTiming(XC_DEVICE_ID * pDeviceId,XC_EX_Internal_TimingType timingtype)5951 void MApi_XC_EX_InitIPForInternalTiming(XC_DEVICE_ID *pDeviceId, XC_EX_Internal_TimingType timingtype)
5952 {
5953 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5954 {
5955 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5956 return;
5957 }
5958
5959 stXC_SET_INIT_IP_FOR_INTERNAL_TIMING XCArgs;
5960 XCArgs.timingtype = timingtype;
5961
5962 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_INIT_IP_FOR_INTERNAL_TIMING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5963 {
5964 printf("Obtain XC engine fail\n");
5965 return;
5966 }
5967 else
5968 {
5969 return;
5970 }
5971 }
5972
MApi_XC_EX_SetIPMux(XC_DEVICE_ID * pDeviceId,MS_U8 u8Val)5973 void MApi_XC_EX_SetIPMux(XC_DEVICE_ID *pDeviceId, MS_U8 u8Val)
5974 {
5975 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5976 {
5977 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
5978 return;
5979 }
5980
5981 stXC_SET_IPMUX XCArgs;
5982 XCArgs.u8Val = u8Val;
5983
5984 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_IPMUX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
5985 {
5986 printf("Obtain XC engine fail\n");
5987 return;
5988 }
5989 else
5990 {
5991 return;
5992 }
5993 }
5994
MApi_XC_EX_Is_H_Sync_Active(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)5995 MS_BOOL MApi_XC_EX_Is_H_Sync_Active(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
5996 {
5997 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
5998 {
5999 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6000 return FALSE;
6001 }
6002
6003 stXC_CHECK_HSYNC_ACTIVE XCArgs;
6004 XCArgs.eWindow = eWindow;
6005 XCArgs.bReturnValue = FALSE;
6006
6007 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_HSYNC_ACTIVE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6008 {
6009 printf("Obtain XC engine fail\n");
6010 return FALSE;
6011 }
6012 else
6013 {
6014 return XCArgs.bReturnValue;
6015 }
6016 }
6017
MApi_XC_EX_Is_V_Sync_Active(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)6018 MS_BOOL MApi_XC_EX_Is_V_Sync_Active(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
6019 {
6020 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6021 {
6022 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6023 return FALSE;
6024 }
6025
6026 stXC_CHECK_VSYNC_ACTIVE XCArgs;
6027 XCArgs.eWindow = eWindow;
6028 XCArgs.bReturnValue = FALSE;
6029
6030 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_VSYNC_ACTIVE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6031 {
6032 printf("Obtain XC engine fail\n");
6033 return FALSE;
6034 }
6035 else
6036 {
6037 return XCArgs.bReturnValue;
6038 }
6039 }
6040
MApi_XC_EX_GetAutoPositionWindow(XC_DEVICE_ID * pDeviceId,MS_U8 u8ValidData,XC_EX_SCALER_WIN eWindow,XC_EX_WINDOW_TYPE * pstAutoPositionWindow)6041 MS_BOOL MApi_XC_EX_GetAutoPositionWindow(XC_DEVICE_ID *pDeviceId, MS_U8 u8ValidData, XC_EX_SCALER_WIN eWindow, XC_EX_WINDOW_TYPE *pstAutoPositionWindow)
6042 {
6043 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6044 {
6045 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6046 return FALSE;
6047 }
6048
6049 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE,XC_EX_WINDOW_TYPE);
6050 stXC_GET_AUTO_POSITION_WINDOW XCArgs;
6051 XCArgs.u8ValidData = u8ValidData;
6052 XCArgs.eWindow = eWindow;
6053 XCArgs.pstAutoPositionWindow = (MS_WINDOW_TYPE*)pstAutoPositionWindow;
6054 XCArgs.bReturnValue = FALSE;
6055
6056 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_AUTO_POSITION_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6057 {
6058 printf("Obtain XC engine fail\n");
6059 return FALSE;
6060 }
6061 else
6062 {
6063 return XCArgs.bReturnValue;
6064 }
6065 }
6066
MApi_XC_EX_SetFrameBufferAddress(XC_DEVICE_ID * pDeviceId,MS_PHY u32FBAddress,MS_PHY u32FBSize,XC_EX_SCALER_WIN eWindow)6067 void MApi_XC_EX_SetFrameBufferAddress(XC_DEVICE_ID *pDeviceId, MS_PHY u32FBAddress, MS_PHY u32FBSize, XC_EX_SCALER_WIN eWindow)
6068 {
6069 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6070 {
6071 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6072 return;
6073 }
6074
6075 stXC_SET_FRAMEBUFFER_ADDRESS XCArgs;
6076 XCArgs.u32FBAddress = u32FBAddress;
6077 XCArgs.u32FBSize = u32FBSize;
6078 XCArgs.eWindow = eWindow;
6079
6080 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRAMEBUFFER_ADDRESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6081 {
6082 printf("Obtain XC engine fail\n");
6083 return;
6084 }
6085 else
6086 {
6087 return;
6088 }
6089 }
6090
MApi_XC_EX_IsFrameBufferEnoughForCusScaling(XC_DEVICE_ID * pDeviceId,XC_EX_SETWIN_INFO * pstXC_SetWin_Info,XC_EX_SCALER_WIN eWindow)6091 MS_BOOL MApi_XC_EX_IsFrameBufferEnoughForCusScaling(XC_DEVICE_ID *pDeviceId, XC_EX_SETWIN_INFO *pstXC_SetWin_Info, XC_EX_SCALER_WIN eWindow)
6092 {
6093 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6094 {
6095 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6096 return FALSE;
6097 }
6098
6099 _XC_ST_CHECK_SIZE(XC_SETWIN_INFO,XC_EX_SETWIN_INFO);
6100 stXC_CHECK_FRAMEBUFFER_ENOUGH_FOR_CUSSCALING XCArgs;
6101 XCArgs.pstXC_SetWin_Info = (XC_SETWIN_INFO*)pstXC_SetWin_Info;
6102 XCArgs.eWindow = eWindow;
6103 XCArgs.bReturnValue = FALSE;
6104
6105 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_FRAMEBUFFER_ENOUGH_FOR_CUSSCALING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6106 {
6107 printf("Obtain XC engine fail\n");
6108 return FALSE;
6109 }
6110 else
6111 {
6112 return XCArgs.bReturnValue;
6113 }
6114 }
6115
MApi_XC_EX_SetScalerMemoryRequest(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_MEMORY_REQUEST_TYPE eType,XC_EX_SCALER_WIN eWindow)6116 XC_EX_RETURN_VALUE MApi_XC_EX_SetScalerMemoryRequest(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_MEMORY_REQUEST_TYPE eType, XC_EX_SCALER_WIN eWindow)
6117 {
6118 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6119 {
6120 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6121 return E_APIXC_RET_FAIL;
6122 }
6123
6124 stXC_SET_SCALER_MEMORY_REQUEST XCArgs;
6125 XCArgs.bEnable = bEnable;
6126 XCArgs.eRequestType = eType;
6127 XCArgs.eWindow = eWindow;
6128 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
6129
6130 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SCALER_MEMORY_REQUEST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6131 {
6132 printf("Obtain XC engine fail\n");
6133 return E_APIXC_RET_FAIL;
6134 }
6135 else
6136 {
6137 return XCArgs.eReturnValue;
6138 }
6139 }
6140
MApi_XC_EX_Get_PixelData(XC_DEVICE_ID * pDeviceId,MS_U16 u16CorX,MS_U16 u16CorY,XC_EX_PIXEL_32BIT * pixel)6141 void MApi_XC_EX_Get_PixelData(XC_DEVICE_ID *pDeviceId, MS_U16 u16CorX, MS_U16 u16CorY, XC_EX_PIXEL_32BIT* pixel)
6142 {
6143 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6144 {
6145 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6146 return;
6147 }
6148
6149 _XC_ST_CHECK_SIZE(MS_PIXEL_32BIT,XC_EX_PIXEL_32BIT);
6150 stXC_GET_PIXEL_DATA XCArgs;
6151 XCArgs.u16CorX = u16CorX;
6152 XCArgs.u16CorY = u16CorY;
6153 XCArgs.pixel = (MS_PIXEL_32BIT*)pixel;
6154
6155 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_PIXEL_DATA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6156 {
6157 printf("Obtain XC engine fail\n");
6158 return;
6159 }
6160 else
6161 {
6162 return;
6163 }
6164 }
6165
MApi_XC_EX_GetAvailableSize(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow,MS_U8 u8FBNum,MS_U32 u32InputSize)6166 MS_U32 MApi_XC_EX_GetAvailableSize(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow, MS_U8 u8FBNum, MS_U32 u32InputSize)
6167 {
6168 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6169 {
6170 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6171 return 0;
6172 }
6173
6174 stXC_GET_AVAILABLE_SIZE XCArgs;
6175 XCArgs.eWindow = eWindow;
6176 XCArgs.u8FBNum = u8FBNum;
6177 XCArgs.u32InputSize = u32InputSize;
6178 XCArgs.u32ReturnValue = 0;
6179
6180 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_AVAILABLE_SIZE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6181 {
6182 printf("Obtain XC engine fail\n");
6183 return 0;
6184 }
6185 else
6186 {
6187 return XCArgs.u32ReturnValue;
6188 }
6189 }
6190
MApi_XC_EX_SetFrameColor(XC_DEVICE_ID * pDeviceId,MS_U32 u32aRGB)6191 void MApi_XC_EX_SetFrameColor(XC_DEVICE_ID *pDeviceId, MS_U32 u32aRGB)
6192 {
6193 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6194 {
6195 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6196 return;
6197 }
6198
6199 stXC_SET_FRAME_COLOR XCArgs;
6200 XCArgs.u32aRGB = u32aRGB;
6201
6202 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRAME_COLOR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6203 {
6204 printf("Obtain XC engine fail\n");
6205 return;
6206 }
6207 else
6208 {
6209 return;
6210 }
6211 }
6212
MApi_XC_EX_SetDispWindowColor(XC_DEVICE_ID * pDeviceId,MS_U8 u8Color,XC_EX_SCALER_WIN eWindow)6213 void MApi_XC_EX_SetDispWindowColor(XC_DEVICE_ID *pDeviceId, MS_U8 u8Color, XC_EX_SCALER_WIN eWindow)
6214 {
6215 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6216 {
6217 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6218 return;
6219 }
6220
6221 stXC_SET_DISPLAY_WINDOW_COLOR XCArgs;
6222 XCArgs.u8Color = u8Color;
6223 XCArgs.eWindow = eWindow;
6224 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_DISPLAY_WINDOW_COLOR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6225 {
6226 printf("Obtain XC engine fail\n");
6227 return;
6228 }
6229 else
6230 {
6231 return;
6232 }
6233 }
6234
MApi_XC_EX_SupportSourceToVE(XC_DEVICE_ID * pDeviceId,MS_U16 * pOutputCapability)6235 XC_EX_RETURN_VALUE MApi_XC_EX_SupportSourceToVE(XC_DEVICE_ID *pDeviceId, MS_U16* pOutputCapability)
6236 {
6237 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6238 {
6239 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6240 return E_APIXC_RET_FAIL;
6241 }
6242
6243 stXC_GET_SUPPORT_SOURCE_TO_VE XCArgs;
6244 XCArgs.pOutputCapability = pOutputCapability;
6245 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
6246
6247 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_SUPPORT_SOURCE_TO_VE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6248 {
6249 printf("Obtain XC engine fail\n");
6250 return E_APIXC_RET_FAIL;
6251 }
6252 else
6253 {
6254 return XCArgs.eReturnValue;
6255 }
6256 }
6257
MApi_XC_EX_SetOutputCapture(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SOURCE_TO_VE eSourceToVE)6258 XC_EX_RETURN_VALUE MApi_XC_EX_SetOutputCapture(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SOURCE_TO_VE eSourceToVE)
6259 {
6260 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6261 {
6262 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6263 return E_APIXC_RET_FAIL;
6264 }
6265
6266 stXC_SET_OUTPUT_CAPTURE XCArgs;
6267 XCArgs.bEnable = bEnable;
6268 XCArgs.eSourceToVE = eSourceToVE;
6269 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
6270
6271 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OUTPUT_CAPTURE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6272 {
6273 printf("Obtain XC engine fail\n");
6274 return E_APIXC_RET_FAIL;
6275 }
6276 else
6277 {
6278 return XCArgs.eReturnValue;
6279 }
6280 }
6281
MApi_XC_EX_SetGammaOnOff(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)6282 void MApi_XC_EX_SetGammaOnOff (XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
6283 {
6284 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6285 {
6286 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6287 return;
6288 }
6289
6290 stXC_SET_GAMMA_ONOFF XCArgs;
6291 XCArgs.bEnable = bEnable;
6292
6293 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_GAMMA_ONOFF, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6294 {
6295 printf("Obtain XC engine fail\n");
6296 return;
6297 }
6298 else
6299 {
6300 return;
6301 }
6302 }
6303
MApi_XC_EX_SetPreGammaGain(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow,XC_EX_VOP_CHANNEL eVop_Channel,MS_U16 u16Val)6304 void MApi_XC_EX_SetPreGammaGain(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow, XC_EX_VOP_CHANNEL eVop_Channel, MS_U16 u16Val)
6305 {
6306 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6307 {
6308 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6309 return;
6310 }
6311
6312 stXC_SET_PREGAMMA_GAIN XCArgs;
6313 XCArgs.eWindow = eWindow;
6314 XCArgs.eVop_Channel = eVop_Channel;
6315 XCArgs.u16Val = u16Val;
6316
6317 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_PREGAMMA_GAIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6318 {
6319 printf("Obtain XC engine fail\n");
6320 return;
6321 }
6322 else
6323 {
6324 return;
6325 }
6326 }
6327
MApi_XC_EX_SetPreGammaOffset(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow,XC_EX_VOP_CHANNEL eVop_Channel,MS_U16 u16Val)6328 void MApi_XC_EX_SetPreGammaOffset(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow, XC_EX_VOP_CHANNEL eVop_Channel, MS_U16 u16Val)
6329 {
6330 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6331 {
6332 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6333 return;
6334 }
6335
6336 stXC_SET_PREGAMMA_OFFSET XCArgs;
6337 XCArgs.eWindow = eWindow;
6338 XCArgs.eVop_Channel = eVop_Channel;
6339 XCArgs.u16Val = u16Val;
6340
6341 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_PREGAMMA_OFFSET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6342 {
6343 printf("Obtain XC engine fail\n");
6344 return;
6345 }
6346 else
6347 {
6348 return;
6349 }
6350 }
6351
MApi_XC_EX_SetPanelTiming(XC_DEVICE_ID * pDeviceId,XC_EX_SetTiming_Info * pTimingInfo,XC_EX_SCALER_WIN eWindow)6352 void MApi_XC_EX_SetPanelTiming(XC_DEVICE_ID *pDeviceId, XC_EX_SetTiming_Info *pTimingInfo, XC_EX_SCALER_WIN eWindow)
6353 {
6354 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6355 {
6356 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6357 return;
6358 }
6359
6360 _XC_ST_CHECK_SIZE(XC_SetTiming_Info,XC_EX_SetTiming_Info);
6361 stXC_SET_PANEL_TIMING XCArgs;
6362 XCArgs.pTimingInfo = (XC_SetTiming_Info*)pTimingInfo;
6363 XCArgs.eWindow = eWindow;
6364
6365 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_PANEL_TIMING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6366 {
6367 printf("Obtain XC engine fail\n");
6368 return;
6369 }
6370 else
6371 {
6372 return;
6373 }
6374 }
6375
MApi_XC_EX_SetOutTimingMode(XC_DEVICE_ID * pDeviceId,XC_EX_PNL_OUT_TIMING_MODE enPnl_Out_Timing_Mode)6376 void MApi_XC_EX_SetOutTimingMode(XC_DEVICE_ID *pDeviceId, XC_EX_PNL_OUT_TIMING_MODE enPnl_Out_Timing_Mode)
6377 {
6378 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6379 {
6380 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6381 return;
6382 }
6383
6384 stXC_SET_OUTPUT_TIMING_MODE XCArgs;
6385 XCArgs.enPnl_Out_Timing_Mode = enPnl_Out_Timing_Mode;
6386
6387 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OUTPUT_TIMING_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6388 {
6389 printf("Obtain XC engine fail\n");
6390 return;
6391 }
6392 else
6393 {
6394 return;
6395 }
6396 }
6397
MApi_XC_EX_SetFreeRunTiming(XC_DEVICE_ID * pDeviceId)6398 void MApi_XC_EX_SetFreeRunTiming(XC_DEVICE_ID *pDeviceId)
6399 {
6400 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6401 {
6402 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6403 return;
6404 }
6405
6406 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FREERUN_TIMING, NULL) != UTOPIA_STATUS_SUCCESS)
6407 {
6408 printf("Obtain XC engine fail\n");
6409 return;
6410 }
6411 else
6412 {
6413 return;
6414 }
6415 }
6416
MApi_XC_EX_Set_CustomerSyncInfo(XC_DEVICE_ID * pDeviceId,MS_U16 u16FrontPorch,MS_U16 u16SyncWidth,MS_U16 u16OutputVfreq)6417 MS_BOOL MApi_XC_EX_Set_CustomerSyncInfo(XC_DEVICE_ID *pDeviceId, MS_U16 u16FrontPorch, MS_U16 u16SyncWidth, MS_U16 u16OutputVfreq)
6418 {
6419 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6420 {
6421 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6422 return FALSE;
6423 }
6424
6425 stXC_SET_CUSTOMER_SYNC_INFO XCArgs;
6426 XCArgs.u16FrontPorch = u16FrontPorch;
6427 XCArgs.u16SyncWidth = u16SyncWidth;
6428 XCArgs.u16OutputVfreq = u16OutputVfreq;
6429 XCArgs.bReturnValue = FALSE;
6430
6431 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CUSTOMER_SYNC_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6432 {
6433 printf("Obtain XC engine fail\n");
6434 return FALSE;
6435 }
6436 else
6437 {
6438 return XCArgs.bReturnValue;
6439 }
6440 }
6441
MApi_XC_EX_WaitFPLLDone(XC_DEVICE_ID * pDeviceId)6442 MS_BOOL MApi_XC_EX_WaitFPLLDone(XC_DEVICE_ID *pDeviceId)
6443 {
6444 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6445 {
6446 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6447 return FALSE;
6448 }
6449
6450 stXC_GET_WAIT_FPLL_DONE XCArgs;
6451 XCArgs.bReturnValue = FALSE;
6452
6453 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_WAIT_FPLL_DONE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6454 {
6455 printf("Obtain XC engine fail\n");
6456 return FALSE;
6457 }
6458 else
6459 {
6460 return XCArgs.bReturnValue;
6461 }
6462 }
6463
MApi_XC_EX_GetOutputVFreqX100(XC_DEVICE_ID * pDeviceId)6464 MS_U16 MApi_XC_EX_GetOutputVFreqX100(XC_DEVICE_ID *pDeviceId)
6465 {
6466 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6467 {
6468 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6469 return 0;
6470 }
6471
6472 stXC_GET_OUTPUT_VFREQX100 XCArgs;
6473 XCArgs.u16ReturnValue = 0;
6474
6475 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_OUTPUT_VFREQX100, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6476 {
6477 printf("Obtain XC engine fail\n");
6478 return 0;
6479 }
6480 else
6481 {
6482 return XCArgs.u16ReturnValue;
6483 }
6484 }
6485
MApi_XC_EX_FrameLockCheck(XC_DEVICE_ID * pDeviceId)6486 MS_BOOL MApi_XC_EX_FrameLockCheck(XC_DEVICE_ID *pDeviceId)
6487 {
6488 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6489 {
6490 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6491 return FALSE;
6492 }
6493
6494 stXC_CHECK_FRAMELOCK XCArgs;
6495 XCArgs.bReturnValue = FALSE;
6496
6497 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_FRAMELOCK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6498 {
6499 printf("Obtain XC engine fail\n");
6500 return FALSE;
6501 }
6502 else
6503 {
6504 return XCArgs.bReturnValue;
6505 }
6506 }
6507
MApi_XC_EX_CustomizeFRCTable(XC_DEVICE_ID * pDeviceId,XC_EX_FRC_SETTING * stFRCTable)6508 XC_EX_RETURN_VALUE MApi_XC_EX_CustomizeFRCTable(XC_DEVICE_ID *pDeviceId, XC_EX_FRC_SETTING* stFRCTable)
6509 {
6510 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6511 {
6512 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6513 return E_APIXC_RET_FAIL;
6514 }
6515
6516 _XC_ST_CHECK_SIZE(SC_FRC_SETTING, XC_EX_FRC_SETTING);
6517 stXC_SET_CUSTOMIZE_FRC_TABLE XCArgs;
6518 XCArgs.stFRCTable = (SC_FRC_SETTING*)stFRCTable;
6519 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
6520
6521 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CUSTOMIZE_FRC_TABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6522 {
6523 printf("Obtain XC engine fail\n");
6524 return E_APIXC_RET_FAIL;
6525 }
6526 else
6527 {
6528 return XCArgs.eReturnValue;
6529 }
6530 }
6531
MApi_XC_EX_OutputFrameCtrl(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_OUTPUTFRAME_Info * stOutFrameInfo,XC_EX_SCALER_WIN eWindow)6532 XC_EX_RETURN_VALUE MApi_XC_EX_OutputFrameCtrl(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_OUTPUTFRAME_Info * stOutFrameInfo,XC_EX_SCALER_WIN eWindow)
6533 {
6534 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6535 {
6536 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6537 return E_APIXC_RET_FAIL;
6538 }
6539
6540 _XC_ST_CHECK_SIZE(XC_OUTPUTFRAME_Info, XC_EX_OUTPUTFRAME_Info);
6541 stXC_SET_OUTPUT_FRAME_CONTROL XCArgs;
6542 XCArgs.bEnable = bEnable;
6543 XCArgs.pstOutFrameInfo = (XC_OUTPUTFRAME_Info*)stOutFrameInfo;
6544 XCArgs.eWindow = eWindow;
6545 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
6546
6547 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OUTPUT_FRAME_CONTROL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6548 {
6549 printf("Obtain XC engine fail\n");
6550 return E_APIXC_RET_FAIL;
6551 }
6552 else
6553 {
6554 return XCArgs.eReturnValue;
6555 }
6556 }
6557
MApi_SC_EX_Enable_FPLL_FSM(XC_DEVICE_ID * pDeviceId,MS_BOOL bTrue)6558 void MApi_SC_EX_Enable_FPLL_FSM(XC_DEVICE_ID *pDeviceId, MS_BOOL bTrue)
6559 {
6560 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6561 {
6562 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6563 return;
6564 }
6565
6566 stXC_SET_FPLL_FSM_ENABLE XCArgs;
6567 XCArgs.bTrue = bTrue;
6568
6569 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FPLL_FSM_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6570 {
6571 printf("Obtain XC engine fail\n");
6572 return;
6573 }
6574 else
6575 {
6576 return;
6577 }
6578 }
6579
MApi_SC_EX_ForceFreerun(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)6580 void MApi_SC_EX_ForceFreerun(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
6581 {
6582 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6583 {
6584 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6585 return;
6586 }
6587
6588 stXC_SET_FORCE_FREERUN XCArgs;
6589 XCArgs.bEnable = bEnable;
6590
6591 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FORCE_FREERUN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6592 {
6593 printf("Obtain XC engine fail\n");
6594 return;
6595 }
6596 else
6597 {
6598 return;
6599 }
6600 }
6601
MApi_SC_EX_IsForceFreerun(XC_DEVICE_ID * pDeviceId)6602 MS_BOOL MApi_SC_EX_IsForceFreerun(XC_DEVICE_ID *pDeviceId)
6603 {
6604 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6605 {
6606 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6607 return FALSE;
6608 }
6609
6610 stXC_CHECK_FORCE_FREERUN XCArgs;
6611 XCArgs.bReturnValue = FALSE;
6612
6613 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_FORCE_FREERUN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6614 {
6615 printf("Obtain XC engine fail\n");
6616 return FALSE;
6617 }
6618 else
6619 {
6620 return XCArgs.bReturnValue;
6621 }
6622 }
6623
MApi_SC_EX_SetFreerunVFreq(XC_DEVICE_ID * pDeviceId,XC_EX_VFREQ_SEL VFreq)6624 void MApi_SC_EX_SetFreerunVFreq(XC_DEVICE_ID *pDeviceId, XC_EX_VFREQ_SEL VFreq)
6625 {
6626 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6627 {
6628 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6629 return;
6630 }
6631
6632 stXC_SET_FREERUN_FREQ XCArgs;
6633 XCArgs.VFreq = VFreq;
6634
6635 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FREERUN_FREQ, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6636 {
6637 printf("Obtain XC engine fail\n");
6638 return;
6639 }
6640 else
6641 {
6642 return;
6643 }
6644 }
6645
MApi_XC_EX_SetExPanelInfo(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_PANEL_INFO_EX * pPanelInfoEx)6646 MS_BOOL MApi_XC_EX_SetExPanelInfo(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_PANEL_INFO_EX *pPanelInfoEx)
6647 {
6648 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6649 {
6650 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6651 return FALSE;
6652 }
6653
6654 _XC_ST_CHECK_SIZE(XC_PANEL_INFO_EX, XC_EX_PANEL_INFO_EX);
6655 stXC_SET_EXPANEL_INFO XCArgs;
6656 XCArgs.bEnable = bEnable;
6657 XCArgs.pPanelInfoEx = (XC_PANEL_INFO_EX*)pPanelInfoEx;
6658 XCArgs.bReturnValue = FALSE;
6659
6660 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_EXPANEL_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6661 {
6662 printf("Obtain XC engine fail\n");
6663 return FALSE;
6664 }
6665 else
6666 {
6667 return XCArgs.bReturnValue;
6668 }
6669 }
6670
MApi_XC_EX_Enable_FPLL_Thresh_Mode(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)6671 void MApi_XC_EX_Enable_FPLL_Thresh_Mode(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
6672 {
6673 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6674 {
6675 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6676 return;
6677 }
6678
6679 stXC_SET_FPLL_THRESHMODE XCArgs;
6680 XCArgs.bEnable = bEnable;
6681
6682 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FPLL_THRESHMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6683 {
6684 printf("Obtain XC engine fail\n");
6685 return;
6686 }
6687 else
6688 {
6689 return;
6690 }
6691 }
6692
MApi_XC_EX_EnableIPAutoNoSignal(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)6693 XC_EX_RETURN_VALUE MApi_XC_EX_EnableIPAutoNoSignal(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow )
6694 {
6695 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6696 {
6697 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6698 return E_APIXC_RET_FAIL;
6699 }
6700
6701 stXC_SET_IPAUTONOSIGNAL XCArgs;
6702 XCArgs.bEnable = bEnable;
6703 XCArgs.eWindow = eWindow;
6704 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
6705
6706 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_IPAUTONOSIGNAL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6707 {
6708 printf("Obtain XC engine fail\n");
6709 return E_APIXC_RET_FAIL;
6710 }
6711 else
6712 {
6713 return XCArgs.eReturnValue;
6714 }
6715 }
6716
MApi_XC_EX_GetIPAutoNoSignal(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)6717 MS_BOOL MApi_XC_EX_GetIPAutoNoSignal(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow )
6718 {
6719 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6720 {
6721 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6722 return FALSE;
6723 }
6724
6725 stXC_GET_IPAUTONOSIGNAL XCArgs;
6726 XCArgs.eWindow = eWindow;
6727 XCArgs.bReturnValue = FALSE;
6728
6729 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_IPAUTONOSIGNAL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6730 {
6731 printf("Obtain XC engine fail\n");
6732 return FALSE;
6733 }
6734 else
6735 {
6736 return XCArgs.bReturnValue;
6737 }
6738 }
6739
MApi_XC_EX_EnableIPAutoCoast(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)6740 void MApi_XC_EX_EnableIPAutoCoast(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
6741 {
6742 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6743 {
6744 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6745 return;
6746 }
6747
6748 stXC_SET_IPAUTOCOAST XCArgs;
6749 XCArgs.bEnable = bEnable;
6750
6751 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_IPAUTOCOAST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6752 {
6753 printf("Obtain XC engine fail\n");
6754 return;
6755 }
6756 else
6757 {
6758 return;
6759 }
6760 }
6761
MApi_XC_EX_EnableIPCoastDebounce(XC_DEVICE_ID * pDeviceId)6762 void MApi_XC_EX_EnableIPCoastDebounce(XC_DEVICE_ID *pDeviceId)
6763 {
6764 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6765 {
6766 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6767 return;
6768 }
6769
6770 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_IPCOAST_DEBOUNCE_ENABLE, NULL) != UTOPIA_STATUS_SUCCESS)
6771 {
6772 printf("Obtain XC engine fail\n");
6773 return;
6774 }
6775 else
6776 {
6777 return;
6778 }
6779 }
6780
MApi_XC_EX_ClearIPCoastStatus(XC_DEVICE_ID * pDeviceId)6781 void MApi_XC_EX_ClearIPCoastStatus(XC_DEVICE_ID *pDeviceId)
6782 {
6783 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6784 {
6785 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6786 return;
6787 }
6788
6789 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CLEAR_IPCOAST_STATUS, NULL) != UTOPIA_STATUS_SUCCESS)
6790 {
6791 printf("Obtain XC engine fail\n");
6792 return;
6793 }
6794 else
6795 {
6796 return;
6797 }
6798 }
6799
MApi_XC_EX_EnableFpllManualSetting(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)6800 void MApi_XC_EX_EnableFpllManualSetting(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
6801 {
6802 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6803 {
6804 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6805 return;
6806 }
6807
6808 stXC_SET_FPLL_MANUAL_SETTING_ENABLE XCArgs;
6809 XCArgs.bEnable = bEnable;
6810
6811 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FPLL_MANUAL_SETTING_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6812 {
6813 printf("Obtain XC engine fail\n");
6814 return;
6815 }
6816 else
6817 {
6818 return;
6819 }
6820 } // debug purpose
6821
MApi_XC_EX_FpllBoundaryTest(XC_DEVICE_ID * pDeviceId,MS_U32 u32FpllSetOffset,MS_U16 u16TestCnt)6822 void MApi_XC_EX_FpllBoundaryTest(XC_DEVICE_ID *pDeviceId, MS_U32 u32FpllSetOffset, MS_U16 u16TestCnt)
6823 {
6824 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6825 {
6826 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6827 return;
6828 }
6829
6830 stXC_SET_FPLL_BOUNDARY_TEST XCArgs;
6831 XCArgs.u32FpllSetOffset = u32FpllSetOffset;
6832 XCArgs.u16TestCnt = u16TestCnt;
6833
6834 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FPLL_BOUNDARY_TEST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6835 {
6836 printf("Obtain XC engine fail\n");
6837 return;
6838 }
6839 else
6840 {
6841 return;
6842 }
6843 } // debug purpose
6844
MApi_XC_EX_SetOffLineDetection(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE u8InputSourceType)6845 void MApi_XC_EX_SetOffLineDetection ( XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE u8InputSourceType )
6846 {
6847 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6848 {
6849 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6850 return;
6851 }
6852
6853 stXC_SET_OFFLINE_DETECTION XCArgs;
6854 XCArgs.u8InputSourceType = u8InputSourceType;
6855
6856 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OFFLINE_DETECTION, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6857 {
6858 printf("Obtain XC engine fail\n");
6859 return;
6860 }
6861 else
6862 {
6863 return;
6864 }
6865 }
6866
MApi_XC_EX_GetOffLineDetection(XC_DEVICE_ID * pDeviceId,XC_EX_INPUT_SOURCE_TYPE u8InputSourceType)6867 MS_U8 MApi_XC_EX_GetOffLineDetection( XC_DEVICE_ID *pDeviceId, XC_EX_INPUT_SOURCE_TYPE u8InputSourceType)
6868 {
6869 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6870 {
6871 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6872 return 0;
6873 }
6874
6875 stXC_GET_OFFLINE_DETECTION XCArgs;
6876 XCArgs.u8InputSourceType = u8InputSourceType;
6877 XCArgs.u8ReturnValue = 0;
6878
6879 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_OFFLINE_DETECTION, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6880 {
6881 printf("Obtain XC engine fail\n");
6882 return 0;
6883 }
6884 else
6885 {
6886 return XCArgs.u8ReturnValue;
6887 }
6888 }
6889
MApi_XC_EX_SetOffLineSogThreshold(XC_DEVICE_ID * pDeviceId,MS_U8 u8Threshold)6890 MS_BOOL MApi_XC_EX_SetOffLineSogThreshold(XC_DEVICE_ID *pDeviceId, MS_U8 u8Threshold)
6891 {
6892 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6893 {
6894 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6895 return FALSE;
6896 }
6897
6898 stXC_SET_OFFLINE_SOG_THRESHOLD XCArgs;
6899 XCArgs.u8Threshold = u8Threshold;
6900 XCArgs.bReturnValue = FALSE;
6901
6902 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OFFLINE_SOG_THRESHOLD, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6903 {
6904 printf("Obtain XC engine fail\n");
6905 return FALSE;
6906 }
6907 else
6908 {
6909 return XCArgs.bReturnValue;
6910 }
6911 } //t2,u3,u4: 0~31 other chip: 0~255
6912
MApi_XC_EX_SetOffLineSogBW(XC_DEVICE_ID * pDeviceId,MS_U8 u8BW)6913 MS_BOOL MApi_XC_EX_SetOffLineSogBW(XC_DEVICE_ID *pDeviceId, MS_U8 u8BW)
6914 {
6915 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6916 {
6917 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6918 return FALSE;
6919 }
6920
6921 stXC_SET_OFFLINE_SOG_BW XCArgs;
6922 XCArgs.u8BW = u8BW;
6923 XCArgs.bReturnValue = FALSE;
6924
6925 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OFFLINE_SOG_BW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6926 {
6927 printf("Obtain XC engine fail\n");
6928 return FALSE;
6929 }
6930 else
6931 {
6932 return XCArgs.bReturnValue;
6933 }
6934 }
6935
MApi_XC_EX_OffLineInit(XC_DEVICE_ID * pDeviceId)6936 MS_BOOL MApi_XC_EX_OffLineInit(XC_DEVICE_ID *pDeviceId)
6937 {
6938 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6939 {
6940 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6941 return FALSE;
6942 }
6943
6944 stXC_SET_OFFLINE_INIT XCArgs;
6945 XCArgs.bReturnValue = FALSE;
6946
6947 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OFFLINE_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6948 {
6949 printf("Obtain XC engine fail\n");
6950 return FALSE;
6951 }
6952 else
6953 {
6954 return XCArgs.bReturnValue;
6955 }
6956 }
6957
MApi_XC_EX_Set_Extra_fetch_adv_line(XC_DEVICE_ID * pDeviceId,MS_U8 u8val)6958 void MApi_XC_EX_Set_Extra_fetch_adv_line(XC_DEVICE_ID *pDeviceId, MS_U8 u8val)
6959 {
6960 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6961 {
6962 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6963 return;
6964 }
6965
6966 stXC_SET_EXTRA_FETCH_ADV_LINE XCArgs;
6967 XCArgs.u8val = u8val;
6968
6969 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_EXTRA_FETCH_ADV_LINE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6970 {
6971 printf("Obtain XC engine fail\n");
6972 return;
6973 }
6974 else
6975 {
6976 return;
6977 }
6978 }
6979
MApi_XC_EX_SetVGASogEn(XC_DEVICE_ID * pDeviceId,MS_BOOL bVGASogEn)6980 XC_EX_RETURN_VALUE MApi_XC_EX_SetVGASogEn(XC_DEVICE_ID *pDeviceId, MS_BOOL bVGASogEn)
6981 {
6982 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
6983 {
6984 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
6985 return E_APIXC_RET_FAIL;
6986 }
6987
6988 stXC_SET_VGA_SOG_ENABLE XCArgs;
6989 XCArgs.bVGASogEn = bVGASogEn;
6990 XCArgs.eReturnValue = FALSE;
6991
6992 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_VGA_SOG_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
6993 {
6994 printf("Obtain XC engine fail\n");
6995 return E_APIXC_RET_FAIL;
6996 }
6997 else
6998 {
6999 return XCArgs.eReturnValue;
7000 }
7001 }
7002
MApi_XC_EX_EnableWindow(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)7003 void MApi_XC_EX_EnableWindow(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
7004 {
7005 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7006 {
7007 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7008 return;
7009 }
7010
7011 stXC_SET_WINDOW_ENABLE XCArgs;
7012 XCArgs.bEnable = bEnable;
7013 XCArgs.eWindow = eWindow;
7014
7015 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_WINDOW_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7016 {
7017 printf("Obtain XC engine fail\n");
7018 return;
7019 }
7020 else
7021 {
7022 return;
7023 }
7024 }
7025
MApi_XC_EX_Is_SubWindowEanble(XC_DEVICE_ID * pDeviceId)7026 MS_BOOL MApi_XC_EX_Is_SubWindowEanble(XC_DEVICE_ID *pDeviceId)
7027 {
7028 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7029 {
7030 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7031 return FALSE;
7032 }
7033
7034 stXC_CHECK_SUBWINDOW_ENABLE XCArgs;
7035 XCArgs.bReturnValue = FALSE;
7036
7037 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_SUBWINDOW_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7038 {
7039 printf("Obtain XC engine fail\n");
7040 return FALSE;
7041 }
7042 else
7043 {
7044 return XCArgs.bReturnValue;
7045 }
7046 }
7047
MApi_XC_EX_SetBorderFormat(XC_DEVICE_ID * pDeviceId,MS_U8 u8Left,MS_U8 u8Right,MS_U8 u8Up,MS_U8 u8Down,MS_U8 u8color,XC_EX_SCALER_WIN eWindow)7048 void MApi_XC_EX_SetBorderFormat( XC_DEVICE_ID *pDeviceId, MS_U8 u8Left, MS_U8 u8Right, MS_U8 u8Up, MS_U8 u8Down, MS_U8 u8color, XC_EX_SCALER_WIN eWindow )
7049 {
7050 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7051 {
7052 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7053 return;
7054 }
7055
7056 stXC_SET_BORDER_FORMAT XCArgs;
7057 XCArgs.u8Left = u8Left;
7058 XCArgs.u8Right = u8Right;
7059 XCArgs.u8Up = u8Up;
7060 XCArgs.u8Down = u8Down;
7061 XCArgs.u8color = u8color;
7062 XCArgs.eWindow = eWindow;
7063
7064 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BORDER_FORMAT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7065 {
7066 printf("Obtain XC engine fail\n");
7067 return;
7068 }
7069 else
7070 {
7071 return;
7072 }
7073 }
7074
MApi_XC_EX_EnableBorder(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)7075 void MApi_XC_EX_EnableBorder(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
7076 {
7077 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7078 {
7079 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7080 return;
7081 }
7082
7083 stXC_SET_BORDER_ENABLE XCArgs;
7084 XCArgs.bEnable = bEnable;
7085 XCArgs.eWindow = eWindow;
7086
7087 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BORDER_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7088 {
7089 printf("Obtain XC engine fail\n");
7090 return;
7091 }
7092 else
7093 {
7094 return;
7095 }
7096 }
7097
MApi_XC_EX_ZorderMainWindowFirst(XC_DEVICE_ID * pDeviceId,MS_BOOL bMainFirst)7098 void MApi_XC_EX_ZorderMainWindowFirst(XC_DEVICE_ID *pDeviceId, MS_BOOL bMainFirst)
7099 {
7100 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7101 {
7102 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7103 return;
7104 }
7105
7106 stXC_SET_ZORDER_MAINWINDOW_FIRST XCArgs;
7107 XCArgs.bMainFirst = bMainFirst;
7108
7109 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_ZORDER_MAINWINDOW_FIRST, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7110 {
7111 printf("Obtain XC engine fail\n");
7112 return;
7113 }
7114 else
7115 {
7116 return;
7117 }
7118 }
7119
MApi_XC_EX_PQ_LoadFunction(XC_DEVICE_ID * pDeviceId,PQ_EX_Function_Info * function_Info,MS_U32 u32InitDataLen)7120 void MApi_XC_EX_PQ_LoadFunction(XC_DEVICE_ID *pDeviceId, PQ_EX_Function_Info* function_Info , MS_U32 u32InitDataLen)
7121 {
7122 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7123 {
7124 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7125 return;
7126 }
7127
7128 _XC_ST_CHECK_SIZE(PQ_Function_Info, PQ_EX_Function_Info);
7129 stXC_SET_PQ_LOADFUNCTION XCArgs;
7130 XCArgs.function_Info = (PQ_Function_Info*)function_Info;
7131 XCArgs.u32InitDataLen = u32InitDataLen;
7132
7133 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_PQ_LOADFUNCTION, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7134 {
7135 printf("Obtain XC engine fail\n");
7136 return;
7137 }
7138 else
7139 {
7140 return;
7141 }
7142 }
7143
MApi_XC_EX_Check_HNonLinearScaling(XC_DEVICE_ID * pDeviceId)7144 MS_BOOL MApi_XC_EX_Check_HNonLinearScaling(XC_DEVICE_ID *pDeviceId)
7145 {
7146 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7147 {
7148 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7149 return FALSE;
7150 }
7151
7152 stXC_CHECK_H_NONLINEAR_SCALING XCArgs;
7153 XCArgs.bReturnValue = FALSE;
7154
7155 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_H_NONLINEAR_SCALING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7156 {
7157 printf("Obtain XC engine fail\n");
7158 return FALSE;
7159 }
7160 else
7161 {
7162 return XCArgs.bReturnValue;
7163 }
7164 }
7165
MApi_XC_EX_EnableEuroHdtvSupport(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)7166 void MApi_XC_EX_EnableEuroHdtvSupport(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
7167 {
7168 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7169 {
7170 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7171 return;
7172 }
7173
7174 stXC_SET_EUROHDTV_SUPPORT_ENABLE XCArgs;
7175 XCArgs.bEnable = bEnable;
7176
7177 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_EUROHDTV_SUPPORT_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7178 {
7179 printf("Obtain XC engine fail\n");
7180 return;
7181 }
7182 else
7183 {
7184 return;
7185 }
7186 }
7187
MApi_XC_EX_EnableEuroHdtvDetection(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)7188 void MApi_XC_EX_EnableEuroHdtvDetection(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
7189 {
7190 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7191 {
7192 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7193 return;
7194 }
7195
7196 stXC_SET_EUROHDTV_DETECTION_ENABLE XCArgs;
7197 XCArgs.bEnable = bEnable;
7198 XCArgs.eWindow = eWindow;
7199
7200 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_EUROHDTV_DETECTION_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7201 {
7202 printf("Obtain XC engine fail\n");
7203 return;
7204 }
7205 else
7206 {
7207 return;
7208 }
7209 }
7210
MApi_XC_EX_ReadByte(MS_U32 u32Reg)7211 MS_U8 MApi_XC_EX_ReadByte(MS_U32 u32Reg)
7212 {
7213 return (MS_U8)MDrv_ReadByte( u32Reg );
7214 if (pu32XCInst == NULL)
7215 {
7216 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
7217 return 0;
7218 }
7219
7220 stXC_READBYTE XCArgs;
7221 XCArgs.u32Reg = u32Reg;
7222 XCArgs.u8ReturnValue = 0;
7223
7224 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_READBYTE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7225 {
7226 printf("Obtain XC engine fail\n");
7227 return 0;
7228 }
7229 else
7230 {
7231 return XCArgs.u8ReturnValue;
7232 }
7233 }
7234
MApi_XC_EX_WriteByte(MS_U32 u32Reg,MS_U8 u8Val)7235 void MApi_XC_EX_WriteByte(MS_U32 u32Reg, MS_U8 u8Val)
7236 {
7237 MDrv_WriteByte( u32Reg, u8Val );
7238 return;
7239 if (pu32XCInst == NULL)
7240 {
7241 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
7242 return;
7243 }
7244
7245 stXC_WRITEBYTE XCArgs;
7246 XCArgs.u32Reg = u32Reg;
7247 XCArgs.u8Val = u8Val;
7248
7249 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_WRITEBYTE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7250 {
7251 printf("Obtain XC engine fail\n");
7252 return;
7253 }
7254 else
7255 {
7256 return;
7257 }
7258 }
7259
MApi_XC_EX_WriteByteMask(MS_U32 u32Reg,MS_U8 u8Val,MS_U8 u8Msk)7260 void MApi_XC_EX_WriteByteMask(MS_U32 u32Reg, MS_U8 u8Val, MS_U8 u8Msk)
7261 {
7262 MDrv_WriteByteMask( u32Reg, u8Val, u8Msk );
7263 return;
7264 if (pu32XCInst == NULL)
7265 {
7266 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
7267 return;
7268 }
7269
7270 stXC_WRITEBYTEMSK XCArgs;
7271 XCArgs.u32Reg = u32Reg;
7272 XCArgs.u8Val = u8Val;
7273 XCArgs.u8Msk = u8Msk;
7274
7275 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_WRITEBYTEMSK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7276 {
7277 printf("Obtain XC engine fail\n");
7278 return;
7279 }
7280 else
7281 {
7282 return;
7283 }
7284 }
7285
MApi_XC_EX_Write2ByteMask(MS_U32 u32Reg,MS_U16 u16val,MS_U16 u16Mask)7286 void MApi_XC_EX_Write2ByteMask(MS_U32 u32Reg, MS_U16 u16val, MS_U16 u16Mask)
7287 {
7288 MDrv_Write2ByteMask(u32Reg, u16val, u16Mask);
7289 return;
7290 if (pu32XCInst == NULL)
7291 {
7292 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
7293 return;
7294 }
7295
7296 stXC_WRITE2BYTEMSK XCArgs;
7297 XCArgs.u32Reg = u32Reg;
7298 XCArgs.u16val = u16val;
7299 XCArgs.u16Mask = u16Mask;
7300
7301 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_WRITE2BYTEMSK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7302 {
7303 printf("Obtain XC engine fail\n");
7304 return;
7305 }
7306 else
7307 {
7308 return;
7309 }
7310 }
7311
MApi_XC_EX_W2BYTE(XC_DEVICE_ID * pDeviceId,MS_U32 u32Reg,MS_U16 u16Val)7312 void MApi_XC_EX_W2BYTE(XC_DEVICE_ID *pDeviceId, MS_U32 u32Reg, MS_U16 u16Val)
7313 {
7314 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7315 {
7316 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7317 return;
7318 }
7319
7320 stXC_W2BYTE XCArgs;
7321 XCArgs.u32Reg = u32Reg;
7322 XCArgs.u16Val = u16Val;
7323
7324 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_W2BYTE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7325 {
7326 printf("Obtain XC engine fail\n");
7327 return;
7328 }
7329 else
7330 {
7331 return;
7332 }
7333 }
7334
MApi_XC_EX_R2BYTE(XC_DEVICE_ID * pDeviceId,MS_U32 u32Reg)7335 MS_U16 MApi_XC_EX_R2BYTE(XC_DEVICE_ID *pDeviceId, MS_U32 u32Reg)
7336 {
7337 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7338 {
7339 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7340 return 0;
7341 }
7342
7343 stXC_R2BYTE XCArgs;
7344 XCArgs.u32Reg = u32Reg;
7345 XCArgs.u16ReturnValue = 0;
7346
7347 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_R2BYTE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7348 {
7349 printf("Obtain XC engine fail\n");
7350 return 0;
7351 }
7352 else
7353 {
7354 return XCArgs.u16ReturnValue;
7355 }
7356 }
7357
MApi_XC_EX_W4BYTE(XC_DEVICE_ID * pDeviceId,MS_U32 u32Reg,MS_U32 u32Val)7358 void MApi_XC_EX_W4BYTE(XC_DEVICE_ID *pDeviceId, MS_U32 u32Reg, MS_U32 u32Val)
7359 {
7360 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7361 {
7362 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7363 return;
7364 }
7365
7366 stXC_W4BYTE XCArgs;
7367 XCArgs.u32Reg = u32Reg;
7368 XCArgs.u32Val = u32Val;
7369
7370 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_W4BYTE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7371 {
7372 printf("Obtain XC engine fail\n");
7373 return;
7374 }
7375 else
7376 {
7377 return;
7378 }
7379 }
7380
MApi_XC_EX_R4BYTE(XC_DEVICE_ID * pDeviceId,MS_U32 u32Reg)7381 MS_U32 MApi_XC_EX_R4BYTE(XC_DEVICE_ID *pDeviceId, MS_U32 u32Reg)
7382 {
7383 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7384 {
7385 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7386 return 0;
7387 }
7388
7389 stXC_R4BYTE XCArgs;
7390 XCArgs.u32Reg = u32Reg;
7391 XCArgs.u32ReturnValue = 0;
7392
7393 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_R4BYTE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7394 {
7395 printf("Obtain XC engine fail\n");
7396 return 0;
7397 }
7398 else
7399 {
7400 return XCArgs.u32ReturnValue;
7401 }
7402 }
7403
MApi_XC_EX_R2BYTEMSK(XC_DEVICE_ID * pDeviceId,MS_U32 u32Reg,MS_U16 u16Mask)7404 MS_U16 MApi_XC_EX_R2BYTEMSK(XC_DEVICE_ID *pDeviceId, MS_U32 u32Reg, MS_U16 u16Mask)
7405 {
7406 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7407 {
7408 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7409 return 0;
7410 }
7411
7412 stXC_R2BYTEMSK XCArgs;
7413 XCArgs.u32Reg = u32Reg;
7414 XCArgs.u16mask = u16Mask;
7415 XCArgs.u16ReturnValue = 0;
7416
7417 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_R2BYTEMSK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7418 {
7419 printf("Obtain XC engine fail\n");
7420 return 0;
7421 }
7422 else
7423 {
7424 return XCArgs.u16ReturnValue;
7425 }
7426 }
7427
MApi_XC_EX_W2BYTEMSK(XC_DEVICE_ID * pDeviceId,MS_U32 u32Reg,MS_U16 u16Val,MS_U16 u16Mask)7428 void MApi_XC_EX_W2BYTEMSK(XC_DEVICE_ID *pDeviceId, MS_U32 u32Reg, MS_U16 u16Val, MS_U16 u16Mask)
7429 {
7430 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7431 {
7432 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7433 return;
7434 }
7435
7436 stXC_W2BYTEMSK XCArgs;
7437 XCArgs.u32Reg = u32Reg;
7438 XCArgs.u16Val = u16Val;
7439 XCArgs.u16mask = u16Mask;
7440
7441 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_W2BYTEMSK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7442 {
7443 printf("Obtain XC engine fail\n");
7444 return;
7445 }
7446 else
7447 {
7448 return;
7449 }
7450 }
7451
MApi_XC_EX_MLoad_Init(XC_DEVICE_ID * pDeviceId,MS_PHY PhyAddr,MS_U32 u32BufByteLen)7452 void MApi_XC_EX_MLoad_Init(XC_DEVICE_ID *pDeviceId, MS_PHY PhyAddr, MS_U32 u32BufByteLen)
7453 {
7454 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7455 {
7456 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7457 return;
7458 }
7459
7460 stXC_MLOAD_INIT XCArgs;
7461 XCArgs.PhyAddr = PhyAddr;
7462 XCArgs.u32BufByteLen = u32BufByteLen;
7463
7464 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLOAD_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7465 {
7466 printf("Obtain XC engine fail\n");
7467 return;
7468 }
7469 else
7470 {
7471 return;
7472 }
7473 }
7474
MApi_XC_EX_MLoad_Enable(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)7475 void MApi_XC_EX_MLoad_Enable(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
7476 {
7477 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7478 {
7479 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7480 return;
7481 }
7482
7483 stXC_MLOAD_ENABLE XCArgs;
7484 XCArgs.bEnable = bEnable;
7485
7486 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLOAD_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7487 {
7488 printf("Obtain XC engine fail\n");
7489 return;
7490 }
7491 else
7492 {
7493 return;
7494 }
7495 }
7496
MApi_XC_EX_MLoad_GetStatus(XC_DEVICE_ID * pDeviceId)7497 XC_EX_MLOAD_TYPE MApi_XC_EX_MLoad_GetStatus(XC_DEVICE_ID *pDeviceId)
7498 {
7499 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7500 {
7501 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7502 return E_MLOAD_UNSUPPORTED;
7503 }
7504
7505 stXC_MLOAD_GETSTATUS XCArgs;
7506 XCArgs.eReturnValue = E_MLOAD_UNSUPPORTED;
7507
7508 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLOAD_GETSTATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7509 {
7510 printf("Obtain XC engine fail\n");
7511 return E_MLOAD_UNSUPPORTED;
7512 }
7513 else
7514 {
7515 return XCArgs.eReturnValue;
7516 }
7517 }
7518
MApi_XC_EX_MLoad_WriteCmd_And_Fire(XC_DEVICE_ID * pDeviceId,MS_U32 u32Addr,MS_U16 u16Data,MS_U16 u16Mask)7519 MS_BOOL MApi_XC_EX_MLoad_WriteCmd_And_Fire(XC_DEVICE_ID *pDeviceId, MS_U32 u32Addr, MS_U16 u16Data, MS_U16 u16Mask)
7520 {
7521 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7522 {
7523 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7524 return FALSE;
7525 }
7526
7527 stXC_MLOAD_WRITE_CMD_AND_FIRE XCArgs;
7528 XCArgs.u32Addr = u32Addr;
7529 XCArgs.u16Data = u16Data;
7530 XCArgs.u16Mask = u16Mask;
7531 XCArgs.bReturnValue = FALSE;
7532
7533 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLOAD_WRITE_CMD_AND_FIRE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7534 {
7535 printf("Obtain XC engine fail\n");
7536 return FALSE;
7537 }
7538 else
7539 {
7540 return XCArgs.bReturnValue;
7541 }
7542 }
7543
MApi_XC_EX_MLoad_WriteCmds_And_Fire(XC_DEVICE_ID * pDeviceId,MS_U32 * pu32Addr,MS_U16 * pu16Data,MS_U16 * pu16Mask,MS_U16 u16CmdCnt)7544 MS_BOOL MApi_XC_EX_MLoad_WriteCmds_And_Fire(XC_DEVICE_ID *pDeviceId, MS_U32 *pu32Addr, MS_U16 *pu16Data, MS_U16 *pu16Mask, MS_U16 u16CmdCnt)
7545 {
7546 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7547 {
7548 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7549 return FALSE;
7550 }
7551
7552 stXC_MLOAD_WRITE_CMDS_AND_FIRE XCArgs;
7553 XCArgs.pu32Addr = pu32Addr;
7554 XCArgs.pu16Data = pu16Data;
7555 XCArgs.pu16Mask = pu16Mask;
7556 XCArgs.u16CmdCnt = u16CmdCnt;
7557 XCArgs.bReturnValue = FALSE;
7558
7559 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLOAD_WRITE_CMDS_AND_FIRE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7560 {
7561 printf("Obtain XC engine fail\n");
7562 return FALSE;
7563 }
7564 else
7565 {
7566 return XCArgs.bReturnValue;
7567 }
7568 }
7569
MApi_XC_EX_MLG_Init(XC_DEVICE_ID * pDeviceId,MS_PHY PhyAddr,MS_U32 u32BufByteLen)7570 void MApi_XC_EX_MLG_Init(XC_DEVICE_ID *pDeviceId, MS_PHY PhyAddr, MS_U32 u32BufByteLen)
7571 {
7572 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7573 {
7574 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7575 return;
7576 }
7577
7578 stXC_MLG_INIT XCArgs;
7579 XCArgs.PhyAddr = PhyAddr;
7580 XCArgs.u32BufByteLen = u32BufByteLen;
7581
7582 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLG_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7583 {
7584 printf("Obtain XC engine fail\n");
7585 return;
7586 }
7587 else
7588 {
7589 return;
7590 }
7591 }
7592
MApi_XC_EX_MLG_Enable(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)7593 void MApi_XC_EX_MLG_Enable(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
7594 {
7595 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7596 {
7597 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7598 return;
7599 }
7600
7601 stXC_MLG_ENABLE XCArgs;
7602 XCArgs.bEnable = bEnable;
7603
7604 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLG_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7605 {
7606 printf("Obtain XC engine fail\n");
7607 return;
7608 }
7609 else
7610 {
7611 return;
7612 }
7613 }
7614
MApi_XC_EX_MLG_GetCaps(XC_DEVICE_ID * pDeviceId)7615 MS_BOOL MApi_XC_EX_MLG_GetCaps(XC_DEVICE_ID *pDeviceId)
7616 {
7617 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7618 {
7619 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7620 return FALSE;
7621 }
7622
7623 stXC_MLG_GET_CAPS XCArgs;
7624 XCArgs.bReturnValue = FALSE;
7625
7626 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLG_GET_CAPS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7627 {
7628 printf("Obtain XC engine fail\n");
7629 return FALSE;
7630 }
7631 else
7632 {
7633 return XCArgs.bReturnValue;
7634 }
7635 }
7636
MApi_XC_EX_MLG_GetStatus(XC_DEVICE_ID * pDeviceId)7637 XC_EX_MLG_TYPE MApi_XC_EX_MLG_GetStatus(XC_DEVICE_ID *pDeviceId)
7638 {
7639 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7640 {
7641 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7642 return E_MLG_UNSUPPORTED;
7643 }
7644
7645 stXC_MLG_GETSTATUS XCArgs;
7646 XCArgs.eReturnValue = E_MLG_UNSUPPORTED;
7647
7648 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_MLG_GETSTATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7649 {
7650 printf("Obtain XC engine fail\n");
7651 return E_MLG_UNSUPPORTED;
7652 }
7653 else
7654 {
7655 return XCArgs.eReturnValue;
7656 }
7657 }
7658
MApi_XC_EX_SetOSD2VEMode(XC_DEVICE_ID * pDeviceId,XC_EX_VOP_SEL_OSD_XC2VE_MUX eVOPSelOSD_MUX)7659 void MApi_XC_EX_SetOSD2VEMode(XC_DEVICE_ID *pDeviceId, XC_EX_VOP_SEL_OSD_XC2VE_MUX eVOPSelOSD_MUX)
7660 {
7661 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7662 {
7663 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7664 return;
7665 }
7666
7667 stXC_SET_OSD2VEMODE XCArgs;
7668 XCArgs.eVOPSelOSD_MUX = eVOPSelOSD_MUX;
7669
7670 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OSD2VEMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7671 {
7672 printf("Obtain XC engine fail\n");
7673 return;
7674 }
7675 else
7676 {
7677 return;
7678 }
7679 }
7680
MApi_XC_EX_IP2_PreFilter_Enable(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)7681 void MApi_XC_EX_IP2_PreFilter_Enable(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
7682 {
7683 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7684 {
7685 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7686 return;
7687 }
7688
7689 stXC_SET_IP2_PREFILTER_ENABLE XCArgs;
7690 XCArgs.bEnable = bEnable;
7691
7692 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_IP2_PREFILTER_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7693 {
7694 printf("Obtain XC engine fail\n");
7695 return;
7696 }
7697 else
7698 {
7699 return;
7700 }
7701 }
7702
MApi_XC_EX_Get_Pixel_RGB(XC_DEVICE_ID * pDeviceId,XC_EX_Get_Pixel_RGB * pData,XC_EX_SCALER_WIN eWindow)7703 XC_EX_GET_PixelRGB_ReturnValue MApi_XC_EX_Get_Pixel_RGB(XC_DEVICE_ID *pDeviceId, XC_EX_Get_Pixel_RGB *pData, XC_EX_SCALER_WIN eWindow)
7704 {
7705 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7706 {
7707 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7708 return E_GET_PIXEL_RET_OUT_OF_RANGE;
7709 }
7710
7711 _XC_ST_CHECK_SIZE(XC_Get_Pixel_RGB, XC_EX_Get_Pixel_RGB);
7712 stXC_GET_PIXELRGB XCArgs;
7713 XCArgs.pData = (XC_Get_Pixel_RGB*)pData;
7714 XCArgs.eWindow = eWindow;
7715 XCArgs.eReturnValue = E_GET_PIXEL_RET_OUT_OF_RANGE;
7716
7717 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_PIXELRGB, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7718 {
7719 printf("Obtain XC engine fail\n");
7720 return E_GET_PIXEL_RET_OUT_OF_RANGE;
7721 }
7722 else
7723 {
7724 return XCArgs.eReturnValue;
7725 }
7726 }
7727
MApi_XC_EX_KeepPixelPointerAppear(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)7728 void MApi_XC_EX_KeepPixelPointerAppear(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
7729 {
7730 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7731 {
7732 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7733 return;
7734 }
7735
7736 stXC_SET_KEEP_PIXELPOINTER_APPEAR XCArgs;
7737 XCArgs.bEnable = bEnable;
7738
7739 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_KEEP_PIXELPOINTER_APPEAR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7740 {
7741 printf("Obtain XC engine fail\n");
7742 return;
7743 }
7744 else
7745 {
7746 return;
7747 }
7748 }
7749
MApi_XC_EX_Set_MemFmtEx(XC_DEVICE_ID * pDeviceId,XC_EX_MEM_FMT eMemFmt,XC_EX_SCALER_WIN eWindow)7750 MS_BOOL MApi_XC_EX_Set_MemFmtEx(XC_DEVICE_ID *pDeviceId, XC_EX_MEM_FMT eMemFmt, XC_EX_SCALER_WIN eWindow)
7751 {
7752 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7753 {
7754 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7755 return FALSE;
7756 }
7757
7758 stXC_SET_MEMORY_FORMAT_EX XCArgs;
7759 XCArgs.eMemFmt = eMemFmt;
7760 XCArgs.eWindow = eWindow;
7761 XCArgs.bReturnValue = FALSE;
7762
7763 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MEMORY_FORMAT_EX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7764 {
7765 printf("Obtain XC engine fail\n");
7766 return FALSE;
7767 }
7768 else
7769 {
7770 return XCArgs.bReturnValue;
7771 }
7772 }
7773
MApi_XC_EX_IsRequestFrameBufferLessMode(XC_DEVICE_ID * pDeviceId)7774 MS_BOOL MApi_XC_EX_IsRequestFrameBufferLessMode(XC_DEVICE_ID *pDeviceId)
7775 {
7776 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7777 {
7778 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7779 return FALSE;
7780 }
7781
7782 stXC_CHECK_REQUEST_FRAMEBUFFERLESS_MODE XCArgs;
7783 XCArgs.bReturnValue = FALSE;
7784
7785 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_CHECK_REQUEST_FRAMEBUFFERLESS_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7786 {
7787 printf("Obtain XC engine fail\n");
7788 return FALSE;
7789 }
7790 else
7791 {
7792 return XCArgs.bReturnValue;
7793 }
7794 }
7795
MApi_XC_EX_SkipSWReset(XC_DEVICE_ID * pDeviceId,MS_BOOL bFlag)7796 XC_EX_RETURN_VALUE MApi_XC_EX_SkipSWReset(XC_DEVICE_ID *pDeviceId, MS_BOOL bFlag)
7797 {
7798 XC_INSTANT_ATTRIBUTE stXCInstantAttribute;
7799 INIT_XC_INSTANT_ATTR(stXCInstantAttribute);
7800
7801 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7802 {
7803 if (pDeviceId->u32Id == 0)
7804 {
7805 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
7806 {
7807 printf("UtopiaOpen XC failed\n");
7808 return E_APIXC_RET_FAIL;
7809 }
7810 }
7811 else if (pDeviceId->u32Id == 1)
7812 {
7813 stXCInstantAttribute.u32DeviceID = 1;
7814 if(UtopiaOpen(MODULE_XC, &pu32XCInst_1, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
7815 {
7816 printf("UtopiaOpen XC failed\n");
7817 return E_APIXC_RET_FAIL;
7818 }
7819 }
7820
7821 }
7822
7823 stXC_SET_SKIP_SWRESET XCArgs;
7824 XCArgs.bFlag = bFlag;
7825 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
7826
7827 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SKIP_SWRESET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7828 {
7829 printf("Obtain XC engine fail\n");
7830 return E_APIXC_RET_FAIL;
7831 }
7832 else
7833 {
7834 return XCArgs.eReturnValue;
7835 }
7836 }
7837
MApi_XC_EX_EnableRepWindowForFrameColor(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)7838 void MApi_XC_EX_EnableRepWindowForFrameColor(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
7839 {
7840 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7841 {
7842 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7843 return;
7844 }
7845
7846 stXC_SET_REPORTWINDOW_FOR_FRAMECOLOR XCArgs;
7847 XCArgs.bEnable = bEnable;
7848
7849 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_REPORTWINDOW_FOR_FRAMECOLOR, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7850 {
7851 printf("Obtain XC engine fail\n");
7852 return;
7853 }
7854 else
7855 {
7856 return;
7857 }
7858 }
7859
MApi_XC_EX_SetOSDLayer(XC_DEVICE_ID * pDeviceId,XC_EX_VOP_OSD_LAYER_SEL eVOPOSDLayer,XC_EX_SCALER_WIN eWindow)7860 XC_EX_RETURN_VALUE MApi_XC_EX_SetOSDLayer(XC_DEVICE_ID *pDeviceId, XC_EX_VOP_OSD_LAYER_SEL eVOPOSDLayer, XC_EX_SCALER_WIN eWindow)
7861 {
7862 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7863 {
7864 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7865 return E_APIXC_RET_FAIL;
7866 }
7867
7868 stXC_SET_OSDLAYER XCArgs;
7869 XCArgs.eVOPOSDLayer = eVOPOSDLayer;
7870 XCArgs.eWindow = eWindow;
7871 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
7872
7873 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OSDLAYER, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7874 {
7875 printf("Obtain XC engine fail\n");
7876 return E_APIXC_RET_FAIL;
7877 }
7878 else
7879 {
7880 return XCArgs.eReturnValue;
7881 }
7882 }
7883
MApi_XC_EX_GetOSDLayer(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)7884 XC_EX_VOP_OSD_LAYER_SEL MApi_XC_EX_GetOSDLayer(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
7885 {
7886 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7887 {
7888 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7889 return E_VOP_LAYER_RESERVED;
7890 }
7891
7892 stXC_GET_OSDLAYER XCArgs;
7893 XCArgs.eWindow = eWindow;
7894 XCArgs.eReturnValue = E_VOP_LAYER_RESERVED;
7895
7896 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_OSDLAYER, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7897 {
7898 printf("Obtain XC engine fail\n");
7899 return E_VOP_LAYER_RESERVED;
7900 }
7901 else
7902 {
7903 return XCArgs.eReturnValue;
7904 }
7905 }
7906
MApi_XC_EX_SetVideoAlpha(XC_DEVICE_ID * pDeviceId,MS_U8 u8Val,XC_EX_SCALER_WIN eWindow)7907 XC_EX_RETURN_VALUE MApi_XC_EX_SetVideoAlpha(XC_DEVICE_ID *pDeviceId, MS_U8 u8Val, XC_EX_SCALER_WIN eWindow)
7908 {
7909 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7910 {
7911 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7912 return E_APIXC_RET_FAIL;
7913 }
7914
7915 stXC_SET_VIDEO_ALPHA XCArgs;
7916 XCArgs.u8Val = u8Val;
7917 XCArgs.eWindow = eWindow;
7918 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
7919
7920 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_VIDEO_ALPHA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7921 {
7922 printf("Obtain XC engine fail\n");
7923 return E_APIXC_RET_FAIL;
7924 }
7925 else
7926 {
7927 return XCArgs.eReturnValue;
7928 }
7929 }
7930
MApi_XC_EX_GetVideoAlpha(XC_DEVICE_ID * pDeviceId,MS_U8 * pu8Val,XC_EX_SCALER_WIN eWindow)7931 XC_EX_RETURN_VALUE MApi_XC_EX_GetVideoAlpha(XC_DEVICE_ID *pDeviceId, MS_U8 *pu8Val, XC_EX_SCALER_WIN eWindow)
7932 {
7933 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7934 {
7935 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7936 return E_APIXC_RET_FAIL;
7937 }
7938
7939 stXC_GET_VIDEO_ALPHA XCArgs;
7940 XCArgs.pu8Val = pu8Val;
7941 XCArgs.eWindow = eWindow;
7942 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
7943
7944 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_VIDEO_ALPHA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7945 {
7946 printf("Obtain XC engine fail\n");
7947 return E_APIXC_RET_FAIL;
7948 }
7949 else
7950 {
7951 return XCArgs.eReturnValue;
7952 }
7953 }
7954
MApi_XC_EX_SkipWaitVsync(XC_DEVICE_ID * pDeviceId,MS_BOOL eWindow,MS_BOOL bIsSkipWaitVsyn)7955 XC_EX_RETURN_VALUE MApi_XC_EX_SkipWaitVsync( XC_DEVICE_ID *pDeviceId, MS_BOOL eWindow, MS_BOOL bIsSkipWaitVsyn)
7956 {
7957 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7958 {
7959 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7960 return E_APIXC_RET_FAIL;
7961 }
7962
7963 stXC_SKIP_WAIT_VSYNC XCArgs;
7964 XCArgs.eWindow = eWindow;
7965 XCArgs.bIsSkipWaitVsyn = bIsSkipWaitVsyn;
7966 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
7967
7968 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SKIP_WAIT_VSYNC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7969 {
7970 printf("Obtain XC engine fail\n");
7971 return E_APIXC_RET_FAIL;
7972 }
7973 else
7974 {
7975 return XCArgs.eReturnValue;
7976 }
7977 }
7978
MApi_XC_EX_OP2VOPDESel(XC_DEVICE_ID * pDeviceId,XC_EX_OP2VOP_DE_SEL eVopDESel)7979 XC_EX_RETURN_VALUE MApi_XC_EX_OP2VOPDESel(XC_DEVICE_ID *pDeviceId, XC_EX_OP2VOP_DE_SEL eVopDESel)
7980 {
7981 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
7982 {
7983 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
7984 return E_APIXC_RET_FAIL;
7985 }
7986
7987 stXC_SET_OP2VOP_DE_SELECTION XCArgs;
7988 XCArgs.eVopDESel = eVopDESel;
7989 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
7990
7991 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OP2VOP_DE_SELECTION, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
7992 {
7993 printf("Obtain XC engine fail\n");
7994 return E_APIXC_RET_FAIL;
7995 }
7996 else
7997 {
7998 return XCArgs.eReturnValue;
7999 }
8000 }
8001
MApi_XC_EX_FRC_SetWindow(XC_DEVICE_ID * pDeviceId,XC_EX_3D_INPUT_MODE e3dInputMode,XC_EX_3D_OUTPUT_MODE e3dOutputMode,XC_EX_3D_PANEL_TYPE e3dPanelType)8002 void MApi_XC_EX_FRC_SetWindow(XC_DEVICE_ID *pDeviceId, XC_EX_3D_INPUT_MODE e3dInputMode, XC_EX_3D_OUTPUT_MODE e3dOutputMode, XC_EX_3D_PANEL_TYPE e3dPanelType)
8003 {
8004 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8005 {
8006 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8007 return;
8008 }
8009
8010 stXC_SET_FRC_WINDOW XCArgs;
8011 XCArgs.e3dInputMode = e3dInputMode;
8012 XCArgs.e3dOutputMode = e3dOutputMode;
8013 XCArgs.e3dPanelType = e3dPanelType;
8014
8015 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRC_WINDOW, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8016 {
8017 printf("Obtain XC engine fail\n");
8018 return;
8019 }
8020 else
8021 {
8022 return;
8023 }
8024 }
8025
MApi_XC_EX_Enable_TwoInitFactor(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)8026 MS_BOOL MApi_XC_EX_Enable_TwoInitFactor(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
8027 {
8028 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8029 {
8030 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8031 return FALSE;
8032 }
8033
8034 stXC_SET_2INITFACTOR_ENABLE XCArgs;
8035 XCArgs.bEnable = bEnable;
8036 XCArgs.eWindow = eWindow;
8037 XCArgs.bReturnValue = FALSE;
8038
8039 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_2INITFACTOR_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8040 {
8041 printf("Obtain XC engine fail\n");
8042 return FALSE;
8043 }
8044 else
8045 {
8046 return XCArgs.bReturnValue;
8047 }
8048
8049 }
8050
MApi_XC_EX_IsFieldPackingModeSupported(void)8051 MS_BOOL MApi_XC_EX_IsFieldPackingModeSupported(void)
8052 {
8053 if (pu32XCInst == NULL)
8054 {
8055 printf("[%s,%5d] ID %ld, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,0L);
8056 return FALSE;
8057 }
8058
8059 stXC_CHECK_FIELDPACKINGMODE_SUPPORTED XCArgs;
8060 XCArgs.bReturnValue = FALSE;
8061
8062 if(UtopiaIoctl(pu32XCInst, E_XC_CMD_CHECK_FIELDPACKINGMODE_SUPPORTED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8063 {
8064 printf("Obtain XC engine fail\n");
8065 return FALSE;
8066 }
8067 else
8068 {
8069 return XCArgs.bReturnValue;
8070 }
8071 }
8072
MApi_XC_EX_PreInit(XC_DEVICE_ID * pDeviceId,XC_EX_PREINIT eType,void * para,MS_U32 u32Length)8073 XC_EX_RETURN_VALUE MApi_XC_EX_PreInit( XC_DEVICE_ID *pDeviceId, XC_EX_PREINIT eType ,void* para, MS_U32 u32Length)
8074 {
8075 XC_INSTANT_ATTRIBUTE stXCInstantAttribute;
8076 INIT_XC_INSTANT_ATTR(stXCInstantAttribute);
8077
8078 if (pDeviceId->u32Id == 0 && pu32XCInst == NULL)
8079 {
8080 if(UtopiaOpen(MODULE_XC, &pu32XCInst, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
8081 {
8082 printf("UtopiaOpen XC failed\n");
8083 return E_APIXC_RET_FAIL;
8084 }
8085 }
8086 else if (pDeviceId->u32Id == 1 && pu32XCInst_1 == NULL)
8087 {
8088 stXCInstantAttribute.u32DeviceID = 1;
8089 if(UtopiaOpen(MODULE_XC, &pu32XCInst_1, 0, &stXCInstantAttribute) != UTOPIA_STATUS_SUCCESS)
8090 {
8091 printf("UtopiaOpen XC failed\n");
8092 return E_APIXC_RET_FAIL;
8093 }
8094 }
8095 else if(pDeviceId->u32Id > 1)
8096 {
8097 printf("Device Id over 2\n");
8098 return E_APIXC_RET_FAIL;
8099 }
8100
8101 stXC_PREINIT XCArgs;
8102 XCArgs.eType = eType;
8103 XCArgs.para = para;
8104 XCArgs.u32Length = u32Length;
8105 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
8106
8107 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_PREINIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8108 {
8109 printf("Obtain XC engine fail\n");
8110 return E_APIXC_RET_FAIL;
8111 }
8112 else
8113 {
8114 return XCArgs.eReturnValue;
8115 }
8116 }
8117
MApi_XC_EX_Get_BufferData(XC_DEVICE_ID * pDeviceId,XC_EX_OUTPUTDATA_TYPE eBufType,XC_EX_WINDOW_TYPE * pRect,void * pRectBuf,XC_EX_SCALER_WIN eWindow)8118 void MApi_XC_EX_Get_BufferData(XC_DEVICE_ID *pDeviceId, XC_EX_OUTPUTDATA_TYPE eBufType, XC_EX_WINDOW_TYPE *pRect, void *pRectBuf, XC_EX_SCALER_WIN eWindow)
8119 {
8120 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8121 {
8122 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8123 return;
8124 }
8125
8126 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE, XC_EX_WINDOW_TYPE);
8127 stXC_GET_BUFFERDATA XCArgs;
8128 XCArgs.eBufType = eBufType;
8129 XCArgs.pRect = (MS_WINDOW_TYPE*)pRect;
8130 XCArgs.pRectBuf = pRectBuf;
8131 XCArgs.eWindow = eWindow;
8132
8133 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_BUFFERDATA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8134 {
8135 printf("Obtain XC engine fail\n");
8136 return;
8137 }
8138 else
8139 {
8140 return;
8141 }
8142 }
8143
MApi_XC_EX_Set_BufferData(XC_DEVICE_ID * pDeviceId,XC_EX_INPUTDATA_TYPE eBufType,XC_EX_WINDOW_TYPE * pDstRect,void * pSrcBuf,XC_EX_WINDOW_TYPE * pSrcRect,XC_EX_SCALER_WIN eWindow)8144 void MApi_XC_EX_Set_BufferData(XC_DEVICE_ID *pDeviceId, XC_EX_INPUTDATA_TYPE eBufType, XC_EX_WINDOW_TYPE *pDstRect, void *pSrcBuf, XC_EX_WINDOW_TYPE *pSrcRect, XC_EX_SCALER_WIN eWindow)
8145 {
8146 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8147 {
8148 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8149 return;
8150 }
8151
8152 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE, XC_EX_WINDOW_TYPE);
8153 stXC_SET_BUFFERDATA XCArgs;
8154 XCArgs.eBufType = eBufType;
8155 XCArgs.pDstRect = (MS_WINDOW_TYPE*)pDstRect;
8156 XCArgs.pSrcBuf = pSrcBuf;
8157 XCArgs.pSrcRect = (MS_WINDOW_TYPE*)pSrcRect;
8158 XCArgs.eWindow = eWindow;
8159
8160 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BUFFERDATA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8161 {
8162 printf("Obtain XC engine fail\n");
8163 return;
8164 }
8165 else
8166 {
8167 return;
8168 }
8169 }
8170
MApi_XC_EX_EnableMainWindow(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)8171 void MApi_XC_EX_EnableMainWindow(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
8172 {
8173 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8174 {
8175 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8176 return;
8177 }
8178
8179 stXC_SET_MAINWINDOW_ENABLE XCArgs;
8180 XCArgs.bEnable = bEnable;
8181
8182 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MAINWINDOW_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8183 {
8184 printf("Obtain XC engine fail\n");
8185 return;
8186 }
8187 else
8188 {
8189 return;
8190 }
8191 } // Turn on/off main/sub window
8192
MApi_XC_EX_EnableSubWindow(XC_DEVICE_ID * pDeviceId,XC_EX_WINDOW_TYPE * pstDispWin)8193 void MApi_XC_EX_EnableSubWindow(XC_DEVICE_ID *pDeviceId, XC_EX_WINDOW_TYPE *pstDispWin)
8194 {
8195 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8196 {
8197 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8198 return;
8199 }
8200
8201 _XC_ST_CHECK_SIZE(MS_WINDOW_TYPE, XC_EX_WINDOW_TYPE);
8202 stXC_SET_SUBWINDOW_ENABLE XCArgs;
8203 XCArgs.pstDispWin = (MS_WINDOW_TYPE*)pstDispWin;
8204
8205 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SUBWINDOW_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8206 {
8207 printf("Obtain XC engine fail\n");
8208 return;
8209 }
8210 else
8211 {
8212 return;
8213 }
8214 }
8215
MApi_XC_EX_DisableSubWindow(XC_DEVICE_ID * pDeviceId)8216 void MApi_XC_EX_DisableSubWindow(XC_DEVICE_ID *pDeviceId)
8217 {
8218 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8219 {
8220 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8221 return;
8222 }
8223
8224 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SUBWINDOW_DISABLE, NULL) != UTOPIA_STATUS_SUCCESS)
8225 {
8226 printf("Obtain XC engine fail\n");
8227 return;
8228 }
8229 else
8230 {
8231 return;
8232 }
8233 }
8234
MApi_XC_EX_SetPixelShift(XC_DEVICE_ID * pDeviceId,MS_S8 s8H,MS_S8 s8V)8235 XC_EX_RETURN_VALUE MApi_XC_EX_SetPixelShift(XC_DEVICE_ID *pDeviceId, MS_S8 s8H, MS_S8 s8V)
8236 {
8237 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8238 {
8239 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8240 return E_APIXC_RET_FAIL;
8241 }
8242
8243 stXC_SET_PIXEL_SHIFT XCArgs;
8244 XCArgs.s8H = s8H;
8245 XCArgs.s8V = s8V;
8246 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
8247
8248 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_PIXEL_SHIFT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8249 {
8250 printf("Obtain XC engine fail\n");
8251 return E_APIXC_RET_FAIL;
8252 }
8253 else
8254 {
8255 return XCArgs.eReturnValue;
8256 }
8257 }
8258
MApi_XC_EX_SetVideoOnOSD(XC_DEVICE_ID * pDeviceId,XC_EX_VIDEO_ON_OSD_LAYER enlayer,XC_EX_SCALER_WIN eWindow)8259 XC_EX_RETURN_VALUE MApi_XC_EX_SetVideoOnOSD(XC_DEVICE_ID *pDeviceId, XC_EX_VIDEO_ON_OSD_LAYER enlayer, XC_EX_SCALER_WIN eWindow)
8260 {
8261 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8262 {
8263 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8264 return E_APIXC_RET_FAIL;
8265 }
8266
8267 stXC_SET_VIDEO_ON_OSD XCArgs;
8268 XCArgs.enlayer = enlayer;
8269 XCArgs.eWindow = eWindow;
8270 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
8271
8272 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_VIDEO_ON_OSD, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8273 {
8274 printf("Obtain XC engine fail\n");
8275 return E_APIXC_RET_FAIL;
8276 }
8277 else
8278 {
8279 return XCArgs.eReturnValue;
8280 }
8281 }
8282
MApi_XC_EX_SetOSDBlendingFormula(XC_DEVICE_ID * pDeviceId,E_XC_EX_OSD_INDEX enOsdIndex,XC_EX_OSD_BlENDING_TYPE enType,XC_EX_SCALER_WIN eWindow)8283 XC_EX_RETURN_VALUE MApi_XC_EX_SetOSDBlendingFormula(XC_DEVICE_ID *pDeviceId, E_XC_EX_OSD_INDEX enOsdIndex, XC_EX_OSD_BlENDING_TYPE enType, XC_EX_SCALER_WIN eWindow)
8284 {
8285 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8286 {
8287 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8288 return E_APIXC_RET_FAIL;
8289 }
8290
8291 stXC_SET_OSD_BLENDING_FORMULA XCArgs;
8292 XCArgs.enOsdIndex = enOsdIndex;
8293 XCArgs.enType = enType;
8294 XCArgs.eWindow = eWindow;
8295 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
8296
8297 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_OSD_BLENDING_FORMULA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8298 {
8299 printf("Obtain XC engine fail\n");
8300 return E_APIXC_RET_FAIL;
8301 }
8302 else
8303 {
8304 return XCArgs.eReturnValue;
8305 }
8306 }
8307
MApi_XC_EX_ReportPixelInfo(XC_DEVICE_ID * pDeviceId,XC_EX_REPORT_PIXELINFO * pstRepPixInfo)8308 MS_BOOL MApi_XC_EX_ReportPixelInfo(XC_DEVICE_ID *pDeviceId, XC_EX_REPORT_PIXELINFO *pstRepPixInfo)
8309 {
8310 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8311 {
8312 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8313 return FALSE;
8314 }
8315
8316 _XC_ST_CHECK_SIZE(MS_XC_REPORT_PIXELINFO, XC_EX_REPORT_PIXELINFO);
8317 stXC_GET_REPORT_PIXEL_INFO XCArgs;
8318 XCArgs.pstRepPixInfo = (MS_XC_REPORT_PIXELINFO*)pstRepPixInfo;
8319 XCArgs.bReturnValue = FALSE;
8320
8321 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_REPORT_PIXEL_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8322 {
8323 printf("Obtain XC engine fail\n");
8324 return E_APIXC_RET_FAIL;
8325 }
8326 else
8327 {
8328 return XCArgs.bReturnValue;
8329 }
8330 }
8331
MApi_XC_EX_SetScaling(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALING_TYPE eScaling_type,XC_EX_VECTOR_TYPE eVector_type,XC_EX_SCALER_WIN eWindow)8332 void MApi_XC_EX_SetScaling( XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALING_TYPE eScaling_type, XC_EX_VECTOR_TYPE eVector_type, XC_EX_SCALER_WIN eWindow )
8333 {
8334 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8335 {
8336 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8337 return;
8338 }
8339
8340 stXC_SET_SCALING XCArgs;
8341 XCArgs.bEnable = bEnable;
8342 XCArgs.eScaling_type = eScaling_type;
8343 XCArgs.eVector_type = eVector_type;
8344 XCArgs.eWindow = eWindow;
8345
8346 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SCALING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8347 {
8348 printf("Obtain XC engine fail\n");
8349 return;
8350 }
8351 else
8352 {
8353 return;
8354 }
8355 }
8356
MApi_XC_EX_SetMCDIBufferAddress(XC_DEVICE_ID * pDeviceId,MS_PHY u32FBAddress,MS_PHY u32FBSize,XC_EX_MCDI_TYPE eType)8357 void MApi_XC_EX_SetMCDIBufferAddress(XC_DEVICE_ID *pDeviceId, MS_PHY u32FBAddress, MS_PHY u32FBSize, XC_EX_MCDI_TYPE eType)
8358 {
8359 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8360 {
8361 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8362 return;
8363 }
8364
8365 stXC_SET_MCDI_BUFFERADDRESS XCArgs;
8366 XCArgs.u32FBAddress = u32FBAddress;
8367 XCArgs.u32FBSize = u32FBSize;
8368 XCArgs.eType = eType;
8369
8370 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MCDI_BUFFERADDRESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8371 {
8372 printf("Obtain XC engine fail\n");
8373 return;
8374 }
8375 else
8376 {
8377 return;
8378 }
8379 }
8380
MApi_XC_EX_EnableMCDI(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_MCDI_TYPE eType)8381 void MApi_XC_EX_EnableMCDI(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_MCDI_TYPE eType)
8382 {
8383 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8384 {
8385 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8386 return;
8387 }
8388
8389 stXC_SET_MCDI_ENABLE XCArgs;
8390 XCArgs.bEnable = bEnable;
8391 XCArgs.eType = eType;
8392
8393 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_MCDI_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8394 {
8395 printf("Obtain XC engine fail\n");
8396 return;
8397 }
8398 else
8399 {
8400 return;
8401 }
8402 }
8403
MApi_XC_EX_SendCmdToFRC(XC_DEVICE_ID * pDeviceId,MS_U8 u8Cmd,MS_U8 count,XC_EX_FRC_R2_CMD_PARAMETER pFRC_R2_Para)8404 MS_BOOL MApi_XC_EX_SendCmdToFRC( XC_DEVICE_ID *pDeviceId, MS_U8 u8Cmd, MS_U8 count, XC_EX_FRC_R2_CMD_PARAMETER pFRC_R2_Para )
8405 {
8406 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8407 {
8408 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8409 return FALSE;
8410 }
8411
8412 _XC_ST_CHECK_SIZE(FRC_R2_CMD_PARAMETER_t, XC_EX_FRC_R2_CMD_PARAMETER);
8413 stXC_SEND_CMD2FRC XCArgs;
8414 XCArgs.u8Cmd = u8Cmd;
8415 XCArgs.count = count;
8416 XCArgs.pFRC_R2_Para = *((FRC_R2_CMD_PARAMETER_t*)(&pFRC_R2_Para));
8417 XCArgs.bReturnValue = FALSE;
8418
8419 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SEND_CMD2FRC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8420 {
8421 printf("Obtain XC engine fail\n");
8422 return FALSE;
8423 }
8424 else
8425 {
8426 return XCArgs.bReturnValue;
8427 }
8428 }
8429
MApi_XC_EX_GetMsgFromFRC(XC_DEVICE_ID * pDeviceId,MS_U8 * pu8Cmd,MS_U8 * pu8ParaCount,MS_U8 * pu8Para)8430 MS_BOOL MApi_XC_EX_GetMsgFromFRC(XC_DEVICE_ID *pDeviceId, MS_U8* pu8Cmd, MS_U8* pu8ParaCount, MS_U8* pu8Para)
8431 {
8432 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8433 {
8434 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8435 return FALSE;
8436 }
8437
8438 stXC_GET_MSG_FROM_FRC XCArgs;
8439 XCArgs.pu8Cmd = pu8Cmd;
8440 XCArgs.pu8ParaCount = pu8ParaCount;
8441 XCArgs.pu8Para = pu8Para;
8442 XCArgs.bReturnValue = FALSE;
8443
8444 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_MSG_FROM_FRC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8445 {
8446 printf("Obtain XC engine fail\n");
8447 return FALSE;
8448 }
8449 else
8450 {
8451 return XCArgs.bReturnValue;
8452 }
8453 }
8454
MApi_XC_EX_EnableRWBankAuto(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)8455 void MApi_XC_EX_EnableRWBankAuto(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
8456 {
8457 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8458 {
8459 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8460 return;
8461 }
8462
8463 stXC_SET_AUTO_RWBANK_ENABLE XCArgs;
8464 XCArgs.bEnable = bEnable;
8465 XCArgs.eWindow = eWindow;
8466
8467 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_AUTO_RWBANK_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8468 {
8469 printf("Obtain XC engine fail\n");
8470 return;
8471 }
8472 else
8473 {
8474 return;
8475 }
8476 }
8477
MApi_XC_EX_SetWRBankMappingNum(XC_DEVICE_ID * pDeviceId,MS_U8 u8Val,XC_EX_SCALER_WIN eWindow)8478 void MApi_XC_EX_SetWRBankMappingNum(XC_DEVICE_ID *pDeviceId, MS_U8 u8Val, XC_EX_SCALER_WIN eWindow)
8479 {
8480 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8481 {
8482 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8483 return;
8484 }
8485
8486 stXC_SET_RWBANK_MAPPING_NUM XCArgs;
8487 XCArgs.u8Val = u8Val;
8488 XCArgs.eWindow = eWindow;
8489
8490 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_RWBANK_MAPPING_NUM, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8491 {
8492 printf("Obtain XC engine fail\n");
8493 return;
8494 }
8495 else
8496 {
8497 return;
8498 }
8499 }
8500
MApi_XC_EX_GetWRBankMappingNum(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)8501 MS_U8 MApi_XC_EX_GetWRBankMappingNum(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
8502 {
8503 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8504 {
8505 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8506 return 0;
8507 }
8508
8509 stXC_GET_RWBANK_MAPPING_NUM XCArgs;
8510 XCArgs.eWindow = eWindow;
8511 XCArgs.u8ReturnValue = 0;
8512
8513 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_RWBANK_MAPPING_NUM, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8514 {
8515 printf("Obtain XC engine fail\n");
8516 return 0;
8517 }
8518 else
8519 {
8520 return XCArgs.u8ReturnValue;
8521 }
8522 }
8523
MApi_XC_EX_GetWRBankMappingNumForZap(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)8524 MS_U8 MApi_XC_EX_GetWRBankMappingNumForZap(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
8525 {
8526 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8527 {
8528 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8529 return FALSE;
8530 }
8531
8532 stXC_GET_RWBANK_MAPPING_NUM_FOR_ZAP XCArgs;
8533 XCArgs.eWindow = eWindow;
8534 XCArgs.u8ReturnValue = 0;
8535
8536 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_RWBANK_MAPPING_NUM_FOR_ZAP, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8537 {
8538 printf("Obtain XC engine fail\n");
8539 return 0;
8540 }
8541 else
8542 {
8543 return XCArgs.u8ReturnValue;
8544 }
8545 }
8546
MApi_XC_EX_SetBOBMode(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)8547 MS_BOOL MApi_XC_EX_SetBOBMode(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
8548 {
8549 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8550 {
8551 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8552 return FALSE;
8553 }
8554
8555 stXC_SET_BOBMODE XCArgs;
8556 XCArgs.bEnable = bEnable;
8557 XCArgs.eWindow = eWindow;
8558 XCArgs.bReturnValue = FALSE;
8559
8560 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BOBMODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8561 {
8562 printf("Obtain XC engine fail\n");
8563 return FALSE;
8564 }
8565 else
8566 {
8567 return XCArgs.bReturnValue;
8568 }
8569 }
8570
MApi_XC_EX_SetForceReadBank(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,MS_U8 u8Bank,XC_EX_SCALER_WIN eWindow)8571 void MApi_XC_EX_SetForceReadBank(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, MS_U8 u8Bank, XC_EX_SCALER_WIN eWindow)
8572 {
8573 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8574 {
8575 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8576 return;
8577 }
8578
8579 stXC_SET_FORCE_READBANK XCArgs;
8580 XCArgs.bEnable = bEnable;
8581 XCArgs.u8Bank = u8Bank;
8582 XCArgs.eWindow = eWindow;
8583
8584 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FORCE_READBANK, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8585 {
8586 printf("Obtain XC engine fail\n");
8587 return;
8588 }
8589 else
8590 {
8591 return;
8592 }
8593 }
8594
MApi_XC_EX_LD_Init(XC_DEVICE_ID * pDeviceId,XC_EX_LD_PANEL_TYPE eLDPanelType)8595 MS_BOOL MApi_XC_EX_LD_Init(XC_DEVICE_ID *pDeviceId, XC_EX_LD_PANEL_TYPE eLDPanelType )
8596 {
8597 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8598 {
8599 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8600 return FALSE;
8601 }
8602
8603 stXC_LD_INIT XCArgs;
8604 XCArgs.enLDPanelType = eLDPanelType;
8605 XCArgs.bReturnValue = FALSE;
8606
8607 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_LD_INIT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8608 {
8609 printf("Obtain XC engine fail\n");
8610 return FALSE;
8611 }
8612 else
8613 {
8614 return XCArgs.bReturnValue;
8615 }
8616 }
8617
MApi_XC_EX_LD_SetMemoryAddress(XC_DEVICE_ID * pDeviceId,MS_U8 u8MIU,MS_U32 u32LDFBase0,MS_U32 u32LDFBase1,MS_U32 u32LDBBase0,MS_U32 u32LDBBase1,MS_U32 u32EDGE2DBase,MS_U32 u32LEDoffset)8618 MS_BOOL MApi_XC_EX_LD_SetMemoryAddress(XC_DEVICE_ID *pDeviceId, MS_U8 u8MIU ,MS_U32 u32LDFBase0,MS_U32 u32LDFBase1,MS_U32 u32LDBBase0,MS_U32 u32LDBBase1,MS_U32 u32EDGE2DBase,MS_U32 u32LEDoffset)
8619 {
8620 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8621 {
8622 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8623 return FALSE;
8624 }
8625
8626 stXC_SET_LD_MEMORYADDRESS XCArgs;
8627 XCArgs.u8MIU = u8MIU;
8628 XCArgs.u32LDFBase0 = u32LDFBase0;
8629 XCArgs.u32LDFBase1 = u32LDFBase1;
8630 XCArgs.u32LDBBase0 = u32LDBBase0;
8631 XCArgs.u32LDBBase1 = u32LDBBase1;
8632 XCArgs.u32EDGE2DBase = u32EDGE2DBase;
8633 XCArgs.u32LEDOffset = u32LEDoffset;
8634 XCArgs.bReturnValue = FALSE;
8635
8636 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_LD_MEMORYADDRESS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8637 {
8638 printf("Obtain XC engine fail\n");
8639 return FALSE;
8640 }
8641 else
8642 {
8643 return XCArgs.bReturnValue;
8644 }
8645 }
8646
MApi_XC_EX_LD_SetLevel(XC_DEVICE_ID * pDeviceId,XC_EX_LD_MODE eMode)8647 MS_BOOL MApi_XC_EX_LD_SetLevel(XC_DEVICE_ID *pDeviceId, XC_EX_LD_MODE eMode)
8648 {
8649 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8650 {
8651 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8652 return FALSE;
8653 }
8654
8655 stXC_SET_LD_LEVEL XCArgs;
8656 XCArgs.enMode = eMode;
8657 XCArgs.bReturnValue = FALSE;
8658
8659 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_LD_LEVEL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8660 {
8661 printf("Obtain XC engine fail\n");
8662 return FALSE;
8663 }
8664 else
8665 {
8666 return XCArgs.bReturnValue;
8667 }
8668 }
8669
MApi_XC_EX_Set_TurnoffLDBL(XC_DEVICE_ID * pDeviceId,MS_BOOL bturnoffbl)8670 MS_BOOL MApi_XC_EX_Set_TurnoffLDBL(XC_DEVICE_ID *pDeviceId, MS_BOOL bturnoffbl)
8671 {
8672 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8673 {
8674 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8675 return FALSE;
8676 }
8677
8678 stXC_SET_LD_TURNOFF_LDBL XCArgs;
8679 XCArgs.bTurnoffBL = bturnoffbl;
8680 XCArgs.bReturnValue = FALSE;
8681
8682 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_LD_TURNOFF_LDBL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8683 {
8684 printf("Obtain XC engine fail\n");
8685 return FALSE;
8686 }
8687 else
8688 {
8689 return XCArgs.bReturnValue;
8690 }
8691 }
8692
MApi_XC_EX_Set_notUpdateSPIDataFlags(XC_DEVICE_ID * pDeviceId,MS_BOOL brefreshSpidata)8693 MS_BOOL MApi_XC_EX_Set_notUpdateSPIDataFlags(XC_DEVICE_ID *pDeviceId, MS_BOOL brefreshSpidata)
8694 {
8695 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8696 {
8697 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8698 return FALSE;
8699 }
8700
8701 stXC_SET_NOTUPDATE_SPI_DATA_FLAGS XCArgs;
8702 XCArgs.bRefreshSPIData = brefreshSpidata;
8703 XCArgs.bReturnValue = FALSE;
8704
8705 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_NOTUPDATE_SPI_DATA_FLAGS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8706 {
8707 printf("Obtain XC engine fail\n");
8708 return FALSE;
8709 }
8710 else
8711 {
8712 return XCArgs.bReturnValue;
8713 }
8714 }
8715
MApi_XC_EX_Set_UsermodeLDFlags(XC_DEVICE_ID * pDeviceId,MS_BOOL buserLDFlags)8716 MS_BOOL MApi_XC_EX_Set_UsermodeLDFlags(XC_DEVICE_ID *pDeviceId, MS_BOOL buserLDFlags)
8717 {
8718 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8719 {
8720 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8721 return FALSE;
8722 }
8723
8724 stXC_SET_LD_USERMODEFLAGS XCArgs;
8725 XCArgs.bUserLDFlags = buserLDFlags;
8726 XCArgs.bReturnValue = FALSE;
8727
8728 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_LD_USERMODEFLAGS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8729 {
8730 printf("Obtain XC engine fail\n");
8731 return FALSE;
8732 }
8733 else
8734 {
8735 return XCArgs.bReturnValue;
8736 }
8737 }
8738
MApi_XC_EX_Set_BLLevel(XC_DEVICE_ID * pDeviceId,MS_U8 u8BLLevel)8739 MS_BOOL MApi_XC_EX_Set_BLLevel(XC_DEVICE_ID *pDeviceId, MS_U8 u8BLLevel)
8740 {
8741 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8742 {
8743 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8744 return FALSE;
8745 }
8746
8747 stXC_SET_BL_LEVEL XCArgs;
8748 XCArgs.u8BLLevel = u8BLLevel;
8749 XCArgs.bReturnValue = FALSE;
8750
8751 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BL_LEVEL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8752 {
8753 printf("Obtain XC engine fail\n");
8754 return FALSE;
8755 }
8756 else
8757 {
8758 return XCArgs.bReturnValue;
8759 }
8760 }
8761
MApi_XC_EX_Set_BWS_Mode(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)8762 void MApi_XC_EX_Set_BWS_Mode(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow)
8763 {
8764 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8765 {
8766 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8767 return;
8768 }
8769
8770 stXC_SET_BWS_MODE XCArgs;
8771 XCArgs.bEnable = bEnable;
8772 XCArgs.eWindow = eWindow;
8773
8774 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BWS_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8775 {
8776 printf("Obtain XC engine fail\n");
8777 return;
8778 }
8779 else
8780 {
8781 return;
8782 }
8783 }
8784
MApi_XC_EX_FRC_ColorPathCtrl(XC_DEVICE_ID * pDeviceId,MS_U16 u16Path_sel,MS_BOOL bEnable)8785 void MApi_XC_EX_FRC_ColorPathCtrl(XC_DEVICE_ID *pDeviceId, MS_U16 u16Path_sel, MS_BOOL bEnable)
8786 {
8787 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8788 {
8789 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8790 return;
8791 }
8792
8793 stXC_SET_FRC_COLOR_PATH_CONTROL XCArgs;
8794 XCArgs.u16Path_sel = u16Path_sel;
8795 XCArgs.bEnable = bEnable;
8796
8797 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRC_COLOR_PATH_CONTROL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8798 {
8799 printf("Obtain XC engine fail\n");
8800 return;
8801 }
8802 else
8803 {
8804 return;
8805 }
8806 }
8807
MApi_XC_EX_FRC_OP2_SetRGBGain(XC_DEVICE_ID * pDeviceId,MS_U16 u16RedGain,MS_U16 u16GreenGain,MS_U16 u16BlueGain)8808 void MApi_XC_EX_FRC_OP2_SetRGBGain(XC_DEVICE_ID *pDeviceId, MS_U16 u16RedGain, MS_U16 u16GreenGain, MS_U16 u16BlueGain)
8809 {
8810 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8811 {
8812 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8813 return;
8814 }
8815
8816 stXC_SET_FRC_OP2_RGBGAIN XCArgs;
8817 XCArgs.u16RedGain = u16RedGain;
8818 XCArgs.u16GreenGain = u16GreenGain;
8819 XCArgs.u16BlueGain = u16BlueGain;
8820
8821 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRC_OP2_RGBGAIN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8822 {
8823 printf("Obtain XC engine fail\n");
8824 return;
8825 }
8826 else
8827 {
8828 return;
8829 }
8830 }
8831
MApi_XC_EX_FRC_OP2_SetRGBOffset(XC_DEVICE_ID * pDeviceId,MS_U16 u16RedOffset,MS_U16 u16GreenOffset,MS_U16 u16BlueOffset)8832 void MApi_XC_EX_FRC_OP2_SetRGBOffset(XC_DEVICE_ID *pDeviceId, MS_U16 u16RedOffset, MS_U16 u16GreenOffset, MS_U16 u16BlueOffset)
8833 {
8834 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8835 {
8836 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8837 return;
8838 }
8839
8840 stXC_SET_FRC_OP2_RGBOFFSET XCArgs;
8841 XCArgs.u16RedOffset = u16RedOffset;
8842 XCArgs.u16GreenOffset = u16GreenOffset;
8843 XCArgs.u16BlueOffset = u16BlueOffset;
8844
8845 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRC_OP2_RGBOFFSET, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8846 {
8847 printf("Obtain XC engine fail\n");
8848 return;
8849 }
8850 else
8851 {
8852 return;
8853 }
8854 }
8855
MApi_XC_EX_FRC_OP2_SetDither(XC_DEVICE_ID * pDeviceId,MS_U16 u16dither)8856 void MApi_XC_EX_FRC_OP2_SetDither(XC_DEVICE_ID *pDeviceId, MS_U16 u16dither)
8857 {
8858 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8859 {
8860 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8861 return;
8862 }
8863
8864 stXC_SET_FRC_OP2_DITHER XCArgs;
8865 XCArgs.u16dither = u16dither;
8866
8867 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FRC_OP2_DITHER, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8868 {
8869 printf("Obtain XC engine fail\n");
8870 return;
8871 }
8872 else
8873 {
8874 return;
8875 }
8876 }
8877
MApi_XC_EX_FRC_BypassMFC(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)8878 MS_BOOL MApi_XC_EX_FRC_BypassMFC(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
8879 {
8880 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8881 {
8882 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8883 return FALSE;
8884 }
8885
8886 stXC_FRC_BYPASS XCArgs;
8887 XCArgs.bEnable = bEnable;
8888 XCArgs.bReturnValue = FALSE;
8889
8890 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_FRC_BYPASS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8891 {
8892 printf("Obtain XC engine fail\n");
8893 return FALSE;
8894 }
8895 else
8896 {
8897 return XCArgs.bReturnValue;
8898 }
8899 }
8900
MApi_XC_EX_ForceReadFrame(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,MS_U16 u16FrameIndex)8901 XC_EX_RETURN_VALUE MApi_XC_EX_ForceReadFrame(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, MS_U16 u16FrameIndex)
8902 {
8903 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8904 {
8905 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8906 return E_APIXC_RET_FAIL;
8907 }
8908
8909 stXC_SET_FORCE_READ_FRAME XCArgs;
8910 XCArgs.bEnable = bEnable;
8911 XCArgs.u16FrameIndex = u16FrameIndex;
8912 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
8913
8914 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_FORCE_READ_FRAME, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8915 {
8916 printf("Obtain XC engine fail\n");
8917 return E_APIXC_RET_FAIL;
8918 }
8919 else
8920 {
8921 return XCArgs.eReturnValue;
8922 }
8923 }
8924
MApi_XC_EX_SetCsc(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_SCALER_WIN eWindow)8925 void MApi_XC_EX_SetCsc( XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_SCALER_WIN eWindow )
8926 {
8927 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8928 {
8929 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8930 return;
8931 }
8932
8933 stXC_SET_CSC XCArgs;
8934 XCArgs.bEnable = bEnable;
8935 XCArgs.eWindow = eWindow;
8936
8937 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_CSC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8938 {
8939 printf("Obtain XC engine fail\n");
8940 return;
8941 }
8942 else
8943 {
8944 return;
8945 }
8946
8947 }
8948
MApi_XC_EX_RegisterPQSetFPLLThreshMode(XC_DEVICE_ID * pDeviceId,void (* fpPQCB)(MS_U8 u8PQWin))8949 void MApi_XC_EX_RegisterPQSetFPLLThreshMode(XC_DEVICE_ID *pDeviceId, void (*fpPQCB)(MS_U8 u8PQWin))
8950 {
8951 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8952 {
8953 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8954 return;
8955 }
8956
8957 stXC_SET_REGISTER_PQ_FPLL_THRESH_MODE XCArgs;
8958 XCArgs.fpPQCB = fpPQCB;
8959
8960 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_REGISTER_PQ_FPLL_THRESH_MODE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8961 {
8962 printf("Obtain XC engine fail\n");
8963 return;
8964 }
8965 else
8966 {
8967 return;
8968 }
8969 }
8970
MApi_XC_EX_GetFreeRunStatus(XC_DEVICE_ID * pDeviceId)8971 MS_BOOL MApi_XC_EX_GetFreeRunStatus(XC_DEVICE_ID *pDeviceId)
8972 {
8973 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8974 {
8975 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8976 return FALSE;
8977 }
8978
8979 stXC_GET_FREERUN_STATUS XCArgs;
8980 XCArgs.bReturnValue = FALSE;
8981
8982 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_FREERUN_STATUS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
8983 {
8984 printf("Obtain XC engine fail\n");
8985 return FALSE;
8986 }
8987 else
8988 {
8989 return XCArgs.bReturnValue;
8990 }
8991 }
8992
MApi_XC_EX_Get_DSForceIndexSupported(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow)8993 XC_EX_RETURN_VALUE MApi_XC_EX_Get_DSForceIndexSupported(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow)
8994 {
8995 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
8996 {
8997 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
8998 return E_APIXC_RET_FAIL;
8999 }
9000
9001 stXC_GET_DS_FORCE_INDEX_SUPPORTED XCArgs;
9002 XCArgs.eWindow = eWindow;
9003 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9004
9005 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_GET_DS_FORCE_INDEX_SUPPORTED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9006 {
9007 printf("Obtain XC engine fail\n");
9008 return E_APIXC_RET_FAIL;
9009 }
9010 else
9011 {
9012 return XCArgs.eReturnValue;
9013 }
9014 }
9015
MApi_XC_EX_Set_DSForceIndex(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,MS_U8 u8Index,XC_EX_SCALER_WIN eWindow)9016 XC_EX_RETURN_VALUE MApi_XC_EX_Set_DSForceIndex(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, MS_U8 u8Index, XC_EX_SCALER_WIN eWindow)
9017 {
9018 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9019 {
9020 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9021 return E_APIXC_RET_FAIL;
9022 }
9023
9024 stXC_SET_DS_FORCE_INDEX XCArgs;
9025 XCArgs.bEnable = bEnable;
9026 XCArgs.u8Index = u8Index;
9027 XCArgs.eWindow = eWindow;
9028 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9029
9030 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_DS_FORCE_INDEX, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9031 {
9032 printf("Obtain XC engine fail\n");
9033 return E_APIXC_RET_FAIL;
9034 }
9035 else
9036 {
9037 return XCArgs.eReturnValue;
9038 }
9039 }
9040
MApi_XC_EX_Set_DSIndexSourceSelect(XC_DEVICE_ID * pDeviceId,XC_EX_DS_INDEX_SOURCE eDSIdxSrc,XC_EX_SCALER_WIN eWindow)9041 XC_EX_RETURN_VALUE MApi_XC_EX_Set_DSIndexSourceSelect(XC_DEVICE_ID *pDeviceId, XC_EX_DS_INDEX_SOURCE eDSIdxSrc, XC_EX_SCALER_WIN eWindow)
9042 {
9043 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9044 {
9045 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9046 return E_APIXC_RET_FAIL;
9047 }
9048
9049 stXC_SET_DS_INDEX_SOURCE_SELECT XCArgs;
9050 XCArgs.eDSIdxSrc = eDSIdxSrc;
9051 XCArgs.eWindow = eWindow;
9052 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9053
9054 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_DS_INDEX_SOURCE_SELECT, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9055 {
9056 printf("Obtain XC engine fail\n");
9057 return E_APIXC_RET_FAIL;
9058 }
9059 else
9060 {
9061 return XCArgs.eReturnValue;
9062 }
9063 }
9064
MApi_XC_EX_OSDC_InitSetting(XC_DEVICE_ID * pDeviceId,XC_EX_OSDC_TGEN_Type E_XC_OSDC_TGEN_Type,XC_EX_OSDC_TGEN_INFO * pstOC_Tgen_Cus,XC_EX_OSDC_CTRL_INFO * pstOC_Ctrl)9065 XC_EX_RETURN_VALUE MApi_XC_EX_OSDC_InitSetting(XC_DEVICE_ID *pDeviceId,
9066 XC_EX_OSDC_TGEN_Type E_XC_OSDC_TGEN_Type,
9067 XC_EX_OSDC_TGEN_INFO *pstOC_Tgen_Cus,
9068 XC_EX_OSDC_CTRL_INFO *pstOC_Ctrl)
9069 {
9070 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9071 {
9072 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9073 return E_APIXC_RET_FAIL;
9074 }
9075
9076 _XC_ST_CHECK_SIZE(MS_XC_OSDC_TGEN_INFO, XC_EX_OSDC_TGEN_INFO);
9077 _XC_ST_CHECK_SIZE(MS_XC_OSDC_CTRL_INFO, XC_EX_OSDC_CTRL_INFO);
9078 stXC_OSDC_INITSETTING XCArgs;
9079 XCArgs.e_osdctgen_type = E_XC_OSDC_TGEN_Type;
9080 XCArgs.pstOC_Tgen_Cus = (MS_XC_OSDC_TGEN_INFO*)pstOC_Tgen_Cus;
9081 XCArgs.pstOC_Ctrl = (MS_XC_OSDC_CTRL_INFO*)pstOC_Ctrl;
9082 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9083
9084 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_OSDC_INITSETTING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9085 {
9086 printf("Obtain XC engine fail\n");
9087 return E_APIXC_RET_FAIL;
9088 }
9089 else
9090 {
9091 return XCArgs.eReturnValue;
9092 }
9093 }
9094
MApi_XC_EX_OSDC_Control(XC_DEVICE_ID * pDeviceId,MS_U32 eCtrl_type)9095 XC_EX_RETURN_VALUE MApi_XC_EX_OSDC_Control(XC_DEVICE_ID *pDeviceId, MS_U32 eCtrl_type)
9096 {
9097 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9098 {
9099 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9100 return E_APIXC_RET_FAIL;
9101 }
9102
9103 stXC_OSDC_CONTROL XCArgs;
9104 XCArgs.eCtrl_type = eCtrl_type;
9105 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9106
9107 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_OSDC_CONTROL, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9108 {
9109 printf("Obtain XC engine fail\n");
9110 return E_APIXC_RET_FAIL;
9111 }
9112 else
9113 {
9114 return XCArgs.eReturnValue;
9115 }
9116 }
9117
MApi_XC_EX_OSDC_GetDstInfo(XC_DEVICE_ID * pDeviceId,XC_EX_OSDC_DST_DispInfo * pDstInfo,MS_U32 u32SizeofDstInfo)9118 XC_EX_RETURN_VALUE MApi_XC_EX_OSDC_GetDstInfo(XC_DEVICE_ID *pDeviceId, XC_EX_OSDC_DST_DispInfo *pDstInfo, MS_U32 u32SizeofDstInfo)
9119 {
9120 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9121 {
9122 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9123 return E_APIXC_RET_FAIL;
9124 }
9125
9126 _XC_ST_CHECK_SIZE(MS_OSDC_DST_DispInfo,XC_EX_OSDC_DST_DispInfo);
9127 stXC_OSDC_GET_DESTINATION_INFO XCArgs;
9128 XCArgs.pDstInfo = (MS_OSDC_DST_DispInfo*)pDstInfo;
9129 XCArgs.u32SizeofDstInfo = u32SizeofDstInfo;
9130 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9131
9132 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_OSDC_GET_DESTINATION_INFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9133 {
9134 printf("Obtain XC engine fail\n");
9135 return E_APIXC_RET_FAIL;
9136 }
9137 else
9138 {
9139 return XCArgs.eReturnValue;
9140 }
9141 }
9142
MApi_XC_EX_OSDC_SetOutVfreqx10(XC_DEVICE_ID * pDeviceId,MS_U16 u16Vfreq)9143 void MApi_XC_EX_OSDC_SetOutVfreqx10(XC_DEVICE_ID *pDeviceId, MS_U16 u16Vfreq)
9144 {
9145 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9146 {
9147 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9148 return;
9149 }
9150
9151 stXC_OSDC_SET_OUTPUTVFREQX10 XCArgs;
9152 XCArgs.u16Vfreq = u16Vfreq;
9153
9154 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_OSDC_SET_OUTPUTVFREQX10, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9155 {
9156 printf("Obtain XC engine fail\n");
9157 return;
9158 }
9159 else
9160 {
9161 return;
9162 }
9163 }
9164
MApi_XC_EX_BYPASS_SetOSDVsyncPos(XC_DEVICE_ID * pDeviceId,MS_U16 u16VsyncStart,MS_U16 u16VsyncEnd)9165 void MApi_XC_EX_BYPASS_SetOSDVsyncPos(XC_DEVICE_ID *pDeviceId, MS_U16 u16VsyncStart, MS_U16 u16VsyncEnd)
9166 {
9167 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9168 {
9169 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9170 return;
9171 }
9172
9173 stXC_SET_BYPASS_OSDVSYNC_POS XCArgs;
9174 XCArgs.u16VsyncStart = u16VsyncStart;
9175 XCArgs.u16VsyncEnd = u16VsyncEnd;
9176
9177 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BYPASS_OSDVSYNC_POS, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9178 {
9179 printf("Obtain XC engine fail\n");
9180 return;
9181 }
9182 else
9183 {
9184 return;
9185 }
9186 }
9187
MApi_XC_EX_BYPASS_SetInputSrc(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,XC_EX_BYPASS_InputSource input)9188 void MApi_XC_EX_BYPASS_SetInputSrc(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, XC_EX_BYPASS_InputSource input)
9189 {
9190 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9191 {
9192 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9193 return;
9194 }
9195
9196 stXC_SET_BYPASS_INPUTSRC XCArgs;
9197 XCArgs.bEnable = bEnable;
9198 XCArgs.input = input;
9199
9200 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BYPASS_INPUTSRC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9201 {
9202 printf("Obtain XC engine fail\n");
9203 return;
9204 }
9205 else
9206 {
9207 return;
9208 }
9209 }
9210
MApi_XC_EX_BYPASS_SetCSC(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable)9211 void MApi_XC_EX_BYPASS_SetCSC(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable)
9212 {
9213 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9214 {
9215 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9216 return;
9217 }
9218
9219 stXC_SET_BYPASS_CSC XCArgs;
9220 XCArgs.bEnable = bEnable;
9221
9222 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_BYPASS_CSC, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9223 {
9224 printf("Obtain XC engine fail\n");
9225 return;
9226 }
9227 else
9228 {
9229 return;
9230 }
9231 }
9232
MApi_XC_EX_SetSeamlessZapping(XC_DEVICE_ID * pDeviceId,XC_EX_SCALER_WIN eWindow,MS_BOOL bEnable)9233 XC_EX_RETURN_VALUE MApi_XC_EX_SetSeamlessZapping(XC_DEVICE_ID *pDeviceId, XC_EX_SCALER_WIN eWindow, MS_BOOL bEnable)
9234 {
9235 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9236 {
9237 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9238 return E_APIXC_RET_FAIL;
9239 }
9240
9241 stXC_SET_SEAMLESS_ZAPPING XCArgs;
9242 XCArgs.eWindow = eWindow;
9243 XCArgs.bEnable = bEnable;
9244 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9245
9246 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_SEAMLESS_ZAPPING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9247 {
9248 printf("Obtain XC engine fail\n");
9249 return E_APIXC_RET_FAIL;
9250 }
9251 else
9252 {
9253 return XCArgs.eReturnValue;
9254 }
9255 }
9256
MApi_XC_EX_Vtrack_SetPayloadData(XC_DEVICE_ID * pDeviceId,MS_U16 u16Timecode,MS_U8 u8OperatorID)9257 XC_EX_RETURN_VALUE MApi_XC_EX_Vtrack_SetPayloadData(XC_DEVICE_ID *pDeviceId, MS_U16 u16Timecode, MS_U8 u8OperatorID)
9258 {
9259 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9260 {
9261 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9262 return E_APIXC_RET_FAIL;
9263 }
9264
9265 stXC_SET_VTRACK_PAYLOADDATA XCArgs;
9266 XCArgs.u16Timecode = u16Timecode;
9267 XCArgs.u8OperatorID = u8OperatorID;
9268 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9269
9270 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_VTRACK_PAYLOADDATA, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9271 {
9272 printf("Obtain XC engine fail\n");
9273 return E_APIXC_RET_FAIL;
9274 }
9275 else
9276 {
9277 return XCArgs.eReturnValue;
9278 }
9279 }
9280
MApi_XC_EX_Vtrack_SetUserDefindedSetting(XC_DEVICE_ID * pDeviceId,MS_BOOL bUserDefinded,MS_U8 * pu8Setting)9281 XC_EX_RETURN_VALUE MApi_XC_EX_Vtrack_SetUserDefindedSetting(XC_DEVICE_ID *pDeviceId, MS_BOOL bUserDefinded, MS_U8 *pu8Setting)
9282 {
9283 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9284 {
9285 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9286 return E_APIXC_RET_FAIL;
9287 }
9288
9289 stXC_SET_VTRACK_USERDEFINED_SETTING XCArgs;
9290 XCArgs.bUserDefinded = bUserDefinded;
9291 XCArgs.pu8Setting = pu8Setting;
9292 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9293
9294 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_VTRACK_USERDEFINED_SETTING, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9295 {
9296 printf("Obtain XC engine fail\n");
9297 return E_APIXC_RET_FAIL;
9298 }
9299 else
9300 {
9301 return XCArgs.eReturnValue;
9302 }
9303 }
9304
MApi_XC_EX_Vtrack_Enable(XC_DEVICE_ID * pDeviceId,MS_U8 u8FrameRate,MS_BOOL bEnable)9305 XC_EX_RETURN_VALUE MApi_XC_EX_Vtrack_Enable(XC_DEVICE_ID *pDeviceId, MS_U8 u8FrameRate, MS_BOOL bEnable)
9306 {
9307 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9308 {
9309 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9310 return E_APIXC_RET_FAIL;
9311 }
9312
9313 stXC_SET_VTRACK_ENABLE XCArgs;
9314 XCArgs.u8FrameRate = u8FrameRate;
9315 XCArgs.bEnable = bEnable;
9316 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9317
9318 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_SET_VTRACK_ENABLE, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9319 {
9320 printf("Obtain XC engine fail\n");
9321 return E_APIXC_RET_FAIL;
9322 }
9323 else
9324 {
9325 return XCArgs.eReturnValue;
9326 }
9327 }
9328
MApi_XC_EX_PreSetPQInfo(XC_DEVICE_ID * pDeviceId,XC_EX_SETWIN_INFO * pstXC_SetWin_Info,XC_EX_SCALER_WIN eWindow)9329 void MApi_XC_EX_PreSetPQInfo(XC_DEVICE_ID *pDeviceId, XC_EX_SETWIN_INFO *pstXC_SetWin_Info, XC_EX_SCALER_WIN eWindow)
9330 {
9331 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9332 {
9333 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9334 return;
9335 }
9336
9337 _XC_ST_CHECK_SIZE(XC_SETWIN_INFO,XC_EX_SETWIN_INFO);
9338 stXC_PRESET_PQINFO XCArgs;
9339 XCArgs.pstXC_SetWin_Info = (XC_SETWIN_INFO*)pstXC_SetWin_Info;
9340 XCArgs.eWindow = eWindow;
9341
9342 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_CMD_PRESET_PQINFO, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9343 {
9344 printf("Obtain XC engine fail\n");
9345 return;
9346 }
9347 else
9348 {
9349 return;
9350 }
9351 }
9352
MApi_XC_EX_Is_OP1_TestPattern_Enabled(XC_DEVICE_ID * pDeviceId)9353 MS_BOOL MApi_XC_EX_Is_OP1_TestPattern_Enabled(XC_DEVICE_ID *pDeviceId)
9354 {
9355 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9356 {
9357 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9358 return FALSE;
9359 }
9360
9361 stXC_GET_OP1_TESTPATTERN_ENABLED XCArgs;
9362 XCArgs.bReturnValue = FALSE;
9363
9364 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_GET_OP1_TESTPATTERN_ENABLED, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9365 {
9366 printf("Obtain XC engine fail\n");
9367 return FALSE;
9368 }
9369 else
9370 {
9371 return XCArgs.bReturnValue;
9372 }
9373 }
9374
MApi_XC_EX_Set_OP1_TestPattern(XC_DEVICE_ID * pDeviceId,XC_EX_OP1_PATTERN ePattern,XC_EX_OP1_PATGEN_MODE eMode)9375 XC_EX_RETURN_VALUE MApi_XC_EX_Set_OP1_TestPattern(XC_DEVICE_ID *pDeviceId, XC_EX_OP1_PATTERN ePattern, XC_EX_OP1_PATGEN_MODE eMode)
9376 {
9377 if (_XC_SELECT_INSTANCE(pDeviceId->u32Id) == NULL)
9378 {
9379 printf("[%s,%5d] ID %td, No instance existed, please get an instance by calling MApi_XC_Init() first\n",__FUNCTION__,__LINE__,(ptrdiff_t)pDeviceId->u32Id);
9380 return E_APIXC_RET_FAIL;
9381 }
9382
9383 stXC_SET_OP1_TESTPATTERN XCArgs;
9384 XCArgs.ePattern = ePattern;
9385 XCArgs.eMode = eMode;
9386 XCArgs.eReturnValue = E_APIXC_RET_FAIL;
9387
9388 if(UtopiaIoctl(_XC_SELECT_INSTANCE(pDeviceId->u32Id), E_XC_SET_OP1_TESTPATTERN, (void*)&XCArgs) != UTOPIA_STATUS_SUCCESS)
9389 {
9390 printf("Obtain XC engine fail\n");
9391 return E_APIXC_RET_FAIL;
9392 }
9393 else
9394 {
9395 return XCArgs.eReturnValue;
9396 }
9397 }
9398
9399 #include "apiXC_DWIN.h"
9400 #include "apiXC_DWIN_EX.h"
9401 //XC_DWIN
MApi_XC_DIP_EX_InitByDIP(XC_DIP_EX_WIN eWindow)9402 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_InitByDIP(XC_DIP_EX_WIN eWindow)
9403 {
9404 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_InitByDIP((SCALER_DIP_WIN)eWindow);
9405 }
MApi_XC_DIP_EX_SetFrameBufferAddress(MS_PHY u32FBAddress,MS_PHY u32FBSize,XC_DIP_EX_WIN eWindow)9406 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetFrameBufferAddress(MS_PHY u32FBAddress, MS_PHY u32FBSize, XC_DIP_EX_WIN eWindow)
9407 {
9408 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetFrameBufferAddress(u32FBAddress, u32FBSize, (SCALER_DIP_WIN)eWindow);
9409 }
MApi_XC_DIP_EX_SetInputSource(XC_EX_INPUT_SOURCE_TYPE enInputSourceType,XC_DIP_EX_WIN eWindow)9410 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetInputSource(XC_EX_INPUT_SOURCE_TYPE enInputSourceType, XC_DIP_EX_WIN eWindow)
9411 {
9412 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetInputSource((INPUT_SOURCE_TYPE_t)enInputSourceType, (SCALER_DIP_WIN)eWindow);
9413 }
MApi_XC_DIP_EX_GetInputSource(XC_EX_INPUT_SOURCE_TYPE * enInputSourceType,XC_DIP_EX_WIN eWindow)9414 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_GetInputSource(XC_EX_INPUT_SOURCE_TYPE *enInputSourceType, XC_DIP_EX_WIN eWindow)
9415 {
9416 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_GetInputSource((INPUT_SOURCE_TYPE_t *)enInputSourceType, (SCALER_DIP_WIN)eWindow);
9417 }
MApi_XC_DIP_EX_DisableInputSource(MS_BOOL bDisable,XC_DIP_EX_WIN eWindow)9418 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_DisableInputSource(MS_BOOL bDisable, XC_DIP_EX_WIN eWindow)
9419 {
9420 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_DisableInputSource(bDisable, (SCALER_DIP_WIN)eWindow);
9421 }
MApi_XC_DIP_EX_SetWindow(XC_EX_SETWIN_INFO * pstXC_SetWin_Info,MS_U32 u32InitDataLen,XC_DIP_EX_WIN eWindow)9422 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetWindow(XC_EX_SETWIN_INFO *pstXC_SetWin_Info, MS_U32 u32InitDataLen, XC_DIP_EX_WIN eWindow)
9423 {
9424 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetWindow((XC_SETWIN_INFO*)pstXC_SetWin_Info, u32InitDataLen, (SCALER_DIP_WIN)eWindow);
9425 }
MApi_XC_DIP_EX_GetDEWindow(XC_EX_WINDOW_TYPE * psWin,XC_DIP_EX_WIN eWindow)9426 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_GetDEWindow(XC_EX_WINDOW_TYPE *psWin, XC_DIP_EX_WIN eWindow)
9427 {
9428 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_GetDEWindow((MS_WINDOW_TYPE*)psWin, (SCALER_DIP_WIN)eWindow);
9429 }
MApi_XC_DIP_EX_SetCaptureWindowVstart(MS_U16 u16Vstart,XC_DIP_EX_WIN eWindow)9430 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetCaptureWindowVstart(MS_U16 u16Vstart, XC_DIP_EX_WIN eWindow)
9431 {
9432 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetCaptureWindowVstart(u16Vstart, (SCALER_DIP_WIN)eWindow);
9433 }
MApi_XC_DIP_EX_SetCaptureWindowHstart(MS_U16 u16Hstart,XC_DIP_EX_WIN eWindow)9434 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetCaptureWindowHstart(MS_U16 u16Hstart, XC_DIP_EX_WIN eWindow)
9435 {
9436 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetCaptureWindowHstart(u16Hstart, (SCALER_DIP_WIN)eWindow);
9437 }
MApi_XC_DIP_EX_SetCaptureWindowVsize(MS_U16 u16Vsize,XC_DIP_EX_WIN eWindow)9438 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetCaptureWindowVsize(MS_U16 u16Vsize, XC_DIP_EX_WIN eWindow)
9439 {
9440 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetCaptureWindowVsize(u16Vsize, (SCALER_DIP_WIN)eWindow);
9441 }
MApi_XC_DIP_EX_SetCaptureWindowHsize(MS_U16 u16Hsize,XC_DIP_EX_WIN eWindow)9442 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetCaptureWindowHsize(MS_U16 u16Hsize, XC_DIP_EX_WIN eWindow)
9443 {
9444 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetCaptureWindowHsize(u16Hsize, (SCALER_DIP_WIN)eWindow);
9445 }
MApi_XC_DIP_EX_GetCaptureWindow(XC_EX_WINDOW_TYPE * capture_win,XC_DIP_EX_WIN eWindow)9446 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_GetCaptureWindow(XC_EX_WINDOW_TYPE* capture_win, XC_DIP_EX_WIN eWindow)
9447 {
9448 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_GetCaptureWindow((MS_WINDOW_TYPE*)capture_win, (SCALER_DIP_WIN)eWindow);
9449 }
MApi_XC_DIP_EX_EnableR2Y(MS_BOOL benable,XC_DIP_EX_WIN eWindow)9450 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_EnableR2Y(MS_BOOL benable, XC_DIP_EX_WIN eWindow)
9451 {
9452 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_EnableR2Y(benable, (SCALER_DIP_WIN)eWindow);
9453 }
9454
9455 //==============Set===================
MApi_XC_DIP_EX_SWReset(XC_DIP_EX_WIN eWindow)9456 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SWReset(XC_DIP_EX_WIN eWindow)
9457 {
9458 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SWReset((SCALER_DIP_WIN)eWindow);
9459 }
MApi_XC_DIP_EX_FrameRateCtrl(MS_BOOL bEnable,MS_U16 u16In,MS_U16 u16Out,XC_DIP_EX_WIN eWindow)9460 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_FrameRateCtrl(MS_BOOL bEnable,MS_U16 u16In,MS_U16 u16Out, XC_DIP_EX_WIN eWindow)
9461 {
9462 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_FrameRateCtrl(bEnable, u16In, u16Out, (SCALER_DIP_WIN)eWindow);
9463 }
MApi_XC_DIP_EX_CapOneFrame(XC_DIP_EX_WIN eWindow)9464 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_CapOneFrame(XC_DIP_EX_WIN eWindow)
9465 {
9466 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_CapOneFrame((SCALER_DIP_WIN)eWindow);
9467 }
MApi_XC_DIP_EX_CapOneFrameFast(XC_DIP_EX_WIN eWindow)9468 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_CapOneFrameFast(XC_DIP_EX_WIN eWindow)
9469 {
9470 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_CapOneFrameFast((SCALER_DIP_WIN)eWindow);
9471 }
MApi_XC_DIP_EX_SetPinpon(MS_BOOL bPinpon,MS_PHY u32PinponAddr,XC_DIP_EX_WIN eWindow)9472 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetPinpon(MS_BOOL bPinpon,MS_PHY u32PinponAddr,XC_DIP_EX_WIN eWindow)
9473 {
9474 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetPinpon(bPinpon, u32PinponAddr, (SCALER_DIP_WIN)eWindow);
9475 }
MApi_XC_DIP_EX_ClearInt(MS_U16 u8mask,XC_DIP_EX_WIN eWindow)9476 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_ClearInt(MS_U16 u8mask, XC_DIP_EX_WIN eWindow)
9477 {
9478 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_ClearInt(u8mask, (SCALER_DIP_WIN)eWindow);
9479 }
MApi_XC_DIP_EX_Ena(MS_BOOL bEnable,XC_DIP_EX_WIN eWindow)9480 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_Ena(MS_BOOL bEnable, XC_DIP_EX_WIN eWindow)
9481 {
9482 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_Ena(bEnable, (SCALER_DIP_WIN)eWindow);
9483 }
MApi_XC_DIP_EX_EnaInt(MS_U16 u8mask,MS_BOOL bEnable,XC_DIP_EX_WIN eWindow)9484 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_EnaInt(MS_U16 u8mask, MS_BOOL bEnable, XC_DIP_EX_WIN eWindow)
9485 {
9486 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_EnaInt(u8mask, bEnable, (SCALER_DIP_WIN)eWindow);
9487 }
MApi_XC_DIP_EX_SetSourceScanType(XC_DIP_EX_SCAN_MODE enScanMode,XC_DIP_EX_WIN eWindow)9488 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetSourceScanType(XC_DIP_EX_SCAN_MODE enScanMode, XC_DIP_EX_WIN eWindow)
9489 {
9490 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetSourceScanType((EN_XC_DIP_SCAN_MODE)enScanMode, (SCALER_DIP_WIN)eWindow);
9491 }
MApi_XC_DIP_EX_EnaInterlaceWrite(MS_BOOL bEnable,XC_DIP_EX_WIN eWindow)9492 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_EnaInterlaceWrite(MS_BOOL bEnable, XC_DIP_EX_WIN eWindow)
9493 {
9494 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_EnaInterlaceWrite(bEnable, (SCALER_DIP_WIN)eWindow);
9495 }
MApi_XC_DIP_EX_SetOutputDataFmt(XC_DIP_EX_DATA_FMT fmt,XC_DIP_EX_WIN eWindow)9496 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetOutputDataFmt(XC_DIP_EX_DATA_FMT fmt, XC_DIP_EX_WIN eWindow)
9497 {
9498 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetOutputDataFmt((EN_XC_DIP_DATA_FMT)fmt, (SCALER_DIP_WIN)eWindow);
9499 }
MApi_XC_DIP_EX_SetDIPWinProperty(XC_DIP_EX_WINPROPERTY * pstDIPWinProperty,XC_DIP_EX_WIN eWindow)9500 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetDIPWinProperty(XC_DIP_EX_WINPROPERTY *pstDIPWinProperty, XC_DIP_EX_WIN eWindow)
9501 {
9502 ST_XC_DIP_WINPROPERTY local_pstDIPWinProperty;
9503 local_pstDIPWinProperty.u8BufCnt = pstDIPWinProperty->u8BufCnt;
9504 local_pstDIPWinProperty.u16Width = pstDIPWinProperty->u16Width;
9505 local_pstDIPWinProperty.u16Height = pstDIPWinProperty->u16Height;
9506 local_pstDIPWinProperty.u16Pitch = pstDIPWinProperty->u16Pitch;
9507 local_pstDIPWinProperty.u32BufStart = pstDIPWinProperty->u32BufStart;
9508 local_pstDIPWinProperty.u32BufEnd = pstDIPWinProperty->u32BufEnd;
9509 local_pstDIPWinProperty.enSource = pstDIPWinProperty->enSource;
9510 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetDIPWinProperty(&local_pstDIPWinProperty, (SCALER_DIP_WIN)eWindow);
9511 }
MApi_XC_DIP_EX_EnableY2R(MS_BOOL bEnable,XC_DIP_EX_WIN eWindow)9512 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_EnableY2R(MS_BOOL bEnable, XC_DIP_EX_WIN eWindow)
9513 {
9514 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_EnableY2R(bEnable, (SCALER_DIP_WIN)eWindow);
9515 }
MApi_XC_DIP_EX_SetAlpha(MS_U8 u8AlphaVal,XC_DIP_EX_WIN eWindow)9516 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetAlpha(MS_U8 u8AlphaVal, XC_DIP_EX_WIN eWindow)
9517 {
9518 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetAlpha(u8AlphaVal, (SCALER_DIP_WIN)eWindow);
9519 }
MApi_XC_DIP_EX_SwapUV(MS_BOOL bEnable,XC_DIP_EX_WIN eWindow)9520 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SwapUV(MS_BOOL bEnable, XC_DIP_EX_WIN eWindow)
9521 {
9522 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SwapUV(bEnable, (SCALER_DIP_WIN)eWindow);
9523 }
MApi_XC_DIP_EX_SwapYC(MS_BOOL bEnable,XC_DIP_EX_WIN eWindow)9524 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SwapYC(MS_BOOL bEnable, XC_DIP_EX_WIN eWindow)
9525 {
9526 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SwapYC(bEnable, (SCALER_DIP_WIN)eWindow);
9527 }
MApi_XC_DIP_EX_SwapRGB(MS_BOOL bEnable,XC_DIP_EX_RGB_SWAP_TYPE enSwapType,XC_DIP_EX_WIN eWindow)9528 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SwapRGB(MS_BOOL bEnable, XC_DIP_EX_RGB_SWAP_TYPE enSwapType, XC_DIP_EX_WIN eWindow)
9529 {
9530 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SwapRGB(bEnable, (EN_XC_DIP_RGB_SWAP_TYPE)enSwapType, (SCALER_DIP_WIN)eWindow);
9531 }
MApi_XC_DIP_EX_SetWinProperty_Ex(MS_U8 u8BufCnt,MS_U16 u16Width,MS_U16 u16Height,MS_PHY u32BufStart,MS_PHY u32BufEnd,XC_DIP_EX_SOURCE_TYPE eSource,XC_DIP_EX_WIN eWindow)9532 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetWinProperty_Ex(MS_U8 u8BufCnt ,MS_U16 u16Width, MS_U16 u16Height, MS_PHY u32BufStart ,MS_PHY u32BufEnd, XC_DIP_EX_SOURCE_TYPE eSource,XC_DIP_EX_WIN eWindow)
9533 {
9534 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetWinProperty_Ex(u8BufCnt, u16Width, u16Height, u32BufStart, u32BufEnd, (SCALER_DIP_SOURCE_TYPE)eSource, (SCALER_DIP_WIN)eWindow);
9535 }
MApi_XC_DIP_EX_SetOutputCapture(MS_BOOL bEnable,XC_DIP_EX_OP_CAPTURE eOpCapture,XC_DIP_EX_WIN eWindow)9536 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetOutputCapture(MS_BOOL bEnable, XC_DIP_EX_OP_CAPTURE eOpCapture, XC_DIP_EX_WIN eWindow)
9537 {
9538 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetOutputCapture(bEnable, (EN_XC_DIP_OP_CAPTURE)eOpCapture, (SCALER_DIP_WIN)eWindow);
9539 }
MApi_XC_DIP_EX_SetMirror(MS_BOOL bHMirror,MS_BOOL bVMirror,XC_DIP_EX_WIN eWindow)9540 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetMirror(MS_BOOL bHMirror, MS_BOOL bVMirror, XC_DIP_EX_WIN eWindow)
9541 {
9542 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetMirror(bHMirror, bVMirror, (SCALER_DIP_WIN)eWindow);
9543 }
MApi_XC_DIP_EX_SetDIPRProperty(XC_DIP_EX_DIPR_PROPERTY * pstDIPRProperty,XC_DIP_EX_WIN eWindow)9544 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_SetDIPRProperty(XC_DIP_EX_DIPR_PROPERTY *pstDIPRProperty, XC_DIP_EX_WIN eWindow)
9545 {
9546 ST_XC_DIPR_PROPERTY local_pstDIPRProperty;
9547 local_pstDIPRProperty.u16Width = pstDIPRProperty ->u16Width;
9548 local_pstDIPRProperty.u16Height = pstDIPRProperty ->u16Height;
9549 local_pstDIPRProperty.u16Pitch = pstDIPRProperty ->u16Pitch;
9550 local_pstDIPRProperty.u32YBufAddr = pstDIPRProperty ->u32YBufAddr;
9551 local_pstDIPRProperty.u32CBufAddr = pstDIPRProperty ->u32CBufAddr;
9552 local_pstDIPRProperty.enDataFmt = pstDIPRProperty ->enDataFmt;
9553 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_SetDIPRProperty(&local_pstDIPRProperty, (SCALER_DIP_WIN)eWindow);
9554 }
MApi_XC_DIP_EX_InterruptAttach(InterruptCb pIntCb,XC_DIP_EX_WIN eWindow)9555 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_InterruptAttach(InterruptCb pIntCb,XC_DIP_EX_WIN eWindow)
9556 {
9557 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_InterruptAttach(pIntCb, (SCALER_DIP_WIN)eWindow);
9558 }
MApi_XC_DIP_EX_InterruptDetach(XC_DIP_EX_WIN eWindow)9559 XC_EX_RETURN_VALUE MApi_XC_DIP_EX_InterruptDetach(XC_DIP_EX_WIN eWindow)
9560 {
9561 return (XC_EX_RETURN_VALUE)MApi_XC_DIP_InterruptDetach((SCALER_DIP_WIN)eWindow);
9562 }
9563 //==============Get===================
MApi_XC_DIP_EX_GetIntStatus(XC_DIP_EX_WIN eWindow)9564 MS_U16 MApi_XC_DIP_EX_GetIntStatus(XC_DIP_EX_WIN eWindow)
9565 {
9566 return MApi_XC_DIP_GetIntStatus((SCALER_DIP_WIN)eWindow);
9567 }
MApi_XC_DIP_EX_GetBufInfo(XC_DIP_EX_WIN eWindow)9568 XC_DIP_EX_BUFFER_INFO MApi_XC_DIP_EX_GetBufInfo(XC_DIP_EX_WIN eWindow)
9569 {
9570 BUFFER_INFO ret = MApi_XC_DIP_GetBufInfo((SCALER_DIP_WIN)eWindow);
9571 XC_DIP_EX_BUFFER_INFO ret_ex;
9572 ret_ex.u8BufCnt = ret.u8BufCnt;
9573 MS_U8 i;
9574 for(i = 0; i < XC_DIP_EX_MAX_BUFF_CNT; i++)
9575 {
9576 ret_ex.u32YBuf[i] = ret.u32YBuf[i];
9577 ret_ex.u32CBuf[i] = ret.u32CBuf[i];
9578 }
9579 return ret_ex;
9580 }
9581
9582 #include "hwreg_ipmux.h"
MApi_XC_EX_Set_WhiteBalance_Pattern(XC_DEVICE_ID * pDeviceId,MS_BOOL bEnable,MS_U16 u16R_CR_Data,MS_U16 u16G_Y_Data,MS_U16 u16B_CB_Data)9583 XC_EX_RETURN_VALUE MApi_XC_EX_Set_WhiteBalance_Pattern(XC_DEVICE_ID *pDeviceId, MS_BOOL bEnable, MS_U16 u16R_CR_Data, MS_U16 u16G_Y_Data ,MS_U16 u16B_CB_Data)
9584 {
9585 XC_EX_RETURN_VALUE enResult = E_XC_EX_RET_OK;
9586
9587 W2BYTEMSK(REG_IPMUX_10_L, (bEnable << 9) , BIT(9));
9588 W2BYTEMSK(REG_IPMUX_10_L, (bEnable << 12), BIT(12));
9589 W2BYTEMSK(REG_IPMUX_10_L, (bEnable << 13), BIT(13));
9590 W2BYTEMSK(REG_IPMUX_10_L, (bEnable << 14), BIT(14));
9591
9592 if(bEnable == TRUE)
9593 {
9594 W2BYTEMSK(REG_IPMUX_1D_L, u16R_CR_Data, BMASK(9:0));
9595 W2BYTEMSK(REG_IPMUX_1E_L, u16G_Y_Data, BMASK(9:0));
9596 W2BYTEMSK(REG_IPMUX_1F_L, u16B_CB_Data, BMASK(9:0));
9597 }
9598
9599 return enResult;
9600 }
9601
9602 #undef _API_XC_ADC_EX_C_
9603 #endif // _API_XC_ADC_EX_C_
9604