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 apiVDEC_EX_wrap.c
98 /// @brief wrapper to wrap VDEC_EX to VDEC API
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102
103 //-------------------------------------------------------------------------------------------------
104 // Include Files
105 //-------------------------------------------------------------------------------------------------
106 #include "MsCommon.h"
107 #include "MsVersion.h"
108 #include "../vdec_ex/apiVDEC_EX.h"
109 #include "apiVDEC.h"
110
111 #include "drvMMIO.h"
112
113 #ifdef MSOS_TYPE_LINUX_KERNEL
114 #include <asm/div64.h>
115 #endif
116
117 #ifdef MSOS_TYPE_LINUX_KERNEL
118 #include <linux/string.h>
119 #else
120 #include <string.h>
121 #endif
122
123 //-------------------------------------------------------------------------------------------------
124 // Local Compiler Options
125 //-------------------------------------------------------------------------------------------------
126
127 //-------------------------------------------------------------------------------------------------
128 // Function and Variable
129 //-------------------------------------------------------------------------------------------------
130
131 //-------------------------------------------------------------------------------------------------
132 // Local Defines
133 //-------------------------------------------------------------------------------------------------
134 #define _VDEC_Memcpy(pDstAddr, pSrcAddr, u32Size) memcpy((pDstAddr), (pSrcAddr), (u32Size))
135 #define _VDEC_Memset(pDstAddr, u8value, u32Size) memset((pDstAddr), (u8value), (u32Size))
136
137 #define _VDEC_WRAP_NOT_INIT_RET(StreamID) \
138 do { \
139 if (VDEC_MAIN_ID != StreamID) \
140 { \
141 return E_VDEC_EX_RET_NOT_INIT; \
142 } \
143 } while(0)
144
145 #define _VDEC_WRAP_NOT_INIT_RET_ZERO(StreamID) \
146 do { \
147 if (VDEC_MAIN_ID != StreamID) \
148 { \
149 return 0; \
150 } \
151 } while(0)
152
153 #define VDEC_U32_MAX 0xffffffffUL
154
155 #if ((defined(CHIP_A1) || defined(CHIP_A7)) && defined (__aeon__))
156 #define VDEC_INFO(x)
157 #else
158 #define VDEC_INFO(x) if (_eDbgMsgLevel >= E_VDEC_DBG_LEVEL_INFO) { (x); }
159 #endif
160
161 #ifndef UNUSED
162 #define UNUSED(x) (void)(x)
163 #endif
164
165 //-------------------------------------------------------------------------------------------------
166 // Local Structures
167 //-------------------------------------------------------------------------------------------------
168
169
170 //------------------------------------------------------------------------------
171 // Local Functions Prototype
172 //------------------------------------------------------------------------------
173
174
175 //-------------------------------------------------------------------------------------------------
176 // Global Variables
177 //-------------------------------------------------------------------------------------------------
178
179
180 //-------------------------------------------------------------------------------------------------
181 // Local Variables
182 //-------------------------------------------------------------------------------------------------
183 #define VDEC_MAIN_ID 0x1111
184
185 //StreamID for VDEC_EX interface
186 static VDEC_StreamId stStreamId = {
187 0, //u32Version
188 VDEC_U32_MAX //u32Id
189 };
190
191 static VDEC_EX_Info _api_vdec_info;
192 #if !((defined(CHIP_A1) || defined(CHIP_A7)) && defined (__aeon__))
193 static VDEC_DbgLevel _eDbgMsgLevel = E_VDEC_DBG_LEVEL_ERR;
194 #endif
195 static VDEC_EX_InitParam _ExVdecInitParam;
196
_VDEC_MapExResult(VDEC_Result eRet)197 static VDEC_EX_Result _VDEC_MapExResult(VDEC_Result eRet)
198 {
199 VDEC_EX_Result eExRet = E_VDEC_EX_FAIL;
200 const VDEC_EX_Result eRetMapTable[E_VDEC_EX_RET_NUM] =
201 {
202 E_VDEC_EX_FAIL,
203 E_VDEC_EX_OK,
204 E_VDEC_EX_RET_INVALID_PARAM,
205 E_VDEC_EX_RET_ILLEGAL_ACCESS,
206 E_VDEC_EX_RET_HARDWARE_BREAKDOWN,
207 E_VDEC_EX_RET_UNSUPPORTED,
208 E_VDEC_EX_RET_TIMEOUT,
209 E_VDEC_EX_RET_NOT_READY,
210 E_VDEC_EX_RET_NOT_INIT,
211 E_VDEC_EX_RET_NOT_EXIT,
212 E_VDEC_EX_RET_NOT_RUNNING
213 };
214
215 //MS_ASSERT(eRet < E_VDEC_EX_RET_NUM);
216 eExRet = eRetMapTable[eRet];
217 return eExRet;
218 }
219
_VDEC_MapExDispInfo(VDEC_DispInfo * pDisp,VDEC_EX_DispInfo * pExDisp)220 static void _VDEC_MapExDispInfo(VDEC_DispInfo* pDisp, VDEC_EX_DispInfo* pExDisp)
221 {
222 pExDisp->u16HorSize = pDisp->u16HorSize;
223 pExDisp->u16VerSize = pDisp->u16VerSize;
224 pExDisp->u32FrameRate = pDisp->u32FrameRate;
225 pExDisp->u8Interlace = pDisp->u8Interlace;
226 pExDisp->u8AFD = pDisp->u8AFD;
227 pExDisp->u16SarWidth = pDisp->u16SarWidth;
228 pExDisp->u16SarHeight = pDisp->u16SarHeight;
229 pExDisp->u16CropRight = pDisp->u16CropRight;
230 pExDisp->u16CropLeft = pDisp->u16CropLeft;
231 pExDisp->u16CropBottom = pDisp->u16CropBottom;
232 pExDisp->u16CropTop = pDisp->u16CropTop;
233 pExDisp->u16Pitch = pDisp->u16Pitch;
234 pExDisp->u16PTSInterval = pDisp->u16PTSInterval;
235 pExDisp->u8MPEG1 = pDisp->u8MPEG1;
236 pExDisp->u8PlayMode = pDisp->u8PlayMode;
237 pExDisp->u8FrcMode = pDisp->u8FrcMode;
238 pExDisp->u8AspectRate = pDisp->u8AspectRate;
239 pExDisp->bWithChroma = pDisp->bWithChroma;
240 pExDisp->bColorInXVYCC = pDisp->bColorInXVYCC;
241 pExDisp->u32DynScalingAddr = pDisp->u32DynScalingAddr;
242 pExDisp->u32DynScalingSize = pDisp->u32DynScalingSize;
243 pExDisp->u8DynScalingDepth = pDisp->u8DynScalingDepth;
244 pExDisp->bEnableMIUSel = pDisp->bEnableMIUSel;
245 pExDisp->u32AspectWidth = pDisp->u32AspectWidth;
246 pExDisp->u32AspectHeight = pDisp->u32AspectHeight;
247 }
248
_VDEC_MapDecCmd(VDEC_EX_DecCmd * pExCmd,VDEC_DecCmd * pCmd)249 static void _VDEC_MapDecCmd(VDEC_EX_DecCmd *pExCmd, VDEC_DecCmd *pCmd)
250 {
251 pCmd->u32ID_H = pExCmd->u32ID_H;
252 pCmd->u32ID_L = pExCmd->u32ID_L;
253 pCmd->u32StAddr = pExCmd->u32StAddr;
254 pCmd->u32Size = pExCmd->u32Size;
255 pCmd->u32Timestamp = pExCmd->u32Timestamp;
256 }
257
_VDEC_MapExFrameType(VDEC_FrameType eFrameType)258 static VDEC_EX_FrameType _VDEC_MapExFrameType(VDEC_FrameType eFrameType)
259 {
260 VDEC_EX_FrameType eExFrameType = E_VDEC_EX_FRM_TYPE_OTHER;
261
262 switch(eFrameType)
263 {
264 case E_VDEC_EX_FRM_TYPE_I:
265 eExFrameType = E_VDEC_EX_FRM_TYPE_I;
266 break;
267 case E_VDEC_EX_FRM_TYPE_P:
268 eExFrameType = E_VDEC_EX_FRM_TYPE_P;
269 break;
270 case E_VDEC_EX_FRM_TYPE_B:
271 eExFrameType = E_VDEC_EX_FRM_TYPE_B;
272 break;
273 case E_VDEC_EX_FRM_TYPE_OTHER:
274 default:
275 eExFrameType = E_VDEC_EX_FRM_TYPE_OTHER;
276 break;
277 }
278
279 return eExFrameType;
280 }
281
_VDEC_MapExFieldType(VDEC_FieldType eFieldType)282 static VDEC_EX_FieldType _VDEC_MapExFieldType(VDEC_FieldType eFieldType)
283 {
284 VDEC_EX_FieldType eExFieldType = E_VDEC_EX_FIELDTYPE_NONE;
285
286 switch(eFieldType)
287 {
288 case E_VDEC_FIELDTYPE_NONE:
289 eExFieldType = E_VDEC_EX_FIELDTYPE_NONE;
290 break;
291 case E_VDEC_FIELDTYPE_TOP:
292 eExFieldType = E_VDEC_EX_FIELDTYPE_TOP;
293 break;
294 case E_VDEC_FIELDTYPE_BOTTOM:
295 eExFieldType = E_VDEC_EX_FIELDTYPE_BOTTOM;
296 break;
297 case E_VDEC_FIELDTYPE_BOTH:
298 eExFieldType = E_VDEC_EX_FIELDTYPE_BOTH;
299 break;
300 default:
301 eExFieldType = E_VDEC_EX_FIELDTYPE_NONE;
302 MS_ASSERT(0);
303 break;
304 }
305
306 return eExFieldType;
307 }
308
_VDEC_MapExFrameInfo(VDEC_FrameInfo * pFrmInfo,VDEC_EX_FrameInfo * pExFrmInfo)309 static void _VDEC_MapExFrameInfo(VDEC_FrameInfo* pFrmInfo, VDEC_EX_FrameInfo* pExFrmInfo)
310 {
311 pExFrmInfo->u32LumaAddr = pFrmInfo->u32LumaAddr ;
312 pExFrmInfo->u32ChromaAddr = pFrmInfo->u32ChromaAddr;
313 pExFrmInfo->u32TimeStamp = pFrmInfo->u32TimeStamp ;
314 pExFrmInfo->u32ID_L = pFrmInfo->u32ID_L;
315 pExFrmInfo->u32ID_H = pFrmInfo->u32ID_H;
316 pExFrmInfo->u16Pitch = pFrmInfo->u16Pitch;
317 pExFrmInfo->u16Width = pFrmInfo->u16Width;
318 pExFrmInfo->u16Height = pFrmInfo->u16Height;
319 pExFrmInfo->eFrameType = _VDEC_MapExFrameType(pFrmInfo->eFrameType);
320 pExFrmInfo->eFieldType = _VDEC_MapExFieldType(pFrmInfo->eFieldType);
321 }
322
_VDEC_MapExtDispInfo(VDEC_ExtDispInfo * pFrmInfo,VDEC_EX_ExtDispInfo * pExFrmInfo)323 static void _VDEC_MapExtDispInfo(VDEC_ExtDispInfo* pFrmInfo, VDEC_EX_ExtDispInfo* pExFrmInfo)
324 {
325 pExFrmInfo->u16VSize = pFrmInfo->u16VSize;
326 pExFrmInfo->u16HSize = pFrmInfo->u16HSize;
327 pExFrmInfo->s16HOffset= pFrmInfo->s16HOffset;
328 pExFrmInfo->s16VOffset= pFrmInfo->s16VOffset;
329 }
330
_VDEC_MapTrickDecMode(VDEC_EX_TrickDec eExTrickDec)331 static VDEC_TrickDec _VDEC_MapTrickDecMode(VDEC_EX_TrickDec eExTrickDec)
332 {
333 VDEC_TrickDec eTrickDec = E_VDEC_TRICK_DEC_ALL;
334
335 switch(eExTrickDec)
336 {
337 case E_VDEC_EX_TRICK_DEC_ALL:
338 eTrickDec = E_VDEC_TRICK_DEC_ALL;
339 break;
340 case E_VDEC_EX_TRICK_DEC_IP:
341 eTrickDec = E_VDEC_TRICK_DEC_IP;
342 break;
343 case E_VDEC_EX_TRICK_DEC_I:
344 eTrickDec = E_VDEC_TRICK_DEC_I;
345 break;
346 default:
347 eTrickDec = E_VDEC_TRICK_DEC_ALL;
348 MS_ASSERT(0);
349 break;
350 }
351
352 return eTrickDec;
353 }
354
_VDEC_MapExTrickDecMode(VDEC_TrickDec eTrickDec)355 static VDEC_EX_TrickDec _VDEC_MapExTrickDecMode(VDEC_TrickDec eTrickDec)
356 {
357 VDEC_EX_TrickDec eExTrickDec = E_VDEC_EX_TRICK_DEC_ALL;
358
359 switch (eTrickDec)
360 {
361 case E_VDEC_TRICK_DEC_ALL:
362 eExTrickDec = E_VDEC_EX_TRICK_DEC_ALL;
363 break;
364 case E_VDEC_TRICK_DEC_IP:
365 eExTrickDec = E_VDEC_EX_TRICK_DEC_IP;
366 break;
367 case E_VDEC_TRICK_DEC_I:
368 eExTrickDec = E_VDEC_EX_TRICK_DEC_I;
369 break;
370 default:
371 eExTrickDec = E_VDEC_EX_TRICK_DEC_ALL;
372 MS_ASSERT(0);
373 break;
374 }
375
376 return eExTrickDec;
377 }
378
_VDEC_MapFreezePicSel(VDEC_EX_FreezePicSelect eExPicSel)379 static VDEC_FreezePicSelect _VDEC_MapFreezePicSel(VDEC_EX_FreezePicSelect eExPicSel)
380 {
381 VDEC_FreezePicSelect ePicSel = E_VDEC_FREEZE_AT_CUR_PIC;
382
383 switch (eExPicSel)
384 {
385 case E_VDEC_EX_FREEZE_AT_CUR_PIC:
386 ePicSel = E_VDEC_FREEZE_AT_CUR_PIC;
387 break;
388 case E_VDEC_EX_FREEZE_AT_LAST_PIC:
389 ePicSel = E_VDEC_FREEZE_AT_LAST_PIC;
390 break;
391 default:
392 ePicSel = E_VDEC_FREEZE_AT_LAST_PIC;
393 MS_ASSERT(0);
394 break;
395 }
396 return ePicSel;
397 }
398
_VDEC_MapSpeedType(VDEC_EX_SpeedType eExSpeedType)399 static VDEC_SpeedType _VDEC_MapSpeedType(VDEC_EX_SpeedType eExSpeedType)
400 {
401 VDEC_SpeedType eSpeedType = E_VDEC_SPEED_DEFAULT;
402
403 switch (eExSpeedType)
404 {
405 case E_VDEC_EX_SPEED_DEFAULT:
406 eSpeedType = E_VDEC_SPEED_DEFAULT;
407 break;
408 case E_VDEC_EX_SPEED_FAST:
409 eSpeedType = E_VDEC_SPEED_FAST;
410 break;
411 case E_VDEC_EX_SPEED_SLOW:
412 eSpeedType = E_VDEC_SPEED_SLOW;
413 break;
414 default:
415 eSpeedType = E_VDEC_SPEED_DEFAULT;
416 MS_ASSERT(0);
417 break;
418 }
419
420 return eSpeedType;
421 }
422
_VDEC_MapDispSpeed(VDEC_EX_DispSpeed eExSpeed)423 static VDEC_DispSpeed _VDEC_MapDispSpeed(VDEC_EX_DispSpeed eExSpeed)
424 {
425 VDEC_DispSpeed eSpeed = E_VDEC_DISP_SPEED_1X;
426
427 switch (eExSpeed)
428 {
429 case E_VDEC_EX_DISP_SPEED_1X:
430 eSpeed = E_VDEC_DISP_SPEED_1X;
431 break;
432 case E_VDEC_EX_DISP_SPEED_2X:
433 eSpeed = E_VDEC_DISP_SPEED_2X;
434 break;
435 case E_VDEC_EX_DISP_SPEED_4X :
436 eSpeed = E_VDEC_DISP_SPEED_4X;
437 break;
438 case E_VDEC_EX_DISP_SPEED_8X :
439 eSpeed = E_VDEC_DISP_SPEED_8X;
440 break;
441 case E_VDEC_EX_DISP_SPEED_16X:
442 eSpeed = E_VDEC_DISP_SPEED_16X;
443 break;
444 case E_VDEC_EX_DISP_SPEED_32X:
445 eSpeed = E_VDEC_DISP_SPEED_32X;
446 break;
447 default:
448 eSpeed = E_VDEC_DISP_SPEED_1X;
449 MS_ASSERT(0);
450 break;
451 }
452
453 return eSpeed;
454 }
455
_VDEC_MapExTimeCode(VDEC_TimeCode * pstTimeCode,VDEC_EX_TimeCode * pstExTimeCode)456 static void _VDEC_MapExTimeCode(VDEC_TimeCode* pstTimeCode, VDEC_EX_TimeCode* pstExTimeCode)
457 {
458 pstExTimeCode->u8TimeCodeHr = pstTimeCode->u8TimeCodeHr;
459 pstExTimeCode->u8TimeCodeMin = pstTimeCode->u8TimeCodeMin;
460 pstExTimeCode->u8TimeCodeSec = pstTimeCode->u8TimeCodeSec;
461 pstExTimeCode->u8TimeCodePic = pstTimeCode->u8TimeCodePic;
462 pstExTimeCode->u8DropFrmFlag = pstTimeCode->u8DropFrmFlag;
463 }
464
_VDEC_MapPatternType(VDEC_EX_PatternType eExPatternType)465 static VDEC_PatternType _VDEC_MapPatternType(VDEC_EX_PatternType eExPatternType)
466 {
467 VDEC_PatternType ePatternType = E_VDEC_PATTERN_FLUSH;
468
469 if (eExPatternType == E_VDEC_EX_PATTERN_FLUSH)
470 {
471 ePatternType = E_VDEC_PATTERN_FLUSH;
472 }
473 else if (eExPatternType == E_VDEC_EX_PATTERN_FILEEND)
474 {
475 ePatternType = E_VDEC_PATTERN_FILEEND;
476 }
477 else
478 {
479 MS_ASSERT(0);
480 }
481
482 return ePatternType;
483 }
484
_VDEC_MapExStatus(VDEC_Status * pStatus,VDEC_EX_Status * pExStatus)485 static void _VDEC_MapExStatus(VDEC_Status* pStatus, VDEC_EX_Status* pExStatus)
486 {
487 pExStatus->bInit = pStatus->bInit;
488 pExStatus->bIdle = pStatus->bIdle;
489 switch (pStatus->eStage)
490 {
491 case E_VDEC_STAGE_STOP: pExStatus->eStage = E_VDEC_EX_STAGE_STOP; break;
492 case E_VDEC_STAGE_INIT: pExStatus->eStage = E_VDEC_EX_STAGE_INIT; break;
493 case E_VDEC_STAGE_PLAY: pExStatus->eStage = E_VDEC_EX_STAGE_PLAY; break;
494 case E_VDEC_STAGE_PAUSE: pExStatus->eStage = E_VDEC_EX_STAGE_PAUSE; break;
495 default: pExStatus->eStage = E_VDEC_EX_STAGE_STOP; break;
496 }
497 return;
498 }
499
_VDEC_MapCodecType(VDEC_EX_CodecType eExCodecType)500 static VDEC_CodecType _VDEC_MapCodecType(VDEC_EX_CodecType eExCodecType)
501 {
502 const VDEC_CodecType eCodecTypeMapTable[E_VDEC_EX_CODEC_TYPE_NUM] =
503 {
504 E_VDEC_CODEC_TYPE_NONE,
505 E_VDEC_CODEC_TYPE_MPEG2,
506 E_VDEC_CODEC_TYPE_H263,
507 E_VDEC_CODEC_TYPE_MPEG4,
508 E_VDEC_CODEC_TYPE_DIVX311,
509 E_VDEC_CODEC_TYPE_DIVX412,
510 E_VDEC_CODEC_TYPE_FLV,
511 E_VDEC_CODEC_TYPE_VC1_ADV,
512 E_VDEC_CODEC_TYPE_VC1_MAIN,
513 E_VDEC_CODEC_TYPE_RV8,
514 E_VDEC_CODEC_TYPE_RV9,
515 E_VDEC_CODEC_TYPE_H264,
516 E_VDEC_CODEC_TYPE_AVS,
517 E_VDEC_CODEC_TYPE_MJPEG,
518 E_VDEC_CODEC_TYPE_MVC,
519 E_VDEC_CODEC_TYPE_VP8
520 };
521 VDEC_CodecType eCodecType = eCodecTypeMapTable[eExCodecType];
522 MS_ASSERT(eExCodecType < E_VDEC_EX_CODEC_TYPE_NUM);
523 return eCodecType;
524 }
525
_VDEC_MapExCodecType(VDEC_CodecType eCodecType)526 static VDEC_EX_CodecType _VDEC_MapExCodecType(VDEC_CodecType eCodecType)
527 {
528 const VDEC_EX_CodecType eExCodecTypeMapTable[E_VDEC_EX_CODEC_TYPE_NUM] =
529 {
530 E_VDEC_EX_CODEC_TYPE_NONE,
531 E_VDEC_EX_CODEC_TYPE_MPEG2,
532 E_VDEC_EX_CODEC_TYPE_H263,
533 E_VDEC_EX_CODEC_TYPE_MPEG4,
534 E_VDEC_EX_CODEC_TYPE_DIVX311,
535 E_VDEC_EX_CODEC_TYPE_DIVX412,
536 E_VDEC_EX_CODEC_TYPE_FLV,
537 E_VDEC_EX_CODEC_TYPE_VC1_ADV,
538 E_VDEC_EX_CODEC_TYPE_VC1_MAIN,
539 E_VDEC_EX_CODEC_TYPE_RV8,
540 E_VDEC_EX_CODEC_TYPE_RV9,
541 E_VDEC_EX_CODEC_TYPE_H264,
542 E_VDEC_EX_CODEC_TYPE_AVS,
543 E_VDEC_EX_CODEC_TYPE_MJPEG,
544 E_VDEC_EX_CODEC_TYPE_MVC,
545 E_VDEC_EX_CODEC_TYPE_VP8
546 };
547 //MS_ASSERT((MS_U32)eCodecType <= (MS_U32)E_VDEC_EX_CODEC_TYPE_NUM); //VDEC only has (E_VDEC_EX_CODEC_TYPE_NUM-1) CodecTypes
548 VDEC_EX_CodecType eExCodecType = eExCodecTypeMapTable[eCodecType];
549 return eExCodecType;
550 }
551 //-------------------------------------------------------------------------------------------------
552 // Debug Functions
553 //-------------------------------------------------------------------------------------------------
MApi_VDEC_EX_DbgCmd(VDEC_StreamId * pStreamId,MS_U32 u8Cmd,MS_U32 u32CmdArg)554 VDEC_EX_Result MApi_VDEC_EX_DbgCmd(VDEC_StreamId *pStreamId, MS_U32 u8Cmd, MS_U32 u32CmdArg)
555 {
556 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
557
558 return _VDEC_MapExResult(MApi_VDEC_DbgCmd(u8Cmd, u32CmdArg));
559 }
560
MApi_VDEC_EX_DbgSetData(VDEC_StreamId * pStreamId,MS_U32 u32Addr,MS_U32 u32Data)561 VDEC_EX_Result MApi_VDEC_EX_DbgSetData(VDEC_StreamId *pStreamId, MS_U32 u32Addr, MS_U32 u32Data)
562 {
563 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
564
565 return _VDEC_MapExResult(MApi_VDEC_DbgSetData(u32Addr, u32Data));
566 }
567
MApi_VDEC_EX_DbgGetData(VDEC_StreamId * pStreamId,MS_U32 u32Addr,MS_U32 * u32Data)568 VDEC_EX_Result MApi_VDEC_EX_DbgGetData(VDEC_StreamId *pStreamId, MS_U32 u32Addr, MS_U32 *u32Data)
569 {
570 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
571
572 VDEC_Result eRetVal = E_VDEC_FAIL;
573 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
574 eRetVal = MApi_VDEC_DbgGetData(u32Addr, u32Data);
575 eExRetVal = _VDEC_MapExResult(eRetVal);
576
577 return eExRetVal;
578 }
579
580 //-------------------------------------------------------------------------------------------------
581 // Local Functions
582 //-------------------------------------------------------------------------------------------------
583
584 //-------------------------------------------------------------------------------------------------
585 // Global Functions
586 //-------------------------------------------------------------------------------------------------
587
588 //------------------------------------------------------------------------------
589 /// Get VDEC version
590 /// @return -the pointer to the VDEC version
591 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetLibVer(const MSIF_Version ** ppVersion)592 VDEC_EX_Result MApi_VDEC_EX_GetLibVer(const MSIF_Version **ppVersion)
593 {
594 VDEC_Result eRetVal = E_VDEC_FAIL;
595 VDEC_EX_Result eEXRetVal = E_VDEC_EX_FAIL;
596 if (!ppVersion)
597 {
598 return eEXRetVal;
599 }
600
601 eRetVal = MApi_VDEC_GetLibVer(ppVersion);
602 eEXRetVal = _VDEC_MapExResult(eRetVal);
603 return eEXRetVal;
604 }
605
606 //-----------------------------------------------------------------------------
607 /// Get VDEC info
608 /// @brief \b Function \b Description: Get information of VDEC API
609 /// @return - the pointer to the VDEC information
610 //-----------------------------------------------------------------------------
MApi_VDEC_EX_GetInfo(const VDEC_EX_Info ** ppInfo)611 VDEC_EX_Result MApi_VDEC_EX_GetInfo(const VDEC_EX_Info **ppInfo)
612 {
613 if (!ppInfo)
614 {
615 return E_VDEC_EX_FAIL;
616 }
617
618 *ppInfo = &_api_vdec_info;
619
620 return E_VDEC_EX_OK;
621 }
622
623 //------------------------------------------------------------------------------
624 /// Get decoder status
625 /// @param pStatus \b OUT : VDEC_Status
626 /// @return TRUE or FALSE
627 /// - TRUE: Useful status got
628 /// - FALSE: No status because of not init yet
629 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetStatus(VDEC_StreamId * pStreamId,VDEC_EX_Status * pExStatus)630 MS_BOOL MApi_VDEC_EX_GetStatus(VDEC_StreamId *pStreamId, VDEC_EX_Status *pExStatus)
631 {
632 MS_BOOL bRet = FALSE;
633 VDEC_Status stStatus;
634
635 if (pExStatus)
636 {
637 bRet = MApi_VDEC_GetStatus(&stStatus);
638 _VDEC_MapExStatus(&stStatus, pExStatus);
639 }
640
641 return bRet;
642 }
643
644 //------------------------------------------------------------------------------
645 /// Check if codec type is supported or not.
646 /// @param eCodecType \b IN : codec type
647 /// @return TRUE or FALSE
648 /// - TRUE: Success
649 /// - FALSE: Failed
650 //------------------------------------------------------------------------------
MApi_VDEC_EX_CheckCaps(VDEC_StreamId * pStreamId,VDEC_EX_CodecType eExCodecType)651 MS_BOOL MApi_VDEC_EX_CheckCaps(VDEC_StreamId *pStreamId, VDEC_EX_CodecType eExCodecType)
652 {
653 VDEC_CodecType eCodecType = _VDEC_MapCodecType(eExCodecType);
654
655 return MApi_VDEC_CheckCaps(eCodecType);
656 }
657
658 //------------------------------------------------------------------------------
659 /// Enable turbo mode for VDEC.
660 /// @param bTurbo \b IN : TRUE for enable or FALSE for disable
661 /// @return VDEC_Result
662 /// - E_VDEC_OK: success
663 /// - E_VDEC_FAIL: failed
664 //------------------------------------------------------------------------------
MApi_VDEC_EX_EnableTurboMode(MS_BOOL bEnable)665 VDEC_EX_Result MApi_VDEC_EX_EnableTurboMode(MS_BOOL bEnable)
666 {
667 VDEC_Result eRetVal = E_VDEC_FAIL;
668 VDEC_EX_Result eEXRetVal = E_VDEC_EX_FAIL;
669
670 eRetVal = MApi_VDEC_EnableTurboMode(bEnable);
671 eEXRetVal = _VDEC_MapExResult(eRetVal);
672 return eEXRetVal;
673 }
674
675 #ifdef _MVD_EVENT_DBG
676 MS_U32 u32Para = 111;
677 extern MS_U8 HAL_MVD_GetAVSyncStatus(MS_U8 u8Idx);
VDEC_TestVSync(MS_U32 eFlag,void * param)678 void VDEC_TestVSync(MS_U32 eFlag, void *param)
679 {
680 if ((E_VDEC_EVENT_DISP_ONE & eFlag) == E_VDEC_EVENT_DISP_ONE)
681 {
682 printf("SyncStat=0x%x, diff=%lld\n", HAL_MVD_GetAVSyncStatus(0), MApi_VDEC_GetVideoPtsStcDelta());
683 //MApi_VDEC_IsFreerun();
684 }
685 }
VDEC_TestCC(MS_U32 eFlag,void * param)686 void VDEC_TestCC(MS_U32 eFlag, void *param)
687 {
688 static MS_U16 u16TempRef = 0xffff;
689 //printf("testCb eFlag=0x%lx, param=%ld\n", eFlag, *(MS_U32*)param);
690
691 if ((E_VDEC_EVENT_USER_DATA_FOUND & eFlag) == E_VDEC_EVENT_USER_DATA_FOUND)
692 {
693 VDEC_CC_Info ccInfo;
694 ccInfo.u32Version = 0;
695 while (MApi_VDEC_IsCCAvailable())
696 {
697 if (E_VDEC_OK == MApi_VDEC_GetCCInfo((void*)&ccInfo, sizeof(VDEC_CC_Info)))
698 {
699 //if ((u16TempRef+1) != ccInfo.u16TempRef)
700 {
701 printf("ccInfo: ");
702 printf("%02d, ", ccInfo.u16TempRef);
703 printf("%d, ", ccInfo.u8PicStructure);
704 printf("%d, ", ccInfo.u8TopFieldFirst);
705 printf("0x%lx, ", ccInfo.u32UserDataBuf);
706 printf("%ld, ", ccInfo.u32UserDataSize);
707 printf("%ld\n", ccInfo.u32Pts);
708 }
709 u16TempRef = ccInfo.u16TempRef;
710 }
711 }
712 }
713
714 return;
715 }
716
_VDEC_MVDEventDbg(void)717 void _VDEC_MVDEventDbg(void)
718 {
719 #if 1
720 //Get info at every VSync:
721 MApi_VDEC_SetEvent(E_VDEC_EVENT_DISP_ONE, VDEC_TestVSync, (void *)&u32Para);
722 #else
723 //Test DisplayOrder user data
724 MApi_VDEC_SetEvent(E_VDEC_EVENT_USER_DATA_FOUND, VDEC_TestCC, (void *)&u32Para);
725 #endif
726 }
727 #endif
728
_VDEC_MapFWSourceType(VDEC_EX_FWSourceType eExFWSrc)729 static VDEC_FWSourceType _VDEC_MapFWSourceType(VDEC_EX_FWSourceType eExFWSrc)
730 {
731 VDEC_FWSourceType eFWSrc = E_VDEC_FW_SOURCE_NONE;
732
733 switch (eExFWSrc)
734 {
735 case E_VDEC_EX_FW_SOURCE_DRAM:
736 eFWSrc = E_VDEC_FW_SOURCE_DRAM;
737 break;
738 case E_VDEC_EX_FW_SOURCE_FLASH:
739 eFWSrc = E_VDEC_FW_SOURCE_FLASH;
740 break;
741 case E_VDEC_EX_FW_SOURCE_NONE:
742 default:
743 eFWSrc = E_VDEC_FW_SOURCE_NONE;
744 break;
745 }
746
747 return eFWSrc;
748 }
749
_VDEC_MapCCFormat(VDEC_EX_CCFormat eExCCFmt)750 static VDEC_CCFormat _VDEC_MapCCFormat(VDEC_EX_CCFormat eExCCFmt)
751 {
752 VDEC_CCFormat eCCFmt = E_VDEC_CC_NONE;
753
754 switch (eExCCFmt)
755 {
756 case E_VDEC_EX_CC_608:
757 eCCFmt = E_VDEC_CC_608;
758 break;
759 case E_VDEC_EX_CC_708:
760 eCCFmt = E_VDEC_CC_708;
761 break;
762 case E_VDEC_EX_CC_UNPACKED:
763 eCCFmt = E_VDEC_CC_UNPACKED;
764 break;
765 case E_VDEC_EX_CC_NONE:
766 default:
767 eCCFmt = E_VDEC_CC_NONE;
768 break;
769 }
770
771 return eCCFmt;
772 }
773
_VDEC_MapCCType(VDEC_EX_CCType eExCCType)774 static VDEC_CCType _VDEC_MapCCType(VDEC_EX_CCType eExCCType)
775 {
776 VDEC_CCType eCCType = E_VDEC_CC_TYPE_NONE;
777
778 switch (eExCCType)
779 {
780 case E_VDEC_EX_CC_TYPE_NTSC_FIELD1:
781 eCCType = E_VDEC_CC_TYPE_NTSC_FIELD1;
782 break;
783 case E_VDEC_EX_CC_TYPE_NTSC_FIELD2:
784 eCCType = E_VDEC_CC_TYPE_NTSC_FIELD2;
785 break;
786 case E_VDEC_EX_CC_TYPE_DTVCC:
787 eCCType = E_VDEC_CC_TYPE_DTVCC;
788 break;
789 case E_VDEC_EX_CC_TYPE_NTSC_TWOFIELD:
790 eCCType = E_VDEC_CC_TYPE_NTSC_TWOFIELD;
791 break;
792 case E_VDEC_EX_CC_TYPE_NONE:
793 default:
794 eCCType = E_VDEC_CC_TYPE_NONE;
795 break;
796 }
797
798 return eCCType;
799 }
800
_VDEC_MapCCInfoCmd(VDEC_EX_CCInfoCmd eExCCInfoCmd)801 static VDEC_CCInfoCmd _VDEC_MapCCInfoCmd(VDEC_EX_CCInfoCmd eExCCInfoCmd)
802 {
803 VDEC_CCInfoCmd eCCInfoCmd = E_VDEC_CC_GET_BUFF_START;
804
805 switch (eExCCInfoCmd)
806 {
807 case E_VDEC_EX_CC_GET_BUFF_START:
808 eCCInfoCmd = E_VDEC_CC_GET_BUFF_START;
809 break;
810 case E_VDEC_EX_CC_GET_BUFF_SIZE:
811 eCCInfoCmd = E_VDEC_CC_GET_BUFF_SIZE;
812 break;
813 case E_VDEC_EX_CC_GET_708_ENABLE:
814 default:
815 eCCInfoCmd = E_VDEC_CC_GET_708_ENABLE;
816 break;
817 }
818
819 return eCCInfoCmd;
820 }
821
_VDEC_MapDbgLevel(VDEC_EX_DbgLevel eExDbg)822 static VDEC_DbgLevel _VDEC_MapDbgLevel(VDEC_EX_DbgLevel eExDbg)
823 {
824 VDEC_DbgLevel eDbg = E_VDEC_DBG_LEVEL_NONE;
825
826 switch (eExDbg)
827 {
828 case E_VDEC_EX_DBG_LEVEL_ERR:
829 eDbg = E_VDEC_DBG_LEVEL_ERR;
830 break;
831 case E_VDEC_EX_DBG_LEVEL_INFO:
832 eDbg = E_VDEC_DBG_LEVEL_INFO;
833 break;
834 case E_VDEC_EX_DBG_LEVEL_DBG:
835 eDbg = E_VDEC_DBG_LEVEL_DBG;
836 break;
837 case E_VDEC_EX_DBG_LEVEL_TRACE:
838 eDbg = E_VDEC_DBG_LEVEL_TRACE;
839 break;
840 case E_VDEC_EX_DBG_LEVEL_FW:
841 eDbg = E_VDEC_DBG_LEVEL_FW;
842 break;
843 case E_VDEC_EX_DBG_LEVEL_NONE:
844 default:
845 eDbg = E_VDEC_DBG_LEVEL_NONE;
846 break;
847 }
848 return eDbg;
849 }
850
_VDEC_MapSysCfg(VDEC_EX_SysCfg * pstExSys,VDEC_SysCfg * pstSys)851 static void _VDEC_MapSysCfg(VDEC_EX_SysCfg* pstExSys, VDEC_SysCfg* pstSys)
852 {
853 pstSys->u32FWBinaryAddr = pstExSys->u32FWBinaryAddr;
854 pstSys->u32FWBinarySize = pstExSys->u32FWBinarySize;
855 pstSys->u32CodeBufAddr = pstExSys->u32CodeBufAddr;
856 pstSys->u32CodeBufSize = pstExSys->u32CodeBufSize;
857 pstSys->u32FrameBufAddr = pstExSys->u32FrameBufAddr;
858 pstSys->u32FrameBufSize = pstExSys->u32FrameBufSize;
859 pstSys->u32BitstreamBufAddr = pstExSys->u32BitstreamBufAddr;
860 pstSys->u32BitstreamBufSize = pstExSys->u32BitstreamBufSize;
861 pstSys->u32DrvProcBufAddr = pstExSys->u32DrvProcBufAddr;
862 pstSys->u32DrvProcBufSize = pstExSys->u32DrvProcBufSize;
863 pstSys->u32VlcBinarySrcAddr = pstExSys->u32VlcBinarySrcAddr;
864 pstSys->u32VlcTabBinarySize = pstExSys->u32VlcTabBinarySize;
865 pstSys->eDbgMsgLevel = _VDEC_MapDbgLevel(pstExSys->eDbgMsgLevel);
866 pstSys->eFWSourceType = _VDEC_MapFWSourceType(pstExSys->eFWSourceType);
867 }
868
_VDEC_MapSrcMode(VDEC_EX_SrcMode eExSrcMode)869 static VDEC_SrcMode _VDEC_MapSrcMode(VDEC_EX_SrcMode eExSrcMode)
870 {
871 VDEC_SrcMode eSrcMode = E_VDEC_SRC_MODE_DTV;
872
873 switch (eExSrcMode)
874 {
875 case E_VDEC_EX_SRC_MODE_DTV:
876 eSrcMode = E_VDEC_SRC_MODE_DTV;
877 break;
878 case E_VDEC_EX_SRC_MODE_TS_FILE:
879 eSrcMode = E_VDEC_SRC_MODE_TS_FILE;
880 break;
881 case E_VDEC_EX_SRC_MODE_FILE:
882 eSrcMode = E_VDEC_SRC_MODE_FILE;
883 break;
884 case E_VDEC_EX_SRC_MODE_TS_FILE_DUAL_ES:
885 eSrcMode = E_VDEC_SRC_MODE_TS_FILE_DUAL_ES;
886 break;
887 case E_VDEC_EX_SRC_MODE_FILE_DUAL_ES:
888 eSrcMode = E_VDEC_SRC_MODE_FILE_DUAL_ES;
889 break;
890 default:
891 VDEC_INFO(printf("input eExSrcMode 0x%x out of range!\n", eExSrcMode));
892 eSrcMode = E_VDEC_SRC_MODE_DTV;
893 break;
894 }
895 return eSrcMode;
896 }
897
_VDEC_MapTimeStampType(VDEC_EX_TimeStampType eExTimeStamp)898 static VDEC_TimeStampType _VDEC_MapTimeStampType(VDEC_EX_TimeStampType eExTimeStamp)
899 {
900 VDEC_TimeStampType eTimeStamp = E_VDEC_TIME_STAMP_NONE;
901
902 switch (eExTimeStamp)
903 {
904 case E_VDEC_EX_TIME_STAMP_PTS:
905 eTimeStamp = E_VDEC_TIME_STAMP_PTS;
906 break;
907 case E_VDEC_EX_TIME_STAMP_DTS:
908 eTimeStamp = E_VDEC_TIME_STAMP_DTS;
909 break;
910 case E_VDEC_EX_TIME_STAMP_STS:
911 eTimeStamp = E_VDEC_TIME_STAMP_STS;
912 break;
913 case E_VDEC_EX_TIME_STAMP_NONE:
914 default:
915 eTimeStamp = E_VDEC_TIME_STAMP_NONE;
916 break;
917 }
918 return eTimeStamp;
919 }
920
_VDEC_MapMjpegScaleFactor(VDEC_EX_MJpegScaleFactor eExMjScaleFactor)921 static VDEC_MJpegScaleFactor _VDEC_MapMjpegScaleFactor(VDEC_EX_MJpegScaleFactor eExMjScaleFactor)
922 {
923 VDEC_MJpegScaleFactor eMjScaleFactor = E_VDEC_MJPEG_SCALE_1to1;
924
925 switch (eExMjScaleFactor)
926 {
927 case E_VDEC_EX_MJPEG_SCALE_1to1:
928 eMjScaleFactor = E_VDEC_MJPEG_SCALE_1to1;
929 break;
930 case E_VDEC_EX_MJPEG_SCALE_2to1:
931 eMjScaleFactor = E_VDEC_MJPEG_SCALE_2to1;
932 break;
933 case E_VDEC_EX_MJPEG_SCALE_4to1:
934 eMjScaleFactor = E_VDEC_MJPEG_SCALE_4to1;
935 break;
936 case E_VDEC_EX_MJPEG_SCALE_8to1:
937 eMjScaleFactor = E_VDEC_MJPEG_SCALE_8to1;
938 break;
939 default:
940 eMjScaleFactor = E_VDEC_MJPEG_SCALE_1to1;
941 break;
942 }
943 return eMjScaleFactor;
944 }
945
_VDEC_MapFBReductionType(VDEC_EX_FBReductionType eExFBReductionType)946 static VDEC_FBReductionType _VDEC_MapFBReductionType(VDEC_EX_FBReductionType eExFBReductionType)
947 {
948 VDEC_FBReductionType eFBReductionType = VDEC_FB_REDUCTION_NONE;
949
950 switch (eExFBReductionType)
951 {
952 case VDEC_EX_FB_REDUCTION_1_2:
953 eFBReductionType = VDEC_FB_REDUCTION_1_2;
954 break;
955 case VDEC_EX_FB_REDUCTION_1_4:
956 eFBReductionType = VDEC_FB_REDUCTION_1_4;
957 break;
958 case VDEC_EX_FB_REDUCTION_NONE:
959 default:
960 eFBReductionType = VDEC_FB_REDUCTION_NONE;
961 break;
962 }
963 return eFBReductionType;
964 }
965
_VDEC_MapFBReduction(VDEC_EX_FBReduction * pstExFBReduction,VDEC_FBReduction * pstFBReduction)966 static void _VDEC_MapFBReduction(VDEC_EX_FBReduction* pstExFBReduction, VDEC_FBReduction* pstFBReduction)
967 {
968 pstFBReduction->bEnableAutoMode = pstExFBReduction->bEnableAutoMode;
969 pstFBReduction->eLumaFBReduction = _VDEC_MapFBReductionType(pstExFBReduction->eLumaFBReduction);
970 pstFBReduction->eChromaFBReduction = _VDEC_MapFBReductionType(pstExFBReduction->eChromaFBReduction);
971 }
972
_VDEC_MapVideoInfo(VDEC_EX_VideoInfo * pstExVidInfo,VDEC_VideoInfo * pstVidInfo)973 static void _VDEC_MapVideoInfo(VDEC_EX_VideoInfo* pstExVidInfo, VDEC_VideoInfo* pstVidInfo)
974 {
975 MS_U8 i = 0;
976
977 pstVidInfo->eSrcMode = _VDEC_MapSrcMode(pstExVidInfo->eSrcMode);
978 pstVidInfo->eTimeStampType = _VDEC_MapTimeStampType(pstExVidInfo->eTimeStampType);
979 pstVidInfo->eMJpegScaleFactor = _VDEC_MapMjpegScaleFactor(pstExVidInfo->eMJpegScaleFactor);
980 pstVidInfo->bWithoutNalStCode = pstExVidInfo->bWithoutNalStCode;
981 pstVidInfo->u32FrameRate = pstExVidInfo->u32FrameRate;
982 pstVidInfo->u32FrameRateBase = pstExVidInfo->u32FrameRateBase;
983 pstVidInfo->u16NumSizes = pstExVidInfo->u16NumSizes;
984
985 for (i = 0; i < 8; i++)
986 {
987 pstVidInfo->u16Width[i] = pstExVidInfo->u16Width[i];
988 pstVidInfo->u16Height[i] = pstExVidInfo->u16Height[i];
989 }
990 }
991
_VDEC_MapInitParam(VDEC_EX_InitParam * pstExInitPara,VDEC_InitParam * pstInitPara)992 static MS_BOOL _VDEC_MapInitParam(VDEC_EX_InitParam* pstExInitPara, VDEC_InitParam* pstInitPara)
993 {
994 pstInitPara->eCodecType = _VDEC_MapCodecType(pstExInitPara->eCodecType);
995 _VDEC_MapSysCfg(&pstExInitPara->SysConfig, &pstInitPara->SysConfig);
996 _VDEC_MapVideoInfo(&pstExInitPara->VideoInfo, &pstInitPara->VideoInfo);
997 pstInitPara->EnableDynaScale = pstExInitPara->EnableDynaScale;
998 pstInitPara->bDisableDropErrFrame = pstExInitPara->bDisableDropErrFrame;
999 pstInitPara->bDisableErrConceal = pstExInitPara->bDisableErrConceal;
1000 pstInitPara->bRepeatLastField = pstExInitPara->bRepeatLastField;
1001 pstInitPara->u8ErrThreshold = pstExInitPara->u8ErrThreshold;
1002 pstInitPara->u32DSVirtualBoxWidth = pstExInitPara->u32DSVirtualBoxWidth;
1003 pstInitPara->u32DSVirtualBoxHeight = pstExInitPara->u32DSVirtualBoxHeight ;
1004 return TRUE;
1005 }
1006
_VDEC_MapInitExParam(VDEC_EX_InitParam * pstExInitPara,VDEC_InitParam_EX1 * pstInitPara)1007 static MS_BOOL _VDEC_MapInitExParam(VDEC_EX_InitParam* pstExInitPara, VDEC_InitParam_EX1* pstInitPara)
1008 {
1009 pstInitPara->u32Version = pstExInitPara->u32Version;
1010 pstInitPara->eCodecType = _VDEC_MapCodecType(pstExInitPara->eCodecType);
1011 _VDEC_MapSysCfg(&pstExInitPara->SysConfig, &pstInitPara->SysConfig);
1012 _VDEC_MapVideoInfo(&pstExInitPara->VideoInfo, &pstInitPara->VideoInfo);
1013 pstInitPara->EnableDynaScale = pstExInitPara->EnableDynaScale;
1014 pstInitPara->bDisableDropErrFrame = pstExInitPara->bDisableDropErrFrame;
1015 pstInitPara->bDisableErrConceal = pstExInitPara->bDisableErrConceal;
1016 pstInitPara->bRepeatLastField = pstExInitPara->bRepeatLastField;
1017 pstInitPara->u8ErrThreshold = pstExInitPara->u8ErrThreshold;
1018 pstInitPara->u32DSVirtualBoxWidth = pstExInitPara->u32DSVirtualBoxWidth;
1019 pstInitPara->u32DSVirtualBoxHeight = pstExInitPara->u32DSVirtualBoxHeight ;
1020
1021 _VDEC_MapFBReduction(&pstExInitPara->stFBReduction, &pstInitPara->stFBReduction);
1022 return TRUE;
1023 }
1024
1025
_VDEC_MapUserCmd(VDEC_EX_User_Cmd eExUserCmd)1026 static VDEC_User_Cmd _VDEC_MapUserCmd(VDEC_EX_User_Cmd eExUserCmd)
1027 {
1028 VDEC_User_Cmd eUserCmd = VDEC_USER_CMD_SET_CONTROL_BASE;
1029 switch (eExUserCmd)
1030 {
1031 case E_VDEC_EX_USER_CMD_SET_CONTROL_BASE : eUserCmd = VDEC_USER_CMD_SET_CONTROL_BASE; break;
1032 case E_VDEC_EX_USER_CMD_REPEAT_LAST_FIELD : eUserCmd = VDEC_USER_CMD_REPEAT_LAST_FIELD; break;
1033 case E_VDEC_EX_USER_CMD_AVSYNC_REPEAT_TH : eUserCmd = VDEC_USER_CMD_AVSYNC_REPEAT_TH; break;
1034 case E_VDEC_EX_USER_CMD_DISP_ONE_FIELD : eUserCmd = VDEC_USER_CMD_DISP_ONE_FIELD; break;
1035 case E_VDEC_EX_USER_CMD_FD_MASK_DELAY_COUNT : eUserCmd = VDEC_USER_CMD_FD_MASK_DELAY_COUNT; break;
1036 case E_VDEC_EX_USER_CMD_FRC_OUTPUT : eUserCmd = VDEC_USER_CMD_FRC_OUTPUT; break;
1037 case E_VDEC_EX_USER_CMD_FRC_DROP_TYPE : eUserCmd = VDEC_USER_CMD_FRC_DROP_TYPE; break;
1038 case E_VDEC_EX_USER_CMD_FAST_DISPLAY : eUserCmd = VDEC_USER_CMD_FAST_DISPLAY; break;
1039 case E_VDEC_EX_USER_CMD_IGNORE_ERR_REF : eUserCmd = VDEC_USER_CMD_IGNORE_ERR_REF; break;
1040 case E_VDEC_EX_USER_CMD_FORCE_FOLLOW_DTV_SPEC : eUserCmd = VDEC_USER_CMD_FORCE_FOLLOW_DTV_SPEC; break;
1041 case E_VDEC_EX_USER_CMD_AVC_MIN_FRM_GAP : eUserCmd = VDEC_USER_CMD_AVC_MIN_FRM_GAP; break;
1042 case E_VDEC_EX_USER_CMD_DISABLE_SEQ_CHG : eUserCmd = VDEC_USER_CMD_DISABLE_SEQ_CHG; break;
1043 //case E_VDEC_EX_USER_CMD_SET_DISP_OUTSIDE_CTRL_MODE : eUserCmd = VDEC_USER_CMD_SET_DISP_OUTSIDE_CTRL_MODE; break; /// Org no define
1044 case E_VDEC_EX_USER_CMD_SET_DTV_USER_DATA_MODE : eUserCmd = VDEC_USER_CMD_SET_DTV_USER_DATA_MODE; break;
1045 case E_VDEC_EX_USER_CMD_SET_SINGLE_TASK_MODE : eUserCmd = VDEC_USER_CMD_SET_SINGLE_TASK_MODE; break;
1046 case E_VDEC_EX_USER_CMD_AVC_DISABLE_ANTI_VDEAD : eUserCmd = VDEC_USER_CMD_AVC_DISABLE_ANTI_VDEAD; break;
1047 case E_VDEC_EX_USER_CMD_DTV_RESET_MVD_PARSER : eUserCmd = VDEC_USER_CMD_DTV_RESET_MVD_PARSER; break;
1048 case E_VDEC_EX_USER_CMD_PVR_FLUSH_FRAME_BUFFER : eUserCmd = VDEC_USER_CMD_PVR_FLUSH_FRAME_BUFFER; break;
1049 case E_VDEC_EX_USER_CMD_FORCE_INTERLACE_MODE : eUserCmd = VDEC_USER_CMD_FORCE_INTERLACE_MODE; break;
1050 case E_VDEC_EX_USER_CMD_RELEASE_FD_MASK : eUserCmd = VDEC_USER_CMD_RELEASE_FD_MASK; break;
1051 case E_VDEC_EX_USER_CMD_SET_DECODE_MODE : eUserCmd = VDEC_USER_CMD_SET_DECODE_MODE; break;
1052 case E_VDEC_EX_USER_CMD_SUPPORT_AVC_TO_MVC : eUserCmd = VDEC_USER_CMD_SUPPORT_AVC_TO_MVC; break;
1053 case E_VDEC_EX_USER_CMD_3DLR_VIEW_EXCHANGE : eUserCmd = VDEC_USER_CMD_3DLR_VIEW_EXCHANGE; break;
1054 case E_VDEC_EX_USER_CMD_SET_VSIZE_ALIGN : eUserCmd = VDEC_USER_CMD_SET_VSIZE_ALIGN; break;
1055 case E_VDEC_EX_USER_CMD_SHOW_DECODE_ORDER : eUserCmd = VDEC_USER_CMD_SHOW_DECODE_ORDER; break;
1056 case E_VDEC_EX_USER_CMD_AVC_DISP_IGNORE_CROP : eUserCmd = VDEC_USER_CMD_AVC_DISP_IGNORE_CROP; break;
1057 case E_VDEC_EX_USER_CMD_SET_DISP_FINISH_MODE : eUserCmd = VDEC_USER_CMD_SET_DISP_FINISH_MODE; break;
1058 case E_VDEC_EX_USER_CMD_SET_AVSYNC_MODE : eUserCmd = VDEC_USER_CMD_SET_AVSYNC_MODE; break;
1059 //case E_VDEC_EX_USER_CMD_SUSPEND_DYNAMIC_SCALE : eUserCmd = VDEC_USER_CMD_SUSPEND_DYNAMIC_SCALE; break;
1060 case E_VDEC_EX_USER_CMD_FORCE_AUTO_MUTE : eUserCmd = VDEC_USER_CMD_FORCE_AUTO_MUTE; break;
1061 case E_VDEC_EX_USER_CMD_PUSH_DISPQ_WITH_REF_NUM : eUserCmd = VDEC_USER_CMD_PUSH_DISPQ_WITH_REF_NUM; break;
1062 case E_VDEC_EX_USER_CMD_SET_IDCT_MODE : eUserCmd = VDEC_USER_CMD_SET_IDCT_MODE; break;
1063 case E_VDEC_EX_USER_CMD_SET_XC_LOW_DELAY_PARA : eUserCmd = VDEC_USER_CMD_SET_XC_LOW_DELAY_PARA; break;
1064 case E_VDEC_EX_USER_CMD_AVC_SUPPORT_REF_NUM_OVER_MAX_DPB_SIZE : eUserCmd = VDEC_USER_CMD_AVC_SUPPORT_REF_NUM_OVER_MAX_DPB_SIZE; break;
1065 case E_VDEC_EX_USER_CMD_AUTO_DROP_DISPLAY_QUEUE : eUserCmd = VDEC_USER_CMD_AUTO_DROP_DISPLAY_QUEUE; break;
1066 case E_VDEC_EX_USER_CMD_SET_DV_XC_SHM_ADDR : eUserCmd = VDEC_USER_CMD_SET_DV_XC_SHM_ADDR ;break;
1067 case E_VDEC_EX_USER_CMD_SET_ENABLE_HDR : eUserCmd = VDEC_USER_CMD_SET_ENABLE_HDR ;break;
1068
1069 case E_VDEC_EX_USER_CMD_MVC_BBU2_PUSH_PACKET : eUserCmd = VDEC_USER_CMD_MVC_BBU2_PUSH_PACKET; break;
1070 case E_VDEC_EX_USER_CMD_MVC_BBU2_FIRE_DECCMD : eUserCmd = VDEC_USER_CMD_MVC_BBU2_FIRE_DECCMD; break;
1071
1072 //Group2:Get Control command
1073 case E_VDEC_EX_USER_CMD_GET_CONTROL_BASE : eUserCmd = VDEC_USER_CMD_GET_CONTROL_BASE; break;
1074 case E_VDEC_EX_USER_CMD_GET_CHROMA_TYPE : eUserCmd = VDEC_USER_CMD_GET_CHROMA_TYPE; break;
1075 case E_VDEC_EX_USER_CMD_GET_REAL_FRAMERATE : eUserCmd = VDEC_USER_CMD_GET_REAL_FRAMERATE; break;
1076 case E_VDEC_EX_USER_CMD_GET_COLOR_MATRIX : eUserCmd = VDEC_USER_CMD_GET_COLOR_MATRIX; break;
1077 case E_VDEC_EX_USER_CMD_GET_DYNSCALE_ENABLED : eUserCmd = VDEC_USER_CMD_GET_DYNSCALE_ENABLED; break;
1078 case E_VDEC_EX_USER_CMD_GET_FPA_SEI : eUserCmd = VDEC_USER_CMD_GET_FPA_SEI; break;
1079 case E_VDEC_EX_USER_CMD_GET_U64PTS : eUserCmd = VDEC_USER_CMD_GET_U64PTS; break;
1080 case E_VDEC_EX_USER_CMD_GET_ORI_INTERLACE_MODE : eUserCmd = VDEC_USER_CMD_GET_ORI_INTERLACE_MODE; break;
1081 //case E_VDEC_EX_USER_CMD_GET_MBS_ONLY_FLAG : eUserCmd = VDEC_USER_CMD_GET_MBS_ONLY_FLAG; break;
1082 //case E_VDEC_EX_USER_CMD_GET_CRC_VALUE : eUserCmd = VDEC_USER_CMD_GET_CRC_VALUE; break;
1083 case E_VDEC_EX_USER_CMD_GET_FLUSH_PATTEN_ENTRY_NUM : eUserCmd = VDEC_USER_CMD_GET_FLUSH_PATTEN_ENTRY_NUM; break;
1084 case E_VDEC_EX_USER_CMD_GET_FW_STATUS_FLAG : eUserCmd = VDEC_USER_CMD_GET_FW_STATUS_FLAG;break;
1085
1086 case E_VDEC_EX_USER_CMD_GET_MVC_SUB_FRAME_DISP_INFO : eUserCmd = VDEC_USER_CMD_GET_MVC_SUB_FRAME_DISP_INFO; break;
1087 case E_VDEC_EX_USER_CMD_GET_MVC_BBU2_DECQ_VACANCY : eUserCmd = VDEC_USER_CMD_GET_MVC_BBU2_DECQ_VACANCY; break;
1088 case E_VDEC_EX_USER_CMD_GET_MVC_ES2_READ_PTR : eUserCmd = VDEC_USER_CMD_GET_MVC_ES2_READ_PTR; break;
1089 case E_VDEC_EX_USER_CMD_GET_MVC_ES2_WRITE_PTR : eUserCmd = VDEC_USER_CMD_GET_MVC_ES2_WRITE_PTR; break;
1090 case E_VDEC_EX_USER_CMD_GET_ES_QUANTITY : eUserCmd = VDEC_USER_CMD_GET_ES_QUANTITY; break;
1091 case E_VDEC_EX_USER_CMD_GET_ES2_QUANTITY : eUserCmd = VDEC_USER_CMD_GET_ES2_QUANTITY; break;
1092 case E_VDEC_EX_USER_CMD_DROP_ERR_FRAME : eUserCmd = VDEC_USER_CMD_DROP_ERR_FRAME; break;
1093 case E_VDEC_EX_USER_CMD_GET_XC_LOW_DELAY_INT_STATE : eUserCmd = VDEC_USER_CMD_GET_XC_LOW_DELAY_INT_STATE; break;
1094 case E_VDEC_EX_USER_CMD_GET_FB_USAGE_MEM : eUserCmd = VDEC_USER_CMD_GET_FB_USAGE_MEM; break;
1095
1096 //Group3-4:Preset Control command=============================
1097 case E_VDEC_EX_USER_CMD_PRESET_CONTROL_BASE : eUserCmd = VDEC_USER_CMD_PRESET_CONTROL_BASE; break;
1098 case E_VDEC_EX_USER_CMD_HVD_ONE_PENDING_BUFFER_MODE : eUserCmd = VDEC_USER_CMD_HVD_ONE_PENDING_BUFFER_MODE; break;
1099 case E_VDEC_EX_USER_CMD_MVD_HWBUFFER_REMAPPING_MODE : eUserCmd = VDEC_USER_CMD_MVD_HWBUFFER_REMAPPING_MODE; break;
1100
1101 default:
1102 break;
1103 }
1104 return eUserCmd;
1105 }
1106
MApi_VDEC_EX_GetFreeStream(void * pInfo,MS_U32 u32Size,VDEC_EX_Stream eStreamType,VDEC_EX_CodecType eCodecType)1107 VDEC_EX_Result MApi_VDEC_EX_GetFreeStream(void *pInfo, MS_U32 u32Size, VDEC_EX_Stream eStreamType, VDEC_EX_CodecType eCodecType)
1108 {
1109 VDEC_StreamId *pStreamId = pInfo;
1110 if(E_VDEC_EX_MAIN_STREAM == eStreamType)
1111 {
1112 pStreamId->u32Id = VDEC_MAIN_ID;
1113 pStreamId->u32Version = stStreamId.u32Version;
1114 return E_VDEC_EX_OK;
1115 }
1116 else
1117 {
1118 printf("%s fail, only support main stream\n", __FUNCTION__);
1119 return E_VDEC_EX_FAIL;
1120 }
1121 }
1122
1123 //------------------------------------------------------------------------------
1124 /// Initial VDEC.
1125 /// @param pInitParam \b IN : pointer to initial parameter
1126 /// @return VDEC_Result
1127 /// - E_VDEC_OK: success
1128 /// - E_VDEC_FAIL: failed
1129 /// - E_VDEC_RET_NOT_EXIT: not ext after last initialization
1130 /// - E_VDEC_RET_INVALID_PARAM: input parameter is invalid
1131 //------------------------------------------------------------------------------
MApi_VDEC_EX_Init(VDEC_StreamId * pStreamId,VDEC_EX_InitParam * pExInitParam)1132 VDEC_EX_Result MApi_VDEC_EX_Init(VDEC_StreamId *pStreamId, VDEC_EX_InitParam *pExInitParam)
1133 {
1134 VDEC_Result eRetVal = E_VDEC_FAIL;
1135 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
1136 VDEC_InitParam stInitPara;
1137 VDEC_InitParam_EX1 stInitPara_EX1;
1138
1139 if (!pExInitParam)
1140 {
1141 return E_VDEC_EX_RET_INVALID_PARAM;
1142 }
1143
1144 if (VDEC_MAIN_ID != pStreamId->u32Id)
1145 {
1146 goto _init_ret;
1147 }
1148
1149 if((pExInitParam->stFBReduction.eLumaFBReduction != VDEC_EX_FB_REDUCTION_NONE)
1150 || (pExInitParam->stFBReduction.eChromaFBReduction != VDEC_EX_FB_REDUCTION_NONE)
1151 || (pExInitParam->stFBReduction.bEnableAutoMode != FALSE))
1152 {
1153 if (!_VDEC_MapInitExParam(pExInitParam, &stInitPara_EX1))
1154 {
1155 return E_VDEC_EX_RET_INVALID_PARAM;
1156 }
1157 eRetVal = MApi_VDEC_Init_EX(&stInitPara_EX1, sizeof(stInitPara_EX1));
1158 }
1159 else
1160 {
1161 if (!_VDEC_MapInitParam(pExInitParam, &stInitPara))
1162 {
1163 return E_VDEC_EX_RET_INVALID_PARAM;
1164 }
1165 eRetVal = MApi_VDEC_Init(&stInitPara);
1166 }
1167
1168 _init_ret:
1169 eExRetVal = _VDEC_MapExResult(eRetVal);
1170
1171 if (E_VDEC_EX_OK == eExRetVal)
1172 {
1173 //printf("%s: Update _ExVdecInitParam\n", __FUNCTION__);
1174 _VDEC_Memcpy(&_ExVdecInitParam, pExInitParam, sizeof(VDEC_EX_InitParam));
1175 }
1176
1177 #ifdef _MVD_EVENT_DBG
1178 _VDEC_MVDEventDbg();
1179 #endif
1180
1181 return eExRetVal;
1182 }
1183
1184 //------------------------------------------------------------------------------
1185 /// Reset decoder.
1186 /// @return VDEC_Result
1187 //------------------------------------------------------------------------------
MApi_VDEC_EX_Rst(VDEC_StreamId * pStreamId)1188 VDEC_EX_Result MApi_VDEC_EX_Rst(VDEC_StreamId *pStreamId)
1189 {
1190 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1191
1192 VDEC_Result eRetVal = E_VDEC_FAIL;
1193 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
1194
1195 eRetVal = MApi_VDEC_Rst();
1196 eExRetVal = _VDEC_MapExResult(eRetVal);
1197
1198 return eExRetVal;
1199 }
1200
1201 //------------------------------------------------------------------------------
1202 /// Stop playback
1203 /// @return VDEC_Result
1204 //------------------------------------------------------------------------------
MApi_VDEC_EX_Exit(VDEC_StreamId * pStreamId)1205 VDEC_EX_Result MApi_VDEC_EX_Exit(VDEC_StreamId *pStreamId)
1206 {
1207 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1208
1209 VDEC_Result eRetVal = E_VDEC_OK;
1210 VDEC_EX_Result eExRetVal = E_VDEC_EX_OK;
1211
1212 eRetVal = MApi_VDEC_Exit();
1213 eExRetVal = _VDEC_MapExResult(eRetVal);
1214
1215 stStreamId.u32Version = 0;
1216 stStreamId.u32Id = VDEC_U32_MAX;
1217
1218 return eExRetVal;
1219 }
1220
1221 //------------------------------------------------------------------------------
1222 /// Check if information for display setting is ready or not
1223 /// @return VDEC_Result
1224 //------------------------------------------------------------------------------
MApi_VDEC_EX_CheckDispInfoRdy(VDEC_StreamId * pStreamId)1225 VDEC_EX_Result MApi_VDEC_EX_CheckDispInfoRdy(VDEC_StreamId *pStreamId)
1226 {
1227 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1228
1229 return _VDEC_MapExResult(MApi_VDEC_CheckDispInfoRdy());
1230 }
1231
_VDEC_MapFrcMode(VDEC_EX_FrcMode eExFrcMode)1232 static VDEC_FrcMode _VDEC_MapFrcMode(VDEC_EX_FrcMode eExFrcMode)
1233 {
1234 VDEC_FrcMode eFrcMode = E_VDEC_FRC_NORMAL;
1235
1236 switch (eExFrcMode)
1237 {
1238 case E_VDEC_EX_FRC_NORMAL:
1239 eFrcMode = E_VDEC_FRC_NORMAL;
1240 break;
1241 case E_VDEC_EX_FRC_DISP_TWICE:
1242 eFrcMode = E_VDEC_FRC_DISP_TWICE;
1243 break;
1244 case E_VDEC_EX_FRC_3_2_PULLDOWN:
1245 eFrcMode = E_VDEC_FRC_3_2_PULLDOWN;
1246 break;
1247 case E_VDEC_EX_FRC_PAL_TO_NTSC:
1248 eFrcMode = E_VDEC_FRC_PAL_TO_NTSC;
1249 break;
1250 case E_VDEC_EX_FRC_NTSC_TO_PAL:
1251 eFrcMode = E_VDEC_FRC_NTSC_TO_PAL;
1252 break;
1253 case E_VDEC_EX_FRC_MODE_50P_60P:
1254 eFrcMode = E_VDEC_FRC_MODE_50P_60P;
1255 break;
1256 case E_VDEC_EX_FRC_MODE_60P_50P:
1257 eFrcMode = E_VDEC_FRC_MODE_60P_50P;
1258 break;
1259 default:
1260 eFrcMode = E_VDEC_FRC_NORMAL;
1261 break;
1262 }
1263
1264 return eFrcMode;
1265 }
1266
1267 //------------------------------------------------------------------------------
1268 /// Set up frame rate conversion mode
1269 /// @param eFrcMode \b IN : frame rate conversion mode
1270 /// @return VDEC_Result
1271 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetFrcMode(VDEC_StreamId * pStreamId,VDEC_EX_FrcMode eExFrcMode)1272 VDEC_EX_Result MApi_VDEC_EX_SetFrcMode(VDEC_StreamId *pStreamId, VDEC_EX_FrcMode eExFrcMode)
1273 {
1274 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1275
1276 return _VDEC_MapExResult(MApi_VDEC_SetFrcMode(_VDEC_MapFrcMode(eExFrcMode)));
1277 }
1278
1279 //------------------------------------------------------------------------------
1280 /// Set up some parameters about dynamic scaling in FW
1281 /// @param u32Addr \b IN : the physical start address of parameter set
1282 /// @param u32Size \b IN : the size of parameter set
1283 /// @return VDEC_Result
1284 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetDynScalingParams(VDEC_StreamId * pStreamId,MS_PHYADDR u32Addr,MS_U32 u32Size)1285 VDEC_EX_Result MApi_VDEC_EX_SetDynScalingParams(VDEC_StreamId *pStreamId, MS_PHYADDR u32Addr, MS_U32 u32Size)
1286 {
1287 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1288
1289 return _VDEC_MapExResult(MApi_VDEC_SetDynScalingParams(u32Addr, u32Size));
1290 }
1291
1292 //------------------------------------------------------------------------------
1293 /// Start playback
1294 /// @return return VDEC_Result
1295 //------------------------------------------------------------------------------
MApi_VDEC_EX_Play(VDEC_StreamId * pStreamId)1296 VDEC_EX_Result MApi_VDEC_EX_Play(VDEC_StreamId *pStreamId)
1297 {
1298 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1299
1300 return _VDEC_MapExResult(MApi_VDEC_Play());
1301 }
1302
1303 //------------------------------------------------------------------------------
1304 /// Pause decode and display
1305 /// @return return VDEC_Result
1306 //-----------------------------------------------------------------------------
MApi_VDEC_EX_Pause(VDEC_StreamId * pStreamId)1307 VDEC_EX_Result MApi_VDEC_EX_Pause(VDEC_StreamId *pStreamId)
1308 {
1309 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1310
1311 return _VDEC_MapExResult(MApi_VDEC_Pause());
1312 }
1313
1314 //------------------------------------------------------------------------------
1315 /// Resume decode and display
1316 /// @return return VDEC_Result
1317 //------------------------------------------------------------------------------
MApi_VDEC_EX_Resume(VDEC_StreamId * pStreamId)1318 VDEC_EX_Result MApi_VDEC_EX_Resume(VDEC_StreamId *pStreamId)
1319 {
1320 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1321
1322 return _VDEC_MapExResult(MApi_VDEC_Resume());
1323 }
1324
1325 //------------------------------------------------------------------------------
1326 /// Trigger to display one frame (background may still decoding)
1327 /// @return return VDEC_Result
1328 //------------------------------------------------------------------------------
MApi_VDEC_EX_StepDisp(VDEC_StreamId * pStreamId)1329 VDEC_EX_Result MApi_VDEC_EX_StepDisp(VDEC_StreamId *pStreamId)
1330 {
1331 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1332
1333 return _VDEC_MapExResult(MApi_VDEC_StepDisp());
1334 }
1335
1336 //------------------------------------------------------------------------------
1337 /// Check if step play done or not
1338 /// @return VDEC_Result
1339 /// - E_VDEC_OK: step display done
1340 /// - E_VDEC_FAIL: not yet
1341 /// - E_VDEC_RET_NOT_INIT: not initial yet
1342 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1343 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsStepDispDone(VDEC_StreamId * pStreamId)1344 VDEC_EX_Result MApi_VDEC_EX_IsStepDispDone(VDEC_StreamId *pStreamId)
1345 {
1346 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1347
1348 return _VDEC_MapExResult(MApi_VDEC_IsStepDispDone());
1349 }
1350
1351 //------------------------------------------------------------------------------
1352 /// Decoder will start decode with full speed until target PTS is reached (equal or larger) then pause.
1353 /// @param u32PTS \b IN : target PTS
1354 /// @return VDEC_Result
1355 //------------------------------------------------------------------------------
MApi_VDEC_EX_SeekToPTS(VDEC_StreamId * pStreamId,MS_U32 u32PTS)1356 VDEC_EX_Result MApi_VDEC_EX_SeekToPTS(VDEC_StreamId *pStreamId, MS_U32 u32PTS)
1357 {
1358 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1359
1360 return _VDEC_MapExResult(MApi_VDEC_SeekToPTS(u32PTS));
1361 }
1362
1363 //------------------------------------------------------------------------------
1364 /// Decoder will skip all frames before target PTS, and start decode with full speed after target PTS is reached.
1365 /// @param u32PTS \b IN : target PTS
1366 /// - 0: turn off this mode.
1367 /// - any not zero: enable this mode.
1368 /// @return VDEC_Result
1369 //------------------------------------------------------------------------------
MApi_VDEC_EX_SkipToPTS(VDEC_StreamId * pStreamId,MS_U32 u32PTS)1370 VDEC_EX_Result MApi_VDEC_EX_SkipToPTS(VDEC_StreamId *pStreamId, MS_U32 u32PTS)
1371 {
1372 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1373
1374 return _VDEC_MapExResult(MApi_VDEC_SkipToPTS(u32PTS));
1375 }
1376
1377 //------------------------------------------------------------------------------
1378 /// Trigger decoder to decode one frame.
1379 /// Decoder seeks to an I frame, decodes and displays it.
1380 /// @return return VDEC_Result
1381 //------------------------------------------------------------------------------
MApi_VDEC_EX_StepDecode(VDEC_StreamId * pStreamId)1382 VDEC_EX_Result MApi_VDEC_EX_StepDecode(VDEC_StreamId *pStreamId)
1383 {
1384 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1385
1386 return _VDEC_MapExResult(MApi_VDEC_StepDecode());
1387 }
1388
1389 //------------------------------------------------------------------------------
1390 /// Check if step decode done or not
1391 /// @return VDEC_Result
1392 /// - E_VDEC_OK: step decode done
1393 /// - E_VDEC_FAIL: not yet
1394 /// - E_VDEC_RET_NOT_INIT: not initial yet
1395 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1396 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsStepDecodeDone(VDEC_StreamId * pStreamId)1397 VDEC_EX_Result MApi_VDEC_EX_IsStepDecodeDone(VDEC_StreamId *pStreamId)
1398 {
1399 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1400
1401 return _VDEC_MapExResult(MApi_VDEC_IsStepDecodeDone());
1402 }
1403
1404 //------------------------------------------------------------------------------
1405 /// Set up trick decode mode for decode I, decode IP and decode all.
1406 /// @param eTrickDec \b IN : trick decode mode
1407 /// @return VDEC_Result
1408 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetTrickMode(VDEC_StreamId * pStreamId,VDEC_EX_TrickDec eExTrickDec)1409 VDEC_EX_Result MApi_VDEC_EX_SetTrickMode(VDEC_StreamId *pStreamId, VDEC_EX_TrickDec eExTrickDec)
1410 {
1411 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1412
1413 return _VDEC_MapExResult(MApi_VDEC_SetTrickMode(_VDEC_MapTrickDecMode(eExTrickDec)));
1414 }
1415
1416 //------------------------------------------------------------------------------
1417 /// Push decode command queue
1418 /// @param pCmd \b IN : the pointer to decode command
1419 /// @return VDEC_Result
1420 //------------------------------------------------------------------------------
MApi_VDEC_EX_PushDecQ(VDEC_StreamId * pStreamId,VDEC_EX_DecCmd * pExCmd)1421 VDEC_EX_Result MApi_VDEC_EX_PushDecQ(VDEC_StreamId *pStreamId, VDEC_EX_DecCmd *pExCmd)
1422 {
1423 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1424
1425 VDEC_Result eRetVal = E_VDEC_FAIL;
1426 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
1427 VDEC_DecCmd stDecCmd;
1428 _VDEC_MapDecCmd(pExCmd, &stDecCmd);
1429 eRetVal = MApi_VDEC_PushDecQ(&stDecCmd);
1430 eExRetVal = _VDEC_MapExResult(eRetVal);
1431
1432 return eExRetVal;
1433 }
1434
1435 //------------------------------------------------------------------------------
1436 /// Fire the decode command which be pushed since last fired
1437 /// @return VDEC_Result
1438 //------------------------------------------------------------------------------
MApi_VDEC_EX_FireDecCmd(VDEC_StreamId * pStreamId)1439 VDEC_EX_Result MApi_VDEC_EX_FireDecCmd(VDEC_StreamId *pStreamId)
1440 {
1441 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1442
1443 return _VDEC_MapExResult(MApi_VDEC_FireDecCmd());
1444 }
1445
1446 //------------------------------------------------------------------------------
1447 /// Get current queue vacancy
1448 /// @return vacancy number
1449 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDecQVacancy(VDEC_StreamId * pStreamId)1450 MS_U32 MApi_VDEC_EX_GetDecQVacancy(VDEC_StreamId *pStreamId)
1451 {
1452 MS_U32 u32DecQVac = 0;
1453
1454 if(VDEC_MAIN_ID != pStreamId->u32Id)
1455 return u32DecQVac;
1456 else
1457 return MApi_VDEC_GetDecQVacancy();
1458 }
1459
MApi_VDEC_EX_IsCCAvailable(VDEC_StreamId * pStreamId)1460 MS_BOOL MApi_VDEC_EX_IsCCAvailable(VDEC_StreamId *pStreamId)
1461 {
1462 MS_BOOL bIsCCAvail = FALSE;
1463
1464 if(VDEC_MAIN_ID != pStreamId->u32Id)
1465 return bIsCCAvail;
1466 else
1467 return MApi_VDEC_IsCCAvailable();
1468 }
1469
MApi_VDEC_EX_GetCCInfo(VDEC_StreamId * pStreamId,void * pInfo,MS_U32 u32Size)1470 VDEC_EX_Result MApi_VDEC_EX_GetCCInfo(VDEC_StreamId *pStreamId, void *pInfo, MS_U32 u32Size)
1471 {
1472 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1473
1474 VDEC_Result eRetVal = E_VDEC_OK;
1475 VDEC_EX_Result eExRetVal = E_VDEC_EX_OK;
1476
1477 MS_U32 u32Version = *((MS_U32 *) pInfo);
1478
1479 if (u32Version == 0 && u32Size == sizeof(VDEC_EX_CC_Info))
1480 {
1481 VDEC_CC_Info stCCInfo;
1482
1483 _VDEC_Memset(&stCCInfo, 0, sizeof(VDEC_CC_Info));
1484
1485 eRetVal = MApi_VDEC_GetCCInfo(&stCCInfo, sizeof(VDEC_CC_Info));
1486
1487 ((VDEC_EX_CC_Info *)pInfo)->u8PicStructure = stCCInfo.u8PicStructure;
1488 ((VDEC_EX_CC_Info *)pInfo)->u8TopFieldFirst = stCCInfo.u8TopFieldFirst;
1489 ((VDEC_EX_CC_Info *)pInfo)->u16TempRef = stCCInfo.u16TempRef;
1490 ((VDEC_EX_CC_Info *)pInfo)->u32Pts = stCCInfo.u32Pts;
1491 ((VDEC_EX_CC_Info *)pInfo)->u32UserDataBuf = stCCInfo.u32UserDataBuf;
1492 ((VDEC_EX_CC_Info *)pInfo)->u32UserDataSize = stCCInfo.u32UserDataSize;
1493 ((VDEC_EX_CC_Info *)pInfo)->eFrameType = E_VDEC_EX_FRM_TYPE_OTHER;
1494
1495 eExRetVal = _VDEC_MapExResult(eRetVal);
1496 }
1497 else
1498 {
1499 VDEC_INFO(printf("%s err: wrong pInfo\n", __FUNCTION__));
1500 eExRetVal = E_VDEC_EX_RET_INVALID_PARAM;
1501 }
1502
1503 return eExRetVal;
1504 }
1505
1506 //------------------------------------------------------------------------------
1507 /// Flush command queue and internal data of decoder
1508 /// @return VDEC_Result
1509 //------------------------------------------------------------------------------
MApi_VDEC_EX_Flush(VDEC_StreamId * pStreamId,VDEC_EX_FreezePicSelect eExFreezePic)1510 VDEC_EX_Result MApi_VDEC_EX_Flush(VDEC_StreamId *pStreamId, VDEC_EX_FreezePicSelect eExFreezePic)
1511 {
1512 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1513
1514 return _VDEC_MapExResult(MApi_VDEC_Flush(_VDEC_MapFreezePicSel(eExFreezePic)));
1515 }
1516
1517 //------------------------------------------------------------------------------
1518 /// Get ES buffer write pointer
1519 /// @return write pointer
1520 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetESWritePtr(VDEC_StreamId * pStreamId)1521 MS_U32 MApi_VDEC_EX_GetESWritePtr(VDEC_StreamId *pStreamId)
1522 {
1523 MS_U32 u32WrPtr = 0;
1524
1525 if(VDEC_MAIN_ID != pStreamId->u32Id)
1526 return u32WrPtr;
1527 else
1528 return MApi_VDEC_GetESWritePtr();
1529 }
1530
1531 //------------------------------------------------------------------------------
1532 /// Get decoder ES buffer read pointer
1533 /// @return read pointer
1534 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetESReadPtr(VDEC_StreamId * pStreamId)1535 MS_U32 MApi_VDEC_EX_GetESReadPtr(VDEC_StreamId *pStreamId)
1536 {
1537 MS_U32 u32RdPtr = 0;
1538
1539 if(VDEC_MAIN_ID != pStreamId->u32Id)
1540 return u32RdPtr;
1541 else
1542 return MApi_VDEC_GetESReadPtr();
1543 }
1544
1545 //------------------------------------------------------------------------------
1546 /// Enable to let decoder force to display all decoded frame when out of input data
1547 /// @param bEnable \b IN : TRUE - enable; FALSE - disable
1548 /// @return VDEC_Result
1549 //------------------------------------------------------------------------------
MApi_VDEC_EX_EnableLastFrameShow(VDEC_StreamId * pStreamId,MS_BOOL bEnable)1550 VDEC_EX_Result MApi_VDEC_EX_EnableLastFrameShow(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
1551 {
1552 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1553
1554 return _VDEC_MapExResult(MApi_VDEC_EnableLastFrameShow(bEnable));
1555 }
1556
1557 //------------------------------------------------------------------------------
1558 /// Check if all decoded frames are displayed when input stream is run out
1559 /// @return VDEC_Result
1560 /// - E_VDEC_OK: finished
1561 /// - E_VDEC_FAIL: not yet
1562 /// - E_VDEC_RET_NOT_INIT: not initial yet
1563 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1564 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsDispFinish(VDEC_StreamId * pStreamId)1565 VDEC_EX_Result MApi_VDEC_EX_IsDispFinish(VDEC_StreamId *pStreamId)
1566 {
1567 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1568
1569 return _VDEC_MapExResult(MApi_VDEC_IsDispFinish());
1570 }
1571
1572 //------------------------------------------------------------------------------
1573 /// Set up display speed
1574 /// @param eSpeedType \b IN : display speed type
1575 /// @param eSpeed \b IN : multiple
1576 /// @return VDEC_Result
1577 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetSpeed(VDEC_StreamId * pStreamId,VDEC_EX_SpeedType eExSpeedType,VDEC_EX_DispSpeed eExSpeed)1578 VDEC_EX_Result MApi_VDEC_EX_SetSpeed(VDEC_StreamId *pStreamId, VDEC_EX_SpeedType eExSpeedType, VDEC_EX_DispSpeed eExSpeed)
1579 {
1580 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1581
1582 VDEC_SpeedType eSpeedType = _VDEC_MapSpeedType(eExSpeedType);
1583 VDEC_DispSpeed eSpeed = _VDEC_MapDispSpeed(eExSpeed);
1584
1585 return _VDEC_MapExResult(MApi_VDEC_SetSpeed(eSpeedType, eSpeed));
1586 }
1587
1588 //------------------------------------------------------------------------------
1589 /// Check if the first frame is showed after play function is called
1590 /// @return VDEC_Result
1591 /// - E_VDEC_OK: ready
1592 /// - E_VDEC_FAIL: not ready
1593 /// - E_VDEC_RET_NOT_INIT: not initial yet
1594 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1595 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsFrameRdy(VDEC_StreamId * pStreamId)1596 VDEC_EX_Result MApi_VDEC_EX_IsFrameRdy(VDEC_StreamId *pStreamId)
1597 {
1598 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1599
1600 return _VDEC_MapExResult(MApi_VDEC_IsFrameRdy());
1601 }
1602
1603 //------------------------------------------------------------------------------
1604 /// Let FW stop updating frames when vsync, but decoding process is still going.
1605 /// @param bEnable \b IN : Enable/Disable
1606 /// @return -The result of command freeze image.
1607 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetFreezeDisp(VDEC_StreamId * pStreamId,MS_BOOL bEnable)1608 VDEC_EX_Result MApi_VDEC_EX_SetFreezeDisp(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
1609 {
1610 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1611
1612 return _VDEC_MapExResult(MApi_VDEC_SetFreezeDisp(bEnable));
1613 }
1614
1615 //------------------------------------------------------------------------------
1616 /// Set blue screen on/off
1617 /// @param bOn \b IN : turn on / off blue screen
1618 /// @return VDEC_Result
1619 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetBlueScreen(VDEC_StreamId * pStreamId,MS_BOOL bOn)1620 VDEC_EX_Result MApi_VDEC_EX_SetBlueScreen(VDEC_StreamId *pStreamId, MS_BOOL bOn)
1621 {
1622 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1623
1624 return _VDEC_MapExResult(MApi_VDEC_SetBlueScreen(bOn));
1625 }
1626
1627 //------------------------------------------------------------------------------
1628 /// Reset PTS
1629 /// @param u32PtsBase \b IN : new PTS base value
1630 /// @return VDEC_Result
1631 //------------------------------------------------------------------------------
MApi_VDEC_EX_ResetPTS(VDEC_StreamId * pStreamId,MS_U32 u32PtsBase)1632 VDEC_EX_Result MApi_VDEC_EX_ResetPTS(VDEC_StreamId *pStreamId, MS_U32 u32PtsBase)
1633 {
1634 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1635
1636 return _VDEC_MapExResult(MApi_VDEC_ResetPTS(u32PtsBase));
1637 }
1638
1639 //------------------------------------------------------------------------------
1640 /// Switch AV sync on/off
1641 /// @param bOn \b IN : on/off
1642 /// @param u32SyncDelay \b IN : delay value
1643 /// @param u16SyncTolerance \b IN : tolerance value
1644 /// @return VDEC_Result
1645 //------------------------------------------------------------------------------
MApi_VDEC_EX_AVSyncOn(VDEC_StreamId * pStreamId,MS_BOOL bOn,MS_U32 u32SyncDelay,MS_U16 u16SyncTolerance)1646 VDEC_EX_Result MApi_VDEC_EX_AVSyncOn(VDEC_StreamId *pStreamId, MS_BOOL bOn, MS_U32 u32SyncDelay, MS_U16 u16SyncTolerance)
1647 {
1648 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1649
1650 return _VDEC_MapExResult(MApi_VDEC_AVSyncOn(bOn, u32SyncDelay, u16SyncTolerance));
1651 }
1652
1653 //------------------------------------------------------------------------------
1654 /// Switch AV sync free run threshold
1655 /// @param u32Threshold \b IN : threshold value
1656 /// @return VDEC_Result
1657 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetAVSyncFreerunThreshold(VDEC_StreamId * pStreamId,MS_U32 u32Threshold)1658 VDEC_EX_Result MApi_VDEC_EX_SetAVSyncFreerunThreshold(VDEC_StreamId *pStreamId, MS_U32 u32Threshold )
1659 {
1660 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1661
1662 return _VDEC_MapExResult(MApi_VDEC_SetAVSyncFreerunThreshold(u32Threshold));
1663 }
1664
1665
1666 //------------------------------------------------------------------------------
1667 /// Check if AV sync on or not
1668 /// @return VDEC_Result
1669 /// - E_VDEC_OK: AV sync on
1670 /// - E_VDEC_FAIL: freerun
1671 /// - E_VDEC_RET_NOT_INIT: not initial yet
1672 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1673 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsAVSyncOn(VDEC_StreamId * pStreamId)1674 VDEC_EX_Result MApi_VDEC_EX_IsAVSyncOn(VDEC_StreamId *pStreamId)
1675 {
1676 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1677
1678 return _VDEC_MapExResult(MApi_VDEC_IsAVSyncOn());
1679 }
1680
1681 //------------------------------------------------------------------------------
1682 /// Get the PTS of current displayed frame
1683 /// @return PTS
1684 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetPTS(VDEC_StreamId * pStreamId)1685 MS_U32 MApi_VDEC_EX_GetPTS(VDEC_StreamId *pStreamId)
1686 {
1687 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1688
1689 return MApi_VDEC_GetPTS();
1690 }
1691
1692 //------------------------------------------------------------------------------
1693 /// Get the PTS of next displayed frame
1694 /// @return next PTS (unit:ms)
1695 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetNextPTS(VDEC_StreamId * pStreamId)1696 MS_U32 MApi_VDEC_EX_GetNextPTS(VDEC_StreamId *pStreamId)
1697 {
1698 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1699
1700 return MApi_VDEC_GetNextPTS();
1701 }
1702
1703 //------------------------------------------------------------------------------
1704 /// Check if decoder is doing AV sync now
1705 /// @return VDEC_Result
1706 /// - E_VDEC_OK: doing AV sync
1707 /// - E_VDEC_FAIL: still freerun
1708 /// - E_VDEC_RET_NOT_INIT: not initial yet
1709 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1710 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsStartSync(VDEC_StreamId * pStreamId)1711 VDEC_EX_Result MApi_VDEC_EX_IsStartSync(VDEC_StreamId *pStreamId)
1712 {
1713 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1714
1715 return _VDEC_MapExResult(MApi_VDEC_IsStartSync());
1716 }
1717
1718 //------------------------------------------------------------------------------
1719 /// Check if the distance of Video time stamp and STC is closed enough.
1720 /// @return VDEC_Result
1721 /// - E_VDEC_OK: sync complete
1722 /// - E_VDEC_FAIL: sync is incomplete
1723 /// - E_VDEC_RET_NOT_INIT: not initial yet
1724 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1725 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsReachSync(VDEC_StreamId * pStreamId)1726 VDEC_EX_Result MApi_VDEC_EX_IsReachSync(VDEC_StreamId *pStreamId)
1727 {
1728 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1729
1730 return _VDEC_MapExResult(MApi_VDEC_IsReachSync());
1731 }
1732
1733 //------------------------------------------------------------------------------
1734 /// Check if decoder is avsync freerun
1735 /// @return VDEC_Result
1736 /// - E_VDEC_OK: freerun
1737 /// - E_VDEC_FAIL: not freerun
1738 /// - E_VDEC_RET_NOT_INIT: not initial yet
1739 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1740 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsFreerun(VDEC_StreamId * pStreamId)1741 VDEC_EX_Result MApi_VDEC_EX_IsFreerun(VDEC_StreamId *pStreamId)
1742 {
1743 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1744
1745 return _VDEC_MapExResult(MApi_VDEC_IsFreerun());
1746 }
1747
1748 //------------------------------------------------------------------------------
1749 /// For MHEG5 MW, decode one I frame
1750 /// @param u32FrameBufAddr \b IN : output buffer address
1751 /// @param u32SrcSt \b IN : source start address
1752 /// @param u32SrcEnd \b IN : source end address
1753 /// @return VDEC_Result
1754 //------------------------------------------------------------------------------
MApi_VDEC_EX_MHEG_DecodeIFrame(VDEC_StreamId * pStreamId,MS_PHYADDR u32FrameBufAddr,MS_PHYADDR u32SrcSt,MS_PHYADDR u32SrcEnd)1755 VDEC_EX_Result MApi_VDEC_EX_MHEG_DecodeIFrame(VDEC_StreamId *pStreamId,
1756 MS_PHYADDR u32FrameBufAddr,
1757 MS_PHYADDR u32SrcSt,
1758 MS_PHYADDR u32SrcEnd)
1759 {
1760 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1761
1762 return _VDEC_MapExResult(MApi_VDEC_MHEG_DecodeIFrame(u32FrameBufAddr, u32SrcSt, u32SrcEnd));
1763 }
1764
1765 //------------------------------------------------------------------------------
1766 /// For MHEG5 MW, check if I frame decode done
1767 /// @return VDEC_Result
1768 /// - E_VDEC_OK: decode done
1769 /// - E_VDEC_FAIL: not yet
1770 /// - E_VDEC_RET_NOT_INIT: not initial yet
1771 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1772 //------------------------------------------------------------------------------
MApi_VDEC_EX_MHEG_IsIFrameDecoding(VDEC_StreamId * pStreamId)1773 VDEC_EX_Result MApi_VDEC_EX_MHEG_IsIFrameDecoding(VDEC_StreamId *pStreamId)
1774 {
1775 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1776
1777 return _VDEC_MapExResult(MApi_VDEC_MHEG_IsIFrameDecoding());
1778 }
1779
1780 //------------------------------------------------------------------------------
1781 /// For MHEG5 MW, reset decoder after I frame decode done
1782 /// @return VDEC_Result
1783 //------------------------------------------------------------------------------
MApi_VDEC_EX_MHEG_RstIFrameDec(VDEC_StreamId * pStreamId)1784 VDEC_EX_Result MApi_VDEC_EX_MHEG_RstIFrameDec(VDEC_StreamId *pStreamId)
1785 {
1786 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1787
1788 VDEC_Result eRetVal = E_VDEC_OK;
1789 VDEC_InitParam stInitPara;
1790 VDEC_EX_InitParam *pExInitParam = &_ExVdecInitParam;
1791
1792 eRetVal = MApi_VDEC_Exit();
1793 if (E_VDEC_OK != eRetVal)
1794 {
1795 printf("%s fail to exit 0x%x\n", __FUNCTION__, eRetVal);
1796 }
1797
1798 if (!_VDEC_MapInitParam(pExInitParam, &stInitPara))
1799 {
1800 return E_VDEC_EX_RET_INVALID_PARAM;
1801 }
1802
1803 eRetVal = MApi_VDEC_Init(&stInitPara);
1804 if (E_VDEC_OK != eRetVal)
1805 {
1806 printf("%s fail to init 0x%x\n", __FUNCTION__, eRetVal);
1807 }
1808
1809 return _VDEC_MapExResult(eRetVal);
1810 }
1811
1812 //------------------------------------------------------------------------------
1813 /// Get error code
1814 /// @return error code
1815 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetErrCode(VDEC_StreamId * pStreamId)1816 MS_U32 MApi_VDEC_EX_GetErrCode(VDEC_StreamId *pStreamId)
1817 {
1818 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1819
1820 return MApi_VDEC_GetErrCode();
1821 }
1822
1823 //------------------------------------------------------------------------------
1824 /// Get accumulated error counter
1825 /// @return error counter
1826 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetErrCnt(VDEC_StreamId * pStreamId)1827 MS_U32 MApi_VDEC_EX_GetErrCnt(VDEC_StreamId *pStreamId)
1828 {
1829 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1830
1831 return MApi_VDEC_GetErrCnt();
1832 }
1833
1834 //------------------------------------------------------------------------------
1835 /// Get codec type which be initialed
1836 /// @return VDEC_CodecType
1837 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetActiveCodecType(VDEC_StreamId * pStreamId)1838 VDEC_EX_CodecType MApi_VDEC_EX_GetActiveCodecType(VDEC_StreamId *pStreamId)
1839 {
1840 VDEC_EX_CodecType eExCodecType = E_VDEC_EX_CODEC_TYPE_NONE;
1841 if(VDEC_MAIN_ID != pStreamId->u32Id)
1842 return eExCodecType;
1843 else
1844 return _VDEC_MapExCodecType(MApi_VDEC_GetActiveCodecType());
1845 }
1846
1847 //------------------------------------------------------------------------------
1848 /// Get bitrate which decoder retrieved from stream
1849 /// @return bitrate
1850 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetBitsRate(VDEC_StreamId * pStreamId)1851 MS_U32 MApi_VDEC_EX_GetBitsRate(VDEC_StreamId *pStreamId)
1852 {
1853 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1854
1855 return MApi_VDEC_GetBitsRate();
1856 }
1857
1858 //------------------------------------------------------------------------------
1859 /// Get 3:2 pull down flag which decoder retrieved from stream
1860 /// @return TRUE/FALSE
1861 //------------------------------------------------------------------------------
MApi_VDEC_EX_Is32PullDown(VDEC_StreamId * pStreamId)1862 MS_BOOL MApi_VDEC_EX_Is32PullDown(VDEC_StreamId *pStreamId)
1863 {
1864 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1865
1866 return MApi_VDEC_Is32PullDown();
1867 }
1868
1869 //------------------------------------------------------------------------------
1870 /// Check whether the status of decoder is running or not.
1871 /// @return VDEC_Result: E_VDEC_OK/E_VDEC_RET_NOT_RUNNING/E_VDEC_RET_NOT_INIT
1872 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsAlive(VDEC_StreamId * pStreamId)1873 VDEC_EX_Result MApi_VDEC_EX_IsAlive(VDEC_StreamId *pStreamId)
1874 {
1875 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1876
1877 return _VDEC_MapExResult(MApi_VDEC_IsAlive());
1878 }
1879
1880 //------------------------------------------------------------------------------
1881 /// Get the value of PTS - STC for video
1882 /// @return the value of PTS - STC for video
1883 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetVideoPtsStcDelta(VDEC_StreamId * pStreamId)1884 MS_S64 MApi_VDEC_EX_GetVideoPtsStcDelta(VDEC_StreamId *pStreamId)
1885 {
1886 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1887
1888 return MApi_VDEC_GetVideoPtsStcDelta();
1889 }
1890
1891 //------------------------------------------------------------------------------
1892 /// Check if decoder got valid stream to decode
1893 /// @return TRUE or FALSE
1894 /// - TRUE: find valid stream
1895 /// - FALSE: not yet
1896 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsWithValidStream(VDEC_StreamId * pStreamId)1897 VDEC_EX_Result MApi_VDEC_EX_IsWithValidStream(VDEC_StreamId *pStreamId)
1898 {
1899 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1900
1901 return _VDEC_MapExResult(MApi_VDEC_IsWithValidStream());
1902 }
1903
1904 //------------------------------------------------------------------------------
1905 /// Check if decoder found I frame after reset or flush queue
1906 /// @return VDEC_Result
1907 /// - E_VDEC_OK: found
1908 /// - E_VDEC_FAIL: not found
1909 /// - E_VDEC_RET_NOT_INIT: not initial yet
1910 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1911 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsIFrameFound(VDEC_StreamId * pStreamId)1912 VDEC_EX_Result MApi_VDEC_EX_IsIFrameFound(VDEC_StreamId *pStreamId)
1913 {
1914 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1915
1916 return _VDEC_MapExResult(MApi_VDEC_IsIFrameFound());
1917 }
1918
1919 //------------------------------------------------------------------------------
1920 /// Check if input stream is with low delay flag
1921 /// @return VDEC_Result
1922 /// - E_VDEC_OK: with low delay
1923 /// - E_VDEC_FAIL: without low delay
1924 /// - E_VDEC_RET_NOT_INIT: not initial yet
1925 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1926 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsWithLowDelay(VDEC_StreamId * pStreamId)1927 VDEC_EX_Result MApi_VDEC_EX_IsWithLowDelay(VDEC_StreamId *pStreamId)
1928 {
1929 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1930
1931 return _VDEC_MapExResult(MApi_VDEC_IsWithLowDelay());
1932 }
1933
1934 //------------------------------------------------------------------------------
1935 /// Check if all date buffers are empty or not
1936 /// @return VDEC_Result
1937 /// - E_VDEC_OK: All of the buffers are empty
1938 /// - E_VDEC_FAIL: Some of the buffers are not empty
1939 /// - E_VDEC_RET_NOT_INIT: not initial yet
1940 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
1941 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsAllBufferEmpty(VDEC_StreamId * pStreamId)1942 VDEC_EX_Result MApi_VDEC_EX_IsAllBufferEmpty(VDEC_StreamId *pStreamId)
1943 {
1944 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
1945
1946 return _VDEC_MapExResult(MApi_VDEC_IsAllBufferEmpty());
1947 }
1948
1949 //------------------------------------------------------------------------------
1950 /// Get picture counter of current GOP
1951 /// @return picture counter
1952 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetGOPCnt(VDEC_StreamId * pStreamId)1953 MS_U8 MApi_VDEC_EX_GetGOPCnt(VDEC_StreamId *pStreamId)
1954 {
1955 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1956
1957 return MApi_VDEC_GetGOPCnt();
1958 }
1959
1960 //-----------------------------------------------------------------------------
1961 /// Get accumulated decoded frame Count
1962 /// @return - decoded frame Count
1963 //-----------------------------------------------------------------------------
MApi_VDEC_EX_GetFrameCnt(VDEC_StreamId * pStreamId)1964 MS_U32 MApi_VDEC_EX_GetFrameCnt(VDEC_StreamId *pStreamId)
1965 {
1966 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1967
1968 return MApi_VDEC_GetFrameCnt();
1969 }
1970
1971 //------------------------------------------------------------------------------
1972 /// Get skipped counter
1973 /// @return counter
1974 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetSkipCnt(VDEC_StreamId * pStreamId)1975 MS_U32 MApi_VDEC_EX_GetSkipCnt(VDEC_StreamId *pStreamId)
1976 {
1977 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1978
1979 return MApi_VDEC_GetSkipCnt();
1980 }
1981
1982 //------------------------------------------------------------------------------
1983 /// Get dropped frame counter
1984 /// @return counter
1985 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDropCnt(VDEC_StreamId * pStreamId)1986 MS_U32 MApi_VDEC_EX_GetDropCnt(VDEC_StreamId *pStreamId)
1987 {
1988 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
1989
1990 return MApi_VDEC_GetDropCnt();
1991 }
1992
1993 //------------------------------------------------------------------------------
1994 /// Get display information
1995 /// @param pDispinfo \b OUT : pointer to display setting information
1996 /// @return VDEC_Result
1997 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDispInfo(VDEC_StreamId * pStreamId,VDEC_EX_DispInfo * pExDispinfo)1998 VDEC_EX_Result MApi_VDEC_EX_GetDispInfo(VDEC_StreamId *pStreamId, VDEC_EX_DispInfo *pExDispinfo)
1999 {
2000 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2001
2002 VDEC_Result eRetVal = E_VDEC_FAIL;
2003 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2004 VDEC_DispInfo stDispinfo;
2005
2006 if (pExDispinfo)
2007 {
2008 eRetVal = MApi_VDEC_GetDispInfo(&stDispinfo);
2009 if (eRetVal == E_VDEC_OK)
2010 {
2011 _VDEC_MapExDispInfo(&stDispinfo, pExDispinfo);
2012 }
2013 else
2014 {
2015 _VDEC_Memset(pExDispinfo, 0, sizeof(VDEC_DispInfo));
2016 }
2017 eExRetVal = _VDEC_MapExResult(eRetVal);
2018 }
2019 else
2020 {
2021 VDEC_INFO(printf("%s err: null input\n", __FUNCTION__));
2022 eExRetVal = E_VDEC_EX_RET_INVALID_PARAM;
2023 }
2024 return eExRetVal;
2025 }
2026
2027 //------------------------------------------------------------------------------
2028 /// Get current trick decode mode of decoder
2029 /// @return VDEC_TrickDec
2030 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetTrickMode(VDEC_StreamId * pStreamId)2031 VDEC_EX_TrickDec MApi_VDEC_EX_GetTrickMode(VDEC_StreamId *pStreamId)
2032 {
2033 if(VDEC_MAIN_ID != pStreamId->u32Id)
2034 return E_VDEC_EX_TRICK_DEC_NUM;
2035 else
2036 return _VDEC_MapExTrickDecMode(MApi_VDEC_GetTrickMode());
2037 }
2038
2039 //------------------------------------------------------------------------------
2040 /// Get stream active format which decoder retrieved
2041 /// @return active format ID
2042 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetActiveFormat(VDEC_StreamId * pStreamId)2043 MS_U8 MApi_VDEC_EX_GetActiveFormat(VDEC_StreamId *pStreamId)
2044 {
2045 MS_U8 u8ActFmt = 0xFF;
2046 if(VDEC_MAIN_ID != pStreamId->u32Id)
2047 return u8ActFmt;
2048 else
2049 return MApi_VDEC_GetActiveFormat();
2050 }
2051
2052 //------------------------------------------------------------------------------
2053 /// Get stream colour primaries
2054 /// @return stream colour primaries
2055 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetColourPrimaries(VDEC_StreamId * pStreamId)2056 MS_U8 MApi_VDEC_EX_GetColourPrimaries(VDEC_StreamId *pStreamId)
2057 {
2058 MS_U8 u8ColourPrimaries = 0xFF;
2059 if(VDEC_MAIN_ID != pStreamId->u32Id)
2060 return u8ColourPrimaries;
2061 else
2062 return MApi_VDEC_GetColourPrimaries();
2063 }
2064
2065 extern VDEC_Result MApi_VDEC_GetHWKey(MS_U8 *pu8Key);
MApi_VDEC_EX_GetHWKey(VDEC_StreamId * pStreamId,MS_U8 * pu8Key)2066 VDEC_EX_Result MApi_VDEC_EX_GetHWKey(VDEC_StreamId *pStreamId, MS_U8 *pu8Key)
2067 {
2068 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2069
2070 VDEC_Result eRetVal = E_VDEC_FAIL;
2071 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2072 eRetVal = MApi_VDEC_GetHWKey(pu8Key);
2073 eExRetVal = _VDEC_MapExResult(eRetVal);
2074
2075 return eExRetVal;
2076 }
2077
2078 //------------------------------------------------------------------------------
2079 /// Check if sequence header is different from previous one
2080 /// @return VDEC_Result
2081 /// - E_VDEC_OK: changed
2082 /// - E_VDEC_FAIL: not changed
2083 /// - E_VDEC_RET_NOT_INIT: not initial yet
2084 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
2085 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsSeqChg(VDEC_StreamId * pStreamId)2086 VDEC_EX_Result MApi_VDEC_EX_IsSeqChg(VDEC_StreamId *pStreamId)
2087 {
2088 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2089
2090 return _VDEC_MapExResult(MApi_VDEC_IsSeqChg());
2091 }
2092
2093 //------------------------------------------------------------------------------
2094 /// Set up debug message level
2095 /// @param eDbgLevel \b IN : message level
2096 /// @return VDEC_Result
2097 /// - E_VDEC_OK: Success
2098 /// - E_VDEC_FAIL: Failed
2099 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetDbgLevel(VDEC_StreamId * pStreamId,VDEC_EX_DbgLevel eExDbgLevel)2100 VDEC_EX_Result MApi_VDEC_EX_SetDbgLevel(VDEC_StreamId *pStreamId, VDEC_EX_DbgLevel eExDbgLevel)
2101 {
2102 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2103
2104 return _VDEC_MapExResult(MApi_VDEC_SetDbgLevel(_VDEC_MapDbgLevel(eExDbgLevel)));
2105 }
2106
2107 //------------------------------------------------------------------------------
2108 /// Get the information of the latest decoded frame.
2109 /// @param pFrmInfo \b IN : the information of the latest decoded frame
2110 /// @return -VDEC_Result
2111 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDecFrameInfo(VDEC_StreamId * pStreamId,VDEC_EX_FrameInfo * pExFrmInfo)2112 VDEC_EX_Result MApi_VDEC_EX_GetDecFrameInfo(VDEC_StreamId *pStreamId, VDEC_EX_FrameInfo *pExFrmInfo)
2113 {
2114 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2115
2116 VDEC_Result eRetVal = E_VDEC_FAIL;
2117 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2118 VDEC_FrameInfo stFrmInfo;
2119
2120 if (!pExFrmInfo)
2121 {
2122 VDEC_INFO(printf("%s err: null pFrmInfo\n", __FUNCTION__));
2123 return E_VDEC_EX_RET_INVALID_PARAM;
2124 }
2125
2126 eRetVal = MApi_VDEC_GetDecFrameInfo(&stFrmInfo);
2127 if (eRetVal == E_VDEC_OK)
2128 {
2129 _VDEC_MapExFrameInfo(&stFrmInfo, pExFrmInfo);
2130 }
2131 eExRetVal = _VDEC_MapExResult(eRetVal);
2132
2133 return eExRetVal;
2134 }
2135
2136 //------------------------------------------------------------------------------
2137 /// Get the information of current displaying frame.
2138 /// @param pFrmInfo \b IN : the information of displaying frame
2139 /// @return -VDEC_Result
2140 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDispFrameInfo(VDEC_StreamId * pStreamId,VDEC_EX_FrameInfo * pExFrmInfo)2141 VDEC_EX_Result MApi_VDEC_EX_GetDispFrameInfo(VDEC_StreamId *pStreamId, VDEC_EX_FrameInfo *pExFrmInfo)
2142 {
2143 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2144
2145 VDEC_Result eRetVal = E_VDEC_FAIL;
2146 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2147 VDEC_FrameInfo stFrmInfo;
2148
2149 if (!pExFrmInfo)
2150 {
2151 VDEC_INFO(printf("%s err: null pFrmInfo\n", __FUNCTION__));
2152 return E_VDEC_EX_RET_INVALID_PARAM;
2153 }
2154
2155 eRetVal = MApi_VDEC_GetDispFrameInfo(&stFrmInfo);
2156 if (eRetVal == E_VDEC_OK)
2157 {
2158 _VDEC_MapExFrameInfo(&stFrmInfo, pExFrmInfo);
2159 }
2160 eExRetVal = _VDEC_MapExResult(eRetVal);
2161
2162 return eExRetVal;
2163 }
2164
2165 //------------------------------------------------------------------------------
2166 /// Get the extension information of decoded frame.
2167 /// @param pExtDispinfo \b IN : the extension information of decoded frame.
2168 /// @return -VDEC_Result
2169 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetExtDispInfo(VDEC_StreamId * pStreamId,VDEC_EX_ExtDispInfo * pExExtDispInfo)2170 VDEC_EX_Result MApi_VDEC_EX_GetExtDispInfo(VDEC_StreamId *pStreamId, VDEC_EX_ExtDispInfo *pExExtDispInfo)
2171 {
2172 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2173
2174 VDEC_Result eRetVal = E_VDEC_FAIL;
2175 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2176 VDEC_ExtDispInfo stExtDispInfo;
2177
2178 if (!pExExtDispInfo)
2179 {
2180 VDEC_INFO(printf("%s err: null pExtDispinfo\n", __FUNCTION__));
2181 return E_VDEC_EX_RET_INVALID_PARAM;
2182 }
2183
2184 eRetVal = MApi_VDEC_GetExtDispInfo(&stExtDispInfo);
2185 if (eRetVal == E_VDEC_OK)
2186 {
2187 _VDEC_MapExtDispInfo(&stExtDispInfo, pExExtDispInfo);
2188 }
2189 eExRetVal = _VDEC_MapExResult(eRetVal);
2190
2191 return eExRetVal;
2192 }
2193
2194 //------------------------------------------------------------------------------
2195 /// Get the time_code of the latest decoded frame.
2196 /// @param pTimeCode \b IN : the time_code of the latest decoded frame
2197 /// @return -VDEC_Result
2198 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDecTimeCode(VDEC_StreamId * pStreamId,VDEC_EX_TimeCode * pExTimeCode)2199 VDEC_EX_Result MApi_VDEC_EX_GetDecTimeCode(VDEC_StreamId *pStreamId, VDEC_EX_TimeCode* pExTimeCode)
2200 {
2201 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2202
2203 VDEC_Result eRetVal = E_VDEC_FAIL;
2204 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2205 VDEC_TimeCode stTimeCode;
2206
2207 if (!pExTimeCode)
2208 {
2209 VDEC_INFO(printf("%s err: null pExTimeCode\n", __FUNCTION__));
2210 return E_VDEC_EX_RET_INVALID_PARAM;
2211 }
2212
2213 eRetVal = MApi_VDEC_GetDecTimeCode(&stTimeCode);
2214
2215 if (eRetVal == E_VDEC_OK)
2216 {
2217 _VDEC_MapExTimeCode(&stTimeCode, pExTimeCode);
2218 }
2219 eExRetVal = _VDEC_MapExResult(eRetVal);
2220
2221 return eExRetVal;
2222 }
2223
2224 //------------------------------------------------------------------------------
2225 /// Get the time_code of the latest displayed frame.
2226 /// @param pTimeCode \b IN : the time_code of the latest displayed frame
2227 /// @return -VDEC_Result
2228 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDispTimeCode(VDEC_StreamId * pStreamId,VDEC_EX_TimeCode * pExTimeCode)2229 VDEC_EX_Result MApi_VDEC_EX_GetDispTimeCode(VDEC_StreamId *pStreamId, VDEC_EX_TimeCode* pExTimeCode)
2230 {
2231 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2232
2233 VDEC_Result eRetVal = E_VDEC_FAIL;
2234 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2235 VDEC_TimeCode stTimeCode;
2236 if (!pExTimeCode)
2237 {
2238 return E_VDEC_EX_RET_INVALID_PARAM;
2239 }
2240
2241 eRetVal = MApi_VDEC_GetDispTimeCode(&stTimeCode);
2242 if (eRetVal == E_VDEC_OK)
2243 {
2244 _VDEC_MapExTimeCode(&stTimeCode, pExTimeCode);
2245 }
2246 eExRetVal = _VDEC_MapExResult(eRetVal);
2247
2248 return eExRetVal;
2249 }
2250
2251 //------------------------------------------------------------------------------
2252 /// [Obsolete] Start CC data parsing.
2253 /// @param pCCParam \b IN : CC configuration
2254 /// @return -VDEC_Result
2255 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_StartParsing(VDEC_StreamId * pStreamId,VDEC_EX_CCCfg * pCCParam)2256 VDEC_EX_Result MApi_VDEC_EX_CC_StartParsing(VDEC_StreamId *pStreamId, VDEC_EX_CCCfg *pCCParam)
2257 {
2258 printf("%s is obsolete\n", __FUNCTION__);
2259 UNUSED(pCCParam);
2260 return E_VDEC_EX_RET_UNSUPPORTED;
2261 }
2262
2263 //------------------------------------------------------------------------------
2264 /// [Obsolete] Stop CC data parsing.
2265 /// @return -VDEC_Result
2266 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_StopParsing(VDEC_StreamId * pStreamId)2267 VDEC_EX_Result MApi_VDEC_EX_CC_StopParsing(VDEC_StreamId *pStreamId)
2268 {
2269 printf("%s is obsolete\n", __FUNCTION__);
2270 return E_VDEC_EX_RET_UNSUPPORTED;
2271 }
2272
2273 //------------------------------------------------------------------------------
2274 /// [Obsolete] Get write pointer of CC data buffer.
2275 /// @param pu32Write \b OUT : current write pointer
2276 /// @return -VDEC_Result
2277 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetWritePtr(VDEC_StreamId * pStreamId,MS_U32 * pu32Write)2278 VDEC_EX_Result MApi_VDEC_EX_CC_GetWritePtr(VDEC_StreamId *pStreamId, MS_U32 *pu32Write)
2279 {
2280 printf("%s is obsolete\n", __FUNCTION__);
2281 UNUSED(pu32Write);
2282 return E_VDEC_EX_RET_UNSUPPORTED;
2283 }
2284
2285 //------------------------------------------------------------------------------
2286 /// [Obsolete] Get the read pointer of CC data buffer.
2287 /// @param pu32Read \b OUT : current read pointer
2288 /// @return -VDEC_Result
2289 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetReadPtr(VDEC_StreamId * pStreamId,MS_U32 * pu32Read)2290 VDEC_EX_Result MApi_VDEC_EX_CC_GetReadPtr(VDEC_StreamId *pStreamId, MS_U32 *pu32Read)
2291 {
2292 printf("%s is obsolete\n", __FUNCTION__);
2293 UNUSED(pu32Read);
2294 return E_VDEC_EX_RET_UNSUPPORTED;
2295 }
2296
2297 //------------------------------------------------------------------------------
2298 /// [Obsolete] Update the read pointer of CC data buffer.
2299 /// @param u32EachPacketSize \b IN : new read pointer
2300 /// @return -VDEC_Result
2301 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_UpdateReadPtr(VDEC_StreamId * pStreamId,MS_U32 u32EachPacketSize)2302 VDEC_EX_Result MApi_VDEC_EX_CC_UpdateReadPtr(VDEC_StreamId *pStreamId, MS_U32 u32EachPacketSize)
2303 {
2304 printf("%s is obsolete\n", __FUNCTION__);
2305 UNUSED(u32EachPacketSize);
2306 return E_VDEC_EX_RET_UNSUPPORTED;
2307 }
2308
2309 //------------------------------------------------------------------------------
2310 /// [Obsolete] Get if CC data buffer is overflow.
2311 /// @param pbOverflow \b OUT : overflow flag
2312 /// @return -VDEC_Result
2313 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetIsOverflow(VDEC_StreamId * pStreamId,MS_BOOL * pbOverflow)2314 VDEC_EX_Result MApi_VDEC_EX_CC_GetIsOverflow(VDEC_StreamId *pStreamId, MS_BOOL *pbOverflow)
2315 {
2316 printf("%s is obsolete\n", __FUNCTION__);
2317 UNUSED(pbOverflow);
2318 return E_VDEC_EX_RET_UNSUPPORTED;
2319 }
2320
MApi_VDEC_EX_SetEvent(VDEC_StreamId * pStreamId,MS_U32 u32EventFlag,VDEC_EX_EventCb pfn,void * param)2321 VDEC_EX_Result MApi_VDEC_EX_SetEvent(VDEC_StreamId *pStreamId, MS_U32 u32EventFlag, VDEC_EX_EventCb pfn, void* param)
2322 {
2323 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2324
2325 VDEC_Result eRetVal = E_VDEC_FAIL;
2326 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2327 eRetVal = MApi_VDEC_SetEvent(u32EventFlag, pfn, param);
2328 eExRetVal = _VDEC_MapExResult(eRetVal);
2329
2330 return eExRetVal;
2331 }
2332
MApi_VDEC_EX_UnsetEvent(VDEC_StreamId * pStreamId,MS_U32 u32EventFlag)2333 VDEC_EX_Result MApi_VDEC_EX_UnsetEvent(VDEC_StreamId *pStreamId, MS_U32 u32EventFlag)
2334 {
2335 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2336
2337 VDEC_Result eRetVal = E_VDEC_FAIL;
2338 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2339 eRetVal = MApi_VDEC_UnsetEvent(u32EventFlag);
2340 eExRetVal = _VDEC_MapExResult(eRetVal);
2341
2342 return eExRetVal;
2343 }
2344
2345 //------------------------------------------------------------------------------
2346 /// set ISR event CB
2347 /// @param cb_type \b IN : The CB type for VDEC interrupt
2348 /// @param u32EnableEvent \b IN : The event flag for user data CB function
2349 /// @param pfn \b IN : user data CB function
2350 /// @param param \b IN : the param of/for user data CB function
2351 /// @return status
2352 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetEvent_MultiCallback(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,MS_U32 u32EventFlag,VDEC_EX_EventCb pfn,void * param)2353 VDEC_EX_Result MApi_VDEC_EX_SetEvent_MultiCallback(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, MS_U32 u32EventFlag, VDEC_EX_EventCb pfn, void *param)
2354 {
2355 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2356
2357 VDEC_Result eRetVal = E_VDEC_FAIL;
2358 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2359 eRetVal = MApi_VDEC_SetEvent_EX((VDEC_CB_TYPE)cb_type, u32EventFlag, pfn, param);
2360 eExRetVal = _VDEC_MapExResult(eRetVal);
2361
2362 return eExRetVal;
2363 }
2364
2365 //------------------------------------------------------------------------------
2366 /// Unset ISR event CB
2367 /// @param cb_type \b IN : The CB type for VDEC interrupt
2368 /// @param u32EnableEvent \b IN : The event flag for user data CB function
2369 /// @return status
2370 //------------------------------------------------------------------------------
MApi_VDEC_EX_UnsetEvent_MultiCallback(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,MS_U32 u32EventFlag)2371 VDEC_EX_Result MApi_VDEC_EX_UnsetEvent_MultiCallback(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, MS_U32 u32EventFlag)
2372 {
2373 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2374
2375 VDEC_Result eRetVal = E_VDEC_FAIL;
2376 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2377 eRetVal = MApi_VDEC_UnsetEvent_EX((VDEC_CB_TYPE)cb_type, u32EventFlag);
2378 eExRetVal = _VDEC_MapExResult(eRetVal);
2379
2380 return eExRetVal;
2381 }
2382
2383 //------------------------------------------------------------------------------
2384 /// Get ISR event status
2385 /// @return status
2386 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetEventInfo(VDEC_StreamId * pStreamId,MS_U32 * u32EventFlag)2387 VDEC_EX_Result MApi_VDEC_EX_GetEventInfo(VDEC_StreamId *pStreamId, MS_U32* u32EventFlag)
2388 {
2389 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2390
2391 VDEC_Result eRetVal = E_VDEC_FAIL;
2392 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2393
2394 if (u32EventFlag)
2395 {
2396 eRetVal = MApi_VDEC_GetEventInfo(u32EventFlag);
2397 eExRetVal = _VDEC_MapExResult(eRetVal);
2398 }
2399
2400 return eExRetVal;
2401 }
2402
2403 //------------------------------------------------------------------------------
2404 /// Generate a special pattern to work with specific functions
2405 /// @param ePatternType \b IN : Pattern type
2406 /// @param u32Addr \b IN : Pattern buffer physical start address
2407 /// @param u32Size \b IN,OUT : Pattern buffer size
2408 /// IN: Pattern buffer size
2409 /// OUT: Used Pattern buffer size
2410 /// @return VDEC_Result
2411 //------------------------------------------------------------------------------
MApi_VDEC_EX_GenPattern(VDEC_StreamId * pStreamId,VDEC_EX_PatternType eExPtnType,MS_PHYADDR u32Addr,MS_U32 * u32Size)2412 VDEC_EX_Result MApi_VDEC_EX_GenPattern(VDEC_StreamId *pStreamId, VDEC_EX_PatternType eExPtnType, MS_PHYADDR u32Addr, MS_U32* u32Size)
2413 {
2414 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2415
2416 VDEC_Result eRetVal = E_VDEC_FAIL;
2417 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2418 VDEC_PatternType ePtnType = _VDEC_MapPatternType(eExPtnType);
2419 eRetVal = MApi_VDEC_GenPattern(ePtnType, u32Addr, u32Size);
2420 eExRetVal = _VDEC_MapExResult(eRetVal);
2421
2422 return eExRetVal;
2423 }
2424
2425 //------------------------------------------------------------------------------
2426 /// Get the information of the least length of pattern used for specific function
2427 /// @param pFrmInfo \b IN : the information of the least length of pattern used for specific function
2428 /// @return -the length (Bytes)
2429 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetPatternLeastLength(VDEC_StreamId * pStreamId,VDEC_EX_PatternType eExPatternType)2430 MS_U32 MApi_VDEC_EX_GetPatternLeastLength(VDEC_StreamId *pStreamId, VDEC_EX_PatternType eExPatternType)
2431 {
2432 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
2433
2434 return MApi_VDEC_GetPatternLeastLength(_VDEC_MapPatternType(eExPatternType));
2435 }
2436
2437 //------------------------------------------------------------------------------
2438 /// Set deblocking process on/off
2439 /// @param bOn \b IN : turn on / off deblocking process
2440 /// @return VDEC_Result
2441 //------------------------------------------------------------------------------
MApi_VDEC_EX_DisableDeblocking(VDEC_StreamId * pStreamId,MS_BOOL bDisable)2442 VDEC_EX_Result MApi_VDEC_EX_DisableDeblocking(VDEC_StreamId *pStreamId, MS_BOOL bDisable)
2443 {
2444 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2445
2446 return _VDEC_MapExResult(MApi_VDEC_DisableDeblocking(bDisable));
2447 }
2448
2449 //------------------------------------------------------------------------------
2450 /// Set Quarter Pixel process on/off
2451 /// @param bOn \b IN : turn on / off Quarter Pixel process
2452 /// @return VDEC_Result
2453 //------------------------------------------------------------------------------
MApi_VDEC_EX_DisableQuarterPixel(VDEC_StreamId * pStreamId,MS_BOOL bDisable)2454 VDEC_EX_Result MApi_VDEC_EX_DisableQuarterPixel(VDEC_StreamId *pStreamId, MS_BOOL bDisable)
2455 {
2456 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2457
2458 return _VDEC_MapExResult(MApi_VDEC_DisableQuarterPixel(bDisable));
2459 }
2460
2461 //------------------------------------------------------------------------------
2462 /// Turn on/off Auto Remove Last Zero Byte process
2463 /// @param bOn \b IN : turn on / off Auto Remove Last Zero Byte process
2464 /// @return VDEC_Result
2465 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetAutoRmLstZeroByte(VDEC_StreamId * pStreamId,MS_BOOL bOn)2466 VDEC_EX_Result MApi_VDEC_EX_SetAutoRmLstZeroByte(VDEC_StreamId *pStreamId, MS_BOOL bOn)
2467 {
2468 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2469
2470 return _VDEC_MapExResult(MApi_VDEC_SetAutoRmLstZeroByte(bOn));
2471 }
2472
2473 //------------------------------------------------------------------------------
2474 /// Set the parameters of Balancing BW
2475 /// @param u8QuarPixelTH \b IN : set Quarter pixel threshold
2476 /// @param u8DeBlockingTH \b IN : set deblocking threshold
2477 /// @param u8UpperBound \b IN : set upper boundary of BW control counter
2478 /// @param u8SafeCoef \b IN : set safety coeffecient of average MB tick.
2479 /// @return VDEC_Result
2480 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetBalanceBW(VDEC_StreamId * pStreamId,MS_U8 u8QuarPixelTH,MS_U8 u8DeBlockingTH,MS_U8 u8UpperBound,MS_U8 u8SafeCoef)2481 VDEC_EX_Result MApi_VDEC_EX_SetBalanceBW(VDEC_StreamId *pStreamId,
2482 MS_U8 u8QuarPixelTH, MS_U8 u8DeBlockingTH, MS_U8 u8UpperBound, MS_U8 u8SafeCoef)
2483 {
2484 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2485
2486 return _VDEC_MapExResult(MApi_VDEC_SetBalanceBW(u8QuarPixelTH, u8DeBlockingTH, u8UpperBound, u8SafeCoef));
2487 }
2488
2489 extern void MApi_VDEC_DbgDumpStatus(void);
MApi_VDEC_EX_DbgDumpStatus(VDEC_StreamId * pStreamId)2490 void MApi_VDEC_EX_DbgDumpStatus(VDEC_StreamId *pStreamId)
2491 {
2492 if(VDEC_MAIN_ID != pStreamId->u32Id)
2493 return;
2494
2495 MApi_VDEC_DbgDumpStatus();
2496 }
2497
2498 extern MS_U32 MApi_VDEC_DbgGetProgCnt(void);
MApi_VDEC_EX_DbgGetProgCnt(void)2499 MS_U32 MApi_VDEC_EX_DbgGetProgCnt(void)
2500 {
2501 return MApi_VDEC_DbgGetProgCnt();
2502 }
2503
MApi_VDEC_EX_SetControl(VDEC_StreamId * pStreamId,VDEC_EX_User_Cmd cmd_id,MS_U32 param)2504 VDEC_EX_Result MApi_VDEC_EX_SetControl(VDEC_StreamId *pStreamId, VDEC_EX_User_Cmd cmd_id, MS_U32 param)
2505 {
2506 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2507
2508 VDEC_Result eRetVal = E_VDEC_FAIL;
2509 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2510 eRetVal = MApi_VDEC_SetControl(_VDEC_MapUserCmd(cmd_id), param);
2511 eExRetVal = _VDEC_MapExResult(eRetVal);
2512
2513 return eExRetVal;
2514 }
2515
MApi_VDEC_EX_GetControl(VDEC_StreamId * pStreamId,VDEC_EX_User_Cmd cmd_id,MS_U32 * param)2516 VDEC_EX_Result MApi_VDEC_EX_GetControl(VDEC_StreamId *pStreamId, VDEC_EX_User_Cmd cmd_id, MS_U32 *param)
2517 {
2518 VDEC_Result eRetVal = E_VDEC_OK;
2519 VDEC_EX_Result eExRetVal = E_VDEC_EX_OK;
2520
2521 eRetVal = MApi_VDEC_GetControl(_VDEC_MapUserCmd(cmd_id), param);
2522 eExRetVal = _VDEC_MapExResult(eRetVal);
2523
2524 return eExRetVal;
2525 }
2526
MApi_VDEC_EX_GetDispCnt(VDEC_StreamId * pStreamId)2527 MS_U32 MApi_VDEC_EX_GetDispCnt(VDEC_StreamId *pStreamId)
2528 {
2529 MS_U32 u32Cnt = 0;
2530
2531 if(VDEC_MAIN_ID != pStreamId->u32Id)
2532 return u32Cnt;
2533 else
2534 return MApi_VDEC_GetDispCnt();
2535 }
2536
MApi_VDEC_EX_GetFwVersion(VDEC_StreamId * pStreamId,VDEC_EX_FwType eFwType)2537 MS_U32 MApi_VDEC_EX_GetFwVersion(VDEC_StreamId *pStreamId, VDEC_EX_FwType eFwType)
2538 {
2539 MS_U32 u32FWVer = 0;
2540
2541 if(VDEC_MAIN_ID != pStreamId->u32Id)
2542 return u32FWVer;
2543 else
2544 return MApi_VDEC_GetFwVersion((VDEC_FwType)eFwType);
2545 }
2546
MApi_VDEC_EX_SetBlockDisplay(VDEC_StreamId * pStreamId,MS_BOOL bEnable)2547 VDEC_EX_Result MApi_VDEC_EX_SetBlockDisplay(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
2548 {
2549 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2550
2551 return _VDEC_MapExResult(MApi_VDEC_SetBlockDisplay(bEnable));
2552 }
2553
MApi_VDEC_EX_EnableESBuffMalloc(VDEC_StreamId * pStreamId,MS_BOOL bEnable)2554 VDEC_EX_Result MApi_VDEC_EX_EnableESBuffMalloc(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
2555 {
2556 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2557
2558 return _VDEC_MapExResult(MApi_VDEC_EnableESBuffMalloc(bEnable));
2559 }
2560
MApi_VDEC_EX_GetESBuffVacancy(VDEC_StreamId * pStreamId,void * pData)2561 MS_U32 MApi_VDEC_EX_GetESBuffVacancy(VDEC_StreamId *pStreamId, void *pData)
2562 {
2563 _VDEC_WRAP_NOT_INIT_RET_ZERO(pStreamId->u32Id);
2564
2565 return MApi_VDEC_GetESBuffVacancy(pData);
2566 }
2567
MApi_VDEC_EX_GetESBuff(VDEC_StreamId * pStreamId,MS_U32 u32ReqSize,MS_U32 * u32AvailSize,MS_PHYADDR * u32Addr)2568 VDEC_EX_Result MApi_VDEC_EX_GetESBuff(VDEC_StreamId *pStreamId, MS_U32 u32ReqSize, MS_U32 *u32AvailSize, MS_PHYADDR *u32Addr)
2569 {
2570 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2571
2572 VDEC_Result eRetVal = E_VDEC_FAIL;
2573 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2574 eRetVal = MApi_VDEC_GetESBuff(u32ReqSize, u32AvailSize, u32Addr);
2575 eExRetVal = _VDEC_MapExResult(eRetVal);
2576
2577 return eExRetVal;
2578 }
2579
MApi_VDEC_EX_GetNextDispFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame ** ppDispFrm)2580 VDEC_EX_Result MApi_VDEC_EX_GetNextDispFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame **ppDispFrm)
2581 {
2582 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2583
2584 VDEC_Result eRetVal = E_VDEC_FAIL;
2585 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2586
2587 //MS_ASSERT(sizeof(VDEC_EX_DispFrame) == sizeof(VDEC_DispFrame));
2588 //MS_ASSERT(sizeof(VDEC_EX_FrameInfo) == sizeof(VDEC_FrameInfo));
2589
2590 eRetVal = MApi_VDEC_GetNextDispFrame((VDEC_DispFrame **)ppDispFrm);
2591 eExRetVal = _VDEC_MapExResult(eRetVal);
2592
2593 return eExRetVal;
2594 }
2595
2596 //------------------------------------------------------------------------------
2597 /// Notify FW to display the specified frame
2598 /// @param pDispFrm \b IN : the pointer of the frame to be displayed
2599 /// @return VDEC_Result
2600 /// @retval -E_VDEC_RET_NOT_INIT: VDEC is not initialized.
2601 /// @retval -E_VDEC_RET_INVALID_PARAM: the pointer is NULL.
2602 /// @retval -E_VDEC_RET_ILLEGAL_ACCESS: the pointer is invalid.
2603 /// There might be multiple frame display/release.
2604 //------------------------------------------------------------------------------
MApi_VDEC_EX_DisplayFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame * pDispFrm)2605 VDEC_EX_Result MApi_VDEC_EX_DisplayFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame *pDispFrm)
2606 {
2607 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2608
2609 VDEC_Result eRetVal = E_VDEC_FAIL;
2610 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2611 eRetVal = MApi_VDEC_DisplayFrame((VDEC_DispFrame*)pDispFrm);
2612 eExRetVal = _VDEC_MapExResult(eRetVal);
2613
2614 return eExRetVal;
2615 }
2616
MApi_VDEC_EX_ReleaseFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame * pDispFrm)2617 VDEC_EX_Result MApi_VDEC_EX_ReleaseFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame *pDispFrm)
2618 {
2619 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2620
2621 VDEC_Result eRetVal = E_VDEC_FAIL;
2622 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2623 eRetVal = MApi_VDEC_ReleaseFrame((VDEC_DispFrame*)pDispFrm);
2624 eExRetVal = _VDEC_MapExResult(eRetVal);
2625
2626 return eExRetVal;
2627 }
2628
2629 extern VDEC_Result MApi_VDEC_CaptureFrame(MS_U32 u32FrmPriData, MS_BOOL bEnable);
MApi_VDEC_EX_CaptureFrame(VDEC_StreamId * pStreamId,MS_U32 u32FrmPriData,MS_BOOL bEnable)2630 VDEC_EX_Result MApi_VDEC_EX_CaptureFrame(VDEC_StreamId *pStreamId, MS_U32 u32FrmPriData, MS_BOOL bEnable)
2631 {
2632 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2633
2634 return _VDEC_MapExResult(MApi_VDEC_CaptureFrame(u32FrmPriData, bEnable));
2635 }
2636
MApi_VDEC_EX_CC_Init(VDEC_StreamId * pStreamId,MS_U32 * pIn)2637 VDEC_EX_Result MApi_VDEC_EX_CC_Init(VDEC_StreamId *pStreamId, MS_U32 *pIn)
2638 {
2639 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2640
2641 VDEC_Result eRetVal = E_VDEC_FAIL;
2642 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2643 eRetVal = MApi_VDEC_CC_Init(pIn);
2644 eExRetVal = _VDEC_MapExResult(eRetVal);
2645
2646 return eExRetVal;
2647 }
2648
MApi_VDEC_EX_CC_SetCfg(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,VDEC_EX_CCType eType,MS_U32 * pIn)2649 VDEC_EX_Result MApi_VDEC_EX_CC_SetCfg(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, VDEC_EX_CCType eType, MS_U32 *pIn)
2650 {
2651 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2652
2653 VDEC_Result eRetVal = E_VDEC_FAIL;
2654 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2655 eRetVal = MApi_VDEC_CC_SetCfg(_VDEC_MapCCFormat(eFmt), _VDEC_MapCCType(eType), pIn);
2656 eExRetVal = _VDEC_MapExResult(eRetVal);
2657
2658 return eExRetVal;
2659 }
2660
MApi_VDEC_EX_CC_SetBuffStartAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)2661 VDEC_EX_Result MApi_VDEC_EX_CC_SetBuffStartAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
2662 {
2663 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2664
2665 VDEC_Result eRetVal = E_VDEC_FAIL;
2666 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2667 eRetVal = MApi_VDEC_CC_SetBuffStartAdd(_VDEC_MapCCFormat(eFmt), pIn);
2668 eExRetVal = _VDEC_MapExResult(eRetVal);
2669
2670 return eExRetVal;
2671 }
2672
MApi_VDEC_EX_CC_UpdateWriteAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)2673 VDEC_EX_Result MApi_VDEC_EX_CC_UpdateWriteAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
2674 {
2675 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2676
2677 VDEC_Result eRetVal = E_VDEC_FAIL;
2678 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2679 eRetVal = MApi_VDEC_CC_UpdateWriteAdd(_VDEC_MapCCFormat(eFmt), pIn);
2680 eExRetVal = _VDEC_MapExResult(eRetVal);
2681
2682 return eExRetVal;
2683 }
2684
MApi_VDEC_EX_CC_UpdateReadAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)2685 VDEC_EX_Result MApi_VDEC_EX_CC_UpdateReadAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
2686 {
2687 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2688
2689 VDEC_Result eRetVal = E_VDEC_FAIL;
2690 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2691 eRetVal = MApi_VDEC_CC_UpdateReadAdd(_VDEC_MapCCFormat(eFmt), pIn);
2692 eExRetVal = _VDEC_MapExResult(eRetVal);
2693
2694 return eExRetVal;
2695 }
2696
MApi_VDEC_EX_CC_DisableParsing(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)2697 VDEC_EX_Result MApi_VDEC_EX_CC_DisableParsing(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
2698 {
2699 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2700
2701 VDEC_Result eRetVal = E_VDEC_FAIL;
2702 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2703 eRetVal = MApi_VDEC_CC_DisableParsing(_VDEC_MapCCFormat(eFmt));
2704 eExRetVal = _VDEC_MapExResult(eRetVal);
2705
2706 return eExRetVal;
2707 }
2708
2709 extern VDEC_Result MApi_VDEC_CC_GetInfo(VDEC_CCFormat eFmt, VDEC_CCInfoCmd eCmd, MS_U32 *pOut);
MApi_VDEC_EX_CC_GetInfo(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,VDEC_EX_CCInfoCmd eCmd,MS_U32 * pOut)2710 VDEC_EX_Result MApi_VDEC_EX_CC_GetInfo(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, VDEC_EX_CCInfoCmd eCmd, MS_U32 *pOut)
2711 {
2712 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2713
2714 VDEC_Result eRetVal = E_VDEC_FAIL;
2715 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2716 eRetVal = MApi_VDEC_CC_GetInfo(_VDEC_MapCCFormat(eFmt), _VDEC_MapCCInfoCmd(eCmd), pOut);
2717 eExRetVal = _VDEC_MapExResult(eRetVal);
2718
2719 return eExRetVal;
2720 }
2721
MApi_VDEC_EX_CC_GetIsRstDone(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)2722 VDEC_EX_Result MApi_VDEC_EX_CC_GetIsRstDone(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
2723 {
2724 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2725
2726 VDEC_Result eRetVal = E_VDEC_FAIL;
2727 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2728 eRetVal = MApi_VDEC_CC_GetIsRstDone(_VDEC_MapCCFormat(eFmt));
2729 eExRetVal = _VDEC_MapExResult(eRetVal);
2730
2731 return eExRetVal;
2732 }
2733
MApi_VDEC_EX_CC_GetIsBuffOverflow(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)2734 VDEC_EX_Result MApi_VDEC_EX_CC_GetIsBuffOverflow(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
2735 {
2736 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2737
2738 VDEC_Result eRetVal = E_VDEC_FAIL;
2739 VDEC_EX_Result eExRetVal = E_VDEC_EX_FAIL;
2740 eRetVal = MApi_VDEC_CC_GetIsBuffOverflow(_VDEC_MapCCFormat(eFmt));
2741 eExRetVal = _VDEC_MapExResult(eRetVal);
2742
2743 return eExRetVal;
2744 }
2745
2746 //------------------------------------------------------------------------------
2747 /// Report the physical address of write pointer
2748 /// @param eFmt \b IN : the format of closed caption
2749 /// @return MS_PHYADDR
2750 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetWriteAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)2751 MS_PHYADDR MApi_VDEC_EX_CC_GetWriteAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
2752 {
2753 MS_PHYADDR u32CCWrPtr = VDEC_U32_MAX;
2754
2755 if(VDEC_MAIN_ID != pStreamId->u32Id)
2756 return u32CCWrPtr;
2757 else
2758 return MApi_VDEC_CC_GetWriteAdd(_VDEC_MapCCFormat(eFmt));
2759 }
2760
2761 //------------------------------------------------------------------------------
2762 /// Report the physical address of read pointer
2763 /// @param eFmt \b IN : the format of closed caption
2764 /// @return MS_PHYADDR
2765 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetReadAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)2766 MS_PHYADDR MApi_VDEC_EX_CC_GetReadAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
2767 {
2768 MS_PHYADDR u32CCRdPtr = VDEC_U32_MAX;
2769
2770 if(VDEC_MAIN_ID != pStreamId->u32Id)
2771 return u32CCRdPtr;
2772 else
2773 return MApi_VDEC_CC_GetReadAdd(_VDEC_MapCCFormat(eFmt));
2774
2775 }
2776
2777 //------------------------------------------------------------------------------
2778 /// Setup cmd for presetting vdec
2779 /// @param param \b IN : input parameter
2780 /// @return VDEC_Result
2781 //------------------------------------------------------------------------------
MApi_VDEC_EX_PreSetControl(VDEC_StreamId * pStreamId,VDEC_EX_User_Cmd cmd_id,MS_U32 param)2782 VDEC_EX_Result MApi_VDEC_EX_PreSetControl(VDEC_StreamId *pStreamId, VDEC_EX_User_Cmd cmd_id, MS_U32 param)
2783 {
2784 _VDEC_WRAP_NOT_INIT_RET(pStreamId->u32Id);
2785
2786 return _VDEC_MapExResult(MApi_VDEC_PreSetControl(_VDEC_MapUserCmd(cmd_id),param));
2787 }
2788
2789