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.c
98 /// @brief 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 "apiVDEC.h"
109 #include "apiMJPEG.h"
110
111 #include "drvMMIO.h"
112 #include "drvSYS.h"
113
114 #ifdef MSOS_TYPE_LINUX_KERNEL
115 #include <asm/div64.h>
116 #endif
117
118 #ifdef MSOS_TYPE_LINUX_KERNEL
119 #include <linux/string.h>
120 #else
121 #include <string.h>
122 #endif
123
124 //#if (VDEC_UTOPIA20)
125 #include "utopia.h"
126 #include "apiVDEC_v2.h"
127 //#endif
128
129 //-------------------------------------------------------------------------------------------------
130 // Local Compiler Options
131 //-------------------------------------------------------------------------------------------------
132 #define VDEC_ENABLE_LINK_WEAK_SYMBOL 1
133
134 #define VDEC_ENABLE_MVD 1
135
136 #if !(defined(CHIP_T7) || defined(CHIP_A6))
137 #define VDEC_ENABLE_HVD 1
138 #else
139 #define VDEC_ENABLE_HVD 0
140 #endif
141
142 #define _VDEC_PTS_TABLE 0
143
144 #if 1 //temparary for bring up
145 #define _VDEC_AUTH_IPCheck_TEST_CODE_
146 #endif
147
148 #ifndef _VDEC_AUTH_IPCheck_TEST_CODE_
149 #if defined(VESTEL_FEATURE)
150 #define VESTEL_FEATURE_ENABLE 1
151 #else
152 #define VESTEL_FEATURE_ENABLE 0
153 #endif
154 #endif
155
156 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
157 #include "_apiVDEC_weak.h"
158 #else
159 #include "../../drv/mvd/drvMVD.h"
160 #include "../../drv/hvd/drvHVD.h"
161 #include "../../drv/rvd/drvRVD.h"
162 #endif
163
164 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_ECOS)
165 #define VDEC_ISR_MONITOR
166 #endif
167
168 #ifdef _VDEC_AUTH_IPCheck_TEST_CODE_
169 #define IPAUTH_VIDEO_MPEG2 (19)
170 #define IPAUTH_VIDEO_MPEG2_HD (20)
171 #define IPAUTH_VIDEO_MPEG4 (21)
172 #define IPAUTH_VIDEO_MPEG4_SD (22)
173 #define IPAUTH_VIDEO_MPEG4_HD (23)
174 #define IPAUTH_VIDEO_DIVX_1080PHD (24)
175 #define IPAUTH_VIDEO_DIVX_DRM (25)
176 #define IPAUTH_VIDEO_DIVX_PLUS (26)
177 #define IPAUTH_VIDEO_H264 (27)
178 #define IPAUTH_VIDEO_RM (28)
179 #define IPAUTH_VIDEO_VC1 (29)
180 #define IPAUTH_VIDEO_WMV (30)
181 #define IPAUTH_VIDEO_WMDRM_PD (31)
182 #define IPAUTH_VIDEO_WMDRM_ND (32)
183 #define IPAUTH_VIDEO_AVS (33)
184 #define IPAUTH_VIDEO_FLV (34)
185 #define IPAUTH_VIDEO_DIVX_QMOBILE (35)
186 #define IPAUTH_VIDEO_DIVX_MOBILE (36)
187 #define IPAUTH_VIDEO_DIVX_HT (37)
188 #define IPAUTH_VIDEO_DIVX_720PHD (38)
189 #define IPAUTH_VIDEO_MVC (40)
190 MS_BOOL bModeSelectHD;
191 extern MS_U8 MDrv_AUTH_IPCheck(MS_U8 u8Bit); //FROM #include "drvIPAUTH.h"
192 #endif
193
194 MS_BOOL bIsSupportDivxPlus;
195 //-------------------------------------------------------------------------------------------------
196 // Function and Variable
197 //-------------------------------------------------------------------------------------------------
198
199 //-------------------------------------------------------------------------------------------------
200 // Local Defines
201 //-------------------------------------------------------------------------------------------------
202 #define E_VDEC_CB_MAX_NUM (E_VDEC_CB_SUB + 1)
203
204 #define MVD_SRCMODE_MAX 5
205
206 #if 0
207 #define _VDEC_Memset(pDstAddr, u8value, u32Size) \
208 do { \
209 MS_U32 i = 0; \
210 volatile MS_U8 *dst = (volatile MS_U8 *)(pDstAddr); \
211 for (i = 0; i < (u32Size); i++) \
212 { \
213 dst[i] = (u8value); \
214 } \
215 } while (0)
216
217 #define _VDEC_Memcpy(pDstAddr, pSrcAddr, u32Size) \
218 do { \
219 MS_U32 i = 0; \
220 volatile MS_U8 *dst = (volatile MS_U8 *)(pDstAddr); \
221 volatile MS_U8 *src = (volatile MS_U8 *)(pSrcAddr); \
222 for (i = 0; i < (u32Size); i++) \
223 { \
224 dst[i] = src[i]; \
225 } \
226 } while (0)
227 #else
228 #define _VDEC_Memcpy(pDstAddr, pSrcAddr, u32Size) memcpy((pDstAddr), (pSrcAddr), (u32Size))
229 #define _VDEC_Memset(pDstAddr, u8value, u32Size) memset((pDstAddr), (u8value), (u32Size))
230 #endif
231
232 #define _MVD_RET_HANDLE(x) \
233 do \
234 { \
235 if (E_MVD_RET_OK != (x)) \
236 { \
237 return E_VDEC_FAIL; \
238 } \
239 } while (0)
240
241 #define _HVD_RET_HANDLE(x) \
242 do \
243 { \
244 if (E_HVD_OK != (x)) \
245 { \
246 return E_VDEC_FAIL; \
247 } \
248 } while (0)
249
250 #define _MJPEG_RET_HANDLE(x) \
251 do \
252 { \
253 if (E_MJPEG_RET_SUCCESS != (x)) \
254 { \
255 return E_VDEC_FAIL; \
256 } \
257 } while (0)
258
259 #define _RVD_RET_HANDLE(x) \
260 do \
261 { \
262 if (E_RVD_RET_SUCCESS != (x)) \
263 { \
264 return E_VDEC_FAIL; \
265 } \
266 } while (0)
267
268 #define _BOOL_TO_VDEC_RESULT(rst, b) \
269 do \
270 { \
271 if (TRUE != (b)) \
272 { \
273 rst = E_VDEC_FAIL; \
274 } \
275 else \
276 { \
277 rst = E_VDEC_OK; \
278 } \
279 } while (0)
280
281 #define _BOOL_TO_MJPEG_RESULT(rst, b) \
282 do \
283 { \
284 if (TRUE != (b)) \
285 { \
286 rst = E_VDEC_FAIL; \
287 } \
288 else \
289 { \
290 rst = E_VDEC_OK; \
291 } \
292 } while (0)
293
294 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
295
296 #define _RET_VDEC_HVD_LINT_CHECK() \
297 do \
298 { \
299 if (!MDrv_HVD_Init) \
300 { \
301 return E_VDEC_RET_ILLEGAL_ACCESS; \
302 } \
303 } while (0)
304
305 #define _RET_VDEC_MVD_LINT_CHECK() \
306 do \
307 { \
308 if (!MDrv_MVD_Init) \
309 { \
310 return E_VDEC_RET_ILLEGAL_ACCESS; \
311 } \
312 } while (0)
313
314 #define _RET_VDEC_RVD_LINT_CHECK() \
315 do \
316 { \
317 if (!MDrv_RVD_Init) \
318 { \
319 return E_VDEC_RET_ILLEGAL_ACCESS; \
320 } \
321 } while (0)
322
323 #define _BOOL_VDEC_HVD_LINT_CHECK() \
324 do \
325 { \
326 if (!MDrv_HVD_Init) \
327 { \
328 return FALSE; \
329 } \
330 } while (0)
331
332 #define _BOOL_VDEC_MVD_LINT_CHECK() \
333 do \
334 { \
335 if (!MDrv_MVD_Init) \
336 { \
337 return FALSE; \
338 } \
339 } while (0)
340
341 #define _BOOL_VDEC_RVD_LINT_CHECK() \
342 do \
343 { \
344 if (!MDrv_RVD_Init) \
345 { \
346 return FALSE; \
347 } \
348 } while (0)
349 #else // VDEC_ENABLE_LINK_WEAK_SYMBOL
350
351 #define _RET_VDEC_MVD_LINT_CHECK()
352 #define _RET_VDEC_HVD_LINT_CHECK()
353 #define _RET_VDEC_RVD_LINT_CHECK()
354 #define _BOOL_VDEC_MVD_LINT_CHECK()
355 #define _BOOL_VDEC_HVD_LINT_CHECK()
356 #define _BOOL_VDEC_RVD_LINT_CHECK()
357
358 #endif //VDEC_ENABLE_LINK_WEAK_SYMBOL
359
360 #ifndef UNUSED
361 #define UNUSED(x) (void)(x)
362 #endif
363
364 #if defined(VDEC_ISR_MONITOR)
365 #define E_VDEC_EVENT_ISR_EVENT_CHANGE 0x80000000
366 #endif
367
368 #define VDEC_U32_MAX 0xffffffffUL
369 #define MAX_VDEC_DQNUM 32
370 #define VDEC_DQ_EMPTY 0xff
371 #define VDEC_INFO(x) if (_Attr.eDbgMsgLevel >= E_VDEC_DBG_LEVEL_INFO) { (x); }
372
373 //-------------------------------------------------------------------------------------------------
374 // Local Structures
375 //-------------------------------------------------------------------------------------------------
376 typedef enum
377 {
378 E_VDEC_DECODER_MVD = 0,
379 E_VDEC_DECODER_HVD,
380 E_VDEC_DECODER_MJPEG,
381 E_VDEC_DECODER_RVD,
382 E_VDEC_DECODER_NONE,
383 } VDEC_Decoder;
384
385 typedef enum
386 {
387 E_VDEC_STREAM_0 = 0,
388 E_VDEC_STREAM_NUM_MAX,
389 } VDEC_STREAM_NUM;
390
391 typedef struct
392 {
393 MS_U32 u32EventBitMap;
394 VDEC_EventCb pVdecEventCb;
395 void* pParam;
396 } VDEC_EventInfo;
397
398 typedef struct
399 {
400 MS_BOOL bInit;
401 VDEC_DbgLevel eDbgMsgLevel;
402 VDEC_CodecType eCodecType;
403 VDEC_Decoder eDecoder;
404 VDEC_SrcMode eSrcMode;
405 VDEC_ErrCode eErrCode;
406 VDEC_CCFormat eCCFormat;
407 VDEC_EventInfo VdecEventInfo[E_VDEC_CB_MAX_NUM];
408 } VDEC_Attr;
409
410 typedef struct
411 {
412 //******** One Pending Buffer ********//
413 MS_BOOL bOnePendingBuffer;
414 //******** HW Buffer ReMapping ********//
415 MS_BOOL bHWBufferReMapping;
416 //******** Frame Rate Handling ********//
417 MS_BOOL bFrameRateHandling;
418 MS_U32 u32PreSetFrameRate;
419 } VDEC_Pre_Ctrl;
420
421 //------------------------------------------------------------------------------
422 // Local Functions Prototype
423 //------------------------------------------------------------------------------
424 static void _VDEC_InitLocalVar(void);
425 static VDEC_Decoder _VDEC_GetDecoderByCodecType(VDEC_CodecType eCodecType);
426 static MVD_CodecType _VDEC_Map2MVDCodecType(VDEC_CodecType vdecCodecType);
427 static MVD_SrcMode _VDEC_Map2MVDSrcMode(VDEC_SrcMode vdecSrcMode);
428 static void _VDEC_MVDCfgDivX(VDEC_CodecType vdecCodecType);
429 static MS_BOOL _VDEC_IsIdle(void);
430 static void _VDEC_IsrProc(void);
431 static MS_U32 _VDEC_GetESBuffVacancy(void);
432
433 #if defined(VDEC_ISR_MONITOR)
434 static MS_BOOL _VDEC_SYS_Init(void);
435 static void _VDEC_MonitorISR_Proc(void);
436 #endif
437 #if 0
438 static MS_BOOL _VDEC_SYS_Exit(void);
439 #endif
440
441 static HVD_ClockSpeed _VDEC_Map2HVDClockSpeed(VDEC_ClockSpeed ClockSpeed);
442 static MVD_ClockSpeed _VDEC_Map2MVDClockSpeed(VDEC_ClockSpeed ClockSpeed);
443 static VDEC_Result _VDEC_SetVPUClockSpeed(VDEC_ClockSpeed ClockSpeed);
444 static VDEC_Result _VDEC_SetHVDClockSpeed(VDEC_ClockSpeed ClockSpeed);
445 static VDEC_Result _VDEC_SetMVDClockSpeed(VDEC_ClockSpeed ClockSpeed);
446 static VDEC_Result _MApi_VDEC_GetFlushPatternEntryNum(MS_U32* param);
447
448 //-------------------------------------------------------------------------------------------------
449 // Global Variables
450 //-------------------------------------------------------------------------------------------------
451
452
453 //-------------------------------------------------------------------------------------------------
454 // Local Variables
455 //-------------------------------------------------------------------------------------------------
456 static MSIF_Version _api_vdec_version =
457 {
458 .DDI = { VDEC_API_VERSION, },
459 };
460
461 static VDEC_Info _api_vdec_info;
462
463 void* pu32VDEC_Inst = NULL;
464
465
466
467
468 static VDEC_Attr _Attr;
469 static VDEC_Pre_Ctrl _Pre_Ctrl = {0};
470 static MS_BOOL bDropErrFrm = FALSE;
471 static MS_BOOL bTurboMode = FALSE;
472 static MS_BOOL bEsBufMgmt = FALSE;
473 static VDEC_DispFrame VDEC_DispQ[E_VDEC_STREAM_NUM_MAX][MAX_VDEC_DQNUM];
474
475 static MS_S32 _s32VdecMutexId = -1;
476 static MS_U8 _u8VdecMutex[] = {"VDEC_Mutex"};
477 #if defined(VDEC_ISR_MONITOR)
478 #define VDEC_STACK_SIZE 4096
479 static MS_U8 _VdecStack[VDEC_STACK_SIZE];
480 static MS_BOOL _bVdecIsrMntr = TRUE; //Coverity:for infinite loop
481 static MS_BOOL _IsSysEnable = FALSE;
482 static MS_S32 _s32VdecEventId = -1;
483 static MS_U8 _u8VdecEvent[] = {"VDEC_Event"};
484 static MS_S32 _s32VdecTaskId = -1;
485 static MS_U8 _u8VdecTask[] = {"VDEC_Task"};
486 static MS_U32 _u32VdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE;
487 static MS_U32 _u32PreVdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE;
488 #else
489 static MS_U32 _u32VdecIsrEventFlag = 0;
490 #endif
491
492 static MS_U32 u32VdecInitParamVersion = 0;
493 static VDEC_InitParam _vdecInitParam;
494 static VDEC_InitParam_EX1 _vdecInitParam_ex1;
495
496 static MS_S32 _s32DqMutexId = -1;
497 static MS_U8 _u8DqMutex[] = {"VDEC_DQ_Mutex"};
498
499 static HVD_FrmPackingSEI _stFrmPacking;
500 EN_POWER_MODE _prev_u16PowerState;
501
502 //Configure MVD parser will be disabled/enabled when bitstream buffer overflow
503 static const MS_U8 bMvdParserDisable[MVD_SRCMODE_MAX] =
504 {
505 1, //E_MVD_FILE_MODE : disable
506 1, //E_MVD_SLQ_MODE : disable
507 0, //E_MVD_TS_MODE : enable
508 1, //E_MVD_SLQ_TBL_MODE: disable
509 0 //E_MVD_TS_FILE_MODE: DISABLE_PKT_LEN
510 };
511
512 //-------------------------------------------------------------------------------------------------
513 // Debug Functions
514 //-------------------------------------------------------------------------------------------------
515 #if _VDEC_PTS_TABLE
516 #define STS_SIZE 1024
517 #define STS_NULL_PTS 0
518 MS_U64 u64PtsTable[STS_SIZE];
519 MS_U32 u32StsNum = 0;
520
_VDEC_PtsTableIsFull(void)521 MS_BOOL _VDEC_PtsTableIsFull(void)
522 {
523 return (u32StsNum >= (STS_SIZE-32));
524 }
525
_VDEC_PtsTableInit(void)526 void _VDEC_PtsTableInit(void)
527 {
528 MS_U32 i = 0;
529 for (i=0; i<STS_SIZE; i++)
530 {
531 u64PtsTable[i] = STS_NULL_PTS;
532 }
533 u32StsNum = 0;
534 }
535
536 //Sort and put, always put the bigger one at u64PtsTable[0]
_VDEC_PtsTablePut(MS_U64 u64Pts)537 void _VDEC_PtsTablePut(MS_U64 u64Pts)
538 {
539 MS_U32 i = 0;
540 MS_U32 u32ResortIdx = 0xffffffffUL;
541 //MS_U64 u64Tmp;
542
543 for (i=0; i<STS_SIZE; i++)
544 {
545 if (u64Pts >= u64PtsTable[i])
546 {
547 //printf("Put [%llu] in idx = %ld\n", u64Pts, i);
548 u32ResortIdx = i;
549 break;
550 }
551 }
552
553 if (u32ResortIdx == 0xffffffffUL)
554 {
555 printf("Err. Cannot find place to put [%llu](%llu)\n", u64Pts, u64PtsTable[0]);
556 return;
557 }
558 u32StsNum++; //since we're gonna add u64Pts
559
560 if (u32StsNum > STS_SIZE)
561 {
562 printf("Err. Overflow!!! DecFrmCnt=%ld\n", MApi_VDEC_GetFrameCnt());
563 return;
564 }
565
566 //move those smaller than u64Pts to reserve u64PtsTable[u32ResortIdx] for it
567 for (i=(u32StsNum-1); i>u32ResortIdx; i--)
568 {
569 u64PtsTable[i] = u64PtsTable[i-1];
570 }
571
572 u64PtsTable[u32ResortIdx] = u64Pts;
573 //printf("_______ptsPut[%ld]=%llu @ %ld\n", u32StsNum, u64Pts, u32ResortIdx);
574 }
575
_VDEC_PtsTableGet(void)576 MS_U64 _VDEC_PtsTableGet(void)
577 {
578 MS_U64 u64PtsMin = 0;
579
580 if (u32StsNum>=1)
581 {
582 u32StsNum--;
583 u64PtsMin = u64PtsTable[u32StsNum];
584 }
585 //printf("_______ptsGet[%ld]=%llu \n", u32StsNum, u64PtsMin);
586
587 return u64PtsMin;
588 }
589 #endif
590
591
MApi_VDEC_DbgCmd(MS_U32 u8Cmd,MS_U32 u32CmdArg)592 VDEC_Result MApi_VDEC_DbgCmd(MS_U32 u8Cmd, MS_U32 u32CmdArg)
593 {
594 VDEC_Result retVal;
595 MVD_CmdArg stCmdArg;
596
597 if (!_Attr.bInit)
598 {
599 return E_VDEC_RET_NOT_INIT;
600 }
601
602 switch (_Attr.eDecoder)
603 {
604 case E_VDEC_DECODER_MVD:
605 _VDEC_Memset(&stCmdArg, 0x00, sizeof(MVD_CmdArg));
606
607 if (u32CmdArg)
608 {
609 stCmdArg.Arg0 = (MS_U8) (u32CmdArg & 0x000000ff);
610 stCmdArg.Arg1 = (MS_U8) ((u32CmdArg & 0x0000ff00) >> 8);
611 stCmdArg.Arg2 = (MS_U8) ((u32CmdArg & 0x00ff0000) >> 16);
612 stCmdArg.Arg3 = (MS_U8) ((u32CmdArg & 0xff000000) >> 24);
613 }
614 if (MDrv_MVD_MVDCommand(u8Cmd, &stCmdArg))
615 {
616 retVal = E_VDEC_OK;
617 }
618 else
619 {
620 retVal = E_VDEC_RET_TIMEOUT;
621 }
622 break;
623
624 case E_VDEC_DECODER_HVD:
625 if (E_HVD_OK == MDrv_HVD_SetCmd_Dbg((MS_U32) u8Cmd,
626 u32CmdArg))
627 {
628 retVal = E_VDEC_OK;
629 }
630 else
631 {
632 retVal = E_VDEC_RET_TIMEOUT;
633 }
634 break;
635
636 case E_VDEC_DECODER_RVD:
637 if (E_RVD_RET_SUCCESS == MDrv_RVD_DbgSetCmd((RVD_User_Cmd) u8Cmd,
638 u32CmdArg))
639 {
640 retVal = E_VDEC_OK;
641 }
642 else
643 {
644 retVal = E_VDEC_RET_TIMEOUT;
645 }
646 break;
647 case E_VDEC_DECODER_MJPEG:
648 default:
649 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
650 break;
651 }
652
653 return retVal;
654 }
655
MApi_VDEC_DbgSetData(MS_U32 u32Addr,MS_U32 u32Data)656 VDEC_Result MApi_VDEC_DbgSetData(MS_U32 u32Addr, MS_U32 u32Data)
657 {
658 VDEC_Result retVal = E_VDEC_OK;
659
660 if (!_Attr.bInit)
661 {
662 return E_VDEC_RET_NOT_INIT;
663 }
664
665 switch (_Attr.eDecoder)
666 {
667 case E_VDEC_DECODER_MVD:
668 break;
669
670 case E_VDEC_DECODER_HVD:
671 MDrv_HVD_SetMem_Dbg(u32Addr, u32Data);
672 break;
673
674 case E_VDEC_DECODER_MJPEG:
675 {
676 MJPEG_Result ret = MApi_MJPEG_DbgSetData(u32Addr, u32Data);
677
678 if (E_MJPEG_RET_SUCCESS != ret)
679 {
680 retVal = E_VDEC_FAIL;
681 }
682 }
683
684 break;
685
686 case E_VDEC_DECODER_RVD:
687 MDrv_RVD_DbgSetData(u32Addr, u32Data);
688 break;
689
690 default:
691 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
692 break;
693 }
694
695 return retVal;
696 }
697
MApi_VDEC_DbgGetData(MS_U32 u32Addr,MS_U32 * u32Data)698 VDEC_Result MApi_VDEC_DbgGetData(MS_U32 u32Addr, MS_U32 *u32Data)
699 {
700 VDEC_Result retVal = E_VDEC_OK;
701
702 if (!_Attr.bInit)
703 {
704 return E_VDEC_RET_NOT_INIT;
705 }
706
707 switch (_Attr.eDecoder)
708 {
709 case E_VDEC_DECODER_MVD:
710 {
711 E_MVD_Result ret = MDrv_MVD_DbgGetData(u32Addr, u32Data);
712
713 if (E_MVD_RET_OK != ret)
714 {
715 retVal = E_VDEC_FAIL;
716 }
717 }
718
719 break;
720
721 case E_VDEC_DECODER_HVD:
722 *u32Data = MDrv_HVD_GetMem_Dbg(u32Addr);
723
724 break;
725
726 case E_VDEC_DECODER_MJPEG:
727 {
728 MJPEG_Result ret = MApi_MJPEG_DbgGetData(u32Addr, u32Data);
729
730 if (E_MJPEG_RET_SUCCESS != ret)
731 {
732 retVal = E_VDEC_FAIL;
733 }
734 }
735
736 break;
737
738 case E_VDEC_DECODER_RVD:
739 {
740 RVD_Result ret = MDrv_RVD_DbgGetData(u32Addr, u32Data);
741
742 if (E_RVD_RET_SUCCESS != ret)
743 {
744 retVal = E_VDEC_FAIL;
745 }
746 }
747
748 break;
749
750 default:
751 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
752
753 break;
754 }
755
756 return retVal;
757 }
758
759
760 //-------------------------------------------------------------------------------------------------
761 // Local Functions
762 //-------------------------------------------------------------------------------------------------
_VDEC_DqMutexLock(void)763 static MS_BOOL _VDEC_DqMutexLock(void)
764 {
765 if (_s32DqMutexId != -1)
766 {
767 return MsOS_ObtainMutex(_s32DqMutexId, MSOS_WAIT_FOREVER);
768 }
769 else
770 {
771 return FALSE;
772 }
773 }
774
_VDEC_DqMutexUnlock(void)775 static MS_BOOL _VDEC_DqMutexUnlock(void)
776 {
777 if (_s32DqMutexId != -1)
778 {
779 return MsOS_ReleaseMutex(_s32DqMutexId);
780 }
781 else
782 {
783 return FALSE;
784 }
785 }
786
_VDEC_InitDq(MS_U8 u8StreamNum)787 static void _VDEC_InitDq(MS_U8 u8StreamNum)
788 {
789 MS_U32 i=0;
790
791 //Create Mutex
792 if(_s32DqMutexId < 0)
793 {
794 _s32DqMutexId = MsOS_CreateMutex(E_MSOS_FIFO, (char*)_u8DqMutex, MSOS_PROCESS_SHARED);
795 }
796 if(_s32DqMutexId < 0)
797 {
798 printf("%s MsOS_CreateMutex failed!!\n", __FUNCTION__);
799 return;
800 }
801
802 _VDEC_DqMutexLock();
803 for (i=0; i<MAX_VDEC_DQNUM; i++)
804 {
805 VDEC_DispQ[u8StreamNum][i].u32Idx = VDEC_DQ_EMPTY;
806 }
807 _VDEC_DqMutexUnlock();
808 }
809
_VDEC_DqMutexExit(void)810 static void _VDEC_DqMutexExit(void)
811 {
812 if(_s32DqMutexId != -1)
813 {
814 MsOS_DeleteMutex(_s32DqMutexId);
815 _s32DqMutexId = -1;
816 }
817 }
818
_VDEC_MallocDq(MS_U8 u8StreamNum)819 static VDEC_DispFrame* _VDEC_MallocDq(MS_U8 u8StreamNum)
820 {
821 VDEC_DispFrame* pDisp = NULL;
822 MS_U32 i=0;
823
824 if (u8StreamNum >= E_VDEC_STREAM_NUM_MAX)
825 {
826 return NULL;
827 }
828 _VDEC_DqMutexLock();
829 for (i=0; i<MAX_VDEC_DQNUM; i++)
830 {
831 if (VDEC_DispQ[u8StreamNum][i].u32Idx == VDEC_DQ_EMPTY)
832 {
833 VDEC_DispQ[u8StreamNum][i].u32Idx = i;
834 pDisp = &VDEC_DispQ[u8StreamNum][i];
835 //printf("_VDEC_MallocDq %ld\n", i);
836 break;
837 }
838 }
839 _VDEC_DqMutexUnlock();
840 return pDisp;
841 }
842
_VDEC_FreeDq(MS_U8 u8StreamNum,VDEC_DispFrame * pDq)843 static void _VDEC_FreeDq(MS_U8 u8StreamNum, VDEC_DispFrame* pDq)
844 {
845 if (pDq && (VDEC_DQ_EMPTY != pDq->u32Idx))
846 {
847 _VDEC_DqMutexLock();
848 VDEC_DispQ[u8StreamNum][pDq->u32Idx].u32Idx = VDEC_DQ_EMPTY;
849 _VDEC_DqMutexUnlock();
850 }
851 }
852
_VDEC_IsDqValid(VDEC_DispFrame * pDq)853 static MS_BOOL _VDEC_IsDqValid(VDEC_DispFrame* pDq)
854 {
855 MS_BOOL bRet = FALSE;
856 if (pDq)
857 {
858 _VDEC_DqMutexLock();
859 bRet = (pDq->u32Idx == VDEC_DQ_EMPTY);
860 _VDEC_DqMutexUnlock();
861 }
862 return bRet;
863 }
864
865 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
_VDEC_LinkWeakSymbolPatch(void)866 static void __attribute__((unused)) _VDEC_LinkWeakSymbolPatch(void)
867 {
868 #if VDEC_ENABLE_MVD
869 MDrv_MVD_LinkWeakSymbolPatch();
870 #endif
871 #if VDEC_ENABLE_HVD
872 MDrv_HVD_LinkWeakSymbolPatch();
873 #endif
874 }
875 #endif
876
_VDEC_InitLocalVar(void)877 static void _VDEC_InitLocalVar(void)
878 {
879 MS_U32 u32Tmp = 0;
880
881 _Attr.bInit = FALSE;
882 _Attr.eDbgMsgLevel = VDEC_DEFAULT_DBG_MSG_LEVEL;
883 _Attr.eCodecType = E_VDEC_CODEC_TYPE_NONE;
884 _Attr.eDecoder = E_VDEC_DECODER_NONE;
885 _Attr.eErrCode = E_VDEC_ERR_CODE_BASE;
886
887 #if defined(VDEC_ISR_MONITOR)
888 MsOS_ClearEvent(_s32VdecEventId, VDEC_U32_MAX);
889 _u32VdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE;
890 _u32PreVdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE;
891 MsOS_SetEvent(_s32VdecEventId, E_VDEC_EVENT_ISR_EVENT_CHANGE);
892 #else
893 _u32VdecIsrEventFlag = 0;
894 #endif
895 _prev_u16PowerState = E_POWER_MECHANICAL;
896
897 for (u32Tmp = 0; u32Tmp < E_VDEC_CB_MAX_NUM; u32Tmp++)
898 {
899 _Attr.VdecEventInfo[u32Tmp].u32EventBitMap = 0;
900 _Attr.VdecEventInfo[u32Tmp].pVdecEventCb = NULL;
901 _Attr.VdecEventInfo[u32Tmp].pParam = NULL;
902 }
903 #if 0
904 if(u32VdecInitParamVersion == 0)
905 {
906 _VDEC_Memset(&_vdecInitParam, 0, sizeof(VDEC_InitParam));
907 }
908 else if(u32VdecInitParamVersion == 1)
909 {
910 _VDEC_Memset(&_vdecInitParam_ex1, 0, sizeof(VDEC_InitParam_EX1));
911 }
912 #endif
913
914 _VDEC_InitDq(E_VDEC_STREAM_0);
915 #if _VDEC_PTS_TABLE
916 _VDEC_PtsTableInit();
917 #endif
918 }
919
920
921 #if defined(VDEC_ISR_MONITOR)
_VDEC_SYS_Init(void)922 static MS_BOOL _VDEC_SYS_Init(void)
923 {
924 //Create Mutex
925 if(_s32VdecMutexId < 0)
926 {
927 _s32VdecMutexId = MsOS_CreateMutex(E_MSOS_FIFO, (char*)_u8VdecMutex, MSOS_PROCESS_SHARED);
928 }
929 if(_s32VdecMutexId < 0)
930 {
931 printf("MsOS_CreateMutex failed!!\n");
932 return FALSE;
933 }
934
935 //Create Event Group
936 if(_s32VdecEventId < 0)
937 {
938 _s32VdecEventId = MsOS_CreateEventGroup((char *)_u8VdecEvent);
939 }
940 if(_s32VdecEventId < 0)
941 {
942 printf("MsOS_CreateEventGroup failed!!\n");
943 MsOS_DeleteMutex(_s32VdecMutexId);
944 return FALSE;
945 }
946
947 //Create Vdec event monitor Task
948 _bVdecIsrMntr = TRUE;
949 if(_s32VdecTaskId < 0)
950 {
951 _s32VdecTaskId = MsOS_CreateTask((TaskEntry)_VDEC_MonitorISR_Proc,
952 (MS_U32)NULL,
953 E_TASK_PRI_MEDIUM,
954 TRUE,
955 (void *)_VdecStack,
956 VDEC_STACK_SIZE,
957 (char *)_u8VdecTask);
958 }
959 if(_s32VdecTaskId < 0)
960 {
961 printf("MsOS_CreateTask failed!!\n");
962 MsOS_DeleteEventGroup(_s32VdecEventId);
963 MsOS_DeleteMutex(_s32VdecMutexId);
964 return FALSE;
965 }
966 return TRUE;
967 }
968 #else
_VDEC_MutexInit(void)969 static MS_BOOL _VDEC_MutexInit(void)
970 {
971 if(_s32VdecMutexId < 0)
972 {
973 _s32VdecMutexId = MsOS_CreateMutex(E_MSOS_FIFO, (char*)_u8VdecMutex, MSOS_PROCESS_SHARED);
974 }
975 return (_s32VdecMutexId != -1);
976 }
977
_VDEC_MutexExit(void)978 static MS_BOOL _VDEC_MutexExit(void)
979 {
980 MS_BOOL bRet = TRUE;
981 if(_s32VdecMutexId != -1)
982 {
983 MsOS_DeleteMutex(_s32VdecMutexId);
984 _s32VdecMutexId = -1;
985 }
986 return bRet;
987 }
988
989 #endif
990
991 #if 0
992 static MS_BOOL _VDEC_SYS_Exit(void)
993 {
994 //Create Mutex
995 if(_s32VdecMutexId != -1)
996 {
997 MsOS_DeleteMutex(_s32VdecMutexId);
998 _s32VdecMutexId = -1;
999 }
1000
1001 if (_s32VdecEventId != -1)
1002 {
1003 MsOS_DeleteEventGroup(_s32VdecEventId);
1004 _s32VdecEventId = -1;
1005 }
1006
1007 if (_s32VdecTaskId != -1)
1008 {
1009 MsOS_DeleteTask(_s32VdecTaskId);
1010 _s32VdecTaskId = -1;
1011 }
1012 return TRUE;
1013 }
1014 #endif
1015
1016 // Mutex function for VDEC API
_VDEC_MutexLock(void)1017 static MS_BOOL _VDEC_MutexLock(void)
1018 {
1019 if (_s32VdecMutexId != -1)
1020 {
1021 return MsOS_ObtainMutex(_s32VdecMutexId, MSOS_WAIT_FOREVER);
1022 }
1023 else
1024 {
1025 return FALSE;
1026 }
1027 }
1028
_VDEC_MutexUnlock(void)1029 static MS_BOOL _VDEC_MutexUnlock(void)
1030 {
1031 if (_s32VdecMutexId != -1)
1032 {
1033 return MsOS_ReleaseMutex(_s32VdecMutexId);
1034 }
1035 else
1036 {
1037 return FALSE;
1038 }
1039 }
1040
1041 #ifdef _VDEC_AUTH_IPCheck_TEST_CODE_
_VDEC_GetDecoderByCodecType(VDEC_CodecType eCodecType)1042 static VDEC_Decoder _VDEC_GetDecoderByCodecType(VDEC_CodecType eCodecType)
1043 {
1044 VDEC_Decoder eDecoder;
1045
1046 bModeSelectHD = FALSE;
1047 bIsSupportDivxPlus = FALSE;
1048
1049 switch (eCodecType)
1050 {
1051 case E_VDEC_CODEC_TYPE_MPEG2:
1052 if ((MDrv_AUTH_IPCheck(IPAUTH_VIDEO_MPEG2) == TRUE)
1053 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_MPEG2_HD) == TRUE))
1054 {
1055 if(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_MPEG2_HD) == TRUE)
1056 bModeSelectHD =TRUE;
1057 else
1058 bModeSelectHD =FALSE;
1059 eDecoder = E_VDEC_DECODER_MVD;
1060 }
1061 else
1062 {
1063 eDecoder = E_VDEC_DECODER_NONE;
1064 }
1065 break;
1066 case E_VDEC_CODEC_TYPE_H263:
1067 case E_VDEC_CODEC_TYPE_MPEG4:
1068 if ((MDrv_AUTH_IPCheck(IPAUTH_VIDEO_MPEG4) == TRUE)
1069 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_MPEG4_SD) == TRUE)
1070 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_MPEG4_HD) == TRUE))
1071 {
1072 if(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_MPEG4_HD) == TRUE)
1073 bModeSelectHD =TRUE;
1074 else
1075 bModeSelectHD =FALSE;
1076 eDecoder = E_VDEC_DECODER_MVD;
1077
1078 if (MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_PLUS) == TRUE)
1079 {
1080 bIsSupportDivxPlus = TRUE;
1081 }
1082 }
1083 else
1084 {
1085 eDecoder = E_VDEC_DECODER_NONE;
1086 }
1087 break;
1088 case E_VDEC_CODEC_TYPE_DIVX311:
1089 case E_VDEC_CODEC_TYPE_DIVX412:
1090 if ((MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_1080PHD) == TRUE)
1091 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_DRM) == TRUE)
1092 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_PLUS) == TRUE)
1093 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_QMOBILE) == TRUE)
1094 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_MOBILE) == TRUE)
1095 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_HT) == TRUE))
1096 {
1097 if ((MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_1080PHD) == TRUE)
1098 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_DRM) == TRUE)
1099 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_PLUS) == TRUE)
1100 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_DIVX_HT) == TRUE))
1101 bModeSelectHD =TRUE;
1102 else
1103 bModeSelectHD =FALSE;
1104 eDecoder = E_VDEC_DECODER_MVD;
1105 }
1106 else
1107 {
1108 eDecoder = E_VDEC_DECODER_NONE;
1109 }
1110 break;
1111
1112 case E_VDEC_CODEC_TYPE_FLV:
1113 if (MDrv_AUTH_IPCheck(IPAUTH_VIDEO_FLV) == TRUE)
1114 {
1115 bModeSelectHD = TRUE;
1116 eDecoder = E_VDEC_DECODER_MVD;
1117 }
1118 else
1119 {
1120 eDecoder = E_VDEC_DECODER_NONE;
1121 }
1122 break;
1123
1124 case E_VDEC_CODEC_TYPE_VC1_ADV:
1125 case E_VDEC_CODEC_TYPE_VC1_MAIN:
1126 if ((MDrv_AUTH_IPCheck(IPAUTH_VIDEO_VC1) == TRUE)
1127 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_WMV) == TRUE)
1128 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_WMDRM_PD) == TRUE)
1129 ||(MDrv_AUTH_IPCheck(IPAUTH_VIDEO_WMDRM_ND) == TRUE))
1130 {
1131
1132 bModeSelectHD =TRUE;
1133 eDecoder = E_VDEC_DECODER_MVD;
1134 }
1135 else
1136 {
1137 eDecoder = E_VDEC_DECODER_NONE;
1138 }
1139 break;
1140
1141 case E_VDEC_CODEC_TYPE_RV8:
1142 case E_VDEC_CODEC_TYPE_RV9:
1143
1144 #if VDEC_ENABLE_HVD
1145 eDecoder = E_VDEC_DECODER_HVD;
1146 #else
1147 eDecoder = E_VDEC_DECODER_NONE;
1148 #endif
1149
1150 if (MDrv_AUTH_IPCheck(IPAUTH_VIDEO_RM) == TRUE)
1151 bModeSelectHD =TRUE;
1152 else
1153 eDecoder = E_VDEC_DECODER_NONE;
1154
1155 break;
1156 case E_VDEC_CODEC_TYPE_H264:
1157 if (MDrv_AUTH_IPCheck(IPAUTH_VIDEO_H264) == TRUE)
1158 {
1159 bModeSelectHD =TRUE;
1160 eDecoder = E_VDEC_DECODER_HVD;
1161 }
1162 else
1163 {
1164 eDecoder = E_VDEC_DECODER_NONE;
1165 }
1166 break;
1167 case E_VDEC_CODEC_TYPE_AVS:
1168 if (MDrv_AUTH_IPCheck(IPAUTH_VIDEO_AVS) == TRUE)
1169 {
1170 bModeSelectHD =TRUE;
1171 eDecoder = E_VDEC_DECODER_HVD;
1172 }
1173 else
1174 {
1175 eDecoder = E_VDEC_DECODER_NONE;
1176 }
1177 break;
1178 case E_VDEC_CODEC_TYPE_MJPEG:
1179 eDecoder = E_VDEC_DECODER_MJPEG;
1180
1181 break;
1182
1183 default:
1184 eDecoder = E_VDEC_DECODER_NONE;
1185
1186 break;
1187 }
1188
1189 return eDecoder;
1190 }
1191 #else
_VDEC_GetDecoderByCodecType(VDEC_CodecType eCodecType)1192 static VDEC_Decoder _VDEC_GetDecoderByCodecType(VDEC_CodecType eCodecType)
1193 {
1194 VDEC_Decoder eDecoder;
1195 switch (eCodecType)
1196 {
1197 case E_VDEC_CODEC_TYPE_MPEG2:
1198 case E_VDEC_CODEC_TYPE_H263:
1199 case E_VDEC_CODEC_TYPE_MPEG4:
1200 #if (!VESTEL_FEATURE_ENABLE)
1201 case E_VDEC_CODEC_TYPE_DIVX311:
1202 case E_VDEC_CODEC_TYPE_DIVX412:
1203 case E_VDEC_CODEC_TYPE_FLV:
1204 case E_VDEC_CODEC_TYPE_VC1_ADV:
1205 case E_VDEC_CODEC_TYPE_VC1_MAIN:
1206 #endif
1207 eDecoder = E_VDEC_DECODER_MVD;
1208 bIsSupportDivxPlus = TRUE;
1209 break;
1210
1211 case E_VDEC_CODEC_TYPE_RV8:
1212 case E_VDEC_CODEC_TYPE_RV9:
1213
1214 #if VDEC_ENABLE_HVD
1215 eDecoder = E_VDEC_DECODER_HVD;
1216 #else
1217 eDecoder = E_VDEC_DECODER_NONE;
1218 #endif
1219 break;
1220 #if (!VESTEL_FEATURE_ENABLE)
1221 case E_VDEC_CODEC_TYPE_H264:
1222 case E_VDEC_CODEC_TYPE_AVS:
1223 eDecoder = E_VDEC_DECODER_HVD;
1224
1225 break;
1226 #endif
1227 case E_VDEC_CODEC_TYPE_MJPEG:
1228 eDecoder = E_VDEC_DECODER_MJPEG;
1229
1230 break;
1231
1232 default:
1233 eDecoder = E_VDEC_DECODER_NONE;
1234
1235 break;
1236 }
1237
1238 return eDecoder;
1239 }
1240 #endif
1241
_VDEC_Map2MVDCodecType(VDEC_CodecType vdecCodecType)1242 static MVD_CodecType _VDEC_Map2MVDCodecType(VDEC_CodecType vdecCodecType)
1243 {
1244 MVD_CodecType mvdCodecType = E_MVD_CODEC_UNKNOWN;
1245
1246 switch (vdecCodecType)
1247 {
1248 case E_VDEC_CODEC_TYPE_MPEG2:
1249 mvdCodecType = E_MVD_CODEC_MPEG2;
1250 break;
1251
1252 case E_VDEC_CODEC_TYPE_H263:
1253 mvdCodecType = E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER;
1254 break;
1255
1256 case E_VDEC_CODEC_TYPE_MPEG4:
1257 case E_VDEC_CODEC_TYPE_DIVX412:
1258 mvdCodecType = E_MVD_CODEC_MPEG4;
1259 break;
1260
1261 case E_VDEC_CODEC_TYPE_DIVX311:
1262 mvdCodecType = E_MVD_CODEC_DIVX311;
1263 break;
1264
1265 case E_VDEC_CODEC_TYPE_FLV:
1266 mvdCodecType = E_MVD_CODEC_FLV;
1267 break;
1268
1269 case E_VDEC_CODEC_TYPE_VC1_ADV:
1270 mvdCodecType = E_MVD_CODEC_VC1_ADV;
1271 break;
1272
1273 case E_VDEC_CODEC_TYPE_VC1_MAIN:
1274 mvdCodecType = E_MVD_CODEC_VC1_MAIN;
1275 break;
1276
1277 default:
1278 mvdCodecType = E_MVD_CODEC_UNKNOWN;
1279 break;
1280 }
1281
1282 return mvdCodecType;
1283 }
1284
_VDEC_Map2MVDSrcMode(VDEC_SrcMode vdecSrcMode)1285 static MVD_SrcMode _VDEC_Map2MVDSrcMode(VDEC_SrcMode vdecSrcMode)
1286 {
1287 MVD_SrcMode mvdSrcMode = E_MVD_TS_MODE;
1288
1289 switch (vdecSrcMode)
1290 {
1291 case E_VDEC_SRC_MODE_DTV:
1292 mvdSrcMode = E_MVD_TS_MODE;
1293 break;
1294
1295 case E_VDEC_SRC_MODE_TS_FILE:
1296 mvdSrcMode = E_MVD_TS_FILE_MODE;
1297 break;
1298
1299 case E_VDEC_SRC_MODE_FILE:
1300 mvdSrcMode = E_MVD_SLQ_TBL_MODE;
1301 break;
1302
1303 default:
1304 mvdSrcMode = E_MVD_TS_MODE;
1305 break;
1306 }
1307
1308 return mvdSrcMode;
1309 }
1310
_VDEC_MapFrmType2MVD(MVD_PicType vdecFrmType)1311 static VDEC_FrameType _VDEC_MapFrmType2MVD(MVD_PicType vdecFrmType)
1312 {
1313 VDEC_FrameType mvdFrmType = E_VDEC_FRM_TYPE_OTHER;
1314
1315 switch (vdecFrmType)
1316 {
1317 case E_MVD_PIC_I:
1318 mvdFrmType = E_VDEC_FRM_TYPE_I;
1319 break;
1320
1321 case E_MVD_PIC_P:
1322 mvdFrmType = E_VDEC_FRM_TYPE_P;
1323 break;
1324
1325 case E_MVD_PIC_B:
1326 mvdFrmType = E_VDEC_FRM_TYPE_B;
1327 break;
1328
1329 default:
1330 mvdFrmType = E_VDEC_FRM_TYPE_OTHER;
1331 break;
1332 }
1333
1334 return mvdFrmType;
1335 }
1336
_VDEC_MapFrmType2HVD(HVD_Frm_Type vdecFrmType)1337 static VDEC_FrameType _VDEC_MapFrmType2HVD(HVD_Frm_Type vdecFrmType)
1338 {
1339 VDEC_FrameType hvdFrmType = E_VDEC_FRM_TYPE_OTHER;
1340
1341 switch (vdecFrmType)
1342 {
1343 case E_HVD_FRM_TYPE_I:
1344 hvdFrmType = E_VDEC_FRM_TYPE_I;
1345 break;
1346
1347 case E_HVD_FRM_TYPE_P:
1348 hvdFrmType = E_VDEC_FRM_TYPE_P;
1349 break;
1350
1351 case E_HVD_FRM_TYPE_B:
1352 hvdFrmType = E_VDEC_FRM_TYPE_B;
1353 break;
1354
1355 default:
1356 hvdFrmType = E_VDEC_FRM_TYPE_OTHER;
1357 break;
1358 }
1359
1360 return hvdFrmType;
1361 }
1362
_VDEC_MapFrmType2MJPEG(MJPEG_FrameType vdecFrmType)1363 static VDEC_FrameType _VDEC_MapFrmType2MJPEG(MJPEG_FrameType vdecFrmType)
1364 {
1365 VDEC_FrameType mjpegFrmType = E_VDEC_FRM_TYPE_OTHER;
1366
1367 switch (vdecFrmType)
1368 {
1369 case E_MJPEG_FRM_TYPE_I:
1370 mjpegFrmType = E_VDEC_FRM_TYPE_I;
1371 break;
1372
1373 case E_MJPEG_FRM_TYPE_OTHER:
1374 default:
1375 mjpegFrmType = E_VDEC_FRM_TYPE_OTHER;
1376 break;
1377 }
1378
1379 return mjpegFrmType;
1380 }
1381
_VDEC_MVDCfgDivX(VDEC_CodecType vdecCodecType)1382 static void _VDEC_MVDCfgDivX(VDEC_CodecType vdecCodecType)
1383 {
1384 switch (vdecCodecType)
1385 {
1386 case E_VDEC_CODEC_TYPE_MPEG4:
1387 MDrv_MVD_SetDivXCfg(0x01, 0x01);
1388 break;
1389
1390 case E_VDEC_CODEC_TYPE_DIVX412:
1391 MDrv_MVD_SetDivXCfg(0x11, 0x01);
1392 break;
1393
1394 case E_VDEC_CODEC_TYPE_DIVX311:
1395 MDrv_MVD_SetDivXCfg(0x00, 0x00);
1396 break;
1397
1398 default:
1399 break;
1400 }
1401
1402 return;
1403 }
1404
_VDEC_IsIdle(void)1405 MS_BOOL _VDEC_IsIdle(void)
1406 {
1407 MS_BOOL bRet;
1408
1409 if (!_Attr.bInit)
1410 {
1411 return FALSE;
1412 }
1413
1414 switch (_Attr.eDecoder)
1415 {
1416 case E_VDEC_DECODER_MVD:
1417 bRet = MDrv_MVD_IsIdle();
1418 break;
1419
1420 case E_VDEC_DECODER_HVD:
1421 bRet = MDrv_HVD_IsIdle();
1422 break;
1423
1424 case E_VDEC_DECODER_MJPEG:
1425 bRet = MApi_MJPEG_IsIdle();
1426 break;
1427
1428 case E_VDEC_DECODER_RVD:
1429 bRet = MDrv_RVD_IsIdle();
1430 break;
1431
1432 default:
1433 bRet = FALSE;
1434 break;
1435 }
1436
1437 return bRet;
1438 }
1439
1440 #if defined(VDEC_ISR_MONITOR)
1441 //------------------------------------------------------------------------------
1442 /// The task for monitoring vdec isr
1443 /// @return -None
1444 //------------------------------------------------------------------------------
_VDEC_MonitorISR_Proc(void)1445 static void _VDEC_MonitorISR_Proc(void)
1446 {
1447 MS_U32 u32VdecEventFlag = 0;
1448 MS_U32 cb_idx = 0;
1449
1450 while (_bVdecIsrMntr == TRUE)
1451 {
1452 if(_u32PreVdecIsrEventFlag != _u32VdecIsrEventFlag)
1453 {
1454 MsOS_ClearEvent(_s32VdecEventId, VDEC_U32_MAX);
1455 _u32PreVdecIsrEventFlag = _u32VdecIsrEventFlag;
1456 }
1457
1458 MsOS_WaitEvent(_s32VdecEventId,
1459 _u32PreVdecIsrEventFlag,
1460 &u32VdecEventFlag,
1461 E_OR_CLEAR,
1462 MSOS_WAIT_FOREVER);
1463
1464 if ((u32VdecEventFlag & ~E_VDEC_EVENT_ISR_EVENT_CHANGE) & _u32VdecIsrEventFlag)
1465 {
1466 for (cb_idx = 0; cb_idx < E_VDEC_CB_MAX_NUM; cb_idx++)
1467 {
1468 MS_U32 u32Event = u32VdecEventFlag &_Attr.VdecEventInfo[cb_idx].u32EventBitMap;
1469
1470 if ((u32Event) &&
1471 (_Attr.VdecEventInfo[cb_idx].pVdecEventCb))
1472 {
1473 _Attr.VdecEventInfo[cb_idx].pVdecEventCb(u32Event,
1474 _Attr.VdecEventInfo[cb_idx].pParam);
1475 }
1476 }
1477 }
1478 }
1479 }
1480 #endif
1481
1482 //------------------------------------------------------------------------------
1483 /// Set decoder event and register it's callback function
1484 /// @param pfn \b In : callback function
1485 /// @return -VDEC_Result
1486 //------------------------------------------------------------------------------
_VDEC_IsrProc(void)1487 static void _VDEC_IsrProc(void)
1488 {
1489 #if !defined(VDEC_ISR_MONITOR)
1490 MS_U32 i = 0;
1491 #endif
1492
1493 _VDEC_MutexLock();
1494
1495 #if defined(VDEC_ISR_MONITOR)
1496 if (_u32VdecIsrEventFlag & ~E_VDEC_EVENT_ISR_EVENT_CHANGE)
1497 #else
1498 if (_u32VdecIsrEventFlag)
1499 #endif
1500 {
1501 MS_U32 eEventFlag = E_VDEC_EVENT_OFF;
1502
1503 switch (_Attr.eDecoder)
1504 {
1505 case E_VDEC_DECODER_MVD:
1506 {
1507 MS_U32 u32MVDIsrEvent = MDrv_MVD_GetIsrEvent();
1508 if (u32MVDIsrEvent != E_MVD_EVENT_DISABLE_ALL)
1509 {
1510 #ifdef _MVD_EVENT_DBG
1511 if (u32MVDIsrEvent & E_MVD_EVENT_DISP_VSYNC)
1512 {
1513 eEventFlag |= E_VDEC_EVENT_DISP_ONE;
1514 }
1515 #endif
1516 if (u32MVDIsrEvent & E_MVD_EVENT_DISP_RDY)
1517 {
1518 eEventFlag |= E_VDEC_EVENT_DISP_INFO_RDY;
1519 }
1520 if (u32MVDIsrEvent & E_MVD_EVENT_SEQ_FOUND)
1521 {
1522 eEventFlag |= E_VDEC_EVENT_SEQ_HDR_FOUND;
1523
1524 if (MDrv_MVD_IsSeqChg())
1525 {
1526 eEventFlag |= E_VDEC_EVENT_DISP_INFO_CHG;
1527 }
1528 }
1529 if (u32MVDIsrEvent & E_MVD_EVENT_USER_DATA)
1530 {
1531 #if !defined(MVD_SUPPORT_X4_CC)
1532 //exclude this for X4_CC for this is UserData in "decoding" order
1533 eEventFlag |= E_VDEC_EVENT_USER_DATA_FOUND;
1534 #endif
1535 MS_U8 u8Afd = MDrv_MVD_GetActiveFormat();
1536
1537 if ((u8Afd != 0) && (u8Afd != 0xff))
1538 {
1539 eEventFlag |= E_VDEC_EVENT_AFD_FOUND;
1540 }
1541 }
1542 if (u32MVDIsrEvent & E_MVD_EVENT_USER_DATA_DISP)
1543 {
1544 //this is UserData in "display" order
1545 eEventFlag |= E_VDEC_EVENT_USER_DATA_FOUND;
1546 }
1547 if (u32MVDIsrEvent & E_MVD_EVENT_UNMUTE)
1548 {
1549 eEventFlag |= E_VDEC_EVENT_VIDEO_UNMUTE;
1550 }
1551 if (u32MVDIsrEvent & E_MVD_EVENT_FIRST_FRAME)
1552 {
1553 eEventFlag |= E_VDEC_EVENT_FIRST_FRAME;
1554 eEventFlag |= E_VDEC_EVENT_DISP_INFO_CHG;
1555 }
1556 if (u32MVDIsrEvent & E_MVD_EVENT_DEC_I)
1557 {
1558 eEventFlag |= E_VDEC_EVENT_DEC_I;
1559 }
1560
1561 #if defined(VDEC_ISR_MONITOR)
1562 MsOS_SetEvent(_s32VdecEventId, eEventFlag);
1563 #else
1564 for (i = 0; i < E_VDEC_CB_MAX_NUM; i++)
1565 {
1566 MS_U32 u32Event = eEventFlag &_Attr.VdecEventInfo[i].u32EventBitMap;
1567
1568 if ((u32Event) &&
1569 (_Attr.VdecEventInfo[i].pVdecEventCb))
1570 {
1571 _VDEC_MutexUnlock();
1572 _Attr.VdecEventInfo[i].pVdecEventCb(u32Event,
1573 _Attr.VdecEventInfo[i].pParam);
1574 _VDEC_MutexLock();
1575 }
1576 }
1577 #endif
1578 }
1579 break;
1580 }
1581 case E_VDEC_DECODER_HVD:
1582 {
1583 MS_U32 u32HVDIsrEvent = E_HVD_ISR_NONE;
1584 if (MDrv_HVD_GetISRInfo(&u32HVDIsrEvent))
1585 {
1586 if (u32HVDIsrEvent & E_HVD_ISR_DISP_ONE)
1587 {
1588 eEventFlag |= E_VDEC_EVENT_DISP_ONE;
1589 }
1590 if (u32HVDIsrEvent & E_HVD_ISR_DISP_REPEAT)
1591 {
1592 eEventFlag |= E_VDEC_EVENT_DISP_REPEAT;
1593 }
1594 if (u32HVDIsrEvent & E_HVD_ISR_DISP_WITH_CC)
1595 {
1596 eEventFlag |= (E_VDEC_EVENT_DISP_WITH_CC |
1597 E_VDEC_EVENT_USER_DATA_FOUND);
1598 }
1599 if (u32HVDIsrEvent & E_HVD_ISR_DISP_FIRST_FRM)
1600 {
1601 eEventFlag |= E_VDEC_EVENT_VIDEO_UNMUTE;
1602 }
1603 if (u32HVDIsrEvent & E_HVD_ISR_DEC_ONE)
1604 {
1605 eEventFlag |= E_VDEC_EVENT_DEC_ONE;
1606 }
1607 if (u32HVDIsrEvent & E_HVD_ISR_DEC_I)
1608 {
1609 eEventFlag |= E_VDEC_EVENT_DEC_I;
1610 }
1611 if (u32HVDIsrEvent & E_HVD_ISR_DEC_HW_ERR)
1612 {
1613 eEventFlag |= E_VDEC_EVENT_DEC_ERR;
1614 }
1615 #if 1 //Currently, for HVD, E_VDEC_EVENT_USER_DATA_FOUND is triggerred by E_HVD_ISR_DISP_WITH_CC
1616 if (u32HVDIsrEvent &E_HVD_ISR_DEC_CC_FOUND )
1617 {
1618 eEventFlag |= E_VDEC_EVENT_USER_DATA_FOUND;
1619 }
1620 #endif
1621 if (u32HVDIsrEvent & E_HVD_ISR_DEC_DISP_INFO_CHANGE)
1622 {
1623 MS_U8 u8Afd = MDrv_HVD_GetActiveFormat();
1624
1625 if (u8Afd != 0)
1626 {
1627 eEventFlag |= E_VDEC_EVENT_AFD_FOUND;
1628 }
1629
1630 eEventFlag |= (E_VDEC_EVENT_DISP_INFO_CHG | E_VDEC_EVENT_DISP_INFO_RDY);
1631 }
1632 if (u32HVDIsrEvent & E_HVD_ISR_DEC_FIRST_FRM)
1633 {
1634 eEventFlag |= E_VDEC_EVENT_FIRST_FRAME;
1635 }
1636 #if defined(VDEC_ISR_MONITOR)
1637 MsOS_SetEvent(_s32VdecEventId, eEventFlag);
1638 #else
1639 for (i = 0; i < E_VDEC_CB_MAX_NUM; i++)
1640 {
1641 MS_U32 u32Event = eEventFlag & _Attr.VdecEventInfo[i].u32EventBitMap;
1642
1643 if ((u32Event) &&
1644 (_Attr.VdecEventInfo[i].pVdecEventCb))
1645 {
1646 _VDEC_MutexUnlock();
1647 _Attr.VdecEventInfo[i].pVdecEventCb(u32Event, _Attr.VdecEventInfo[i].pParam);
1648 _VDEC_MutexLock();
1649 }
1650 }
1651 #endif
1652 }
1653 break;
1654 }
1655 case E_VDEC_DECODER_MJPEG:
1656 break;
1657 case E_VDEC_DECODER_RVD:
1658 break;
1659 default:
1660 break;
1661 }
1662 }
1663
1664 _VDEC_MutexUnlock();
1665 }
1666
_VDEC_Map2MVDSpeed(VDEC_DispSpeed eSpeed)1667 static MS_U8 _VDEC_Map2MVDSpeed(VDEC_DispSpeed eSpeed)
1668 {
1669 MS_U8 u8Speed = 0;
1670
1671 switch (eSpeed)
1672 {
1673 case E_VDEC_DISP_SPEED_32X:
1674 u8Speed = 32;
1675 break;
1676
1677 case E_VDEC_DISP_SPEED_16X:
1678 u8Speed = 16;
1679 break;
1680
1681 case E_VDEC_DISP_SPEED_8X:
1682 u8Speed = 8;
1683 break;
1684
1685 case E_VDEC_DISP_SPEED_4X:
1686 u8Speed = 4;
1687 break;
1688
1689 case E_VDEC_DISP_SPEED_2X:
1690 u8Speed = 2;
1691 break;
1692
1693 case E_VDEC_DISP_SPEED_1X:
1694 u8Speed = 1;
1695 break;
1696
1697 default:
1698 u8Speed = (MS_U8) eSpeed;
1699 break;
1700 }
1701
1702 return u8Speed;
1703 }
1704
_VDEC_Map2HVDSpeed(VDEC_DispSpeed eSpeed)1705 static MS_U8 _VDEC_Map2HVDSpeed(VDEC_DispSpeed eSpeed)
1706 {
1707 return _VDEC_Map2MVDSpeed(eSpeed);
1708 }
1709
1710 //------------------------------------------------------------------------------
1711 /// Enable to let decoder force to display repeat last field
1712 /// @param bEnable \b IN : TRUE - enable; FALSE - disable
1713 /// @return VDEC_Result
1714 //------------------------------------------------------------------------------
_VDEC_RepeatLastField(MS_BOOL bEnable)1715 static VDEC_Result _VDEC_RepeatLastField(MS_BOOL bEnable)
1716 {
1717 VDEC_Result ret = E_VDEC_FAIL;
1718
1719 switch (_Attr.eDecoder)
1720 {
1721 case E_VDEC_DECODER_MVD:
1722 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_DispRepeatField(bEnable));
1723 break;
1724 case E_VDEC_DECODER_HVD:
1725 {
1726 _HVD_RET_HANDLE(MDrv_HVD_SetDispRepeatField(bEnable));
1727 ret = E_VDEC_OK;
1728 break;
1729 }
1730 case E_VDEC_DECODER_MJPEG:
1731 ret = E_VDEC_RET_UNSUPPORTED;
1732 break;
1733 case E_VDEC_DECODER_RVD:
1734 ret = E_VDEC_RET_UNSUPPORTED;
1735 break;
1736 default:
1737 break;
1738 }
1739
1740 return ret;
1741 }
1742
1743 //------------------------------------------------------------------------------
1744 /// Set the maximum repeat times for one frame when av is not sync.
1745 /// @param -u32Th \b IN : repeat times. 0x01 ~ 0xFF
1746 /// 0xff - repeat current frame until STC catch up PTS.
1747 /// @return -The result of command set sync repeat threashold
1748 //------------------------------------------------------------------------------
_VDEC_SetAVSyncRepeatThreshold(MS_U32 u32Th)1749 static VDEC_Result _VDEC_SetAVSyncRepeatThreshold(MS_U32 u32Th)
1750 {
1751 VDEC_Result ret = E_VDEC_FAIL;
1752
1753 switch (_Attr.eDecoder)
1754 {
1755 case E_VDEC_DECODER_MVD:
1756 MDrv_MVD_SetAVSyncThreshold(u32Th);
1757 ret = E_VDEC_OK;
1758 break;
1759 case E_VDEC_DECODER_HVD:
1760 {
1761 _HVD_RET_HANDLE(MDrv_HVD_SetSyncRepeatTH(u32Th));
1762 ret = E_VDEC_OK;
1763 break;
1764 }
1765 case E_VDEC_DECODER_MJPEG:
1766 ret = E_VDEC_RET_UNSUPPORTED;
1767 break;
1768 case E_VDEC_DECODER_RVD:
1769 ret = E_VDEC_RET_UNSUPPORTED;
1770 break;
1771 default:
1772 break;
1773 }
1774
1775 return ret;
1776 }
1777
1778 //------------------------------------------------------------------------------
1779 /// Enable FW only show one field.
1780 /// @param bEnable \b IN : TRUE - show one field; FALSE - disable
1781 /// @return VDEC_Result
1782 //------------------------------------------------------------------------------
_VDEC_DispOneField(MS_U32 u32Arg)1783 static VDEC_Result _VDEC_DispOneField(MS_U32 u32Arg)
1784 {
1785 VDEC_Result ret = E_VDEC_FAIL;
1786
1787 switch (_Attr.eDecoder)
1788 {
1789 case E_VDEC_DECODER_MVD:
1790 _MVD_RET_HANDLE(MDrv_MVD_EnableDispOneField((MS_BOOL)u32Arg));
1791 ret = E_VDEC_OK;
1792 break;
1793
1794 case E_VDEC_DECODER_HVD:
1795 _HVD_RET_HANDLE(MDrv_HVD_SetDispOneField((MS_BOOL)u32Arg));
1796 ret = E_VDEC_OK;
1797 break;
1798
1799 case E_VDEC_DECODER_MJPEG:
1800 ret = E_VDEC_RET_UNSUPPORTED;
1801 break;
1802
1803 case E_VDEC_DECODER_RVD:
1804 ret = E_VDEC_RET_UNSUPPORTED;
1805 break;
1806
1807 default:
1808 break;
1809 }
1810
1811 return ret;
1812 }
1813
1814 //------------------------------------------------------------------------------
1815 /// Set fd mask delay count.
1816 /// @param u32Arg \b IN : unit is in vsync base for muting the fd_mask
1817 /// @return VDEC_Result
1818 //------------------------------------------------------------------------------
_VDEC_SetFdMaskDelayCnt(MS_U32 u32Arg)1819 static VDEC_Result _VDEC_SetFdMaskDelayCnt(MS_U32 u32Arg)
1820 {
1821 VDEC_Result ret = E_VDEC_FAIL;
1822
1823 switch (_Attr.eDecoder)
1824 {
1825 case E_VDEC_DECODER_MVD:
1826 _MVD_RET_HANDLE(MDrv_MVD_SetFdMaskDelayCount((MS_U16)u32Arg));
1827 ret = E_VDEC_OK;
1828 break;
1829
1830 case E_VDEC_DECODER_HVD:
1831 _HVD_RET_HANDLE(MDrv_HVD_SetFdMaskDelayCnt((MS_U8)u32Arg));
1832 ret = E_VDEC_OK;
1833 break;
1834
1835 case E_VDEC_DECODER_MJPEG:
1836 ret = E_VDEC_RET_UNSUPPORTED;
1837 break;
1838
1839 case E_VDEC_DECODER_RVD:
1840 ret = E_VDEC_RET_UNSUPPORTED;
1841 break;
1842
1843 default:
1844 break;
1845 }
1846
1847 return ret;
1848 }
1849
1850
1851 //------------------------------------------------------------------------------
1852 /// Set frame rate convert output mode
1853 /// @param pFRC \b IN : the address of VDEC_FRC_OutputParam
1854 /// @return VDEC_Result
1855 //------------------------------------------------------------------------------
_VDEC_FrameRateConvert(VDEC_FRC_OutputParam * pFRC)1856 static VDEC_Result _VDEC_FrameRateConvert(VDEC_FRC_OutputParam *pFRC)
1857 {
1858 VDEC_Result ret = E_VDEC_FAIL;
1859
1860 switch (_Attr.eDecoder)
1861 {
1862 case E_VDEC_DECODER_MVD:
1863 _MVD_RET_HANDLE(MDrv_MVD_SetOutputFRCMode((MS_U8)(pFRC->u32OutputFrameRate), pFRC->u8Interlace));
1864 ret = E_VDEC_OK;
1865 break;
1866
1867 case E_VDEC_DECODER_HVD:
1868 _HVD_RET_HANDLE(MDrv_HVD_SetOutputFRCMode((MS_U8)(pFRC->u32OutputFrameRate), pFRC->u8Interlace));
1869 ret = E_VDEC_OK;
1870 break;
1871
1872 case E_VDEC_DECODER_MJPEG:
1873 ret = E_VDEC_RET_UNSUPPORTED;
1874 break;
1875
1876 case E_VDEC_DECODER_RVD:
1877 ret = E_VDEC_RET_UNSUPPORTED;
1878 break;
1879
1880 default:
1881 break;
1882 }
1883
1884 return ret;
1885 }
1886
1887 //------------------------------------------------------------------------------
1888 /// Set ignore error reference
1889 /// @param bIgnore \b IN : turn on / off.
1890 /// @return VDEC_Result
1891 //------------------------------------------------------------------------------
_VDEC_SetIgnoreErrRef(MS_BOOL bIgnore)1892 static VDEC_Result _VDEC_SetIgnoreErrRef(MS_BOOL bIgnore)
1893 {
1894 VDEC_Result ret = E_VDEC_FAIL;
1895
1896 switch (_Attr.eDecoder)
1897 {
1898 case E_VDEC_DECODER_MVD:
1899 ret = E_VDEC_RET_UNSUPPORTED;
1900 break;
1901 case E_VDEC_DECODER_HVD:
1902 _HVD_RET_HANDLE(MDrv_HVD_SetIgnoreErrRef(bIgnore));
1903 ret = E_VDEC_OK;
1904 break;
1905 case E_VDEC_DECODER_MJPEG:
1906 ret = E_VDEC_RET_UNSUPPORTED;
1907 break;
1908 case E_VDEC_DECODER_RVD:
1909 ret = E_VDEC_RET_UNSUPPORTED;
1910 break;
1911 default:
1912 break;
1913 }
1914
1915 return ret;
1916 }
1917
1918 //------------------------------------------------------------------------------
1919 /// Set ignore error reference
1920 /// @param bIgnore \b IN : turn on / off.
1921 /// @return VDEC_Result
1922 //------------------------------------------------------------------------------
_VDEC_ForceFollowDTVSpec(MS_BOOL bEnable)1923 static VDEC_Result _VDEC_ForceFollowDTVSpec(MS_BOOL bEnable)
1924 {
1925 VDEC_Result ret = E_VDEC_FAIL;
1926
1927 switch (_Attr.eDecoder)
1928 {
1929 case E_VDEC_DECODER_MVD:
1930 ret = E_VDEC_RET_UNSUPPORTED;
1931 break;
1932 case E_VDEC_DECODER_HVD:
1933 _HVD_RET_HANDLE(MDrv_HVD_ForceFollowDTVSpec(bEnable));
1934 ret = E_VDEC_OK;
1935 break;
1936 case E_VDEC_DECODER_MJPEG:
1937 ret = E_VDEC_RET_UNSUPPORTED;
1938 break;
1939 case E_VDEC_DECODER_RVD:
1940 ret = E_VDEC_RET_UNSUPPORTED;
1941 break;
1942 default:
1943 break;
1944 }
1945
1946 return ret;
1947 }
1948
1949
1950 //------------------------------------------------------------------------------
1951 /// Set fast display, not caring av-sync
1952 /// @param bFastDisplay \b IN : turn on / off.
1953 /// @return VDEC_Result
1954 //------------------------------------------------------------------------------
_VDEC_SetFastDisplay(MS_BOOL bFastDisplay)1955 static VDEC_Result _VDEC_SetFastDisplay(MS_BOOL bFastDisplay)
1956 {
1957 VDEC_Result ret = E_VDEC_FAIL;
1958
1959 switch (_Attr.eDecoder)
1960 {
1961 case E_VDEC_DECODER_MVD:
1962 ret = E_VDEC_RET_UNSUPPORTED;
1963 break;
1964 case E_VDEC_DECODER_HVD:
1965 _HVD_RET_HANDLE(MDrv_HVD_SetFastDisplay(bFastDisplay));
1966 ret = E_VDEC_OK;
1967 break;
1968 case E_VDEC_DECODER_MJPEG:
1969 ret = E_VDEC_RET_UNSUPPORTED;
1970 break;
1971 case E_VDEC_DECODER_RVD:
1972 ret = E_VDEC_RET_UNSUPPORTED;
1973 break;
1974 default:
1975 break;
1976 }
1977
1978 return ret;
1979 }
1980
1981 //------------------------------------------------------------------------------
1982 /// Set frame rate convert drop type
1983 /// @param u32DropType \b IN : FRC drop type.
1984 /// @return VDEC_Result
1985 //------------------------------------------------------------------------------
_VDEC_SetFRCDropType(MS_U32 u32DropType)1986 static VDEC_Result _VDEC_SetFRCDropType(MS_U32 u32DropType)
1987 {
1988 VDEC_Result ret = E_VDEC_FAIL;
1989
1990 switch (_Attr.eDecoder)
1991 {
1992 case E_VDEC_DECODER_MVD:
1993 _MVD_RET_HANDLE(MDrv_MVD_SetFRCDropType((MS_U8)u32DropType));
1994 ret = E_VDEC_OK;
1995 break;
1996
1997 case E_VDEC_DECODER_HVD:
1998 _HVD_RET_HANDLE(MDrv_HVD_SetFRCDropType((MS_U8)u32DropType));
1999 ret = E_VDEC_RET_UNSUPPORTED;
2000 break;
2001
2002 case E_VDEC_DECODER_MJPEG:
2003 ret = E_VDEC_RET_UNSUPPORTED;
2004 break;
2005
2006 case E_VDEC_DECODER_RVD:
2007 ret = E_VDEC_RET_UNSUPPORTED;
2008 break;
2009
2010 default:
2011 break;
2012 }
2013
2014 return ret;
2015 }
2016
2017 //------------------------------------------------------------------------------
2018 /// Set disable resolution change
2019 /// @param bEnable \b IN : turn on / off.
2020 /// @return VDEC_Result
2021 //------------------------------------------------------------------------------
_VDEC_SetDisableSeqChange(MS_BOOL bEnable)2022 static VDEC_Result _VDEC_SetDisableSeqChange(MS_BOOL bEnable)
2023 {
2024 VDEC_Result ret = E_VDEC_FAIL;
2025
2026 switch (_Attr.eDecoder)
2027 {
2028 case E_VDEC_DECODER_MVD:
2029 _MVD_RET_HANDLE(MDrv_MVD_SetDisableSeqChange(bEnable));
2030 ret = E_VDEC_OK;
2031 break;
2032 case E_VDEC_DECODER_HVD:
2033 ret = E_VDEC_RET_UNSUPPORTED;
2034 break;
2035 case E_VDEC_DECODER_MJPEG:
2036 ret = E_VDEC_RET_UNSUPPORTED;
2037 break;
2038 case E_VDEC_DECODER_RVD:
2039 ret = E_VDEC_RET_UNSUPPORTED;
2040 break;
2041 default:
2042 break;
2043 }
2044
2045 return ret;
2046 }
2047
2048 //------------------------------------------------------------------------------
2049 /// Set the theshold of H264 frame gap, 0xFFFFFFFF don't care frame gap
2050 /// @param u32FrmGap \b IN : frame gap
2051 /// @return VDEC_Result
2052 //------------------------------------------------------------------------------
_VDEC_SetMinFrameGap(MS_U32 u32FrmGap)2053 static VDEC_Result _VDEC_SetMinFrameGap(MS_U32 u32FrmGap)
2054 {
2055 VDEC_Result ret = E_VDEC_FAIL;
2056
2057 switch (_Attr.eDecoder)
2058 {
2059 case E_VDEC_DECODER_HVD:
2060 _HVD_RET_HANDLE(MDrv_HVD_SetSettings_Pro(E_HVD_SSET_MIN_FRAME_GAP, u32FrmGap));
2061 ret = E_VDEC_OK;
2062 break;
2063 case E_VDEC_DECODER_MVD:
2064 case E_VDEC_DECODER_MJPEG:
2065 ret = E_VDEC_RET_UNSUPPORTED;
2066 break;
2067 default:
2068 break;
2069 }
2070
2071 return ret;
2072 }
2073
2074 //------------------------------------------------------------------------------
2075 /// Set disable Anti-Video Deadlock function
2076 /// @param u32FrmGap \b IN : none
2077 /// @return VDEC_Result
2078 //------------------------------------------------------------------------------
_VDEC_SetDisableAntiVdead(MS_U32 u32Arg)2079 static VDEC_Result _VDEC_SetDisableAntiVdead(MS_U32 u32Arg)
2080 {
2081 VDEC_Result ret = E_VDEC_FAIL;
2082
2083 switch (_Attr.eDecoder)
2084 {
2085 case E_VDEC_DECODER_HVD:
2086 _HVD_RET_HANDLE(MDrv_HVD_SetSettings_Pro(E_HVD_SSET_DISABLE_ANTI_VDEAD, u32Arg));
2087 ret = E_VDEC_OK;
2088 break;
2089 case E_VDEC_DECODER_MVD:
2090 case E_VDEC_DECODER_MJPEG:
2091 ret = E_VDEC_RET_UNSUPPORTED;
2092 break;
2093 default:
2094 break;
2095 }
2096
2097 return ret;
2098 }
2099
2100 //------------------------------------------------------------------------------
2101 /// Reset MVD parser
2102 /// @param bEnable \b IN : turn on / off.
2103 /// @return VDEC_Result
2104 //------------------------------------------------------------------------------
_VDEC_ResetMvdParser(MS_BOOL bEnable)2105 static VDEC_Result _VDEC_ResetMvdParser(MS_BOOL bEnable)
2106 {
2107 VDEC_Result ret = E_VDEC_FAIL;
2108
2109 switch (_Attr.eDecoder)
2110 {
2111 case E_VDEC_DECODER_MVD:
2112 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_ParserRstDone(bEnable));
2113 break;
2114 case E_VDEC_DECODER_HVD:
2115 case E_VDEC_DECODER_MJPEG:
2116 ret = E_VDEC_RET_UNSUPPORTED;
2117 break;
2118 default:
2119 break;
2120 }
2121
2122 return ret;
2123 }
2124
2125 //------------------------------------------------------------------------------
2126 /// Set Flush Frame buffer
2127 /// @param bEnable \b IN : turn on / off.
2128 /// @return VDEC_Result
2129 //------------------------------------------------------------------------------
_VDEC_DoFlushFrmBuffer(MS_BOOL bEnable)2130 static VDEC_Result _VDEC_DoFlushFrmBuffer(MS_BOOL bEnable)
2131 {
2132 VDEC_Result ret = E_VDEC_FAIL;
2133
2134 switch (_Attr.eDecoder)
2135 {
2136 case E_VDEC_DECODER_MVD:
2137 _MVD_RET_HANDLE(MDrv_MVD_PVRFlushDispQueue(bEnable));
2138 ret = E_VDEC_OK;
2139 break;
2140 case E_VDEC_DECODER_HVD:
2141 _HVD_RET_HANDLE(MDrv_HVD_SetSettings_Pro(E_HVD_SSET_FLUSH_FRM_BUF,!bEnable));
2142 ret = E_VDEC_OK;
2143 break;
2144 case E_VDEC_DECODER_MJPEG:
2145 ret = E_VDEC_RET_UNSUPPORTED;
2146 break;
2147 case E_VDEC_DECODER_RVD:
2148 ret = E_VDEC_RET_UNSUPPORTED;
2149 break;
2150 default:
2151 break;
2152 }
2153
2154 return ret;
2155 }
2156
2157 //------------------------------------------------------------------------------
2158 /// Set DTV User Data packet mode
2159 /// @param u32Mode \b IN : User Data Packet Mode, 0: DVB normal, 1: ATSC DirectTV. default:0.
2160 /// @return VDEC_Result
2161 //------------------------------------------------------------------------------
_VDEC_SetDTVUserDataMode(MS_U32 u32Mode)2162 static VDEC_Result _VDEC_SetDTVUserDataMode(MS_U32 u32Mode)
2163 {
2164 VDEC_Result ret = E_VDEC_FAIL;
2165
2166 switch (_Attr.eDecoder)
2167 {
2168 case E_VDEC_DECODER_MVD:
2169 ret = E_VDEC_RET_UNSUPPORTED;
2170 break;
2171
2172 case E_VDEC_DECODER_HVD:
2173 _HVD_RET_HANDLE(MDrv_HVD_SetDTVUserDataMode((MS_U8)u32Mode));
2174 ret = E_VDEC_OK;
2175 break;
2176
2177 case E_VDEC_DECODER_MJPEG:
2178 ret = E_VDEC_RET_UNSUPPORTED;
2179 break;
2180
2181 case E_VDEC_DECODER_RVD:
2182 ret = E_VDEC_RET_UNSUPPORTED;
2183 break;
2184
2185 default:
2186 break;
2187 }
2188
2189 return ret;
2190 }
2191
2192 //------------------------------------------------------------------------------
2193 /// Force into interlace mode
2194 /// @param u32Mode \b IN : 0: Disable, 1: Enable
2195 /// @return VDEC_Result
2196 //------------------------------------------------------------------------------
_VDEC_ForceInterlaceMode(MS_U32 u32Mode)2197 static VDEC_Result _VDEC_ForceInterlaceMode(MS_U32 u32Mode)
2198 {
2199 VDEC_Result ret = E_VDEC_FAIL;
2200
2201 switch (_Attr.eDecoder)
2202 {
2203 case E_VDEC_DECODER_MVD:
2204 ret = E_VDEC_RET_UNSUPPORTED;
2205 break;
2206
2207 case E_VDEC_DECODER_HVD:
2208 _HVD_RET_HANDLE(MDrv_HVD_ForceInterlaceMode((MS_U8)u32Mode));
2209 ret = E_VDEC_RET_UNSUPPORTED;
2210 break;
2211
2212 case E_VDEC_DECODER_MJPEG:
2213 ret = E_VDEC_RET_UNSUPPORTED;
2214 break;
2215
2216 case E_VDEC_DECODER_RVD:
2217 ret = E_VDEC_RET_UNSUPPORTED;
2218 break;
2219
2220 default:
2221 break;
2222 }
2223
2224 return ret;
2225 }
2226
2227 //------------------------------------------------------------------------------
2228 /// Show Decode Order
2229 /// @param u32Mode \b IN : 0: Disable, 1: Enable
2230 /// @return VDEC_Result
2231 //------------------------------------------------------------------------------
_VDEC_ShowDecodeOrder(MS_U32 u32Mode)2232 static VDEC_Result _VDEC_ShowDecodeOrder(MS_U32 u32Mode)
2233 {
2234 VDEC_Result ret = E_VDEC_FAIL;
2235
2236 switch (_Attr.eDecoder)
2237 {
2238 case E_VDEC_DECODER_MVD:
2239 ret = E_VDEC_RET_UNSUPPORTED;
2240 break;
2241
2242 case E_VDEC_DECODER_HVD:
2243 _HVD_RET_HANDLE(MDrv_HVD_ShowDecodeOrder((MS_U8)u32Mode));
2244 ret = E_VDEC_RET_UNSUPPORTED;
2245 break;
2246
2247 case E_VDEC_DECODER_MJPEG:
2248 ret = E_VDEC_RET_UNSUPPORTED;
2249 break;
2250
2251 case E_VDEC_DECODER_RVD:
2252 ret = E_VDEC_RET_UNSUPPORTED;
2253 break;
2254
2255 default:
2256 break;
2257 }
2258
2259 return ret;
2260 }
2261
2262 //------------------------------------------------------------------------------
2263 /// Force set FW to mute if resolution change
2264 /// @param u32Mode \b IN : 0: Disable(default), 1: Enable
2265 /// @return VDEC_Result
2266 //------------------------------------------------------------------------------
_VDEC_ForceAutoMute(MS_BOOL u32Mode)2267 static VDEC_Result _VDEC_ForceAutoMute(MS_BOOL u32Mode)
2268 {
2269 VDEC_Result ret = E_VDEC_FAIL;
2270
2271 switch (_Attr.eDecoder)
2272 {
2273 case E_VDEC_DECODER_MVD:
2274 _MVD_RET_HANDLE(MDrv_MVD_SetAutoMute(u32Mode));
2275 ret = E_VDEC_OK;
2276 break;
2277
2278 case E_VDEC_DECODER_HVD:
2279 ret = E_VDEC_RET_UNSUPPORTED;
2280 break;
2281
2282 case E_VDEC_DECODER_MJPEG:
2283 ret = E_VDEC_RET_UNSUPPORTED;
2284 break;
2285
2286 case E_VDEC_DECODER_RVD:
2287 ret = E_VDEC_RET_UNSUPPORTED;
2288 break;
2289
2290 default:
2291 break;
2292 }
2293
2294 return ret;
2295 }
2296
_VDEC_SetVSizeAlign(MS_BOOL bEnable)2297 static VDEC_Result _VDEC_SetVSizeAlign(MS_BOOL bEnable)
2298 {
2299 VDEC_Result ret = E_VDEC_FAIL;
2300
2301 switch (_Attr.eDecoder)
2302 {
2303 case E_VDEC_DECODER_MVD:
2304 _MVD_RET_HANDLE(MDrv_MVD_SetVSizeAlign(bEnable));
2305 ret = E_VDEC_OK;
2306 break;
2307
2308 case E_VDEC_DECODER_HVD:
2309 _HVD_RET_HANDLE(MDrv_HVD_EnableVSizeAlign(bEnable));
2310 ret = E_VDEC_OK;
2311 break;
2312
2313 case E_VDEC_DECODER_MJPEG:
2314 ret = E_VDEC_RET_UNSUPPORTED;
2315 break;
2316
2317 case E_VDEC_DECODER_RVD:
2318 ret = E_VDEC_RET_UNSUPPORTED;
2319 break;
2320
2321 default:
2322 break;
2323 }
2324
2325 return ret;
2326 }
2327
_VDEC_Disp_Ignore_Crop(MS_BOOL bEnable)2328 static VDEC_Result _VDEC_Disp_Ignore_Crop(MS_BOOL bEnable)
2329 {
2330 VDEC_Result ret = E_VDEC_FAIL;
2331
2332 switch (_Attr.eDecoder)
2333 {
2334 case E_VDEC_DECODER_MVD:
2335 ret = E_VDEC_RET_UNSUPPORTED;
2336 break;
2337
2338 case E_VDEC_DECODER_HVD:
2339 _HVD_RET_HANDLE(MDrv_HVD_Disp_Ignore_Crop(bEnable));
2340 ret = E_VDEC_RET_UNSUPPORTED;
2341 break;
2342
2343 case E_VDEC_DECODER_MJPEG:
2344 ret = E_VDEC_RET_UNSUPPORTED;
2345 break;
2346
2347 case E_VDEC_DECODER_RVD:
2348 ret = E_VDEC_RET_UNSUPPORTED;
2349 break;
2350
2351 default:
2352 break;
2353 }
2354
2355 return ret;
2356 }
2357
_VDEC_SetDispFinishMode(MS_U8 u8Mode)2358 static VDEC_Result _VDEC_SetDispFinishMode(MS_U8 u8Mode)
2359 {
2360 VDEC_Result ret = E_VDEC_FAIL;
2361
2362 switch (_Attr.eDecoder)
2363 {
2364 case E_VDEC_DECODER_MVD:
2365 _MVD_RET_HANDLE(MDrv_MVD_SetDispFinishMode(u8Mode));
2366 ret = E_VDEC_OK;
2367 break;
2368
2369 case E_VDEC_DECODER_HVD:
2370 ret = E_VDEC_RET_UNSUPPORTED;
2371 break;
2372
2373 case E_VDEC_DECODER_MJPEG:
2374 ret = E_VDEC_RET_UNSUPPORTED;
2375 break;
2376
2377 case E_VDEC_DECODER_RVD:
2378 ret = E_VDEC_RET_UNSUPPORTED;
2379 break;
2380
2381 default:
2382 break;
2383 }
2384
2385 return ret;
2386 }
2387
_VDEC_SetAVSyncMode(MS_U8 u8Mode)2388 static VDEC_Result _VDEC_SetAVSyncMode(MS_U8 u8Mode)
2389 {
2390 VDEC_Result ret = E_VDEC_FAIL;
2391
2392 switch (_Attr.eDecoder)
2393 {
2394 case E_VDEC_DECODER_MVD:
2395 _MVD_RET_HANDLE(MDrv_MVD_SetAVSyncMode(u8Mode));
2396 ret = E_VDEC_OK;
2397 break;
2398
2399 case E_VDEC_DECODER_HVD:
2400 ret = E_VDEC_RET_UNSUPPORTED;
2401 break;
2402
2403 case E_VDEC_DECODER_MJPEG:
2404 ret = E_VDEC_RET_UNSUPPORTED;
2405 break;
2406
2407 case E_VDEC_DECODER_RVD:
2408 ret = E_VDEC_RET_UNSUPPORTED;
2409 break;
2410
2411 default:
2412 break;
2413 }
2414
2415 return ret;
2416 }
2417
_VDEC_SetCcInfoEnhanceMode(MS_BOOL bEnable)2418 static VDEC_Result _VDEC_SetCcInfoEnhanceMode(MS_BOOL bEnable)
2419 {
2420 VDEC_Result ret = E_VDEC_FAIL;
2421
2422 switch (_Attr.eDecoder)
2423 {
2424 case E_VDEC_DECODER_MVD:
2425 ret = (MDrv_CC_InfoEnhanceMode(bEnable)) ? E_VDEC_OK : E_VDEC_FAIL ;
2426 break;
2427
2428 case E_VDEC_DECODER_HVD:
2429 ret = (MDrv_HVD_CC_InfoEnhanceMode(bEnable)) ? E_VDEC_OK : E_VDEC_FAIL ;
2430 break;
2431
2432 case E_VDEC_DECODER_MJPEG:
2433 ret = E_VDEC_RET_UNSUPPORTED;
2434 break;
2435
2436 case E_VDEC_DECODER_RVD:
2437 ret = E_VDEC_RET_UNSUPPORTED;
2438 break;
2439
2440 default:
2441 break;
2442 }
2443
2444 return ret;
2445 }
2446
_VDEC_SetIdctMode(MS_U8 u8Mode)2447 static VDEC_Result _VDEC_SetIdctMode(MS_U8 u8Mode)
2448 {
2449 VDEC_Result ret = E_VDEC_FAIL;
2450
2451 switch (_Attr.eDecoder)
2452 {
2453 case E_VDEC_DECODER_MVD:
2454 _MVD_RET_HANDLE(MDrv_MVD_SetIdctMode(u8Mode));
2455 ret = E_VDEC_OK;
2456 break;
2457
2458 case E_VDEC_DECODER_HVD:
2459 ret = E_VDEC_RET_UNSUPPORTED;
2460 break;
2461
2462 case E_VDEC_DECODER_MJPEG:
2463 ret = E_VDEC_RET_UNSUPPORTED;
2464 break;
2465
2466 case E_VDEC_DECODER_RVD:
2467 ret = E_VDEC_RET_UNSUPPORTED;
2468 break;
2469
2470 default:
2471 break;
2472 }
2473
2474 return ret;
2475 }
2476
2477
_VDEC_Map2HVDClockSpeed(VDEC_ClockSpeed ClockSpeed)2478 static HVD_ClockSpeed _VDEC_Map2HVDClockSpeed(VDEC_ClockSpeed ClockSpeed)
2479 {
2480 HVD_ClockSpeed hvdClockSpeed = E_HVD_CLOCK_SPEED_NONE;
2481
2482 switch(ClockSpeed)
2483 {
2484 case E_VDEC_CLOCK_SPEED_HIGHEST:
2485 hvdClockSpeed = E_HVD_CLOCK_SPEED_HIGHEST;
2486 break;
2487 case E_VDEC_CLOCK_SPEED_HIGH:
2488 hvdClockSpeed = E_HVD_CLOCK_SPEED_HIGH;
2489 break;
2490 case E_VDEC_CLOCK_SPEED_MEDIUM:
2491 hvdClockSpeed = E_HVD_CLOCK_SPEED_MEDIUM;
2492 break;
2493 case E_VDEC_CLOCK_SPEED_LOW:
2494 hvdClockSpeed = E_HVD_CLOCK_SPEED_LOW;
2495 break;
2496 case E_VDEC_CLOCK_SPEED_LOWEST:
2497 hvdClockSpeed = E_HVD_CLOCK_SPEED_LOWEST;
2498 break;
2499 case E_VDEC_CLOCK_SPEED_DEFAULT:
2500 hvdClockSpeed = E_HVD_CLOCK_SPEED_DEFAULT;
2501 break;
2502 default:
2503 hvdClockSpeed = E_HVD_CLOCK_SPEED_NONE;
2504 break;
2505 }
2506
2507 return hvdClockSpeed;
2508 }
2509
_VDEC_Map2MVDClockSpeed(VDEC_ClockSpeed ClockSpeed)2510 static MVD_ClockSpeed _VDEC_Map2MVDClockSpeed(VDEC_ClockSpeed ClockSpeed)
2511 {
2512 MVD_ClockSpeed mvdClockSpeed = E_MVD_CLOCK_SPEED_NONE;
2513
2514 switch(ClockSpeed)
2515 {
2516 case E_VDEC_CLOCK_SPEED_HIGHEST:
2517 mvdClockSpeed = E_MVD_CLOCK_SPEED_HIGHEST;
2518 break;
2519 case E_VDEC_CLOCK_SPEED_HIGH:
2520 mvdClockSpeed = E_MVD_CLOCK_SPEED_HIGH;
2521 break;
2522 case E_VDEC_CLOCK_SPEED_MEDIUM:
2523 mvdClockSpeed = E_MVD_CLOCK_SPEED_MEDIUM;
2524 break;
2525 case E_VDEC_CLOCK_SPEED_LOW:
2526 mvdClockSpeed = E_MVD_CLOCK_SPEED_LOW;
2527 break;
2528 case E_VDEC_CLOCK_SPEED_LOWEST:
2529 mvdClockSpeed = E_MVD_CLOCK_SPEED_LOWEST;
2530 break;
2531 case E_VDEC_CLOCK_SPEED_DEFAULT:
2532 mvdClockSpeed = E_MVD_CLOCK_SPEED_DEFAULT;
2533 break;
2534 default:
2535 mvdClockSpeed = E_MVD_CLOCK_SPEED_NONE;
2536 break;
2537 }
2538
2539 return mvdClockSpeed;
2540 }
2541
2542
_VDEC_SetVPUClockSpeed(VDEC_ClockSpeed ClockSpeed)2543 static VDEC_Result _VDEC_SetVPUClockSpeed(VDEC_ClockSpeed ClockSpeed)
2544 {
2545 _HVD_RET_HANDLE(MDrv_HVD_SetVPUClockSpeed(_VDEC_Map2HVDClockSpeed(ClockSpeed)));
2546
2547 return E_VDEC_OK;
2548 }
2549
2550
_VDEC_SetHVDClockSpeed(VDEC_ClockSpeed ClockSpeed)2551 static VDEC_Result _VDEC_SetHVDClockSpeed(VDEC_ClockSpeed ClockSpeed)
2552 {
2553 _HVD_RET_HANDLE(MDrv_HVD_SetHVDClockSpeed(_VDEC_Map2HVDClockSpeed(ClockSpeed)));
2554
2555 return E_VDEC_OK;
2556 }
2557
2558
_VDEC_SetMVDClockSpeed(VDEC_ClockSpeed ClockSpeed)2559 static VDEC_Result _VDEC_SetMVDClockSpeed(VDEC_ClockSpeed ClockSpeed)
2560 {
2561 _MVD_RET_HANDLE(MDrv_MVD_SetMVDClockSpeed(_VDEC_Map2MVDClockSpeed(ClockSpeed)));
2562
2563 return E_VDEC_OK;
2564 }
2565
2566
_VDEC_GetESBuffVacancy(void)2567 static MS_U32 _VDEC_GetESBuffVacancy(void)
2568 {
2569 MS_U32 u32ESWtPtr = MApi_VDEC_GetESWritePtr();
2570 MS_U32 u32ESRdPtr = MApi_VDEC_GetESReadPtr();
2571
2572 if (u32VdecInitParamVersion == 0)
2573 {
2574 if (u32ESWtPtr == u32ESRdPtr)
2575 {
2576 return _vdecInitParam.SysConfig.u32BitstreamBufSize;
2577 }
2578 else if (u32ESWtPtr > u32ESRdPtr)
2579 {
2580 return _vdecInitParam.SysConfig.u32BitstreamBufSize - u32ESWtPtr + u32ESRdPtr;
2581 }
2582 }
2583 else if (u32VdecInitParamVersion == 1)
2584 {
2585 if (u32ESWtPtr == u32ESRdPtr)
2586 {
2587 return _vdecInitParam_ex1.SysConfig.u32BitstreamBufSize;
2588 }
2589 else if (u32ESWtPtr > u32ESRdPtr)
2590 {
2591 return _vdecInitParam_ex1.SysConfig.u32BitstreamBufSize - u32ESWtPtr + u32ESRdPtr;
2592 }
2593 }
2594
2595 return u32ESRdPtr - u32ESWtPtr;
2596 }
2597
_VDEC_DropErrFrame(MS_BOOL bEnable)2598 static VDEC_Result _VDEC_DropErrFrame(MS_BOOL bEnable)
2599 {
2600 VDEC_Result ret = E_VDEC_FAIL;
2601
2602 switch (_Attr.eDecoder)
2603 {
2604 case E_VDEC_DECODER_MVD:
2605 ret = (MDrv_MVD_DropErrorFrame(bEnable)) ? E_VDEC_OK : E_VDEC_FAIL ;
2606 break;
2607
2608 case E_VDEC_DECODER_HVD:
2609 ret = (MDrv_HVD_SetDispErrFrm(!bEnable)) ? E_VDEC_OK : E_VDEC_FAIL ;
2610 break;
2611
2612 case E_VDEC_DECODER_MJPEG:
2613 ret = E_VDEC_RET_UNSUPPORTED;
2614 break;
2615
2616 case E_VDEC_DECODER_RVD:
2617 ret = E_VDEC_RET_UNSUPPORTED;
2618 break;
2619
2620 default:
2621 break;
2622 }
2623
2624 return ret;
2625 }
2626
2627 //------------------------------------------------------------------------------
2628 /// Push Disp Q with Ref Number
2629 /// @param u32Mode \b IN : 0: Disable, 1: Enable
2630 /// @return VDEC_Result
2631 //------------------------------------------------------------------------------
_VDEC_PushDispQWithRefNum(MS_U32 u32Mode)2632 static VDEC_Result _VDEC_PushDispQWithRefNum(MS_U32 u32Mode)
2633 {
2634 VDEC_Result ret = E_VDEC_FAIL;
2635
2636 if ((u32Mode != 0) && (u32Mode != 1))
2637 return ret;
2638
2639 switch (_Attr.eDecoder)
2640 {
2641 case E_VDEC_DECODER_HVD:
2642 _HVD_RET_HANDLE(MDrv_HVD_PushDispQWithRefNum((MS_BOOL)u32Mode));
2643 ret = E_VDEC_OK;
2644 break;
2645
2646 case E_VDEC_DECODER_MVD:
2647 ret = E_VDEC_RET_UNSUPPORTED;
2648 break;
2649
2650 case E_VDEC_DECODER_MJPEG:
2651 ret = E_VDEC_RET_UNSUPPORTED;
2652 break;
2653
2654 case E_VDEC_DECODER_RVD:
2655 ret = E_VDEC_RET_UNSUPPORTED;
2656 break;
2657
2658 default:
2659 break;
2660 }
2661
2662 return ret;
2663 }
2664
2665
2666 //------------------------------------------------------------------------------
2667 /// Push First
2668 /// @param u32Mode \b IN : 0: Disable, 1: Enable
2669 /// @return VDEC_Result
2670 //------------------------------------------------------------------------------
_VDEC_ShowFirstFrameDirect(MS_U32 u32Mode)2671 static VDEC_Result _VDEC_ShowFirstFrameDirect(MS_U32 u32Mode)
2672 {
2673 VDEC_Result ret = E_VDEC_FAIL;
2674
2675 if ((u32Mode != 0) && (u32Mode != 1))
2676 return ret;
2677
2678 switch (_Attr.eDecoder)
2679 {
2680 case E_VDEC_DECODER_HVD:
2681 _HVD_RET_HANDLE(MDrv_HVD_ShowFirstFrameDirect((MS_BOOL)u32Mode));
2682 ret = E_VDEC_OK;
2683 break;
2684
2685 case E_VDEC_DECODER_MVD:
2686 _MVD_RET_HANDLE(MDrv_MVD_ShowFirstFrameDirect((MS_BOOL)u32Mode));
2687 ret = E_VDEC_OK;
2688 break;
2689
2690 case E_VDEC_DECODER_MJPEG:
2691 ret = E_VDEC_RET_UNSUPPORTED;
2692 break;
2693
2694 case E_VDEC_DECODER_RVD:
2695 ret = E_VDEC_RET_UNSUPPORTED;
2696 break;
2697
2698 default:
2699 break;
2700 }
2701
2702 return ret;
2703 }
2704
_VDEC_SetAutoExhaustESMode(MS_U32 u32ESBound)2705 static VDEC_Result _VDEC_SetAutoExhaustESMode(MS_U32 u32ESBound)
2706 {
2707 VDEC_Result ret = E_VDEC_FAIL;
2708
2709
2710 switch (_Attr.eDecoder)
2711 {
2712 case E_VDEC_DECODER_MVD:
2713 ret = E_VDEC_RET_UNSUPPORTED;
2714 break;
2715 case E_VDEC_DECODER_HVD:
2716
2717 if(_Attr.eCodecType != E_VDEC_CODEC_TYPE_H264)
2718 {
2719 return E_VDEC_RET_UNSUPPORTED;
2720 }
2721 _HVD_RET_HANDLE(MDrv_HVD_AutoExhaustESMode(u32ESBound));
2722 ret = E_VDEC_OK;
2723 break;
2724 case E_VDEC_DECODER_MJPEG:
2725 ret = E_VDEC_RET_UNSUPPORTED;
2726 break;
2727 default:
2728 break;
2729 }
2730
2731 return ret;
2732 }
2733
_VDEC_AVCSupportRefNumOverMaxDBPSize(MS_BOOL bEnable)2734 static VDEC_Result _VDEC_AVCSupportRefNumOverMaxDBPSize(MS_BOOL bEnable)
2735 {
2736 VDEC_Result ret = E_VDEC_FAIL;
2737
2738 switch (_Attr.eDecoder)
2739 {
2740 case E_VDEC_DECODER_MVD:
2741 ret = E_VDEC_RET_UNSUPPORTED;
2742 break;
2743
2744 case E_VDEC_DECODER_HVD:
2745 if(_Attr.eCodecType != E_VDEC_CODEC_TYPE_H264)
2746 {
2747 return E_VDEC_RET_UNSUPPORTED;
2748 }
2749 _HVD_RET_HANDLE(MDrv_HVD_AVCSupportRefNumOverMaxDBPSize( bEnable));
2750 ret = E_VDEC_OK;
2751 break;
2752
2753 case E_VDEC_DECODER_MJPEG:
2754 ret = E_VDEC_RET_UNSUPPORTED;
2755 break;
2756
2757 case E_VDEC_DECODER_RVD:
2758 ret = E_VDEC_RET_UNSUPPORTED;
2759 break;
2760
2761 default:
2762 break;
2763 }
2764
2765 return ret;
2766 }
2767
2768
_VDEC_SetMinTspDataSize(MS_U32 u32Size)2769 static VDEC_Result _VDEC_SetMinTspDataSize(MS_U32 u32Size)
2770 {
2771 VDEC_Result ret = E_VDEC_FAIL;
2772
2773
2774 switch (_Attr.eDecoder)
2775 {
2776 case E_VDEC_DECODER_MVD:
2777 ret = E_VDEC_RET_UNSUPPORTED;
2778 break;
2779 case E_VDEC_DECODER_HVD:
2780
2781 if(_Attr.eCodecType != E_VDEC_CODEC_TYPE_H264)
2782 {
2783 return E_VDEC_RET_UNSUPPORTED;
2784 }
2785 _HVD_RET_HANDLE(MDrv_HVD_SetMinTspDataSize(u32Size));
2786 ret = E_VDEC_OK;
2787 break;
2788 case E_VDEC_DECODER_MJPEG:
2789 ret = E_VDEC_RET_UNSUPPORTED;
2790 break;
2791 default:
2792 break;
2793 }
2794
2795 return ret;
2796 }
2797
2798
_MApi_VDEC_GetFlushPatternEntryNum(MS_U32 * param)2799 static VDEC_Result _MApi_VDEC_GetFlushPatternEntryNum(MS_U32* param)
2800 {
2801 VDEC_Result ret = E_VDEC_FAIL;
2802
2803 switch (_Attr.eDecoder)
2804 {
2805 case E_VDEC_DECODER_MVD:
2806 {
2807 *param = (MS_U32)1;
2808 ret = E_VDEC_OK;
2809 break;
2810 }
2811 case E_VDEC_DECODER_HVD:
2812 {
2813 *param = (MS_U32)2;
2814 ret = E_VDEC_OK;
2815 break;
2816 }
2817 case E_VDEC_DECODER_MJPEG:
2818 case E_VDEC_DECODER_RVD:
2819 default:
2820 ret = E_VDEC_RET_UNSUPPORTED;
2821 break;
2822 }
2823 return ret;
2824 }
2825
2826
2827
2828 //-------------------------------------------------------------------------------------------------
2829 // Global Functions
2830 //-------------------------------------------------------------------------------------------------
2831
2832 //------------------------------------------------------------------------------
2833 /// Get VDEC version
2834 /// @return -the pointer to the VDEC version
2835 //------------------------------------------------------------------------------
MApi_VDEC_GetLibVer(const MSIF_Version ** ppVersion)2836 VDEC_Result MApi_VDEC_GetLibVer(const MSIF_Version **ppVersion)
2837 {
2838 if (pu32VDEC_Inst == NULL)
2839 {
2840 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2841 return E_VDEC_FAIL;
2842 }
2843
2844 VDEC_V2_IO_Param IO_arg;
2845 VDEC_Result eRet = E_VDEC_FAIL;
2846
2847
2848 IO_arg.param[0] = (void *)ppVersion;
2849 IO_arg.pRet = (void *)&eRet;
2850
2851 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETLIBVER, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
2852 {
2853 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2854 return E_VDEC_FAIL;
2855 }
2856 else
2857 {
2858 return eRet;
2859 }
2860 }
MApi_VDEC_V2_GetLibVer(const MSIF_Version ** ppVersion)2861 VDEC_Result MApi_VDEC_V2_GetLibVer(const MSIF_Version **ppVersion)
2862 {
2863 if (!ppVersion)
2864 {
2865 return E_VDEC_FAIL;
2866 }
2867
2868 *ppVersion = &_api_vdec_version;
2869
2870 return E_VDEC_OK;
2871 }
2872
2873 //-----------------------------------------------------------------------------
2874 /// Get VDEC info
2875 /// @brief \b Function \b Description: Get information of VDEC API
2876 /// @return - the pointer to the VDEC information
2877 //-----------------------------------------------------------------------------
MApi_VDEC_GetInfo(const VDEC_Info ** ppInfo)2878 VDEC_Result MApi_VDEC_GetInfo(const VDEC_Info **ppInfo)
2879 {
2880 if (pu32VDEC_Inst == NULL)
2881 {
2882 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2883 return E_VDEC_FAIL;
2884 }
2885
2886 VDEC_V2_IO_Param IO_arg;
2887 VDEC_Result eRet = E_VDEC_FAIL;
2888
2889
2890 IO_arg.param[0] = (void *)ppInfo;
2891 IO_arg.pRet = (void *)&eRet;
2892
2893 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETINFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
2894 {
2895 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2896 return E_VDEC_FAIL;
2897 }
2898 else
2899 {
2900 return eRet;
2901 }
2902 }
MApi_VDEC_V2_GetInfo(const VDEC_Info ** ppInfo)2903 VDEC_Result MApi_VDEC_V2_GetInfo(const VDEC_Info **ppInfo)
2904 {
2905 if (!ppInfo)
2906 {
2907 return E_VDEC_FAIL;
2908 }
2909
2910 *ppInfo = &_api_vdec_info;
2911
2912 return E_VDEC_OK;
2913 }
2914
2915 //------------------------------------------------------------------------------
2916 /// Get decoder status
2917 /// @param pStatus \b OUT : VDEC_Status
2918 /// @return TRUE or FALSE
2919 /// - TRUE: Useful status got
2920 /// - FALSE: No status because of not init yet
2921 //------------------------------------------------------------------------------
MApi_VDEC_GetStatus(VDEC_Status * pStatus)2922 MS_BOOL MApi_VDEC_GetStatus(VDEC_Status *pStatus)
2923 {
2924 if (pu32VDEC_Inst == NULL)
2925 {
2926 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2927 return E_VDEC_FAIL;
2928 }
2929
2930 VDEC_V2_IO_Param IO_arg;
2931 VDEC_Result eRet = E_VDEC_FAIL;
2932
2933
2934 IO_arg.param[0] = (void *)pStatus;
2935 IO_arg.pRet = (void *)&eRet;
2936
2937 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETSTATUS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
2938 {
2939 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2940 return E_VDEC_FAIL;
2941 }
2942 else
2943 {
2944 return eRet;
2945 }
2946 }
MApi_VDEC_V2_GetStatus(VDEC_Status * pStatus)2947 MS_BOOL MApi_VDEC_V2_GetStatus(VDEC_Status *pStatus)
2948 {
2949 pStatus->bInit = _Attr.bInit;
2950
2951 if (!_Attr.bInit)
2952 {
2953 pStatus->bIdle = TRUE;
2954 pStatus->eStage = E_VDEC_STAGE_STOP;
2955 return FALSE;
2956 }
2957 else
2958 {
2959 pStatus->bIdle = _VDEC_IsIdle();
2960 // FIXME
2961 //pStatus->eStage =
2962 return TRUE;
2963 }
2964 }
2965
2966 //------------------------------------------------------------------------------
2967 /// Check if codec type is supported or not.
2968 /// @param eCodecType \b IN : codec type
2969 /// @return TRUE or FALSE
2970 /// - TRUE: Success
2971 /// - FALSE: Failed
2972 //------------------------------------------------------------------------------
MApi_VDEC_CheckCaps(VDEC_CodecType eCodecType)2973 MS_BOOL MApi_VDEC_CheckCaps(VDEC_CodecType eCodecType)
2974 {
2975 if (pu32VDEC_Inst == NULL)
2976 {
2977 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2978 return E_VDEC_FAIL;
2979 }
2980
2981 VDEC_V2_IO_Param IO_arg;
2982 VDEC_Result eRet = E_VDEC_FAIL;
2983
2984
2985 IO_arg.param[0] = (void *)&eCodecType;
2986 IO_arg.pRet = (void *)&eRet;
2987
2988 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CHECKCAPS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
2989 {
2990 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
2991 return E_VDEC_FAIL;
2992 }
2993 else
2994 {
2995 return eRet;
2996 }
2997 }
2998
MApi_VDEC_V2_CheckCaps(VDEC_CodecType eCodecType)2999 MS_BOOL MApi_VDEC_V2_CheckCaps(VDEC_CodecType eCodecType)
3000 {
3001 VDEC_Decoder eDecoder;
3002
3003 eDecoder = _VDEC_GetDecoderByCodecType(eCodecType);
3004
3005 switch (eDecoder)
3006 {
3007 case E_VDEC_DECODER_MVD:
3008 _BOOL_VDEC_MVD_LINT_CHECK();
3009 {
3010 MVD_Caps caps;
3011
3012 _VDEC_Memset(&caps, 0, sizeof(MVD_Caps));
3013
3014 if (MDrv_MVD_GetCaps(&caps))
3015 {
3016 if (E_VDEC_CODEC_TYPE_MPEG2 == eCodecType)
3017 {
3018 return caps.bMPEG2;
3019 }
3020 else if (E_VDEC_CODEC_TYPE_MPEG4 == eCodecType)
3021 {
3022 return caps.bMPEG4;
3023 }
3024 else if (E_VDEC_CODEC_TYPE_VC1_ADV == eCodecType || E_VDEC_CODEC_TYPE_VC1_MAIN == eCodecType)
3025 {
3026 return caps.bVC1;
3027 }
3028 }
3029 else
3030 {
3031 return FALSE;
3032 }
3033
3034 break;
3035 }
3036 case E_VDEC_DECODER_HVD:
3037 _BOOL_VDEC_HVD_LINT_CHECK();
3038 {
3039 if (E_VDEC_CODEC_TYPE_H264 == eCodecType)
3040 {
3041 return MDrv_HVD_GetCaps(E_HVD_AVC);
3042 }
3043 else if (E_VDEC_CODEC_TYPE_AVS == eCodecType)
3044 {
3045 return MDrv_HVD_GetCaps(E_HVD_AVS);
3046 }
3047 else if (E_VDEC_CODEC_TYPE_RV8 == eCodecType || E_VDEC_CODEC_TYPE_RV9 == eCodecType)
3048 {
3049 return MDrv_HVD_GetCaps(E_HVD_RM);
3050 }
3051 else
3052 {
3053 return FALSE;
3054 }
3055
3056 break;
3057 }
3058 case E_VDEC_DECODER_MJPEG:
3059 // unnecessary
3060 break;
3061
3062 case E_VDEC_DECODER_RVD:
3063 _BOOL_VDEC_RVD_LINT_CHECK();
3064 return MDrv_RVD_CheckCaps();
3065
3066 default:
3067 break;
3068 }
3069
3070 return TRUE;
3071 }
3072
3073 //------------------------------------------------------------------------------
3074 /// Enable turbo mode for VDEC.
3075 /// @param bTurbo \b IN : TRUE for enable or FALSE for disable
3076 /// @return VDEC_Result
3077 /// - E_VDEC_OK: success
3078 /// - E_VDEC_FAIL: failed
3079 //------------------------------------------------------------------------------
MApi_VDEC_EnableTurboMode(MS_BOOL bEnable)3080 VDEC_Result MApi_VDEC_EnableTurboMode(MS_BOOL bEnable)
3081 {
3082 if (pu32VDEC_Inst == NULL)
3083 {
3084 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
3085 return E_VDEC_FAIL;
3086 }
3087
3088 VDEC_V2_IO_Param IO_arg;
3089 VDEC_Result eRet = E_VDEC_FAIL;
3090
3091
3092 IO_arg.param[0] = (void *)&bEnable;
3093 IO_arg.pRet = (void *)&eRet;
3094
3095 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_ENABLETUEBOMODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
3096 {
3097 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
3098 return E_VDEC_FAIL;
3099 }
3100 else
3101 {
3102 return eRet;
3103 }
3104 }
3105
MApi_VDEC_V2_EnableTurboMode(MS_BOOL bEnable)3106 VDEC_Result MApi_VDEC_V2_EnableTurboMode(MS_BOOL bEnable)
3107 {
3108 bTurboMode = bEnable;
3109 return E_VDEC_OK;
3110 }
3111
3112 #ifdef _MVD_EVENT_DBG
3113 MS_U32 u32Para = 111;
3114 extern MS_U8 HAL_MVD_GetAVSyncStatus(void);
VDEC_TestVSync(MS_U32 eFlag,void * param)3115 void VDEC_TestVSync(MS_U32 eFlag, void *param)
3116 {
3117 if ((E_VDEC_EVENT_DISP_ONE & eFlag) == E_VDEC_EVENT_DISP_ONE)
3118 {
3119 printf("SyncStat=0x%x, diff=%ld\n", HAL_MVD_GetAVSyncStatus(), MDrv_MVD_GetPtsStcDiff());
3120 MDrv_MVD_GetIsFreerun();
3121 }
3122 }
VDEC_TestCC(MS_U32 eFlag,void * param)3123 void VDEC_TestCC(MS_U32 eFlag, void *param)
3124 {
3125 static MS_U16 u16TempRef = 0xffff;
3126 //printf("testCb eFlag=0x%lx, param=%ld\n", eFlag, *(MS_U32*)param);
3127
3128 if ((E_VDEC_EVENT_USER_DATA_FOUND & eFlag) == E_VDEC_EVENT_USER_DATA_FOUND)
3129 {
3130 VDEC_CC_Info ccInfo;
3131 ccInfo.u32Version = 0;
3132 while (MApi_VDEC_IsCCAvailable())
3133 {
3134 if (E_VDEC_OK == MApi_VDEC_GetCCInfo((void*)&ccInfo, sizeof(VDEC_CC_Info)))
3135 {
3136 //if ((u16TempRef+1) != ccInfo.u16TempRef)
3137 {
3138 printf("ccInfo: ");
3139 printf("%d, ", ccInfo.u16TempRef);
3140 printf("%d, ", ccInfo.u8PicStructure);
3141 printf("%d, ", ccInfo.u8TopFieldFirst);
3142 printf("0x%lx, ", ccInfo.u32UserDataBuf);
3143 printf("%ld, ", ccInfo.u32UserDataSize);
3144 printf("%ld\n", ccInfo.u32Pts);
3145 }
3146 u16TempRef = ccInfo.u16TempRef;
3147 }
3148 }
3149 }
3150
3151 return;
3152 }
3153
_VDEC_MVDEventDbg(void)3154 void _VDEC_MVDEventDbg(void)
3155 {
3156 #if 1
3157 //Get info at every VSync:
3158 MApi_VDEC_SetEvent(E_VDEC_EVENT_DISP_ONE, VDEC_TestVSync, (void *)&u32Para);
3159 #else
3160 //Test DisplayOrder user data
3161 MApi_VDEC_SetEvent(E_VDEC_EVENT_USER_DATA_FOUND, VDEC_TestCC, (void *)&u32Para);
3162 #endif
3163 }
3164 #endif
3165
_MApi_VDEC_IsChroma420(MS_U32 * param)3166 VDEC_Result _MApi_VDEC_IsChroma420(MS_U32* param)
3167 {
3168 VDEC_Result ret = E_VDEC_FAIL;
3169
3170 if (!_Attr.bInit)
3171 {
3172 return E_VDEC_RET_NOT_INIT;
3173 }
3174
3175 switch (_Attr.eDecoder)
3176 {
3177 case E_VDEC_DECODER_MVD:
3178 if (MDrv_MVD_GetChromaFormat() <= 1)
3179 {
3180 *param = TRUE;
3181 }
3182 else
3183 {
3184 *param = FALSE;
3185 }
3186 ret = E_VDEC_OK;
3187 break;
3188
3189 case E_VDEC_DECODER_HVD:
3190 case E_VDEC_DECODER_MJPEG:
3191 case E_VDEC_DECODER_RVD:
3192 *param = TRUE;
3193 ret = E_VDEC_OK;
3194 break;
3195
3196 default:
3197 *param = FALSE;
3198 break;
3199 }
3200
3201 return ret;
3202 }
3203
_MApi_VDEC_GetRealFrameRate(MS_U32 * param)3204 VDEC_Result _MApi_VDEC_GetRealFrameRate(MS_U32* param)
3205 {
3206 VDEC_Result ret = E_VDEC_FAIL;
3207 VDEC_DispInfo Dispinfo;
3208
3209 if (!_Attr.bInit)
3210 {
3211 return E_VDEC_RET_NOT_INIT;
3212 }
3213
3214 if ( MApi_VDEC_CheckDispInfoRdy() != E_VDEC_OK )
3215 { // DispInfo isn't ready
3216 return E_VDEC_RET_NOT_READY;
3217 }
3218
3219 switch (_Attr.eDecoder)
3220 {
3221 case E_VDEC_DECODER_HVD:
3222 *param = MDrv_HVD_GetData(E_HVD_GDATA_TYPE_REAL_FRAMERATE);
3223 ret = E_VDEC_OK;
3224 break;
3225 case E_VDEC_DECODER_MVD:
3226 case E_VDEC_DECODER_MJPEG:
3227 case E_VDEC_DECODER_RVD:
3228 default:
3229 if ( MApi_VDEC_GetDispInfo(&Dispinfo) == E_VDEC_OK )
3230 {
3231 *param = Dispinfo.u32FrameRate;
3232 ret = E_VDEC_OK;
3233 }
3234 break;
3235 }
3236
3237 return ret;
3238 }
3239
_MApi_VDEC_GetColorMatrixCoef(MS_U32 * param)3240 VDEC_Result _MApi_VDEC_GetColorMatrixCoef(MS_U32* param)
3241 {
3242 VDEC_Result ret = E_VDEC_FAIL;
3243
3244 if (!_Attr.bInit)
3245 {
3246 return E_VDEC_RET_NOT_INIT;
3247 }
3248
3249 switch (_Attr.eDecoder)
3250 {
3251 case E_VDEC_DECODER_MVD:
3252 *param = MDrv_MVD_GetMatrixCoef();
3253 ret = E_VDEC_OK;
3254 break;
3255 case E_VDEC_DECODER_HVD:
3256 case E_VDEC_DECODER_MJPEG:
3257 case E_VDEC_DECODER_RVD:
3258 default:
3259 *param = 0xff;
3260 ret = E_VDEC_RET_UNSUPPORTED;
3261 break;
3262 }
3263
3264 return ret;
3265 }
3266
_MApi_VDEC_GetIsDynScalingEnabled(MS_U32 * param)3267 VDEC_Result _MApi_VDEC_GetIsDynScalingEnabled(MS_U32* param)
3268 {
3269 VDEC_Result ret = E_VDEC_FAIL;
3270
3271 if (!param)
3272 {
3273 return E_VDEC_RET_INVALID_PARAM;
3274 }
3275 else
3276 {
3277 *param = FALSE;
3278 }
3279
3280 if (!_Attr.bInit)
3281 {
3282 VDEC_INFO(printf("%s NOT_INIT\n", __FUNCTION__));
3283 return E_VDEC_RET_NOT_INIT;
3284 }
3285
3286 if ( MApi_VDEC_CheckDispInfoRdy() != E_VDEC_OK )
3287 { // DispInfo isn't ready
3288 VDEC_INFO(printf("%s NOT_RDY\n", __FUNCTION__));
3289 return E_VDEC_RET_NOT_READY;
3290 }
3291
3292 switch (_Attr.eDecoder)
3293 {
3294 case E_VDEC_DECODER_HVD:
3295 *param = (MS_BOOL) MDrv_HVD_GetDynamicScalingInfo(E_HVD_DS_IS_ENABLED);
3296 ret = E_VDEC_OK;
3297 break;
3298 case E_VDEC_DECODER_MVD:
3299 *param = MDrv_MVD_GetIsDynScalingEnabled();
3300 ret = E_VDEC_OK;
3301 break;
3302 case E_VDEC_DECODER_MJPEG:
3303 case E_VDEC_DECODER_RVD:
3304 default:
3305 ret = E_VDEC_RET_UNSUPPORTED;
3306 break;
3307 }
3308
3309 VDEC_INFO(printf("%s = %x\n", __FUNCTION__, (MS_BOOL)*param));
3310 return ret;
3311 }
3312
_MApi_VDEC_GetIsOriInterlaceMode(MS_U32 * param)3313 VDEC_Result _MApi_VDEC_GetIsOriInterlaceMode(MS_U32* param)
3314 {
3315 VDEC_Result ret = E_VDEC_FAIL;
3316
3317 if (!_Attr.bInit)
3318 {
3319 return E_VDEC_RET_NOT_INIT;
3320 }
3321
3322 switch (_Attr.eDecoder)
3323 {
3324 case E_VDEC_DECODER_MVD:
3325 {
3326 MVD_FrameInfo info;
3327 _VDEC_Memset(&info, 0, sizeof(MVD_FrameInfo));
3328 MDrv_MVD_GetFrameInfo(&info);
3329 *param = (MS_U32)info.u8Interlace;
3330 ret = E_VDEC_OK;
3331
3332 break;
3333 }
3334 case E_VDEC_DECODER_HVD:
3335 {
3336 if(MDrv_HVD_CheckDispInfoRdy() == E_HVD_OK)
3337 {
3338 *param = MDrv_HVD_GetData(E_HVD_GDATA_TYPE_IS_ORI_INTERLACE_MODE);
3339 ret = E_VDEC_OK;
3340 }
3341 break;
3342 }
3343 case E_VDEC_DECODER_MJPEG:
3344 case E_VDEC_DECODER_RVD:
3345 {
3346 *param = 0;
3347 ret = E_VDEC_OK;
3348 break;
3349 }
3350 default:
3351 *param = 0;
3352 break;
3353 }
3354
3355 return ret;
3356 }
3357
_VDEC_Map2MVDCCFmt(VDEC_CCFormat eFmt)3358 static MS_U8 _VDEC_Map2MVDCCFmt(VDEC_CCFormat eFmt)
3359 {
3360 MS_U8 u8Fmt = 0xff;
3361 u8Fmt = (E_VDEC_CC_608==eFmt)?E_CC_MVD_TYPE_608:E_CC_MVD_TYPE_708;
3362 return u8Fmt;
3363 }
3364
_VDEC_Map2MVDCCOpt(VDEC_CCType eType)3365 static MS_U8 _VDEC_Map2MVDCCOpt(VDEC_CCType eType)
3366 {
3367 MS_U8 u8Operation = 0;
3368 switch (eType)
3369 {
3370 case E_VDEC_CC_TYPE_NTSC_FIELD1:
3371 u8Operation = 0x01;
3372 break;
3373 case E_VDEC_CC_TYPE_NTSC_FIELD2:
3374 u8Operation = 0x02;
3375 break;
3376 case E_VDEC_CC_TYPE_NTSC_TWOFIELD:
3377 u8Operation = 0x03;
3378 break;
3379 case E_VDEC_CC_TYPE_DTVCC:
3380 default:
3381 u8Operation = 0x04;
3382 break;
3383 }
3384 return u8Operation;
3385 }
3386
3387
_VDEC_Map2HVDCCFmt(VDEC_CCFormat eFmt)3388 static MS_U8 _VDEC_Map2HVDCCFmt(VDEC_CCFormat eFmt)
3389 {
3390 MS_U8 u8Fmt = 0xff;
3391 u8Fmt = (E_VDEC_CC_608==eFmt)?1:0;
3392 return u8Fmt;
3393 }
3394
_VDEC_Map2HVDCCOpt(VDEC_CCType eType)3395 static MS_U8 _VDEC_Map2HVDCCOpt(VDEC_CCType eType)
3396 {
3397 MS_U8 u8Operation = 0;
3398 switch (eType)
3399 {
3400 case E_VDEC_CC_TYPE_NTSC_FIELD1:
3401 u8Operation = 0x01;
3402 break;
3403 case E_VDEC_CC_TYPE_NTSC_FIELD2:
3404 u8Operation = 0x02;
3405 break;
3406 case E_VDEC_CC_TYPE_NTSC_TWOFIELD:
3407 u8Operation = 0x03;
3408 break;
3409 case E_VDEC_CC_TYPE_DTVCC:
3410 default:
3411 u8Operation = 0x04;
3412 break;
3413 }
3414 return u8Operation;
3415 }
3416
3417
_MApi_VDEC_GetFrmPackingArrSEI(void * param)3418 static VDEC_Result _MApi_VDEC_GetFrmPackingArrSEI(void *param)
3419 {
3420 VDEC_Result ret = E_VDEC_OK;
3421 VDEC_Frame_packing_SEI *pFPASEIInfo = NULL;
3422
3423 if (!_Attr.bInit)
3424 {
3425 return E_VDEC_RET_NOT_INIT;
3426 }
3427
3428 if( param == NULL)
3429 {
3430 return E_VDEC_RET_INVALID_PARAM;
3431 }
3432 else
3433 {
3434 pFPASEIInfo = (VDEC_Frame_packing_SEI *)param;
3435 }
3436
3437 switch (_Attr.eDecoder)
3438 {
3439 case E_VDEC_DECODER_MVD:
3440 ret = E_VDEC_RET_UNSUPPORTED;
3441 break;
3442 case E_VDEC_DECODER_HVD:
3443 _HVD_RET_HANDLE(MDrv_HVD_GetFrmPackingArrSEI(&_stFrmPacking));
3444
3445 pFPASEIInfo->u8Frm_packing_arr_cnl_flag = _stFrmPacking.u8Frm_packing_arr_cnl_flag;
3446 pFPASEIInfo->u8Frm_packing_arr_type = _stFrmPacking.u8Frm_packing_arr_type;
3447 pFPASEIInfo->u8content_interpretation_type = _stFrmPacking.u8content_interpretation_type;
3448 pFPASEIInfo->u1Quincunx_sampling_flag = _stFrmPacking.u1Quincunx_sampling_flag;
3449
3450 pFPASEIInfo->u1Spatial_flipping_flag = _stFrmPacking.u1Spatial_flipping_flag;
3451 pFPASEIInfo->u1Frame0_flipping_flag = _stFrmPacking.u1Frame0_flipping_flag;
3452 pFPASEIInfo->u1Field_views_flag = _stFrmPacking.u1Field_views_flag;
3453 pFPASEIInfo->u1Current_frame_is_frame0_flag = _stFrmPacking.u1Current_frame_is_frame0_flag;
3454
3455 pFPASEIInfo->u1Frame0_self_contained_flag = _stFrmPacking.u1Frame0_self_contained_flag;
3456 pFPASEIInfo->u1Frame1_self_contained_flag = _stFrmPacking.u1Frame1_self_contained_flag;
3457 pFPASEIInfo->u4Frame0_grid_position_x = _stFrmPacking.u4Frame0_grid_position_x;
3458 pFPASEIInfo->u4Frame0_grid_position_y = _stFrmPacking.u4Frame0_grid_position_y;
3459
3460 pFPASEIInfo->u4Frame1_grid_position_x = _stFrmPacking.u4Frame1_grid_position_x;
3461 pFPASEIInfo->u4Frame1_grid_position_y = _stFrmPacking.u4Frame1_grid_position_y;
3462
3463 break;
3464 case E_VDEC_DECODER_MJPEG:
3465 default:
3466 ret = E_VDEC_RET_UNSUPPORTED;
3467 break;
3468 }
3469 return ret;
3470 }
3471
_MApi_VDEC_GetFBUsageMem(MS_U32 * param)3472 VDEC_Result _MApi_VDEC_GetFBUsageMem(MS_U32* param)
3473 {
3474 VDEC_Result ret = E_VDEC_FAIL;
3475
3476 if (!_Attr.bInit)
3477 {
3478 return E_VDEC_RET_NOT_INIT;
3479 }
3480
3481 if ( MApi_VDEC_CheckDispInfoRdy() != E_VDEC_OK )
3482 { // DispInfo isn't ready
3483 return E_VDEC_RET_NOT_READY;
3484 }
3485
3486 switch (_Attr.eDecoder)
3487 {
3488 case E_VDEC_DECODER_HVD:
3489 *param = MDrv_HVD_GetData(E_HVD_GDATA_TYPE_FB_USAGE_MEM);
3490 ret = E_VDEC_OK;
3491 break;
3492 case E_VDEC_DECODER_MVD:
3493 case E_VDEC_DECODER_MJPEG:
3494 case E_VDEC_DECODER_RVD:
3495 default:
3496 *param = 0xffff;
3497 ret = E_VDEC_RET_UNSUPPORTED;
3498 break;
3499 }
3500
3501 return ret;
3502 }
3503
3504
3505 //------------------------------------------------------------------------------
3506 /// Initial VDEC.
3507 /// @param pInitParam \b IN : pointer to initial parameter
3508 /// @return VDEC_Result
3509 /// - E_VDEC_OK: success
3510 /// - E_VDEC_FAIL: failed
3511 /// - E_VDEC_RET_NOT_EXIT: not ext after last initialization
3512 /// - E_VDEC_RET_INVALID_PARAM: input parameter is invalid
3513 //------------------------------------------------------------------------------
MApi_VDEC_Init(VDEC_InitParam * pInitParam)3514 VDEC_Result MApi_VDEC_Init(VDEC_InitParam *pInitParam)
3515 {
3516 if (pu32VDEC_Inst == NULL)
3517 {
3518 if(UtopiaOpen(MODULE_VDEC, &pu32VDEC_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
3519 {
3520 printf("Utopia Open VDEC failed\n");
3521 return E_VDEC_FAIL;
3522 }
3523 }
3524
3525 VDEC_V2_IO_Param IO_arg;
3526 VDEC_Result eRet = E_VDEC_FAIL;
3527
3528 IO_arg.param[0] = (void*)pInitParam;
3529 IO_arg.pRet = (void*)&eRet;
3530
3531 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_INIT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
3532 {
3533 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
3534 return E_VDEC_FAIL;
3535 }
3536 else
3537 {
3538 return eRet;
3539 }
3540 }
3541
3542
3543 //------------------------------------------------------------------------------
3544 /// Initial VDEC.
3545 /// @param pInitParam \b IN : pointer to initial parameter
3546 /// @return VDEC_Result
3547 /// - E_VDEC_OK: success
3548 /// - E_VDEC_FAIL: failed
3549 /// - E_VDEC_RET_NOT_EXIT: not ext after last initialization
3550 /// - E_VDEC_RET_INVALID_PARAM: input parameter is invalid
3551 //------------------------------------------------------------------------------
MApi_VDEC_V2_Init(VDEC_InitParam * pInitParam)3552 VDEC_Result MApi_VDEC_V2_Init(VDEC_InitParam *pInitParam)
3553 {
3554 MS_BOOL bNotReloadFW = FALSE;
3555
3556 if (_Attr.bInit== TRUE)
3557 {
3558 printf("VDEC Warn: re-init VDEC Driver\n");
3559 #if defined( MS_DEBUG )
3560 return E_VDEC_RET_NOT_EXIT;
3561 #endif
3562 }
3563
3564 u32VdecInitParamVersion = 0;
3565
3566 _VDEC_InitLocalVar();
3567
3568 _VDEC_Memcpy(&_vdecInitParam, pInitParam, sizeof(VDEC_InitParam));
3569
3570 _Attr.eCodecType = pInitParam->eCodecType;
3571 _Attr.eDecoder = _VDEC_GetDecoderByCodecType(pInitParam->eCodecType);
3572 _Attr.eSrcMode = pInitParam->VideoInfo.eSrcMode;
3573 _Attr.eDbgMsgLevel = pInitParam->SysConfig.eDbgMsgLevel;
3574
3575 #if (defined(CHIP_A5)) || defined(CHIP_A5P)
3576 #define _CHIP_U02 0x01
3577 if (pInitParam->EnableDynaScale)
3578 {
3579 MS_U8 u8ChipRev = MDrv_SYS_GetChipRev();
3580 if (u8ChipRev < _CHIP_U02)
3581 {
3582 printf("VDEC Warn: DS(%x) unsupported! Force EnableDynaScale as FALSE.\n", u8ChipRev);
3583 pInitParam->EnableDynaScale = FALSE;
3584 }
3585 }
3586 #endif
3587
3588 // init debug message
3589 MApi_VDEC_SetDbgLevel(_Attr.eDbgMsgLevel);
3590
3591 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
3592 // it is critical very any nos compile envi
3593 _VDEC_LinkWeakSymbolPatch();
3594 #endif
3595
3596 if (bTurboMode)
3597 {
3598 bNotReloadFW = TRUE;
3599 }
3600 switch (_Attr.eDecoder)
3601 {
3602 case E_VDEC_DECODER_MVD:
3603 _RET_VDEC_MVD_LINT_CHECK();
3604 {
3605 if (_Pre_Ctrl.bHWBufferReMapping)
3606 {
3607 //////MDrv_MVD_HWBuffer_ReMappingMode(_Pre_Ctrl.bHWBufferReMapping);
3608 }
3609
3610 VDEC_SysCfg cfg = pInitParam->SysConfig;
3611 MVD_FWCfg fwCfg;
3612 MVD_MEMCfg memCfg;
3613 MVD_InfoCfg infoCfg;
3614 MVD_CodecType eMvdCodecType = E_MVD_CODEC_UNKNOWN;
3615 MVD_SrcMode eMvdSrcMode;
3616 MVD_TIMESTAMP_TYPE eSyncType = E_MVD_TIMESTAMP_FREERUN;
3617
3618 // check codec type
3619 eMvdCodecType = _VDEC_Map2MVDCodecType(_Attr.eCodecType);
3620 if (eMvdCodecType == E_MVD_CODEC_UNKNOWN)
3621 {
3622 //printf("%s(%d): Unknown eMvdCodecType!\n", __FUNCTION__, __LINE__);
3623 return E_VDEC_FAIL;
3624 }
3625
3626 // check source type
3627 eMvdSrcMode = _VDEC_Map2MVDSrcMode(_Attr.eSrcMode);
3628 if ((eMvdSrcMode == 0xff) || (eMvdSrcMode >= MVD_SRCMODE_MAX))
3629 {
3630 //printf("%s(%d): Invalid eMvdSrcMode!\n", __FUNCTION__, __LINE__);
3631 return E_VDEC_FAIL;
3632 }
3633
3634 _VDEC_Memset(&fwCfg, 0, sizeof(MVD_FWCfg));
3635 _VDEC_Memset(&memCfg, 0, sizeof(MVD_MEMCfg));
3636
3637 fwCfg.eCodecType = eMvdCodecType;
3638 fwCfg.bNotReload = bNotReloadFW; //TRUE for not load fw more than once
3639 memCfg.eFWSrcType = (MVD_FWSrcType)cfg.eFWSourceType;
3640 memCfg.u32FWBinAddr = cfg.u32FWBinaryAddr;
3641 memCfg.u32FWBinSize = cfg.u32FWBinarySize;
3642 memCfg.u32FWCodeAddr = cfg.u32CodeBufAddr;
3643 memCfg.u32FWCodeSize = cfg.u32CodeBufSize;
3644 memCfg.u32FBAddr = cfg.u32FrameBufAddr;
3645 memCfg.u32FBSize = cfg.u32FrameBufSize;
3646 memCfg.u32BSAddr = cfg.u32BitstreamBufAddr;
3647 memCfg.u32BSSize = cfg.u32BitstreamBufSize;
3648 memCfg.u32DrvBufAddr = cfg.u32DrvProcBufAddr;
3649 memCfg.u32DrvBufSize = cfg.u32DrvProcBufSize;
3650 memCfg.bEnableDynScale = pInitParam->EnableDynaScale;
3651 #ifdef _VDEC_AUTH_IPCheck_TEST_CODE_
3652 memCfg.bSupportSDModeOnly = !bModeSelectHD;
3653 #endif
3654
3655 infoCfg.u8CodecType = eMvdCodecType;
3656 infoCfg.u8BSProviderMode = eMvdSrcMode;
3657 infoCfg.bDisablePESParsing = bMvdParserDisable[eMvdSrcMode];
3658
3659 _MVD_RET_HANDLE(MDrv_MVD_SetCfg(&fwCfg, &memCfg, &infoCfg));
3660
3661 //the very first step: Get register base addr
3662 //notice: must do this first before accessing any register.
3663 MS_U32 u32NonPMBankSize;
3664 MS_U32 u32NonPMBankAddr = 0;
3665 if (!MDrv_MMIO_GetBASE(&u32NonPMBankAddr, &u32NonPMBankSize, MS_MODULE_MVD))
3666 {
3667 printf("_MVD_Init: IOMap failure\n");
3668 return E_VDEC_FAIL;
3669 }
3670 else
3671 {
3672 MDrv_MVD_RegSetBase(u32NonPMBankAddr);
3673 //printf("_MVD_Init: u32RiuBaseAdd = %lx\n", u32NonPMBankAddr);
3674 }
3675
3676 if (!MDrv_MVD_Init())
3677 {
3678 return E_VDEC_FAIL;
3679 }
3680
3681 if (eMvdSrcMode == E_MVD_TS_FILE_MODE)
3682 {
3683 MS_U32 u32bsBufUnderflowTH = ((((cfg.u32BitstreamBufSize*15)/16)>>3)<<3);
3684 MS_U32 u32bsBufOverflowTH = (((cfg.u32BitstreamBufSize-0x4000)>>3)<<3); //16K
3685 MDrv_MVD_SetUnderflowTH(u32bsBufUnderflowTH);
3686 MDrv_MVD_SetOverflowTH(u32bsBufOverflowTH);
3687 }
3688
3689 MDrv_MVD_SetCodecInfo(eMvdCodecType, eMvdSrcMode, bMvdParserDisable[eMvdSrcMode]);
3690
3691 if (FALSE == MDrv_MVD_DropErrorFrame(!pInitParam->bDisableDropErrFrame))
3692 {
3693 return E_VDEC_FAIL;
3694 }
3695 bDropErrFrm = (!pInitParam->bDisableDropErrFrame);
3696
3697 if (FALSE == MDrv_MVD_DispRepeatField(pInitParam->bRepeatLastField))
3698 {
3699 return E_VDEC_FAIL;
3700 }
3701
3702 MDrv_MVD_DisableErrConceal(!pInitParam->bDisableErrConceal);
3703 /*
3704 E_MVD_Result ret = MDrv_MVD_DisableErrConceal(pInitParam->bDisableErrConceal);
3705
3706
3707 if (E_MVD_RET_OK != ret)
3708 {
3709 return E_VDEC_FAIL;
3710 }
3711 */
3712
3713 MDrv_MVD_SetVirtualBox(pInitParam->u32DSVirtualBoxWidth, pInitParam->u32DSVirtualBoxHeight);
3714
3715 if (eMvdSrcMode == E_MVD_SLQ_TBL_MODE)
3716 {
3717 if (E_VDEC_TIME_STAMP_DTS == pInitParam->VideoInfo.eTimeStampType)
3718 {
3719 eSyncType = E_MVD_TIMESTAMP_DTS;
3720 }
3721 else if (E_VDEC_TIME_STAMP_PTS == pInitParam->VideoInfo.eTimeStampType)
3722 {
3723 eSyncType = E_MVD_TIMESTAMP_PTS;
3724 }
3725 else if (E_VDEC_TIME_STAMP_NONE == pInitParam->VideoInfo.eTimeStampType)
3726 {
3727 eSyncType = E_MVD_TIMESTAMP_FREERUN;
3728 }
3729 else if (E_VDEC_TIME_STAMP_STS == pInitParam->VideoInfo.eTimeStampType)
3730 {
3731 eSyncType = E_MVD_TIMESTAMP_STS;
3732 }
3733 else if (E_VDEC_TIME_STAMP_DTS_MPEG_DIRECTV_SD == pInitParam->VideoInfo.eTimeStampType)
3734 {
3735 eSyncType = E_MVD_TIMESTAMP_DTS_RVU;
3736 }
3737 else if (E_VDEC_TIME_STAMP_PTS_MPEG_DIRECTV_SD == pInitParam->VideoInfo.eTimeStampType)
3738 {
3739 eSyncType = E_MVD_TIMESTAMP_PTS_RVU;
3740 }
3741
3742 else
3743 {
3744 printf("Invalid sync type %d for MVD\n", pInitParam->VideoInfo.eTimeStampType);
3745 return E_VDEC_FAIL;
3746 }
3747 if ((eSyncType != E_MVD_TIMESTAMP_STS) && (FALSE == MDrv_MVD_SetFileModeAVSync(eSyncType)))
3748 {
3749 return E_VDEC_FAIL;
3750 }
3751 }
3752
3753 if ((eMvdSrcMode == E_MVD_TS_FILE_MODE)||(eMvdSrcMode == E_MVD_SLQ_TBL_MODE))
3754 { //set up MVD for MediaCodec playback
3755 _VDEC_MVDCfgDivX(_Attr.eCodecType);
3756
3757 if (eMvdCodecType == E_MVD_CODEC_DIVX311)
3758 {
3759 MVD_FrameInfo stFrminfo;
3760 _VDEC_Memset(&stFrminfo, 0, sizeof(MVD_FrameInfo));
3761 stFrminfo.u16HorSize = pInitParam->VideoInfo.u16Width[0];
3762 stFrminfo.u16VerSize = pInitParam->VideoInfo.u16Height[0];
3763 #ifdef MSOS_TYPE_LINUX_KERNEL
3764 MS_U64 u64Tmp = (MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000;
3765 do_div(u64Tmp, pInitParam->VideoInfo.u32FrameRateBase);
3766 stFrminfo.u32FrameRate = (MS_U32)u64Tmp;
3767 #else
3768 stFrminfo.u32FrameRate =
3769 (MS_U32)(((MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000) / pInitParam->VideoInfo.u32FrameRateBase);
3770 #endif
3771 #if 0
3772 printf("==>DivX311 w=0x%x h=0x%x fr=0x%lx,0x%lx\n",
3773 pInitParam->VideoInfo.u16Width[0],pInitParam->VideoInfo.u16Height[0],
3774 pInitParam->VideoInfo.u32FrameRate, pInitParam->VideoInfo.u32FrameRateBase);
3775 printf("==>DivX311 w=0x%x h=0x%x fr=%ld\n",
3776 stFrminfo.u16HorSize, stFrminfo.u16VerSize, stFrminfo.u32FrameRate);
3777 #endif
3778 MDrv_MVD_SetFrameInfo(&stFrminfo);
3779 }
3780 else if (eMvdCodecType != E_MVD_CODEC_MPEG2)
3781 {
3782 MVD_FrameInfo stFrminfo1;
3783 _VDEC_Memset(&stFrminfo1, 0, sizeof(MVD_FrameInfo));
3784 if(pInitParam->VideoInfo.u32FrameRateBase == 0)
3785 {
3786 printf("Invalid FrameRate base\n");
3787 pInitParam->VideoInfo.u32FrameRateBase = 1;
3788 }
3789 #ifdef MSOS_TYPE_LINUX_KERNEL
3790 MS_U64 u64Tmp = (MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000;
3791 do_div(u64Tmp, pInitParam->VideoInfo.u32FrameRateBase);
3792 stFrminfo1.u32FrameRate = (MS_U32)u64Tmp;
3793 #else
3794 stFrminfo1.u32FrameRate =
3795 (MS_U32)(((MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000) / pInitParam->VideoInfo.u32FrameRateBase);
3796 #endif
3797 MDrv_MVD_SetFrameInfo(&stFrminfo1);
3798 }
3799
3800 if (MDrv_MVD_SkipToIFrame() != TRUE)
3801 {
3802 return E_VDEC_FAIL;
3803 }
3804 }
3805 break;
3806 }
3807 case E_VDEC_DECODER_HVD:
3808 _RET_VDEC_HVD_LINT_CHECK();
3809 {
3810 if (_Pre_Ctrl.bOnePendingBuffer)
3811 {
3812 MDrv_HVD_OnePendingBufferMode(_Pre_Ctrl.bOnePendingBuffer);
3813 }
3814
3815 if (_Pre_Ctrl.bFrameRateHandling)
3816 {
3817 MDrv_HVD_FrameRateHandling(_Pre_Ctrl.bFrameRateHandling, _Pre_Ctrl.u32PreSetFrameRate);
3818 }
3819
3820 VDEC_SysCfg cfg = pInitParam->SysConfig;
3821 HVD_MemCfg stMemCfg;
3822 HVD_Init_Settings stInitSettings;
3823 RV_Info stRVInfo;
3824
3825 _VDEC_Memset(&stMemCfg, 0, sizeof(HVD_MemCfg));
3826 _VDEC_Memset(&stInitSettings, 0, sizeof(HVD_Init_Settings));
3827 _VDEC_Memset(&stRVInfo, 0, sizeof(RV_Info));
3828
3829 stInitSettings.pRVFileInfo = &stRVInfo;
3830
3831 stMemCfg.eFWSourceType = (HVD_FWSourceType) cfg.eFWSourceType;
3832 stMemCfg.u32FWBinaryAddr = (MS_PHYADDR) cfg.u32FWBinaryAddr;
3833
3834 if (stMemCfg.eFWSourceType == E_HVD_FW_SOURCE_DRAM)
3835 {
3836 stMemCfg.u32FWBinaryVAddr = MS_PA2KSEG1((MS_U32) cfg.u32FWBinaryAddr);
3837 }
3838
3839 stMemCfg.u32FWBinarySize = cfg.u32FWBinarySize;
3840
3841 stMemCfg.u32VLCBinaryAddr = (MS_PHYADDR) cfg.u32VlcBinarySrcAddr;
3842
3843 if (stMemCfg.eFWSourceType == E_HVD_FW_SOURCE_DRAM)
3844 {
3845 stMemCfg.u32VLCBinaryVAddr = MS_PA2KSEG1((MS_U32) cfg.u32VlcBinarySrcAddr);
3846 }
3847
3848 stMemCfg.u32VLCBinarySize = cfg.u32VlcTabBinarySize;
3849
3850 stMemCfg.u32CodeBufAddr = (MS_PHYADDR) cfg.u32CodeBufAddr;
3851 stMemCfg.u32CodeBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32CodeBufAddr);
3852 stMemCfg.u32CodeBufSize = cfg.u32CodeBufSize;
3853 stMemCfg.u32FrameBufAddr = (MS_PHYADDR) cfg.u32FrameBufAddr;
3854 stMemCfg.u32FrameBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32FrameBufAddr);
3855 stMemCfg.u32FrameBufSize = cfg.u32FrameBufSize;
3856 stMemCfg.u32BitstreamBufAddr = (MS_PHYADDR) cfg.u32BitstreamBufAddr;
3857 stMemCfg.u32BitstreamBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32BitstreamBufAddr);
3858 stMemCfg.u32BitstreamBufSize = cfg.u32BitstreamBufSize;
3859
3860 stMemCfg.u32DrvProcessBufAddr = (MS_PHYADDR) cfg.u32DrvProcBufAddr;
3861 stMemCfg.u32DrvProcessBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32DrvProcBufAddr);
3862 stMemCfg.u32DrvProcessBufSize = cfg.u32DrvProcBufSize;
3863
3864 // set codec flag
3865 if (E_VDEC_CODEC_TYPE_H264 == _Attr.eCodecType)
3866 {
3867 stInitSettings.u32ModeFlag |= HVD_INIT_HW_AVC;
3868 }
3869 else if (E_VDEC_CODEC_TYPE_AVS == _Attr.eCodecType)
3870 {
3871 stInitSettings.u32ModeFlag |= HVD_INIT_HW_AVS;
3872 }
3873 else if ((E_VDEC_CODEC_TYPE_RV8 == _Attr.eCodecType)
3874 || (E_VDEC_CODEC_TYPE_RV9 == _Attr.eCodecType))
3875 {
3876 stInitSettings.u32ModeFlag |= HVD_INIT_HW_RM;
3877 }
3878
3879 // set input source mode
3880 if (E_VDEC_SRC_MODE_DTV == _Attr.eSrcMode)
3881 {
3882 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_LIVE_STREAM;
3883 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_TSP;
3884 stInitSettings.u8SyncType = E_HVD_SYNC_ATS;
3885 }
3886 else if (E_VDEC_SRC_MODE_TS_FILE == _Attr.eSrcMode)
3887 {
3888 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_FILE_TS;
3889 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_TSP;
3890 stInitSettings.u8SyncType = E_HVD_SYNC_ATS;
3891 }
3892 else if (E_VDEC_SRC_MODE_FILE == _Attr.eSrcMode)
3893 {
3894 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_FILE_RAW;
3895 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_DRV;
3896
3897 if (E_VDEC_TIME_STAMP_STS == pInitParam->VideoInfo.eTimeStampType)
3898 {
3899 stInitSettings.u8SyncType = E_HVD_SYNC_STS;
3900 }
3901 else if (E_VDEC_TIME_STAMP_NONE == pInitParam->VideoInfo.eTimeStampType)
3902 {
3903 stInitSettings.u8SyncType = E_HVD_SYNC_ATS;
3904 }
3905 else if (E_VDEC_TIME_STAMP_DTS == pInitParam->VideoInfo.eTimeStampType)
3906 {
3907 stInitSettings.u8SyncType = E_HVD_SYNC_DTS;
3908 }
3909 else if (E_VDEC_TIME_STAMP_PTS == pInitParam->VideoInfo.eTimeStampType)
3910 {
3911 stInitSettings.u8SyncType = E_HVD_SYNC_PTS;
3912 }
3913 else
3914 {
3915 printf("Invalid sync type %d\n", pInitParam->VideoInfo.eTimeStampType);
3916
3917 return E_VDEC_FAIL;
3918 }
3919 }
3920
3921 // set start code exist
3922 if (pInitParam->VideoInfo.bWithoutNalStCode)
3923 {
3924 stInitSettings.u32ModeFlag |= HVD_INIT_START_CODE_REMOVED;
3925 }
3926 else
3927 {
3928 stInitSettings.u32ModeFlag |= HVD_INIT_START_CODE_REMAINED;
3929 }
3930
3931 // pro settings
3932 stInitSettings.u32FrameRate = pInitParam->VideoInfo.u32FrameRate;
3933 stInitSettings.u32FrameRateBase = pInitParam->VideoInfo.u32FrameRateBase;
3934
3935 if (E_VDEC_SRC_MODE_FILE == _Attr.eSrcMode)
3936 {
3937 stInitSettings.u8MinFrmGap = 2; // default set
3938 }
3939 else
3940 {
3941 stInitSettings.u8MinFrmGap = 0; // default set
3942 }
3943
3944 stInitSettings.bAutoPowerSaving = TRUE;
3945 stInitSettings.bFastDisplay = TRUE;
3946
3947 stInitSettings.u8TimeUnit = 1; // ms
3948 stInitSettings.bDynamicScaling = pInitParam->EnableDynaScale;
3949
3950 if (bNotReloadFW)
3951 {
3952 stInitSettings.u8TurboInit |= E_HVD_TURBOINIT_FW_RELOAD; //set for not load fw more than once
3953 }
3954
3955 // for RM
3956 if (E_VDEC_CODEC_TYPE_RV8 == pInitParam->eCodecType)
3957 {
3958 stRVInfo.RV_Version = 0;
3959 }
3960 else if (E_VDEC_CODEC_TYPE_RV9 == pInitParam->eCodecType)
3961 {
3962 stRVInfo.RV_Version = 1;
3963 }
3964
3965 stRVInfo.ulNumSizes = pInitParam->VideoInfo.u16NumSizes;
3966 _VDEC_Memcpy(stRVInfo.ulPicSizes_w, pInitParam->VideoInfo.u16Width, sizeof(pInitParam->VideoInfo.u16Width));
3967 _VDEC_Memcpy(stRVInfo.ulPicSizes_h, pInitParam->VideoInfo.u16Height, sizeof(pInitParam->VideoInfo.u16Height));
3968
3969 {
3970 MS_U32 u32NonPMBankSize=0,u32RiuBaseAdd=0;
3971 if( !MDrv_MMIO_GetBASE( &u32RiuBaseAdd, &u32NonPMBankSize, MS_MODULE_HW))
3972 {
3973 printf("VDEC HVD Init Err: MMIO_GetBASE failure\n");
3974 return E_VDEC_FAIL;
3975 }
3976 else
3977 {
3978 //printf("HVD:1 u32RiuBaseAdd = %lx\n", u32RiuBaseAdd);
3979 MDrv_HVD_SetOSRegBase(u32RiuBaseAdd);
3980 }
3981 }
3982
3983 _HVD_RET_HANDLE(MDrv_HVD_Init(&stMemCfg, &stInitSettings));
3984
3985 // SPS filter
3986 if (E_VDEC_SRC_MODE_DTV == _Attr.eSrcMode)
3987 {
3988 HVD_Disp_Info_Threshold stDispInfoTH;
3989
3990 stDispInfoTH.u32FrmrateLowBound = 0;
3991 stDispInfoTH.u32FrmrateUpBound = 0;
3992 //stDispInfoTH.u32FrmrateLowBound = 10000;
3993 //stDispInfoTH.u32FrmrateUpBound = 170000;
3994 stDispInfoTH.u32MvopLowBound = 16000000;
3995 stDispInfoTH.u32MvopUpBound = 0;
3996
3997 MDrv_HVD_SetDispInfoTH(&stDispInfoTH);
3998 }
3999
4000 if (pInitParam->EnableDynaScale)
4001 {
4002 _HVD_RET_HANDLE(MDrv_HVD_SetVirtualBox(pInitParam->u32DSVirtualBoxWidth,
4003 pInitParam->u32DSVirtualBoxHeight));
4004 }
4005
4006 _HVD_RET_HANDLE(MDrv_HVD_SetDispErrFrm(pInitParam->bDisableDropErrFrame));
4007
4008 _HVD_RET_HANDLE(MDrv_HVD_SetErrConceal(!pInitParam->bDisableErrConceal));
4009
4010 break;
4011 }
4012 case E_VDEC_DECODER_MJPEG:
4013 {
4014 VDEC_SysCfg cfg = pInitParam->SysConfig;
4015 MJPEG_INIT_PARAM initParam;
4016
4017 _VDEC_Memset(&initParam, 0, sizeof(MJPEG_INIT_PARAM));
4018
4019 initParam.u32FwBinAddr = cfg.u32FWBinaryAddr;
4020 initParam.u32FwBinSize = cfg.u32FWBinarySize;
4021 initParam.u32FwAddr = cfg.u32CodeBufAddr;
4022 initParam.u32FwSize = cfg.u32CodeBufSize;
4023 initParam.u32MRCBufAddr = cfg.u32BitstreamBufAddr;
4024 initParam.u32MRCBufSize = cfg.u32BitstreamBufSize;
4025 initParam.u32MWCBufAddr = cfg.u32FrameBufAddr;
4026 initParam.u32MWCBufSize = cfg.u32FrameBufSize;
4027 initParam.u32InternalBufAddr = cfg.u32DrvProcBufAddr;
4028 initParam.u32InternalBufSize = cfg.u32DrvProcBufSize;
4029 initParam.u32FrameRate = pInitParam->VideoInfo.u32FrameRate;
4030 initParam.u32FrameRateBase= pInitParam->VideoInfo.u32FrameRateBase;
4031 initParam.eFwSrcType = (MJPEG_FWSourceType)cfg.eFWSourceType;
4032 //For M10. frame buffer size is controlled by width and height
4033 initParam.u32Width = (MS_U32)pInitParam->VideoInfo.u16Width[0];
4034 initParam.u32Height = (MS_U32)pInitParam->VideoInfo.u16Height[0];
4035
4036 MApi_MJPEG_EnableTurboFWMode(bNotReloadFW);
4037
4038 _MJPEG_RET_HANDLE(MApi_MJPEG_Init(&initParam));
4039
4040 break;
4041 }
4042 case E_VDEC_DECODER_RVD:
4043 _RET_VDEC_RVD_LINT_CHECK();
4044 {
4045 VDEC_SysCfg cfg = pInitParam->SysConfig;
4046 RVD_FileInfo info;
4047 RVD_MEMCfg memCfg;
4048
4049 _VDEC_Memset(&info, 0, sizeof(RVD_FileInfo));
4050 _VDEC_Memset(&memCfg, 0, sizeof(RVD_MEMCfg));
4051
4052
4053 if (E_VDEC_CODEC_TYPE_RV8 == pInitParam->eCodecType)
4054 {
4055 info.RV_Version = 0;
4056 }
4057 else if (E_VDEC_CODEC_TYPE_RV9 == pInitParam->eCodecType)
4058 {
4059 info.RV_Version = 1;
4060 }
4061
4062 info.ulNumSizes = pInitParam->VideoInfo.u16NumSizes;
4063 _VDEC_Memcpy(info.ulPicSizes_w, pInitParam->VideoInfo.u16Width, sizeof(pInitParam->VideoInfo.u16Width));
4064 _VDEC_Memcpy(info.ulPicSizes_h, pInitParam->VideoInfo.u16Height, sizeof(pInitParam->VideoInfo.u16Height));
4065 memCfg.eFWSourceType = (RVD_FWSourceType)cfg.eFWSourceType;
4066 memCfg.u32FWAddr = cfg.u32CodeBufAddr;
4067 memCfg.u32FWSize = cfg.u32CodeBufSize;
4068 memCfg.u32FBAddr = cfg.u32FrameBufAddr;
4069 memCfg.u32FBSize = cfg.u32FrameBufSize;
4070 memCfg.u32BSAddr = cfg.u32BitstreamBufAddr;
4071 memCfg.u32BSSize = cfg.u32BitstreamBufSize;
4072 memCfg.u32PBAddr = cfg.u32DrvProcBufAddr;
4073 memCfg.u32PBSize = cfg.u32DrvProcBufSize;
4074 memCfg.u32VLCBinAddr = cfg.u32VlcBinarySrcAddr;
4075 memCfg.u32VLCBinSize = cfg.u32VlcTabBinarySize;
4076 memCfg.u32FWBinAddr = cfg.u32FWBinaryAddr;
4077 memCfg.u32FWBinSize = cfg.u32FWBinarySize;
4078 {
4079 MS_U32 u32NonPMBankSize=0,u32NonPMBankAddr=0;
4080 if( !MDrv_MMIO_GetBASE( &u32NonPMBankAddr, &u32NonPMBankSize, MS_MODULE_RVD))
4081 {
4082 printf("_MDrv_RVD_Init: IOMap failure\n");
4083 return E_VDEC_FAIL;
4084 }
4085 else
4086 {
4087 MDrv_RVD_SetOSRegBase(u32NonPMBankAddr);
4088 //RVD_MSG_INF("_MDrv_RVD_Init: u32RiuBaseAdd = %lx\n", u32NonPMBankAddr);
4089 }
4090 }
4091 #if 0 //RVD reload fw mechanism need to be check
4092 MDrv_RVD_EnableTurboFWMode(bNotReloadFW);
4093 #endif
4094 _RVD_RET_HANDLE(MDrv_RVD_Init(&info, &memCfg));
4095 if (pInitParam->EnableDynaScale)
4096 {
4097 MDrv_RVD_SetVirtualBox(pInitParam->u32DSVirtualBoxWidth, pInitParam->u32DSVirtualBoxHeight);
4098 MDrv_RVD_EnableDynamicScaling(TRUE);
4099 }
4100 break;
4101 }
4102
4103 default:
4104 {
4105 if(_Attr.eDbgMsgLevel >= E_VDEC_DBG_LEVEL_ERR)
4106 {
4107 printf("VDEC Err: Decoder is not supported!!\n");
4108 }
4109 return E_VDEC_RET_INVALID_PARAM;
4110 }
4111 }
4112
4113 #if defined(VDEC_ISR_MONITOR)
4114 if(FALSE == _IsSysEnable)
4115 {
4116 if(FALSE == _VDEC_SYS_Init())
4117 {
4118 return E_VDEC_FAIL;
4119 }
4120 _IsSysEnable = TRUE;
4121 }
4122 #else
4123 _VDEC_MutexInit();
4124 #endif
4125
4126 _Attr.bInit = TRUE;
4127
4128 #ifdef _MVD_EVENT_DBG
4129 _VDEC_MVDEventDbg();
4130 #endif
4131 return E_VDEC_OK;
4132 }
4133
MApi_VDEC_Init_EX(void * pInfo,MS_U32 u32Size)4134 VDEC_Result MApi_VDEC_Init_EX(void *pInfo, MS_U32 u32Size)
4135 {
4136 if (pu32VDEC_Inst == NULL)
4137 {
4138 if(UtopiaOpen(MODULE_VDEC, &pu32VDEC_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
4139 {
4140 printf("Utopia Open VDEC failed\n");
4141 return E_VDEC_FAIL;
4142 }
4143 }
4144
4145 VDEC_V2_IO_Param IO_arg;
4146 VDEC_Result eRet = E_VDEC_FAIL;
4147
4148 IO_arg.param[0] = (void*)pInfo;
4149 IO_arg.param[1] = (void*)&u32Size;
4150 IO_arg.pRet = (void*)&eRet;
4151
4152 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_INIT_EX, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
4153 {
4154 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
4155 return E_VDEC_FAIL;
4156 }
4157 else
4158 {
4159 return eRet;
4160 }
4161 }
4162
MApi_VDEC_V2_Init_EX(void * pInfo,MS_U32 u32Size)4163 VDEC_Result MApi_VDEC_V2_Init_EX(void *pInfo, MS_U32 u32Size)
4164 {
4165 MS_BOOL bNotReloadFW = FALSE;
4166 MS_U32 u32Version = *((MS_U32 *)pInfo);
4167
4168 if (_Attr.bInit)
4169 {
4170 printf("VDEC Warn: re-init VDEC Driver\n");
4171 #if defined( MS_DEBUG )
4172 return E_VDEC_RET_NOT_EXIT;
4173 #endif
4174 }
4175
4176 if ((u32Version == 1) && (u32Size == sizeof(VDEC_InitParam_EX1)))
4177 {
4178 VDEC_InitParam_EX1 *pInitParam = (VDEC_InitParam_EX1 *)pInfo;
4179
4180 u32VdecInitParamVersion = 1;
4181
4182 _VDEC_InitLocalVar();
4183
4184 _VDEC_Memcpy(&_vdecInitParam_ex1, pInitParam, sizeof(VDEC_InitParam_EX1));
4185
4186 _Attr.eCodecType = pInitParam->eCodecType;
4187 _Attr.eDecoder = _VDEC_GetDecoderByCodecType(pInitParam->eCodecType);
4188 _Attr.eSrcMode = pInitParam->VideoInfo.eSrcMode;
4189 _Attr.eDbgMsgLevel = pInitParam->SysConfig.eDbgMsgLevel;
4190
4191 // init debug message
4192 MApi_VDEC_SetDbgLevel(_Attr.eDbgMsgLevel);
4193
4194 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
4195 // it is critical very any nos compile envi
4196 _VDEC_LinkWeakSymbolPatch();
4197 #endif
4198
4199 if (bTurboMode)
4200 {
4201 bNotReloadFW = TRUE;
4202 }
4203 switch (_Attr.eDecoder)
4204 {
4205 case E_VDEC_DECODER_MVD:
4206 _RET_VDEC_MVD_LINT_CHECK();
4207 {
4208 VDEC_SysCfg cfg = pInitParam->SysConfig;
4209 MVD_FWCfg fwCfg;
4210 MVD_MEMCfg memCfg;
4211 MVD_InfoCfg infoCfg;
4212 MVD_CodecType eMvdCodecType = E_MVD_CODEC_UNKNOWN;
4213 MVD_SrcMode eMvdSrcMode;
4214 MVD_TIMESTAMP_TYPE eSyncType = E_MVD_TIMESTAMP_FREERUN;
4215
4216 // check codec type
4217 eMvdCodecType = _VDEC_Map2MVDCodecType(_Attr.eCodecType);
4218 if (eMvdCodecType == E_MVD_CODEC_UNKNOWN)
4219 {
4220 //printf("%s(%d): Unknown eMvdCodecType!\n", __FUNCTION__, __LINE__);
4221 return E_VDEC_FAIL;
4222 }
4223
4224 // check source type
4225 eMvdSrcMode = _VDEC_Map2MVDSrcMode(_Attr.eSrcMode);
4226 if ((eMvdSrcMode == 0xff) || (eMvdSrcMode >= MVD_SRCMODE_MAX))
4227 {
4228 //printf("%s(%d): Invalid eMvdSrcMode!\n", __FUNCTION__, __LINE__);
4229 return E_VDEC_FAIL;
4230 }
4231
4232 _VDEC_Memset(&fwCfg, 0, sizeof(MVD_FWCfg));
4233 _VDEC_Memset(&memCfg, 0, sizeof(MVD_MEMCfg));
4234
4235 fwCfg.eCodecType = eMvdCodecType;
4236 fwCfg.bNotReload = bNotReloadFW; //TRUE for not load fw more than once
4237 memCfg.eFWSrcType = (MVD_FWSrcType)cfg.eFWSourceType;
4238 memCfg.u32FWBinAddr = cfg.u32FWBinaryAddr;
4239 memCfg.u32FWBinSize = cfg.u32FWBinarySize;
4240 memCfg.u32FWCodeAddr = cfg.u32CodeBufAddr;
4241 memCfg.u32FWCodeSize = cfg.u32CodeBufSize;
4242 memCfg.u32FBAddr = cfg.u32FrameBufAddr;
4243 memCfg.u32FBSize = cfg.u32FrameBufSize;
4244 memCfg.u32BSAddr = cfg.u32BitstreamBufAddr;
4245 memCfg.u32BSSize = cfg.u32BitstreamBufSize;
4246 memCfg.u32DrvBufAddr = cfg.u32DrvProcBufAddr;
4247 memCfg.u32DrvBufSize = cfg.u32DrvProcBufSize;
4248 memCfg.bEnableDynScale = pInitParam->EnableDynaScale;
4249 #ifdef _VDEC_AUTH_IPCheck_TEST_CODE_
4250 memCfg.bSupportSDModeOnly = !bModeSelectHD;
4251 #endif
4252
4253 infoCfg.u8CodecType = eMvdCodecType;
4254 infoCfg.u8BSProviderMode = eMvdSrcMode;
4255 infoCfg.bDisablePESParsing = bMvdParserDisable[eMvdSrcMode];
4256
4257
4258 fwCfg.stFBReduction.LumaFBReductionMode = (MVD_FB_Reduction_Type)pInitParam->stFBReduction.eLumaFBReduction;
4259 fwCfg.stFBReduction.ChromaFBReductionMode = (MVD_FB_Reduction_Type)pInitParam->stFBReduction.eChromaFBReduction;
4260 fwCfg.stFBReduction.u8EnableAutoMode = (MS_U8)pInitParam->stFBReduction.bEnableAutoMode;
4261
4262 _MVD_RET_HANDLE(MDrv_MVD_SetCfg(&fwCfg, &memCfg, &infoCfg));
4263
4264 //the very first step: Get register base addr
4265 //notice: must do this first before accessing any register.
4266 MS_U32 u32NonPMBankSize;
4267 MS_U32 u32NonPMBankAddr = 0;
4268 if (!MDrv_MMIO_GetBASE(&u32NonPMBankAddr, &u32NonPMBankSize, MS_MODULE_MVD))
4269 {
4270 printf("_MVD_Init: IOMap failure\n");
4271 return E_VDEC_FAIL;
4272 }
4273 else
4274 {
4275 MDrv_MVD_RegSetBase(u32NonPMBankAddr);
4276 //printf("_MVD_Init: u32RiuBaseAdd = %lx\n", u32NonPMBankAddr);
4277 }
4278
4279 if (!MDrv_MVD_Init())
4280 {
4281 return E_VDEC_FAIL;
4282 }
4283
4284 if (eMvdSrcMode == E_MVD_TS_FILE_MODE)
4285 {
4286 MS_U32 u32bsBufUnderflowTH = ((((cfg.u32BitstreamBufSize*15)/16)>>3)<<3);
4287 MS_U32 u32bsBufOverflowTH = (((cfg.u32BitstreamBufSize-0x4000)>>3)<<3); //16K
4288 MDrv_MVD_SetUnderflowTH(u32bsBufUnderflowTH);
4289 MDrv_MVD_SetOverflowTH(u32bsBufOverflowTH);
4290 }
4291
4292 MDrv_MVD_SetCodecInfo(eMvdCodecType, eMvdSrcMode, bMvdParserDisable[eMvdSrcMode]);
4293
4294 if (FALSE == MDrv_MVD_DropErrorFrame(!pInitParam->bDisableDropErrFrame))
4295 {
4296 return E_VDEC_FAIL;
4297 }
4298 bDropErrFrm = (!pInitParam->bDisableDropErrFrame);
4299
4300 if (FALSE == MDrv_MVD_DispRepeatField(pInitParam->bRepeatLastField))
4301 {
4302 return E_VDEC_FAIL;
4303 }
4304
4305 MDrv_MVD_DisableErrConceal(!pInitParam->bDisableErrConceal);
4306 /*
4307 E_MVD_Result ret = MDrv_MVD_DisableErrConceal(pInitParam->bDisableErrConceal);
4308
4309
4310 if (E_MVD_RET_OK != ret)
4311 {
4312 return E_VDEC_FAIL;
4313 }
4314 */
4315
4316 MDrv_MVD_SetVirtualBox(pInitParam->u32DSVirtualBoxWidth, pInitParam->u32DSVirtualBoxHeight);
4317
4318 if (eMvdSrcMode == E_MVD_SLQ_TBL_MODE)
4319 {
4320 if (E_VDEC_TIME_STAMP_DTS == pInitParam->VideoInfo.eTimeStampType)
4321 {
4322 eSyncType = E_MVD_TIMESTAMP_DTS;
4323 }
4324 else if (E_VDEC_TIME_STAMP_PTS == pInitParam->VideoInfo.eTimeStampType)
4325 {
4326 eSyncType = E_MVD_TIMESTAMP_PTS;
4327 }
4328 else if (E_VDEC_TIME_STAMP_NONE == pInitParam->VideoInfo.eTimeStampType)
4329 {
4330 eSyncType = E_MVD_TIMESTAMP_FREERUN;
4331 }
4332 else if (E_VDEC_TIME_STAMP_STS == pInitParam->VideoInfo.eTimeStampType)
4333 {
4334 eSyncType = E_MVD_TIMESTAMP_STS;
4335 }
4336 else if (E_VDEC_TIME_STAMP_DTS_MPEG_DIRECTV_SD == pInitParam->VideoInfo.eTimeStampType)
4337 {
4338 eSyncType = E_MVD_TIMESTAMP_DTS_RVU;
4339 }
4340 else if (E_VDEC_TIME_STAMP_PTS_MPEG_DIRECTV_SD == pInitParam->VideoInfo.eTimeStampType)
4341 {
4342 eSyncType = E_MVD_TIMESTAMP_PTS_RVU;
4343 }
4344
4345 else
4346 {
4347 printf("Invalid sync type %d for MVD\n", pInitParam->VideoInfo.eTimeStampType);
4348 return E_VDEC_FAIL;
4349 }
4350 if ((eSyncType != E_MVD_TIMESTAMP_STS) && (FALSE == MDrv_MVD_SetFileModeAVSync(eSyncType)))
4351 {
4352 return E_VDEC_FAIL;
4353 }
4354 }
4355
4356 if ((eMvdSrcMode == E_MVD_TS_FILE_MODE)||(eMvdSrcMode == E_MVD_SLQ_TBL_MODE))
4357 { //set up MVD for MediaCodec playback
4358 _VDEC_MVDCfgDivX(_Attr.eCodecType);
4359
4360 if (eMvdCodecType == E_MVD_CODEC_DIVX311)
4361 {
4362 MVD_FrameInfo stFrminfo;
4363 _VDEC_Memset(&stFrminfo, 0, sizeof(MVD_FrameInfo));
4364 stFrminfo.u16HorSize = pInitParam->VideoInfo.u16Width[0];
4365 stFrminfo.u16VerSize = pInitParam->VideoInfo.u16Height[0];
4366 #ifdef MSOS_TYPE_LINUX_KERNEL
4367 MS_U64 u64Tmp = (MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000;
4368 do_div(u64Tmp, pInitParam->VideoInfo.u32FrameRateBase);
4369 stFrminfo.u32FrameRate = (MS_U32)u64Tmp;
4370 #else
4371 stFrminfo.u32FrameRate =
4372 (MS_U32)(((MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000) / pInitParam->VideoInfo.u32FrameRateBase);
4373 #endif
4374 #if 0
4375 printf("==>DivX311 w=0x%x h=0x%x fr=0x%lx,0x%lx\n",
4376 pInitParam->VideoInfo.u16Width[0],pInitParam->VideoInfo.u16Height[0],
4377 pInitParam->VideoInfo.u32FrameRate, pInitParam->VideoInfo.u32FrameRateBase);
4378 printf("==>DivX311 w=0x%x h=0x%x fr=%ld\n",
4379 stFrminfo.u16HorSize, stFrminfo.u16VerSize, stFrminfo.u32FrameRate);
4380 #endif
4381 MDrv_MVD_SetFrameInfo(&stFrminfo);
4382 }
4383 else if (eMvdCodecType != E_MVD_CODEC_MPEG2)
4384 {
4385 MVD_FrameInfo stFrminfo1;
4386 _VDEC_Memset(&stFrminfo1, 0, sizeof(MVD_FrameInfo));
4387 if(pInitParam->VideoInfo.u32FrameRateBase == 0)
4388 {
4389 printf("Invalid FrameRate base\n");
4390 pInitParam->VideoInfo.u32FrameRateBase = 1;
4391 }
4392 #ifdef MSOS_TYPE_LINUX_KERNEL
4393 MS_U64 u64Tmp = (MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000;
4394 do_div(u64Tmp, pInitParam->VideoInfo.u32FrameRateBase);
4395 stFrminfo1.u32FrameRate = (MS_U32)u64Tmp;
4396 #else
4397 stFrminfo1.u32FrameRate =
4398 (MS_U32)(((MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000) / pInitParam->VideoInfo.u32FrameRateBase);
4399 #endif
4400 MDrv_MVD_SetFrameInfo(&stFrminfo1);
4401 }
4402
4403 if (MDrv_MVD_SkipToIFrame() != TRUE)
4404 {
4405 return E_VDEC_FAIL;
4406 }
4407 }
4408 break;
4409 }
4410 case E_VDEC_DECODER_HVD:
4411 _RET_VDEC_HVD_LINT_CHECK();
4412 {
4413 VDEC_SysCfg cfg = pInitParam->SysConfig;
4414 HVD_MemCfg stMemCfg;
4415 HVD_Init_Settings stInitSettings;
4416 RV_Info stRVInfo;
4417
4418 _VDEC_Memset(&stMemCfg, 0, sizeof(HVD_MemCfg));
4419 _VDEC_Memset(&stInitSettings, 0, sizeof(HVD_Init_Settings));
4420 _VDEC_Memset(&stRVInfo, 0, sizeof(RV_Info));
4421
4422 stInitSettings.pRVFileInfo = &stRVInfo;
4423
4424 stMemCfg.eFWSourceType = (HVD_FWSourceType) cfg.eFWSourceType;
4425 stMemCfg.u32FWBinaryAddr = (MS_PHYADDR) cfg.u32FWBinaryAddr;
4426
4427 if (stMemCfg.eFWSourceType == E_HVD_FW_SOURCE_DRAM)
4428 {
4429 stMemCfg.u32FWBinaryVAddr = MS_PA2KSEG1((MS_U32) cfg.u32FWBinaryAddr);
4430 }
4431
4432 stMemCfg.u32FWBinarySize = cfg.u32FWBinarySize;
4433
4434 stMemCfg.u32VLCBinaryAddr = (MS_PHYADDR) cfg.u32VlcBinarySrcAddr;
4435
4436 if (stMemCfg.eFWSourceType == E_HVD_FW_SOURCE_DRAM)
4437 {
4438 stMemCfg.u32VLCBinaryVAddr = MS_PA2KSEG1((MS_U32) cfg.u32VlcBinarySrcAddr);
4439 }
4440
4441 stMemCfg.u32VLCBinarySize = cfg.u32VlcTabBinarySize;
4442
4443 stMemCfg.u32CodeBufAddr = (MS_PHYADDR) cfg.u32CodeBufAddr;
4444 stMemCfg.u32CodeBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32CodeBufAddr);
4445 stMemCfg.u32CodeBufSize = cfg.u32CodeBufSize;
4446 stMemCfg.u32FrameBufAddr = (MS_PHYADDR) cfg.u32FrameBufAddr;
4447 stMemCfg.u32FrameBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32FrameBufAddr);
4448 stMemCfg.u32FrameBufSize = cfg.u32FrameBufSize;
4449 stMemCfg.u32BitstreamBufAddr = (MS_PHYADDR) cfg.u32BitstreamBufAddr;
4450 stMemCfg.u32BitstreamBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32BitstreamBufAddr);
4451 stMemCfg.u32BitstreamBufSize = cfg.u32BitstreamBufSize;
4452
4453 stMemCfg.u32DrvProcessBufAddr = (MS_PHYADDR) cfg.u32DrvProcBufAddr;
4454 stMemCfg.u32DrvProcessBufVAddr = MS_PA2KSEG1((MS_U32) cfg.u32DrvProcBufAddr);
4455 stMemCfg.u32DrvProcessBufSize = cfg.u32DrvProcBufSize;
4456
4457 // set codec flag
4458 if (E_VDEC_CODEC_TYPE_H264 == _Attr.eCodecType)
4459 {
4460 stInitSettings.u32ModeFlag |= HVD_INIT_HW_AVC;
4461 }
4462 else if (E_VDEC_CODEC_TYPE_AVS == _Attr.eCodecType)
4463 {
4464 stInitSettings.u32ModeFlag |= HVD_INIT_HW_AVS;
4465 }
4466 else if ((E_VDEC_CODEC_TYPE_RV8 == _Attr.eCodecType)
4467 || (E_VDEC_CODEC_TYPE_RV9 == _Attr.eCodecType))
4468 {
4469 stInitSettings.u32ModeFlag |= HVD_INIT_HW_RM;
4470 }
4471
4472 // set input source mode
4473 if (E_VDEC_SRC_MODE_DTV == _Attr.eSrcMode)
4474 {
4475 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_LIVE_STREAM;
4476 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_TSP;
4477 stInitSettings.u8SyncType = E_HVD_SYNC_ATS;
4478 }
4479 else if (E_VDEC_SRC_MODE_TS_FILE == _Attr.eSrcMode)
4480 {
4481 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_FILE_TS;
4482 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_TSP;
4483 stInitSettings.u8SyncType = E_HVD_SYNC_ATS;
4484 }
4485 else if (E_VDEC_SRC_MODE_FILE == _Attr.eSrcMode)
4486 {
4487 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_FILE_RAW;
4488 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_DRV;
4489
4490 if (E_VDEC_TIME_STAMP_STS == pInitParam->VideoInfo.eTimeStampType)
4491 {
4492 stInitSettings.u8SyncType = E_HVD_SYNC_STS;
4493 }
4494 else if (E_VDEC_TIME_STAMP_NONE == pInitParam->VideoInfo.eTimeStampType)
4495 {
4496 stInitSettings.u8SyncType = E_HVD_SYNC_ATS;
4497 }
4498 else if (E_VDEC_TIME_STAMP_DTS == pInitParam->VideoInfo.eTimeStampType)
4499 {
4500 stInitSettings.u8SyncType = E_HVD_SYNC_DTS;
4501 }
4502 else if (E_VDEC_TIME_STAMP_PTS == pInitParam->VideoInfo.eTimeStampType)
4503 {
4504 stInitSettings.u8SyncType = E_HVD_SYNC_PTS;
4505 }
4506 else
4507 {
4508 printf("Invalid sync type %d\n", pInitParam->VideoInfo.eTimeStampType);
4509
4510 return E_VDEC_FAIL;
4511 }
4512 }
4513
4514 // set start code exist
4515 if (pInitParam->VideoInfo.bWithoutNalStCode)
4516 {
4517 stInitSettings.u32ModeFlag |= HVD_INIT_START_CODE_REMOVED;
4518 }
4519 else
4520 {
4521 stInitSettings.u32ModeFlag |= HVD_INIT_START_CODE_REMAINED;
4522 }
4523
4524 // pro settings
4525 stInitSettings.u32FrameRate = pInitParam->VideoInfo.u32FrameRate;
4526 stInitSettings.u32FrameRateBase = pInitParam->VideoInfo.u32FrameRateBase;
4527
4528 if (E_VDEC_SRC_MODE_FILE == _Attr.eSrcMode)
4529 {
4530 stInitSettings.u8MinFrmGap = 2; // default set
4531 }
4532 else
4533 {
4534 stInitSettings.u8MinFrmGap = 0; // default set
4535 }
4536
4537 stInitSettings.bAutoPowerSaving = TRUE;
4538 #if defined(SEC_X4)
4539 stInitSettings.bFastDisplay = FALSE;
4540 #else
4541 stInitSettings.bFastDisplay = TRUE;
4542 #endif
4543 stInitSettings.u8TimeUnit = 1; // ms
4544 stInitSettings.bDynamicScaling = pInitParam->EnableDynaScale;
4545
4546 if (bNotReloadFW)
4547 {
4548 stInitSettings.u8TurboInit |= E_HVD_TURBOINIT_FW_RELOAD; //set for not load fw more than once
4549 }
4550
4551 // for RM
4552 if (E_VDEC_CODEC_TYPE_RV8 == pInitParam->eCodecType)
4553 {
4554 stRVInfo.RV_Version = 0;
4555 }
4556 else if (E_VDEC_CODEC_TYPE_RV9 == pInitParam->eCodecType)
4557 {
4558 stRVInfo.RV_Version = 1;
4559 }
4560
4561 stRVInfo.ulNumSizes = pInitParam->VideoInfo.u16NumSizes;
4562 _VDEC_Memcpy(stRVInfo.ulPicSizes_w, pInitParam->VideoInfo.u16Width, sizeof(pInitParam->VideoInfo.u16Width));
4563 _VDEC_Memcpy(stRVInfo.ulPicSizes_h, pInitParam->VideoInfo.u16Height, sizeof(pInitParam->VideoInfo.u16Height));
4564
4565 {
4566 MS_U32 u32NonPMBankSize=0,u32RiuBaseAdd=0;
4567 if( !MDrv_MMIO_GetBASE( &u32RiuBaseAdd, &u32NonPMBankSize, MS_MODULE_HW))
4568 {
4569 printf("VDEC HVD Init Err: MMIO_GetBASE failure\n");
4570 return E_VDEC_FAIL;
4571 }
4572 else
4573 {
4574 //printf("HVD:1 u32RiuBaseAdd = %lx\n", u32RiuBaseAdd);
4575 MDrv_HVD_SetOSRegBase(u32RiuBaseAdd);
4576 }
4577 }
4578
4579 stInitSettings.stFBReduction.LumaFBReductionMode = (HVD_FB_Reduction_Type)pInitParam->stFBReduction.eLumaFBReduction;
4580 stInitSettings.stFBReduction.ChromaFBReductionMode = (HVD_FB_Reduction_Type)pInitParam->stFBReduction.eChromaFBReduction;
4581 stInitSettings.stFBReduction.u8EnableAutoMode = (MS_U8)pInitParam->stFBReduction.bEnableAutoMode;
4582
4583 _HVD_RET_HANDLE(MDrv_HVD_Init(&stMemCfg, &stInitSettings));
4584
4585 // SPS filter
4586 if (E_VDEC_SRC_MODE_DTV == _Attr.eSrcMode)
4587 {
4588 HVD_Disp_Info_Threshold stDispInfoTH;
4589
4590 stDispInfoTH.u32FrmrateLowBound = 10000;
4591 stDispInfoTH.u32FrmrateUpBound = 0;
4592 //stDispInfoTH.u32FrmrateUpBound = 170000;
4593 stDispInfoTH.u32MvopLowBound = 16000000;
4594 stDispInfoTH.u32MvopUpBound = 0;
4595
4596 MDrv_HVD_SetDispInfoTH(&stDispInfoTH);
4597 }
4598
4599 if (pInitParam->EnableDynaScale)
4600 {
4601 _HVD_RET_HANDLE(MDrv_HVD_SetVirtualBox(pInitParam->u32DSVirtualBoxWidth,
4602 pInitParam->u32DSVirtualBoxHeight));
4603 }
4604
4605 _HVD_RET_HANDLE(MDrv_HVD_SetDispErrFrm(pInitParam->bDisableDropErrFrame));
4606
4607 _HVD_RET_HANDLE(MDrv_HVD_SetErrConceal(!pInitParam->bDisableErrConceal));
4608
4609 break;
4610 }
4611 case E_VDEC_DECODER_MJPEG:
4612 {
4613 VDEC_SysCfg cfg = pInitParam->SysConfig;
4614 MJPEG_INIT_PARAM initParam;
4615
4616 _VDEC_Memset(&initParam, 0, sizeof(MJPEG_INIT_PARAM));
4617
4618 initParam.u32FwBinAddr = cfg.u32FWBinaryAddr;
4619 initParam.u32FwBinSize = cfg.u32FWBinarySize;
4620 initParam.u32FwAddr = cfg.u32CodeBufAddr;
4621 initParam.u32FwSize = cfg.u32CodeBufSize;
4622 initParam.u32MRCBufAddr = cfg.u32BitstreamBufAddr;
4623 initParam.u32MRCBufSize = cfg.u32BitstreamBufSize;
4624 initParam.u32MWCBufAddr = cfg.u32FrameBufAddr;
4625 initParam.u32MWCBufSize = cfg.u32FrameBufSize;
4626 initParam.u32InternalBufAddr = cfg.u32DrvProcBufAddr;
4627 initParam.u32InternalBufSize = cfg.u32DrvProcBufSize;
4628 initParam.u32FrameRate = pInitParam->VideoInfo.u32FrameRate;
4629 initParam.u32FrameRateBase= pInitParam->VideoInfo.u32FrameRateBase;
4630 initParam.eFwSrcType = (MJPEG_FWSourceType)cfg.eFWSourceType;
4631 MApi_MJPEG_EnableTurboFWMode(bNotReloadFW);
4632
4633 _MJPEG_RET_HANDLE(MApi_MJPEG_Init(&initParam));
4634
4635 break;
4636 }
4637 case E_VDEC_DECODER_RVD:
4638 _RET_VDEC_RVD_LINT_CHECK();
4639 {
4640 VDEC_SysCfg cfg = pInitParam->SysConfig;
4641 RVD_FileInfo info;
4642 RVD_MEMCfg memCfg;
4643
4644 _VDEC_Memset(&info, 0, sizeof(RVD_FileInfo));
4645 _VDEC_Memset(&memCfg, 0, sizeof(RVD_MEMCfg));
4646
4647 if (E_VDEC_CODEC_TYPE_RV8 == pInitParam->eCodecType)
4648 {
4649 info.RV_Version = 0;
4650 }
4651 else if (E_VDEC_CODEC_TYPE_RV9 == pInitParam->eCodecType)
4652 {
4653 info.RV_Version = 1;
4654 }
4655
4656 info.ulNumSizes = pInitParam->VideoInfo.u16NumSizes;
4657 _VDEC_Memcpy(info.ulPicSizes_w, pInitParam->VideoInfo.u16Width, sizeof(pInitParam->VideoInfo.u16Width));
4658 _VDEC_Memcpy(info.ulPicSizes_h, pInitParam->VideoInfo.u16Height, sizeof(pInitParam->VideoInfo.u16Height));
4659 memCfg.eFWSourceType = (RVD_FWSourceType)cfg.eFWSourceType;
4660 memCfg.u32FWAddr = cfg.u32CodeBufAddr;
4661 memCfg.u32FWSize = cfg.u32CodeBufSize;
4662 memCfg.u32FBAddr = cfg.u32FrameBufAddr;
4663 memCfg.u32FBSize = cfg.u32FrameBufSize;
4664 memCfg.u32BSAddr = cfg.u32BitstreamBufAddr;
4665 memCfg.u32BSSize = cfg.u32BitstreamBufSize;
4666 memCfg.u32PBAddr = cfg.u32DrvProcBufAddr;
4667 memCfg.u32PBSize = cfg.u32DrvProcBufSize;
4668 memCfg.u32VLCBinAddr = cfg.u32VlcBinarySrcAddr;
4669 memCfg.u32VLCBinSize = cfg.u32VlcTabBinarySize;
4670 memCfg.u32FWBinAddr = cfg.u32FWBinaryAddr;
4671 memCfg.u32FWBinSize = cfg.u32FWBinarySize;
4672 {
4673 MS_U32 u32NonPMBankSize=0,u32NonPMBankAddr=0;
4674 if( !MDrv_MMIO_GetBASE( &u32NonPMBankAddr, &u32NonPMBankSize, MS_MODULE_RVD))
4675 {
4676 printf("_MDrv_RVD_Init: IOMap failure\n");
4677 return E_VDEC_FAIL;
4678 }
4679 else
4680 {
4681 MDrv_RVD_SetOSRegBase(u32NonPMBankAddr);
4682 //RVD_MSG_INF("_MDrv_RVD_Init: u32RiuBaseAdd = %lx\n", u32NonPMBankAddr);
4683 }
4684 }
4685 #if 0 //RVD reload fw mechanism need to be check
4686 MDrv_RVD_EnableTurboFWMode(bNotReloadFW);
4687 #endif
4688 _RVD_RET_HANDLE(MDrv_RVD_Init(&info, &memCfg));
4689 if (pInitParam->EnableDynaScale)
4690 {
4691 MDrv_RVD_SetVirtualBox(pInitParam->u32DSVirtualBoxWidth, pInitParam->u32DSVirtualBoxHeight);
4692 MDrv_RVD_EnableDynamicScaling(TRUE);
4693 }
4694 break;
4695 }
4696
4697 default:
4698 {
4699 if(_Attr.eDbgMsgLevel >= E_VDEC_DBG_LEVEL_ERR)
4700 {
4701 printf("VDEC Err: Decoder is not supported!!\n");
4702 }
4703 return E_VDEC_RET_INVALID_PARAM;
4704 }
4705 }
4706
4707 #if defined(VDEC_ISR_MONITOR)
4708 if(FALSE == _IsSysEnable)
4709 {
4710 if(FALSE == _VDEC_SYS_Init())
4711 {
4712 return E_VDEC_FAIL;
4713 }
4714 _IsSysEnable = TRUE;
4715 }
4716 #else
4717 _VDEC_MutexInit();
4718 #endif
4719
4720 _Attr.bInit = TRUE;
4721
4722 #ifdef _MVD_EVENT_DBG
4723 _VDEC_MVDEventDbg();
4724 #endif
4725 return E_VDEC_OK;
4726 }
4727 else
4728 {
4729 MS_ASSERT(FALSE);
4730 return E_VDEC_FAIL;
4731 }
4732 }
4733
4734
4735 //------------------------------------------------------------------------------
4736 /// Reset decoder.
4737 /// @return VDEC_Result
4738 //------------------------------------------------------------------------------
MApi_VDEC_Rst(void)4739 VDEC_Result MApi_VDEC_Rst(void)
4740 {
4741
4742 if (pu32VDEC_Inst == NULL)
4743 {
4744 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
4745 return E_VDEC_FAIL;
4746 }
4747
4748 VDEC_V2_IO_Param IO_arg;
4749 VDEC_Result eRet = E_VDEC_FAIL;;
4750
4751 IO_arg.pRet = (void*)&eRet;
4752
4753 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_RST, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
4754 {
4755 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
4756 return E_VDEC_FAIL;
4757 }
4758 else
4759 {
4760 return eRet;
4761 }
4762 }
4763
4764
4765 //------------------------------------------------------------------------------
4766 /// Reset decoder.
4767 /// @return VDEC_Result
4768 //------------------------------------------------------------------------------
MApi_VDEC_V2_Rst(void)4769 VDEC_Result MApi_VDEC_V2_Rst(void)
4770 {
4771 if (!_Attr.bInit)
4772 {
4773 return E_VDEC_RET_NOT_INIT;
4774 }
4775
4776 switch (_Attr.eDecoder)
4777 {
4778 case E_VDEC_DECODER_MVD:
4779 {
4780 _MVD_RET_HANDLE(MDrv_MVD_Rst());
4781
4782 break;
4783 }
4784 case E_VDEC_DECODER_HVD:
4785 {
4786 _HVD_RET_HANDLE(MDrv_HVD_Rst(FALSE));
4787
4788 break;
4789 }
4790 case E_VDEC_DECODER_MJPEG:
4791 {
4792 _MJPEG_RET_HANDLE(MApi_MJPEG_Rst());
4793
4794 break;
4795 }
4796 case E_VDEC_DECODER_RVD:
4797 {
4798 _RVD_RET_HANDLE(MDrv_RVD_Rst());
4799
4800 break;
4801 }
4802 default:
4803 break;
4804 }
4805
4806 return E_VDEC_OK;
4807 }
4808
4809
4810 //------------------------------------------------------------------------------
4811 /// Stop playback
4812 /// @return VDEC_Result
4813 //------------------------------------------------------------------------------
MApi_VDEC_Exit(void)4814 VDEC_Result MApi_VDEC_Exit(void)
4815 {
4816
4817 if (pu32VDEC_Inst == NULL)
4818 {
4819 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
4820 return E_VDEC_FAIL;
4821 }
4822 VDEC_V2_IO_Param IO_arg;
4823 VDEC_Result eRet = E_VDEC_FAIL;;
4824
4825 IO_arg.pRet = (void*)&eRet;
4826
4827 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_EXIT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
4828 {
4829 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
4830 return E_VDEC_FAIL;
4831 }
4832 else
4833 {
4834
4835 if(UtopiaClose(pu32VDEC_Inst) != UTOPIA_STATUS_SUCCESS)
4836 {
4837 printf("Utopia Close VDEC failed\n");
4838 pu32VDEC_Inst = NULL;
4839 return E_VDEC_FAIL;
4840 }
4841 pu32VDEC_Inst = NULL;
4842
4843
4844 return eRet;
4845 }
4846 }
4847
4848
4849 //------------------------------------------------------------------------------
4850 /// Stop playback
4851 /// @return VDEC_Result
4852 //------------------------------------------------------------------------------
MApi_VDEC_V2_Exit(MS_BOOL suspend_flag)4853 VDEC_Result MApi_VDEC_V2_Exit(MS_BOOL suspend_flag)
4854 {
4855 if (!_Attr.bInit)
4856 {
4857 return E_VDEC_RET_NOT_INIT;
4858 }
4859
4860 //Disable VDEC ISR when exit.
4861 #if defined(VDEC_ISR_MONITOR)
4862 _u32VdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE;
4863 MsOS_SetEvent(_s32VdecEventId, E_VDEC_EVENT_ISR_EVENT_CHANGE);
4864 #else
4865 _u32VdecIsrEventFlag = 0;
4866 #endif
4867
4868 switch (_Attr.eDecoder)
4869 {
4870 case E_VDEC_DECODER_MVD:
4871 {
4872 if (FALSE == MDrv_MVD_Exit())
4873 {
4874 return E_VDEC_FAIL;
4875 }
4876
4877 break;
4878 }
4879 case E_VDEC_DECODER_HVD:
4880 {
4881 _HVD_RET_HANDLE(MDrv_HVD_Exit());
4882
4883 break;
4884 }
4885 case E_VDEC_DECODER_MJPEG:
4886 {
4887 _MJPEG_RET_HANDLE(MApi_MJPEG_Stop());
4888
4889 break;
4890 }
4891 case E_VDEC_DECODER_RVD:
4892 {
4893 _RVD_RET_HANDLE(MDrv_RVD_Exit());
4894
4895 break;
4896 }
4897 default:
4898 break;
4899 }
4900
4901 if(suspend_flag == FALSE)
4902 {
4903 _VDEC_Memset((void*) &_Pre_Ctrl, 0, sizeof(VDEC_Pre_Ctrl));
4904 _Attr.bInit = FALSE;
4905
4906
4907 #if defined(VDEC_ISR_MONITOR)
4908 #if 0
4909 _VDEC_SYS_Exit();
4910 #endif
4911 #else
4912 _VDEC_MutexExit();
4913 #endif
4914 _VDEC_DqMutexExit();
4915 }
4916 return E_VDEC_OK;
4917 }
4918
MApi_VDEC_V2_SetPowerState(EN_POWER_MODE u16PowerState)4919 VDEC_Result MApi_VDEC_V2_SetPowerState(EN_POWER_MODE u16PowerState)
4920 {
4921 VDEC_Result ret = E_VDEC_FAIL;
4922
4923 if (u16PowerState == E_POWER_SUSPEND)
4924 {
4925 if(_Attr.bInit == TRUE)
4926 {
4927 MApi_VDEC_V2_Exit(TRUE);
4928 }
4929
4930 _prev_u16PowerState = u16PowerState;
4931 ret = E_VDEC_OK;
4932 }
4933 else if (u16PowerState == E_POWER_RESUME)
4934 {
4935 if (_prev_u16PowerState == E_POWER_SUSPEND)
4936 {
4937 if(_Attr.bInit == TRUE)
4938 {
4939 MApi_VDEC_V2_Init(&(_vdecInitParam));
4940 MApi_VDEC_V2_Play();
4941 }
4942 _prev_u16PowerState = u16PowerState;
4943 ret = E_VDEC_OK;
4944 }
4945 else
4946 {
4947 printf("[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
4948 ret = E_VDEC_FAIL;
4949 }
4950 }
4951 else
4952 {
4953 printf("[%s,%5d]Do Nothing: %d\n",__FUNCTION__,__LINE__,u16PowerState);
4954 ret = E_VDEC_FAIL;
4955 }
4956 return ret;
4957 }
4958
4959 //------------------------------------------------------------------------------
4960 /// Check if information for display setting is ready or not
4961 /// @return VDEC_Result
4962 //------------------------------------------------------------------------------
MApi_VDEC_CheckDispInfoRdy(void)4963 VDEC_Result MApi_VDEC_CheckDispInfoRdy(void)
4964 {
4965
4966 if (pu32VDEC_Inst == NULL)
4967 {
4968 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
4969 return E_VDEC_FAIL;
4970 }
4971
4972 VDEC_V2_IO_Param IO_arg;
4973 VDEC_Result eRet = E_VDEC_FAIL;;
4974
4975 IO_arg.pRet = (void*)&eRet;
4976
4977 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CHECK_DISP_INFO_RDY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
4978 {
4979 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
4980 return E_VDEC_FAIL;
4981 }
4982 else
4983 {
4984 return eRet;
4985 }
4986
4987 }
4988
4989 //------------------------------------------------------------------------------
4990 /// Check if information for display setting is ready or not
4991 /// @return VDEC_Result
4992 //------------------------------------------------------------------------------
MApi_VDEC_V2_CheckDispInfoRdy(void)4993 VDEC_Result MApi_VDEC_V2_CheckDispInfoRdy(void)
4994 {
4995 if (!_Attr.bInit)
4996 {
4997 return E_VDEC_RET_NOT_INIT;
4998 }
4999
5000 switch (_Attr.eDecoder)
5001 {
5002 case E_VDEC_DECODER_MVD:
5003 if (0 == MDrv_MVD_GetDispRdy())
5004 {
5005 return E_VDEC_RET_NOT_READY;
5006 }
5007
5008 break;
5009
5010 case E_VDEC_DECODER_HVD:
5011 {
5012 HVD_Result ret = MDrv_HVD_CheckDispInfoRdy();
5013
5014 if (E_HVD_OK != ret)
5015 {
5016 if (E_HVD_RET_NOTREADY == ret)
5017 {
5018 return E_VDEC_RET_NOT_READY;
5019 }
5020 else if( ret == E_HVD_RET_UNSUPPORTED)
5021 {
5022 return E_VDEC_RET_UNSUPPORTED;
5023 }
5024 else
5025 {
5026 return E_VDEC_FAIL;
5027 }
5028 }
5029
5030 break;
5031 }
5032 case E_VDEC_DECODER_MJPEG:
5033 {
5034 _MJPEG_RET_HANDLE(MApi_MJPEG_CheckDispInfoRdy());
5035
5036 break;
5037 }
5038 case E_VDEC_DECODER_RVD:
5039 if (!MDrv_RVD_CheckDispInfoRdy())
5040 {
5041 return E_VDEC_FAIL;
5042 }
5043
5044 break;
5045
5046 default:
5047 break;
5048 }
5049
5050 return E_VDEC_OK;
5051 }
5052
5053 //------------------------------------------------------------------------------
5054 /// Set up frame rate conversion mode
5055 /// @param eFrcMode \b IN : frame rate conversion mode
5056 /// @return VDEC_Result
5057 //------------------------------------------------------------------------------
MApi_VDEC_SetFrcMode(VDEC_FrcMode eFrcMode)5058 VDEC_Result MApi_VDEC_SetFrcMode(VDEC_FrcMode eFrcMode)
5059 {
5060
5061 if (pu32VDEC_Inst == NULL)
5062 {
5063 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5064 return E_VDEC_FAIL;
5065 }
5066
5067 VDEC_V2_IO_Param IO_arg;
5068 VDEC_Result eRet = E_VDEC_FAIL;;
5069
5070 IO_arg.param[0] = (void*)&eFrcMode;
5071 IO_arg.pRet = (void*)&eRet;
5072
5073
5074
5075 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_FRC_MODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5076 {
5077 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5078 return E_VDEC_FAIL;
5079 }
5080 else
5081 {
5082 return eRet;
5083 }
5084
5085 }
5086
5087
5088 //------------------------------------------------------------------------------
5089 /// Set up frame rate conversion mode
5090 /// @param eFrcMode \b IN : frame rate conversion mode
5091 /// @return VDEC_Result
5092 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetFrcMode(VDEC_FrcMode eFrcMode)5093 VDEC_Result MApi_VDEC_V2_SetFrcMode(VDEC_FrcMode eFrcMode)
5094 {
5095 if (!_Attr.bInit)
5096 {
5097 return E_VDEC_RET_NOT_INIT;
5098 }
5099
5100 switch (_Attr.eDecoder)
5101 {
5102 case E_VDEC_DECODER_MVD:
5103 {
5104 if (E_VDEC_FRC_NORMAL == eFrcMode)
5105 {
5106 if (FALSE == MDrv_MVD_DispCtrl(FALSE, bDropErrFrm, FALSE, E_MVD_FRC_NORMAL))
5107 {
5108 return E_VDEC_FAIL;
5109 }
5110 }
5111 else if (E_VDEC_FRC_DISP_TWICE == eFrcMode)
5112 {
5113 if (FALSE == MDrv_MVD_DispCtrl(FALSE, bDropErrFrm, FALSE, E_MVD_FRC_DISP_TWICE))
5114 {
5115 return E_VDEC_FAIL;
5116 }
5117 }
5118 else if (E_VDEC_FRC_3_2_PULLDOWN == eFrcMode)
5119 {
5120 if (FALSE == MDrv_MVD_DispCtrl(FALSE, bDropErrFrm, FALSE, E_MVD_FRC_3_2_PULLDOWN))
5121 {
5122 return E_VDEC_FAIL;
5123 }
5124 }
5125 else if ((E_VDEC_FRC_PAL_TO_NTSC == eFrcMode) || (E_VDEC_FRC_MODE_50P_60P == eFrcMode))
5126 {
5127 if (FALSE == MDrv_MVD_DispCtrl(FALSE, bDropErrFrm, FALSE, E_MVD_FRC_PAL_TO_NTSC))
5128 {
5129 return E_VDEC_FAIL;
5130 }
5131 }
5132 else if ((E_VDEC_FRC_NTSC_TO_PAL == eFrcMode) || (E_VDEC_FRC_MODE_60P_50P == eFrcMode))
5133 {
5134 if (FALSE == MDrv_MVD_DispCtrl(FALSE, bDropErrFrm, FALSE, E_MVD_FRC_NTSC_TO_PAL))
5135 {
5136 return E_VDEC_FAIL;
5137 }
5138 }
5139 else
5140 {
5141 return E_VDEC_RET_INVALID_PARAM;
5142 }
5143 break;
5144 }
5145 case E_VDEC_DECODER_HVD:
5146 {
5147 if (E_VDEC_FRC_NORMAL == eFrcMode)
5148 {
5149 _HVD_RET_HANDLE(MDrv_HVD_SetFrcMode(E_HVD_FRC_MODE_NORMAL));
5150 }
5151 else if (E_VDEC_FRC_DISP_TWICE == eFrcMode)
5152 {
5153 _HVD_RET_HANDLE(MDrv_HVD_SetFrcMode(E_HVD_FRC_MODE_DISP_2X));
5154 }
5155 else if (E_VDEC_FRC_3_2_PULLDOWN == eFrcMode)
5156 {
5157 _HVD_RET_HANDLE(MDrv_HVD_SetFrcMode(E_HVD_FRC_MODE_32PULLDOWN));
5158 }
5159 else if (E_VDEC_FRC_PAL_TO_NTSC == eFrcMode)
5160 {
5161 _HVD_RET_HANDLE(MDrv_HVD_SetFrcMode(E_HVD_FRC_MODE_PAL2NTSC));
5162 }
5163 else if (E_VDEC_FRC_NTSC_TO_PAL == eFrcMode)
5164 {
5165 _HVD_RET_HANDLE(MDrv_HVD_SetFrcMode(E_HVD_FRC_MODE_NTSC2PAL));
5166 }
5167 else if (E_VDEC_FRC_MODE_50P_60P == eFrcMode)
5168 {
5169 _HVD_RET_HANDLE(MDrv_HVD_SetFrcMode(E_HVD_FRC_MODE_50P_60P));
5170 }
5171 else if (E_VDEC_FRC_MODE_60P_50P == eFrcMode)
5172 {
5173 _HVD_RET_HANDLE(MDrv_HVD_SetFrcMode(E_HVD_FRC_MODE_60P_50P));
5174 }
5175 else
5176 {
5177 return E_VDEC_RET_INVALID_PARAM;
5178 }
5179
5180 break;
5181 }
5182 case E_VDEC_DECODER_MJPEG:
5183 case E_VDEC_DECODER_RVD:
5184 return E_VDEC_RET_UNSUPPORTED;
5185
5186 default:
5187 break;
5188 }
5189
5190 return E_VDEC_OK;
5191 }
5192
5193
5194 //------------------------------------------------------------------------------
5195 /// Set up some parameters about dynamic scaling in FW
5196 /// @param u32Addr \b IN : the physical start address of parameter set
5197 /// @param u32Size \b IN : the size of parameter set
5198 /// @return VDEC_Result
5199 //------------------------------------------------------------------------------
MApi_VDEC_SetDynScalingParams(MS_PHYADDR u32Addr,MS_U32 u32Size)5200 VDEC_Result MApi_VDEC_SetDynScalingParams( MS_PHYADDR u32Addr , MS_U32 u32Size)
5201 {
5202
5203 if (pu32VDEC_Inst == NULL)
5204 {
5205 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5206 return E_VDEC_FAIL;
5207 }
5208
5209 VDEC_V2_IO_Param IO_arg;
5210 VDEC_Result eRet = E_VDEC_FAIL;;
5211
5212 IO_arg.param[0] = (void*)&u32Addr;
5213 IO_arg.param[1] = (void*)&u32Size;
5214 IO_arg.pRet = (void*)&eRet;
5215
5216 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_DYNSCALING_PARAMS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5217 {
5218 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5219 return E_VDEC_FAIL;
5220 }
5221 else
5222 {
5223 return eRet;
5224 }
5225
5226
5227 }
5228
5229
5230 //------------------------------------------------------------------------------
5231 /// Set up some parameters about dynamic scaling in FW
5232 /// @param u32Addr \b IN : the physical start address of parameter set
5233 /// @param u32Size \b IN : the size of parameter set
5234 /// @return VDEC_Result
5235 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetDynScalingParams(MS_PHYADDR u32Addr,MS_U32 u32Size)5236 VDEC_Result MApi_VDEC_V2_SetDynScalingParams( MS_PHYADDR u32Addr , MS_U32 u32Size)
5237 {
5238 VDEC_Result ret = E_VDEC_OK;
5239 if (!_Attr.bInit)
5240 {
5241 return E_VDEC_RET_NOT_INIT;
5242 }
5243
5244 switch (_Attr.eDecoder)
5245 {
5246 case E_VDEC_DECODER_MVD:
5247 _MVD_RET_HANDLE(MDrv_MVD_SetDynScalingParam(u32Addr, u32Size));
5248 break;
5249 case E_VDEC_DECODER_HVD:
5250 _HVD_RET_HANDLE(MDrv_HVD_SetDynScalingParam( (void*)MS_PA2KSEG1(u32Addr) , u32Size ) );
5251 break;
5252
5253 case E_VDEC_DECODER_MJPEG:
5254 ret = E_VDEC_OK;
5255 break;
5256
5257 case E_VDEC_DECODER_RVD:
5258 _RVD_RET_HANDLE(MDrv_RVD_SetDynScalingParam(MS_PA2KSEG1(u32Addr), u32Size));
5259 break;
5260
5261 default:
5262 ret = E_VDEC_RET_UNSUPPORTED;
5263 break;
5264 }
5265 return ret;
5266 }
5267
5268
5269 //------------------------------------------------------------------------------
5270 /// Start playback
5271 /// @return return VDEC_Result
5272 //------------------------------------------------------------------------------
MApi_VDEC_Play(void)5273 VDEC_Result MApi_VDEC_Play(void)
5274 {
5275
5276 if (pu32VDEC_Inst == NULL)
5277 {
5278 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5279 return E_VDEC_FAIL;
5280 }
5281
5282
5283 VDEC_V2_IO_Param IO_arg;
5284 VDEC_Result eRet = E_VDEC_FAIL;;
5285 IO_arg.pRet = (void*)&eRet;
5286
5287 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_PLAY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5288 {
5289 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5290 return E_VDEC_FAIL;
5291 }
5292 else
5293 {
5294 return eRet;
5295 }
5296 }
5297
5298 //------------------------------------------------------------------------------
5299 /// Start playback
5300 /// @return return VDEC_Result
5301 //------------------------------------------------------------------------------
MApi_VDEC_V2_Play(void)5302 VDEC_Result MApi_VDEC_V2_Play(void)
5303 {
5304 if (!_Attr.bInit)
5305 {
5306 return E_VDEC_RET_NOT_INIT;
5307 }
5308
5309 switch (_Attr.eDecoder)
5310 {
5311 case E_VDEC_DECODER_MVD:
5312 {
5313 MDrv_MVD_Play();
5314
5315 break;
5316 }
5317 case E_VDEC_DECODER_HVD:
5318 {
5319 _HVD_RET_HANDLE(MDrv_HVD_Play());
5320
5321 break;
5322 }
5323 case E_VDEC_DECODER_MJPEG:
5324 {
5325 _MJPEG_RET_HANDLE(MApi_MJPEG_Play());
5326
5327 break;
5328 }
5329 case E_VDEC_DECODER_RVD:
5330 {
5331 _RVD_RET_HANDLE(MDrv_RVD_Play());
5332
5333 break;
5334 }
5335 default:
5336 break;
5337 }
5338
5339 return E_VDEC_OK;
5340 }
5341
5342 //------------------------------------------------------------------------------
5343 /// Pause decode and display
5344 /// @return return VDEC_Result
5345 //-----------------------------------------------------------------------------
MApi_VDEC_Pause(void)5346 VDEC_Result MApi_VDEC_Pause(void)
5347 {
5348 if (pu32VDEC_Inst == NULL)
5349 {
5350 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5351 return E_VDEC_FAIL;
5352 }
5353
5354 VDEC_V2_IO_Param IO_arg;
5355 VDEC_Result eRet = E_VDEC_FAIL;;
5356 IO_arg.pRet = (void*)&eRet;
5357
5358 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_PAUSE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5359 {
5360 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5361 return E_VDEC_FAIL;
5362 }
5363 else
5364 {
5365 return eRet;
5366 }
5367 }
5368
5369
5370 //------------------------------------------------------------------------------
5371 /// Pause decode and display
5372 /// @return return VDEC_Result
5373 //-----------------------------------------------------------------------------
MApi_VDEC_V2_Pause(void)5374 VDEC_Result MApi_VDEC_V2_Pause(void)
5375 {
5376 if (!_Attr.bInit)
5377 {
5378 return E_VDEC_RET_NOT_INIT;
5379 }
5380
5381 switch (_Attr.eDecoder)
5382 {
5383 case E_VDEC_DECODER_MVD:
5384 {
5385 MDrv_MVD_Pause();
5386
5387 break;
5388 }
5389 case E_VDEC_DECODER_HVD:
5390 {
5391 _HVD_RET_HANDLE(MDrv_HVD_Pause());
5392
5393 break;
5394 }
5395 case E_VDEC_DECODER_MJPEG:
5396 {
5397 _MJPEG_RET_HANDLE(MApi_MJPEG_Pause());
5398
5399 break;
5400 }
5401 case E_VDEC_DECODER_RVD:
5402 {
5403 _RVD_RET_HANDLE(MDrv_RVD_Pause());
5404
5405 break;
5406 }
5407 default:
5408 break;
5409 }
5410
5411 return E_VDEC_OK;
5412 }
5413
5414 //------------------------------------------------------------------------------
5415 /// Resume decode and display
5416 /// @return return VDEC_Result
5417 //------------------------------------------------------------------------------
MApi_VDEC_Resume(void)5418 VDEC_Result MApi_VDEC_Resume(void)
5419 {
5420 if (pu32VDEC_Inst == NULL)
5421 {
5422 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5423 return E_VDEC_FAIL;
5424 }
5425
5426 VDEC_V2_IO_Param IO_arg;
5427 VDEC_Result eRet = E_VDEC_FAIL;;
5428 IO_arg.pRet = (void*)&eRet;
5429
5430 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_RESUME, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5431 {
5432 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5433 return E_VDEC_FAIL;
5434 }
5435 else
5436 {
5437 return eRet;
5438 }
5439 }
5440
5441 //------------------------------------------------------------------------------
5442 /// Resume decode and display
5443 /// @return return VDEC_Result
5444 //------------------------------------------------------------------------------
MApi_VDEC_V2_Resume(void)5445 VDEC_Result MApi_VDEC_V2_Resume(void)
5446 {
5447 if (!_Attr.bInit)
5448 {
5449 return E_VDEC_RET_NOT_INIT;
5450 }
5451
5452 switch (_Attr.eDecoder)
5453 {
5454 case E_VDEC_DECODER_MVD:
5455 {
5456 MDrv_MVD_Resume();
5457 break;
5458 }
5459 case E_VDEC_DECODER_HVD:
5460 {
5461 _HVD_RET_HANDLE(MDrv_HVD_Play());
5462
5463 break;
5464 }
5465 case E_VDEC_DECODER_MJPEG:
5466 {
5467 _MJPEG_RET_HANDLE(MApi_MJPEG_Resume());
5468
5469 break;
5470 }
5471 case E_VDEC_DECODER_RVD:
5472 {
5473 _RVD_RET_HANDLE(MDrv_RVD_Resume());
5474
5475 break;
5476 }
5477 default:
5478 break;
5479 }
5480
5481 return E_VDEC_OK;
5482 }
5483
5484 //------------------------------------------------------------------------------
5485 /// Trigger to display one frame (background may still decoding)
5486 /// @return return VDEC_Result
5487 //------------------------------------------------------------------------------
MApi_VDEC_StepDisp(void)5488 VDEC_Result MApi_VDEC_StepDisp(void)
5489 {
5490 if (pu32VDEC_Inst == NULL)
5491 {
5492 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5493 return E_VDEC_FAIL;
5494 }
5495
5496 VDEC_V2_IO_Param IO_arg;
5497 VDEC_Result eRet = E_VDEC_FAIL;;
5498 IO_arg.pRet = (void*)&eRet;
5499
5500 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_STEP_DISP, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5501 {
5502 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5503 return E_VDEC_FAIL;
5504 }
5505 else
5506 {
5507 return eRet;
5508 }
5509 }
5510
5511 //------------------------------------------------------------------------------
5512 /// Trigger to display one frame (background may still decoding)
5513 /// @return return VDEC_Result
5514 //------------------------------------------------------------------------------
MApi_VDEC_V2_StepDisp(void)5515 VDEC_Result MApi_VDEC_V2_StepDisp(void)
5516 {
5517 if (!_Attr.bInit)
5518 {
5519 return E_VDEC_RET_NOT_INIT;
5520 }
5521
5522 switch (_Attr.eDecoder)
5523 {
5524 case E_VDEC_DECODER_MVD:
5525 {
5526 if (FALSE == MDrv_MVD_StepDisp())
5527 {
5528 return E_VDEC_FAIL;
5529 }
5530
5531 break;
5532 }
5533 case E_VDEC_DECODER_HVD:
5534 {
5535 _HVD_RET_HANDLE(MDrv_HVD_StepDisp());
5536
5537 break;
5538 }
5539 case E_VDEC_DECODER_MJPEG:
5540 {
5541 _MJPEG_RET_HANDLE(MApi_MJPEG_StepPlay());
5542
5543 break;
5544 }
5545 case E_VDEC_DECODER_RVD:
5546 {
5547 _RVD_RET_HANDLE(MDrv_RVD_StepPlay());
5548
5549 break;
5550 }
5551 default:
5552 break;
5553 }
5554
5555 return E_VDEC_OK;
5556 }
5557
5558
5559 //------------------------------------------------------------------------------
5560 /// Check if step play done or not
5561 /// @return VDEC_Result
5562 /// - E_VDEC_OK: step display done
5563 /// - E_VDEC_FAIL: not yet
5564 /// - E_VDEC_RET_NOT_INIT: not initial yet
5565 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
5566 //------------------------------------------------------------------------------
MApi_VDEC_IsStepDispDone(void)5567 VDEC_Result MApi_VDEC_IsStepDispDone(void)
5568 {
5569 if (pu32VDEC_Inst == NULL)
5570 {
5571 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5572 return E_VDEC_FAIL;
5573 }
5574
5575 VDEC_V2_IO_Param IO_arg;
5576 VDEC_Result eRet = E_VDEC_FAIL;;
5577 IO_arg.pRet = (void*)&eRet;
5578
5579 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_STEP_DISP_DONE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5580 {
5581 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5582 return E_VDEC_FAIL;
5583 }
5584 else
5585 {
5586 return eRet;
5587 }
5588 }
5589
5590
5591 //------------------------------------------------------------------------------
5592 /// Check if step play done or not
5593 /// @return VDEC_Result
5594 /// - E_VDEC_OK: step display done
5595 /// - E_VDEC_FAIL: not yet
5596 /// - E_VDEC_RET_NOT_INIT: not initial yet
5597 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
5598 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsStepDispDone(void)5599 VDEC_Result MApi_VDEC_V2_IsStepDispDone(void)
5600 {
5601 VDEC_Result ret;
5602
5603 if (!_Attr.bInit)
5604 {
5605 return E_VDEC_RET_NOT_INIT;
5606 }
5607
5608 switch (_Attr.eDecoder)
5609 {
5610 case E_VDEC_DECODER_MVD:
5611 {
5612 if (FALSE == MDrv_MVD_IsStepDispDone())
5613 {
5614 ret = E_VDEC_FAIL;
5615 }
5616 else
5617 {
5618 ret = E_VDEC_OK;
5619 }
5620 break;
5621 }
5622 case E_VDEC_DECODER_HVD:
5623 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsFrameShowed());
5624 break;
5625
5626 case E_VDEC_DECODER_MJPEG:
5627 _BOOL_TO_VDEC_RESULT(ret, MApi_MJPEG_IsStepPlayDone());
5628 break;
5629
5630 case E_VDEC_DECODER_RVD:
5631 _BOOL_TO_VDEC_RESULT(ret, MDrv_RVD_IsStepPlayDone());
5632 break;
5633
5634 default:
5635 ret = E_VDEC_RET_UNSUPPORTED;
5636 break;
5637 }
5638
5639 return ret;
5640 }
5641
5642 //------------------------------------------------------------------------------
5643 /// Decoder will start decode with full speed until target PTS is reached (equal or larger) then pause.
5644 /// @param u32PTS \b IN : target PTS
5645 /// @return VDEC_Result
5646 //------------------------------------------------------------------------------
MApi_VDEC_SeekToPTS(MS_U32 u32PTS)5647 VDEC_Result MApi_VDEC_SeekToPTS(MS_U32 u32PTS)
5648 {
5649 if (pu32VDEC_Inst == NULL)
5650 {
5651 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5652 return E_VDEC_FAIL;
5653 }
5654
5655 VDEC_V2_IO_Param IO_arg;
5656 VDEC_Result eRet = E_VDEC_FAIL;
5657
5658 IO_arg.param[0] = (void*)&u32PTS;
5659 IO_arg.pRet = (void *)&eRet;
5660
5661 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SEEK_TO_PTS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5662 {
5663 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5664 return E_VDEC_FAIL;
5665 }
5666 else
5667 {
5668 return eRet;
5669 }
5670 }
5671
5672 //------------------------------------------------------------------------------
5673 /// Decoder will start decode with full speed until target PTS is reached (equal or larger) then pause.
5674 /// @param u32PTS \b IN : target PTS
5675 /// @return VDEC_Result
5676 //------------------------------------------------------------------------------
MApi_VDEC_V2_SeekToPTS(MS_U32 u32PTS)5677 VDEC_Result MApi_VDEC_V2_SeekToPTS(MS_U32 u32PTS)
5678 {
5679 VDEC_Result ret = E_VDEC_FAIL;
5680
5681 if (!_Attr.bInit)
5682 {
5683 return E_VDEC_RET_NOT_INIT;
5684 }
5685
5686 switch (_Attr.eDecoder)
5687 {
5688 case E_VDEC_DECODER_MVD:
5689 {
5690 if (FALSE == MDrv_MVD_SeekToPTS(u32PTS))
5691 {
5692 return E_VDEC_FAIL;
5693 }
5694
5695 break;
5696 }
5697 case E_VDEC_DECODER_HVD:
5698 {
5699 _HVD_RET_HANDLE(MDrv_HVD_SeekToPTS(u32PTS));
5700
5701 break;
5702 }
5703 case E_VDEC_DECODER_MJPEG:
5704 {
5705 _MJPEG_RET_HANDLE(MApi_MJPEG_SeekToPTS(u32PTS));
5706
5707 break;
5708 }
5709 case E_VDEC_DECODER_RVD:
5710 {
5711 _RVD_RET_HANDLE(MDrv_RVD_JumpToPTS(u32PTS));
5712
5713 break;
5714 }
5715 default:
5716 break;
5717 }
5718
5719 return ret;
5720 }
5721
5722 //------------------------------------------------------------------------------
5723 /// Decoder will skip all frames before target PTS, and start decode with full speed after target PTS is reached.
5724 /// @param u32PTS \b IN : target PTS
5725 /// - 0: turn off this mode.
5726 /// - any not zero: enable this mode.
5727 /// @return VDEC_Result
5728 //------------------------------------------------------------------------------
MApi_VDEC_SkipToPTS(MS_U32 u32PTS)5729 VDEC_Result MApi_VDEC_SkipToPTS(MS_U32 u32PTS)
5730 {
5731 if (pu32VDEC_Inst == NULL)
5732 {
5733 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5734 return E_VDEC_FAIL;
5735 }
5736
5737 VDEC_V2_IO_Param IO_arg;
5738 VDEC_Result eRet = E_VDEC_FAIL;
5739
5740 IO_arg.param[0] = (void*)&u32PTS;
5741 IO_arg.pRet = (void *)&eRet;
5742
5743
5744 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SKIP_TO_PTS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5745 {
5746 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5747 return E_VDEC_FAIL;
5748 }
5749 else
5750 {
5751 return eRet;
5752 }
5753 }
5754
5755 //------------------------------------------------------------------------------
5756 /// Decoder will skip all frames before target PTS, and start decode with full speed after target PTS is reached.
5757 /// @param u32PTS \b IN : target PTS
5758 /// - 0: turn off this mode.
5759 /// - any not zero: enable this mode.
5760 /// @return VDEC_Result
5761 //------------------------------------------------------------------------------
MApi_VDEC_V2_SkipToPTS(MS_U32 u32PTS)5762 VDEC_Result MApi_VDEC_V2_SkipToPTS(MS_U32 u32PTS)
5763 {
5764 VDEC_Result ret = E_VDEC_FAIL;
5765
5766 if (!_Attr.bInit)
5767 {
5768 return E_VDEC_RET_NOT_INIT;
5769 }
5770
5771 switch (_Attr.eDecoder)
5772 {
5773 case E_VDEC_DECODER_MVD:
5774 {
5775 if (FALSE == MDrv_MVD_SkipToPTS(u32PTS))
5776 {
5777 return E_VDEC_FAIL;
5778 }
5779
5780 break;
5781 }
5782 case E_VDEC_DECODER_HVD:
5783 {
5784 _HVD_RET_HANDLE(MDrv_HVD_SkipToPTS(u32PTS));
5785
5786 break;
5787 }
5788 case E_VDEC_DECODER_MJPEG:
5789 {
5790 _MJPEG_RET_HANDLE(MApi_MJPEG_SkipToPTS(u32PTS));
5791
5792 break;
5793 }
5794 case E_VDEC_DECODER_RVD:
5795 {
5796 _RVD_RET_HANDLE(MDrv_RVD_SkipToPTS(u32PTS));
5797
5798 break;
5799 }
5800 default:
5801 break;
5802 }
5803
5804 return ret;
5805 }
5806
5807 //------------------------------------------------------------------------------
5808 /// Trigger decoder to decode one frame.
5809 /// Decoder seeks to an I frame, decodes and displays it.
5810 /// @return return VDEC_Result
5811 //------------------------------------------------------------------------------
MApi_VDEC_StepDecode(void)5812 VDEC_Result MApi_VDEC_StepDecode(void)
5813 {
5814 if (pu32VDEC_Inst == NULL)
5815 {
5816 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5817 return E_VDEC_FAIL;
5818 }
5819
5820 VDEC_V2_IO_Param IO_arg;
5821 VDEC_Result eRet = E_VDEC_FAIL;
5822
5823 IO_arg.pRet = (void *)&eRet;
5824
5825
5826 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_STEP_DECODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5827 {
5828 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5829 return E_VDEC_FAIL;
5830 }
5831 else
5832 {
5833 return eRet;
5834 }
5835 }
5836
5837
5838 //------------------------------------------------------------------------------
5839 /// Trigger decoder to decode one frame.
5840 /// Decoder seeks to an I frame, decodes and displays it.
5841 /// @return return VDEC_Result
5842 //------------------------------------------------------------------------------
MApi_VDEC_V2_StepDecode(void)5843 VDEC_Result MApi_VDEC_V2_StepDecode(void)
5844 {
5845 if (!_Attr.bInit)
5846 {
5847 return E_VDEC_RET_NOT_INIT;
5848 }
5849
5850 switch (_Attr.eDecoder)
5851 {
5852 case E_VDEC_DECODER_MVD:
5853 {
5854 if (FALSE == MDrv_MVD_StepDecode())
5855 {
5856 return E_VDEC_FAIL;
5857 }
5858
5859 break;
5860 }
5861 case E_VDEC_DECODER_HVD:
5862 {
5863 _HVD_RET_HANDLE(MDrv_HVD_StepDecode());
5864
5865 break;
5866 }
5867 case E_VDEC_DECODER_MJPEG:
5868 {
5869 // Now we always return success
5870 _MJPEG_RET_HANDLE(MApi_MJPEG_StepDecode());
5871
5872 break;
5873 }
5874 case E_VDEC_DECODER_RVD:
5875 {
5876 _RVD_RET_HANDLE(MDrv_RVD_StepDecode());
5877
5878 break;
5879 }
5880 default:
5881 break;
5882 }
5883
5884 return E_VDEC_OK;
5885 }
5886
5887
5888 //------------------------------------------------------------------------------
5889 /// Check if step decode done or not
5890 /// @return VDEC_Result
5891 /// - E_VDEC_OK: step decode done
5892 /// - E_VDEC_FAIL: not yet
5893 /// - E_VDEC_RET_NOT_INIT: not initial yet
5894 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
5895 //------------------------------------------------------------------------------
MApi_VDEC_IsStepDecodeDone(void)5896 VDEC_Result MApi_VDEC_IsStepDecodeDone(void)
5897 {
5898 if (pu32VDEC_Inst == NULL)
5899 {
5900 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5901 return E_VDEC_FAIL;
5902 }
5903
5904 VDEC_V2_IO_Param IO_arg;
5905 VDEC_Result eRet = E_VDEC_FAIL;
5906
5907 IO_arg.pRet = (void *)&eRet;
5908
5909
5910 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_STEP_DECODE_DONE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5911 {
5912 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5913 return E_VDEC_FAIL;
5914 }
5915 else
5916 {
5917 return eRet;
5918 }
5919 }
5920
5921 //------------------------------------------------------------------------------
5922 /// Check if step decode done or not
5923 /// @return VDEC_Result
5924 /// - E_VDEC_OK: step decode done
5925 /// - E_VDEC_FAIL: not yet
5926 /// - E_VDEC_RET_NOT_INIT: not initial yet
5927 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
5928 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsStepDecodeDone(void)5929 VDEC_Result MApi_VDEC_V2_IsStepDecodeDone(void)
5930 {
5931 VDEC_Result ret;
5932
5933 if (!_Attr.bInit)
5934 {
5935 return E_VDEC_RET_NOT_INIT;
5936 }
5937
5938 switch (_Attr.eDecoder)
5939 {
5940 case E_VDEC_DECODER_MVD:
5941 {
5942 if (FALSE == MDrv_MVD_IsStepDecodeDone())
5943 {
5944 return E_VDEC_FAIL;
5945 }
5946 else
5947 {
5948 return E_VDEC_OK;
5949 }
5950 break;
5951 }
5952
5953 case E_VDEC_DECODER_HVD:
5954 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsStepDecodeDone());
5955 break;
5956
5957 case E_VDEC_DECODER_MJPEG:
5958 _BOOL_TO_VDEC_RESULT(ret, MApi_MJPEG_IsStepDecodeDone());
5959 break;
5960
5961 case E_VDEC_DECODER_RVD:
5962 _BOOL_TO_VDEC_RESULT(ret, MDrv_RVD_IsStepDecodeDone());
5963 break;
5964
5965 default:
5966 ret = E_VDEC_RET_UNSUPPORTED;
5967 break;
5968 }
5969
5970 return ret;
5971 }
5972
5973
5974 //------------------------------------------------------------------------------
5975 /// Set up trick decode mode for decode I, decode IP and decode all.
5976 /// @param eTrickDec \b IN : trick decode mode
5977 /// @return VDEC_Result
5978 //------------------------------------------------------------------------------
MApi_VDEC_SetTrickMode(VDEC_TrickDec eTrickDec)5979 VDEC_Result MApi_VDEC_SetTrickMode(VDEC_TrickDec eTrickDec)
5980 {
5981 if (pu32VDEC_Inst == NULL)
5982 {
5983 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5984 return E_VDEC_FAIL;
5985 }
5986
5987 VDEC_V2_IO_Param IO_arg;
5988 VDEC_Result eRet = E_VDEC_FAIL;
5989
5990 IO_arg.param[0] = (void*)&eTrickDec;
5991 IO_arg.pRet = (void *)&eRet;
5992
5993 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_TRICK_MODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
5994 {
5995 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
5996 return E_VDEC_FAIL;
5997 }
5998 else
5999 {
6000 return eRet;
6001 }
6002 }
6003
6004 //------------------------------------------------------------------------------
6005 /// Set up trick decode mode for decode I, decode IP and decode all.
6006 /// @param eTrickDec \b IN : trick decode mode
6007 /// @return VDEC_Result
6008 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetTrickMode(VDEC_TrickDec eTrickDec)6009 VDEC_Result MApi_VDEC_V2_SetTrickMode(VDEC_TrickDec eTrickDec)
6010 {
6011 if (!_Attr.bInit)
6012 {
6013 return E_VDEC_RET_NOT_INIT;
6014 }
6015
6016 switch (_Attr.eDecoder)
6017 {
6018 case E_VDEC_DECODER_MVD:
6019 {
6020 if (E_VDEC_TRICK_DEC_ALL == eTrickDec)
6021 {
6022 if (FALSE == MDrv_MVD_TrickPlay(E_MVD_TRICK_DEC_ALL, 1))
6023 {
6024 return E_VDEC_FAIL;
6025 }
6026 }
6027 else if (E_VDEC_TRICK_DEC_IP == eTrickDec)
6028 {
6029 if (FALSE == MDrv_MVD_TrickPlay(E_MVD_TRICK_DEC_IP, 1))
6030 {
6031 return E_VDEC_FAIL;
6032 }
6033 }
6034 else if (E_VDEC_TRICK_DEC_I == eTrickDec)
6035 {
6036 if (FALSE == MDrv_MVD_TrickPlay(E_MVD_TRICK_DEC_I, 1))
6037 {
6038 return E_VDEC_FAIL;
6039 }
6040 }
6041 else
6042 {
6043 return E_VDEC_FAIL;
6044 }
6045
6046 break;
6047 }
6048 case E_VDEC_DECODER_HVD:
6049 {
6050 if (E_VDEC_TRICK_DEC_ALL == eTrickDec)
6051 {
6052 _HVD_RET_HANDLE(MDrv_HVD_SetSkipDecMode(E_HVD_SKIP_DECODE_ALL));
6053 }
6054 else if (E_VDEC_TRICK_DEC_IP == eTrickDec)
6055 {
6056 _HVD_RET_HANDLE(MDrv_HVD_SetSkipDecMode(E_HVD_SKIP_DECODE_IP));
6057 }
6058 else if (E_VDEC_TRICK_DEC_I == eTrickDec)
6059 {
6060 _HVD_RET_HANDLE(MDrv_HVD_SetSkipDecMode(E_HVD_SKIP_DECODE_I));
6061 }
6062 else
6063 {
6064 return E_VDEC_RET_INVALID_PARAM;
6065 }
6066
6067 break;
6068 }
6069 case E_VDEC_DECODER_MJPEG:
6070 return E_VDEC_RET_UNSUPPORTED;
6071
6072 case E_VDEC_DECODER_RVD:
6073 {
6074 if (E_VDEC_TRICK_DEC_ALL == eTrickDec)
6075 {
6076 MDrv_RVD_SetTrickMode(E_RVD_TRICKMODE_DECODE_ALL);
6077 }
6078 else if (E_VDEC_TRICK_DEC_IP == eTrickDec)
6079 {
6080 MDrv_RVD_SetTrickMode(E_RVD_TRICKMODE_DECODE_IP);
6081 }
6082 else if (E_VDEC_TRICK_DEC_I == eTrickDec)
6083 {
6084 MDrv_RVD_SetTrickMode(E_RVD_TRICKMODE_DECODE_I);
6085 }
6086
6087 break;
6088 }
6089 default:
6090 break;
6091 }
6092
6093 return E_VDEC_OK;
6094 }
6095
6096 //------------------------------------------------------------------------------
6097 /// Push decode command queue
6098 /// @param pCmd \b IN : the pointer to decode command
6099 /// @return VDEC_Result
6100 //------------------------------------------------------------------------------
MApi_VDEC_PushDecQ(VDEC_DecCmd * pCmd)6101 VDEC_Result MApi_VDEC_PushDecQ(VDEC_DecCmd *pCmd)
6102 {
6103 if (pu32VDEC_Inst == NULL)
6104 {
6105 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6106 return E_VDEC_FAIL;
6107 }
6108
6109 VDEC_V2_IO_Param IO_arg;
6110 VDEC_Result eRet = E_VDEC_FAIL;
6111
6112 IO_arg.param[0] = (void*)pCmd;
6113 IO_arg.pRet = (void *)&eRet;
6114
6115 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_PUSH_DECQ, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6116 {
6117 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6118 return E_VDEC_FAIL;
6119 }
6120 else
6121 {
6122 return eRet;
6123 }
6124 }
6125 //------------------------------------------------------------------------------
6126 /// Push decode command queue
6127 /// @param pCmd \b IN : the pointer to decode command
6128 /// @return VDEC_Result
6129 //------------------------------------------------------------------------------
MApi_VDEC_V2_PushDecQ(VDEC_DecCmd * pCmd)6130 VDEC_Result MApi_VDEC_V2_PushDecQ(VDEC_DecCmd *pCmd)
6131 {
6132 if (!_Attr.bInit)
6133 {
6134 return E_VDEC_RET_NOT_INIT;
6135 }
6136
6137 if (bEsBufMgmt)
6138 {
6139 //minus bsStartAdd automatically since GetESBuff returns PA but PushDecQ use offset
6140 if(u32VdecInitParamVersion == 0)
6141 {
6142 pCmd->u32StAddr = pCmd->u32StAddr - _vdecInitParam.SysConfig.u32BitstreamBufAddr;
6143 }
6144 else if(u32VdecInitParamVersion == 1)
6145 {
6146 pCmd->u32StAddr = pCmd->u32StAddr - _vdecInitParam_ex1.SysConfig.u32BitstreamBufAddr;
6147 }
6148 }
6149
6150 switch (_Attr.eDecoder)
6151 {
6152 case E_VDEC_DECODER_MVD:
6153 {
6154 MVD_PacketInfo stMvdPktInfo;
6155
6156 _VDEC_Memset(&stMvdPktInfo, 0, sizeof(MVD_PacketInfo));
6157
6158 stMvdPktInfo.u32StAddr = pCmd->u32StAddr;
6159 stMvdPktInfo.u32Length = pCmd->u32Size;
6160 stMvdPktInfo.u32TimeStamp = pCmd->u32Timestamp;
6161 stMvdPktInfo.u32ID_H = pCmd->u32ID_H;
6162 stMvdPktInfo.u32ID_L = pCmd->u32ID_L;
6163
6164 _MVD_RET_HANDLE(MDrv_MVD_PushQueue(&stMvdPktInfo));
6165
6166 break;
6167 }
6168 case E_VDEC_DECODER_HVD:
6169 { // File mode
6170 HVD_Packet_Info packetInfo;
6171
6172 _VDEC_Memset(&packetInfo, 0, sizeof(HVD_Packet_Info));
6173
6174 packetInfo.u32Staddr = pCmd->u32StAddr;
6175 packetInfo.u32Length = pCmd->u32Size;
6176 packetInfo.u32TimeStamp = pCmd->u32Timestamp;
6177 packetInfo.u32ID_H = pCmd->u32ID_H;
6178 packetInfo.u32ID_L = pCmd->u32ID_L;
6179
6180 _HVD_RET_HANDLE(MDrv_HVD_PushQueue(&packetInfo));
6181
6182 break;
6183 }
6184 case E_VDEC_DECODER_MJPEG:
6185 {
6186 MJPEG_Packet_Info packetInfo;
6187
6188 _VDEC_Memset(&packetInfo, 0, sizeof(MJPEG_Packet_Info));
6189
6190 packetInfo.u32StAddr = pCmd->u32StAddr;
6191 packetInfo.u32Size = pCmd->u32Size;
6192 packetInfo.u32TimeStamp = pCmd->u32Timestamp;
6193 packetInfo.u32ID_H = pCmd->u32ID_H;
6194 packetInfo.u32ID_L = pCmd->u32ID_L;
6195
6196 _MJPEG_RET_HANDLE(MApi_MJPEG_PushQueue(&packetInfo));
6197
6198 break;
6199 }
6200 case E_VDEC_DECODER_RVD:
6201 {
6202 RVD_Packet_ID packetID;
6203
6204 packetID.u32PacketID_HI = pCmd->u32ID_H;
6205 packetID.u32PacketID_LO = pCmd->u32ID_L;
6206
6207 MDrv_RVD_PushBBU(pCmd->u32StAddr, pCmd->u32Size, &packetID);
6208
6209 break;
6210 }
6211 default:
6212 break;
6213 }
6214
6215 #if _VDEC_PTS_TABLE
6216 _VDEC_PtsTablePut(pCmd->u32Timestamp);
6217 #endif
6218
6219 return E_VDEC_OK;
6220 }
6221
6222 //------------------------------------------------------------------------------
6223 /// Fire the decode command which be pushed since last fired
6224 /// @return VDEC_Result
6225 //------------------------------------------------------------------------------
MApi_VDEC_FireDecCmd(void)6226 VDEC_Result MApi_VDEC_FireDecCmd(void)
6227 {
6228
6229 if (pu32VDEC_Inst == NULL)
6230 {
6231 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6232 return E_VDEC_FAIL;
6233 }
6234
6235 VDEC_V2_IO_Param IO_arg;
6236 VDEC_Result eRet = E_VDEC_FAIL;
6237 IO_arg.pRet = (void *)&eRet;
6238
6239 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_FIRE_DEC_CMD, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6240 {
6241 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6242 return E_VDEC_FAIL;
6243 }
6244 else
6245 {
6246 return eRet;
6247 }
6248 }
6249
6250
6251 //------------------------------------------------------------------------------
6252 /// Fire the decode command which be pushed since last fired
6253 /// @return VDEC_Result
6254 //------------------------------------------------------------------------------
MApi_VDEC_V2_FireDecCmd(void)6255 VDEC_Result MApi_VDEC_V2_FireDecCmd(void)
6256 {
6257 VDEC_Result ret;
6258
6259 if (!_Attr.bInit)
6260 {
6261 return E_VDEC_RET_NOT_INIT;
6262 }
6263
6264 switch (_Attr.eDecoder)
6265 {
6266 case E_VDEC_DECODER_MVD:
6267 MDrv_MVD_SetSLQWritePtr(TRUE);
6268 ret = E_VDEC_OK;
6269 break;
6270
6271 case E_VDEC_DECODER_HVD:
6272 MDrv_HVD_PushQueue_Fire();
6273 ret = E_VDEC_OK;
6274 break;
6275
6276 case E_VDEC_DECODER_MJPEG:
6277 ret = E_VDEC_RET_UNSUPPORTED;
6278 break;
6279
6280 case E_VDEC_DECODER_RVD:
6281 _BOOL_TO_VDEC_RESULT(ret, MDrv_RVD_FireDecCmd());
6282 break;
6283
6284 default:
6285 ret = E_VDEC_RET_UNSUPPORTED;
6286 break;
6287 }
6288
6289 return ret;
6290 }
6291
6292 //------------------------------------------------------------------------------
6293 /// Get current queue vacancy
6294 /// @return vacancy number
6295 //------------------------------------------------------------------------------
MApi_VDEC_GetDecQVacancy(void)6296 MS_U32 MApi_VDEC_GetDecQVacancy(void)
6297 {
6298
6299
6300 if (pu32VDEC_Inst == NULL)
6301 {
6302 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6303 return E_VDEC_FAIL;
6304 }
6305
6306 VDEC_V2_IO_Param IO_arg;
6307 MS_U32 u32Vacancy = 0;
6308 IO_arg.pRet = (void *)&u32Vacancy;
6309
6310
6311 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_DECQ_VACANCY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6312 {
6313 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6314 return 0;
6315 }
6316 else
6317 {
6318 return u32Vacancy;
6319 }
6320 }
6321
6322 //------------------------------------------------------------------------------
6323 /// Get current queue vacancy
6324 /// @return vacancy number
6325 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetDecQVacancy(void)6326 MS_U32 MApi_VDEC_V2_GetDecQVacancy(void)
6327 {
6328 MS_U32 u32Vacancy = 0;
6329
6330 if (!_Attr.bInit)
6331 {
6332 return 0;
6333 }
6334
6335 switch (_Attr.eDecoder)
6336 {
6337 case E_VDEC_DECODER_MVD:
6338 u32Vacancy = MDrv_MVD_GetQueueVacancy(TRUE);
6339
6340 break;
6341
6342 case E_VDEC_DECODER_HVD:
6343 u32Vacancy = MDrv_HVD_GetBBUVacancy();
6344
6345 break;
6346
6347 case E_VDEC_DECODER_MJPEG:
6348 u32Vacancy = MApi_MJPEG_GetQueueVacancy();
6349
6350 break;
6351
6352 case E_VDEC_DECODER_RVD:
6353 u32Vacancy = MDrv_RVD_GetQmemSwBbuVacancy();
6354
6355 break;
6356
6357 default:
6358 u32Vacancy = 0;
6359 break;
6360 }
6361
6362 return u32Vacancy;
6363 }
6364
MApi_VDEC_IsCCAvailable(void)6365 MS_BOOL MApi_VDEC_IsCCAvailable(void)
6366 {
6367
6368
6369 if (pu32VDEC_Inst == NULL)
6370 {
6371 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6372 return E_VDEC_FAIL;
6373 }
6374
6375 VDEC_V2_IO_Param IO_arg;
6376 MS_BOOL ret = FALSE;
6377 IO_arg.pRet = (void *)&ret;
6378
6379 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_CC_AVAILABLE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6380 {
6381 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6382 return FALSE;
6383 }
6384 else
6385 {
6386 return ret;
6387 }
6388 }
6389
MApi_VDEC_V2_IsCCAvailable(void)6390 MS_BOOL MApi_VDEC_V2_IsCCAvailable(void)
6391 {
6392 MS_BOOL ret = FALSE;
6393 if (!_Attr.bInit)
6394 {
6395 return FALSE;
6396 }
6397
6398 switch (_Attr.eDecoder)
6399 {
6400 case E_VDEC_DECODER_MVD:
6401 {
6402 ret = MDrv_MVD_GetUsrDataIsAvailable();
6403
6404 break;
6405 }
6406 case E_VDEC_DECODER_HVD:
6407 {
6408 ret = MDrv_HVD_GetUsrDataIsAvailable();
6409 break;
6410 }
6411 case E_VDEC_DECODER_MJPEG:
6412 {
6413 break;
6414 }
6415 case E_VDEC_DECODER_RVD:
6416 {
6417 break;
6418 }
6419 default:
6420 break;
6421 }
6422
6423 return ret;
6424 }
6425
MApi_VDEC_GetCCInfo(void * pInfo,MS_U32 u32Size)6426 VDEC_Result MApi_VDEC_GetCCInfo(void *pInfo, MS_U32 u32Size)
6427 {
6428 if (pu32VDEC_Inst == NULL)
6429 {
6430 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6431 return E_VDEC_FAIL;
6432 }
6433
6434
6435 VDEC_V2_IO_Param IO_arg;
6436 VDEC_Result eRet = E_VDEC_FAIL;
6437
6438 IO_arg.param[0] = pInfo;
6439 IO_arg.param[1] = (void*)(&u32Size);
6440 IO_arg.pRet = (void *)&eRet;
6441
6442 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_CC_INFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6443 {
6444 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6445 return E_VDEC_FAIL;
6446 }
6447 else
6448 {
6449 return eRet;
6450 }
6451
6452 }
6453
MApi_VDEC_V2_GetCCInfo(void * pInfo,MS_U32 u32Size)6454 VDEC_Result MApi_VDEC_V2_GetCCInfo(void *pInfo, MS_U32 u32Size)
6455 {
6456 VDEC_Result ret = E_VDEC_OK;
6457 if (!_Attr.bInit)
6458 {
6459 return E_VDEC_RET_NOT_INIT;
6460 }
6461
6462 MS_U32 u32Version = *((MS_U32 *) pInfo);
6463
6464 if (u32Version == 0 && u32Size == sizeof(VDEC_CC_Info))
6465 {
6466 VDEC_CC_Info *pCCInfo = (VDEC_CC_Info *) pInfo;
6467
6468 switch (_Attr.eDecoder)
6469 {
6470 case E_VDEC_DECODER_MVD:
6471 {
6472 MVD_UsrDataInfo stUsrInfo;
6473 _VDEC_Memset(&stUsrInfo, 0, sizeof(MVD_UsrDataInfo));
6474
6475 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_GetUsrDataInfo(&stUsrInfo));
6476 pCCInfo->u8PicStructure = (VDEC_PicStructure)stUsrInfo.u8PicStruct;
6477 pCCInfo->u8TopFieldFirst = stUsrInfo.u8TopFieldFirst;
6478 pCCInfo->u16TempRef = stUsrInfo.u16TmpRef;
6479 pCCInfo->u32Pts = stUsrInfo.u32Pts;
6480 pCCInfo->u32UserDataBuf = stUsrInfo.u32DataBuf;
6481 pCCInfo->u32UserDataSize = stUsrInfo.u8ByteCnt;
6482
6483 break;
6484 }
6485 case E_VDEC_DECODER_HVD:
6486 {
6487 HVD_UserData_Info stUsrInfo;
6488 _VDEC_Memset(&stUsrInfo, 0, sizeof(HVD_UserData_Info));
6489
6490 _HVD_RET_HANDLE(MDrv_HVD_GetUserDataInfo(&stUsrInfo));
6491 pCCInfo->u8PicStructure = (VDEC_PicStructure)stUsrInfo.u8PicStruct;
6492 pCCInfo->u8TopFieldFirst = stUsrInfo.u8TopFieldFirst;
6493 pCCInfo->u16TempRef = stUsrInfo.u16TmpRef;
6494 pCCInfo->u32Pts = stUsrInfo.u32Pts;
6495 pCCInfo->u32UserDataBuf = stUsrInfo.u32DataBuf;
6496 pCCInfo->u32UserDataSize = stUsrInfo.u8ByteCnt;
6497
6498 break;
6499 }
6500 case E_VDEC_DECODER_MJPEG:
6501 {
6502 ret = E_VDEC_RET_UNSUPPORTED;
6503 break;
6504 }
6505 case E_VDEC_DECODER_RVD:
6506 {
6507 ret = E_VDEC_RET_UNSUPPORTED;
6508 break;
6509 }
6510 default:
6511 break;
6512 }
6513 }
6514
6515 return ret;
6516
6517 }
6518
6519 //------------------------------------------------------------------------------
6520 /// Flush command queue and internal data of decoder
6521 /// @return VDEC_Result
6522 //------------------------------------------------------------------------------
MApi_VDEC_Flush(VDEC_FreezePicSelect eFreezePic)6523 VDEC_Result MApi_VDEC_Flush(VDEC_FreezePicSelect eFreezePic)
6524 {
6525 if (pu32VDEC_Inst == NULL)
6526 {
6527 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6528 return E_VDEC_FAIL;
6529 }
6530
6531 VDEC_V2_IO_Param IO_arg;
6532 VDEC_Result eRet = E_VDEC_FAIL;
6533
6534 IO_arg.param[0] = (void*)(&eFreezePic);
6535 IO_arg.pRet = (void *)&eRet;
6536
6537
6538 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_FLUSH, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6539 {
6540 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6541 return E_VDEC_FAIL;
6542 }
6543 else
6544 {
6545 return eRet;
6546 }
6547 }
6548 //------------------------------------------------------------------------------
6549 /// Flush command queue and internal data of decoder
6550 /// @return VDEC_Result
6551 //------------------------------------------------------------------------------
MApi_VDEC_V2_Flush(VDEC_FreezePicSelect eFreezePic)6552 VDEC_Result MApi_VDEC_V2_Flush(VDEC_FreezePicSelect eFreezePic)
6553 {
6554 if (!_Attr.bInit)
6555 {
6556 return E_VDEC_RET_NOT_INIT;
6557 }
6558
6559 switch (_Attr.eDecoder)
6560 {
6561 case E_VDEC_DECODER_MVD:
6562 {
6563 _MVD_RET_HANDLE(MDrv_MVD_FlushQueue());
6564
6565 break;
6566 }
6567 case E_VDEC_DECODER_HVD:
6568 {
6569 if (eFreezePic == E_VDEC_FREEZE_AT_LAST_PIC)
6570 {
6571 _HVD_RET_HANDLE(MDrv_HVD_Flush(TRUE));
6572 }
6573 else
6574 {
6575 _HVD_RET_HANDLE(MDrv_HVD_Flush(FALSE));
6576 }
6577
6578 break;
6579 }
6580 case E_VDEC_DECODER_MJPEG:
6581 {
6582 _MJPEG_RET_HANDLE(MApi_MJPEG_FlushQueue());
6583
6584 break;
6585 }
6586 case E_VDEC_DECODER_RVD:
6587 {
6588 _RVD_RET_HANDLE(MDrv_RVD_FlushQueue());
6589
6590 break;
6591 }
6592 default:
6593 break;
6594 }
6595
6596 return E_VDEC_OK;
6597 }
6598
6599 //------------------------------------------------------------------------------
6600 /// Get ES buffer write pointer
6601 /// @return write pointer
6602 //------------------------------------------------------------------------------
MApi_VDEC_GetESWritePtr(void)6603 MS_U32 MApi_VDEC_GetESWritePtr(void)
6604 {
6605
6606 if (pu32VDEC_Inst == NULL)
6607 {
6608 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6609 return E_VDEC_FAIL;
6610 }
6611
6612 VDEC_V2_IO_Param IO_arg;
6613 MS_U32 u32Ptr = 0;
6614 IO_arg.pRet = (void*)(&u32Ptr);
6615
6616 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_ES_WRITE_PTR, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6617 {
6618 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6619 return 0;
6620 }
6621 else
6622 {
6623 return u32Ptr;
6624 }
6625 }
6626
6627 //------------------------------------------------------------------------------
6628 /// Get ES buffer write pointer
6629 /// @return write pointer
6630 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetESWritePtr(void)6631 MS_U32 MApi_VDEC_V2_GetESWritePtr(void)
6632 {
6633 MS_U32 u32Ptr = 0;
6634
6635 if (!_Attr.bInit)
6636 {
6637 return 0;
6638 }
6639
6640 switch (_Attr.eDecoder)
6641 {
6642 case E_VDEC_DECODER_MVD:
6643 u32Ptr = (MS_U32) MDrv_MVD_GetESWritePtr();
6644
6645 break;
6646
6647 case E_VDEC_DECODER_HVD:
6648 u32Ptr = MDrv_HVD_GetESWritePtr();
6649
6650 break;
6651
6652 case E_VDEC_DECODER_MJPEG:
6653 u32Ptr = MApi_MJPEG_GetESWritePtr();
6654
6655 break;
6656
6657 case E_VDEC_DECODER_RVD:
6658 u32Ptr = MDrv_RVD_GetESWritePtr();
6659
6660 break;
6661
6662 default:
6663 u32Ptr = 0;
6664 break;
6665 }
6666
6667 return u32Ptr;
6668 }
6669
6670
6671 //------------------------------------------------------------------------------
6672 /// Get decoder ES buffer read pointer
6673 /// @return read pointer
6674 //------------------------------------------------------------------------------
MApi_VDEC_GetESReadPtr(void)6675 MS_U32 MApi_VDEC_GetESReadPtr(void)
6676 {
6677
6678 if (pu32VDEC_Inst == NULL)
6679 {
6680 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6681 return E_VDEC_FAIL;
6682 }
6683
6684 VDEC_V2_IO_Param IO_arg;
6685 MS_U32 u32Ptr = 0;
6686 IO_arg.pRet = (void*)(&u32Ptr);
6687
6688 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_ES_READ_PTR, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6689 {
6690 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6691 return 0;
6692 }
6693 else
6694 {
6695 return u32Ptr;
6696 }
6697 }
6698
6699 //------------------------------------------------------------------------------
6700 /// Get decoder ES buffer read pointer
6701 /// @return read pointer
6702 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetESReadPtr(void)6703 MS_U32 MApi_VDEC_V2_GetESReadPtr(void)
6704 {
6705 MS_U32 u32Ptr = 0;
6706
6707 if (!_Attr.bInit)
6708 {
6709 return 0;
6710 }
6711
6712 switch (_Attr.eDecoder)
6713 {
6714 case E_VDEC_DECODER_MVD:
6715 u32Ptr = (MS_U32) MDrv_MVD_GetESReadPtr();
6716
6717 break;
6718
6719 case E_VDEC_DECODER_HVD:
6720 u32Ptr = MDrv_HVD_GetESReadPtr();
6721
6722 break;
6723
6724 case E_VDEC_DECODER_MJPEG:
6725 u32Ptr = MApi_MJPEG_GetESReadPtr();
6726
6727 break;
6728
6729 case E_VDEC_DECODER_RVD:
6730 u32Ptr = MDrv_RVD_GetESReadPtr();
6731
6732 break;
6733
6734 default:
6735 u32Ptr = 0;
6736 break;
6737 }
6738
6739 return u32Ptr;
6740 }
6741
6742 //------------------------------------------------------------------------------
6743 /// Enable to let decoder force to display all decoded frame when out of input data
6744 /// @param bEnable \b IN : TRUE - enable; FALSE - disable
6745 /// @return VDEC_Result
6746 //------------------------------------------------------------------------------
MApi_VDEC_EnableLastFrameShow(MS_BOOL bEnable)6747 VDEC_Result MApi_VDEC_EnableLastFrameShow(MS_BOOL bEnable)
6748 {
6749 if (pu32VDEC_Inst == NULL)
6750 {
6751 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6752 return E_VDEC_FAIL;
6753 }
6754
6755
6756 VDEC_V2_IO_Param IO_arg;
6757 VDEC_Result eRet = E_VDEC_FAIL;
6758
6759 IO_arg.param[0] = (void*)(&bEnable);
6760 IO_arg.pRet = (void *)&eRet;
6761
6762
6763 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_ENABLE_LAST_FRAME_SHOW, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6764 {
6765 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6766 return E_VDEC_FAIL;
6767 }
6768 else
6769 {
6770 return eRet;
6771 }
6772 }
6773
6774 //------------------------------------------------------------------------------
6775 /// Enable to let decoder force to display all decoded frame when out of input data
6776 /// @param bEnable \b IN : TRUE - enable; FALSE - disable
6777 /// @return VDEC_Result
6778 //------------------------------------------------------------------------------
MApi_VDEC_V2_EnableLastFrameShow(MS_BOOL bEnable)6779 VDEC_Result MApi_VDEC_V2_EnableLastFrameShow(MS_BOOL bEnable)
6780 {
6781 if (!_Attr.bInit)
6782 {
6783 return E_VDEC_RET_NOT_INIT;
6784 }
6785
6786 switch (_Attr.eDecoder)
6787 {
6788 case E_VDEC_DECODER_MVD:
6789 {
6790 _MVD_RET_HANDLE(MDrv_MVD_EnableLastFrameShow(bEnable));
6791
6792 break;
6793 }
6794 case E_VDEC_DECODER_HVD:
6795 {
6796 _HVD_RET_HANDLE(MDrv_HVD_SetDataEnd(bEnable));
6797
6798 break;
6799 }
6800 case E_VDEC_DECODER_MJPEG:
6801 {
6802 _MJPEG_RET_HANDLE(MApi_MJPEG_EnableLastFrameShow(bEnable));
6803
6804 break;
6805 }
6806 case E_VDEC_DECODER_RVD:
6807 {
6808 _RVD_RET_HANDLE(MDrv_RVD_EnableLastFrameShowed(bEnable));
6809
6810 break;
6811 }
6812 default:
6813 break;
6814 }
6815
6816 return E_VDEC_OK;
6817 }
6818
6819
6820 //------------------------------------------------------------------------------
6821 /// Check if all decoded frames are displayed when input stream is run out
6822 /// @return VDEC_Result
6823 /// - E_VDEC_OK: finished
6824 /// - E_VDEC_FAIL: not yet
6825 /// - E_VDEC_RET_NOT_INIT: not initial yet
6826 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
6827 //------------------------------------------------------------------------------
MApi_VDEC_IsDispFinish(void)6828 VDEC_Result MApi_VDEC_IsDispFinish(void)
6829 {
6830 if (pu32VDEC_Inst == NULL)
6831 {
6832 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6833 return E_VDEC_FAIL;
6834 }
6835
6836
6837 VDEC_V2_IO_Param IO_arg;
6838 VDEC_Result eRet = E_VDEC_FAIL;
6839
6840 IO_arg.pRet = (void *)&eRet;
6841
6842 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_DISP_FINISH, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6843 {
6844 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6845 return E_VDEC_FAIL;
6846 }
6847 else
6848 {
6849 return eRet;
6850 }
6851 }
6852
6853 //------------------------------------------------------------------------------
6854 /// Check if all decoded frames are displayed when input stream is run out
6855 /// @return VDEC_Result
6856 /// - E_VDEC_OK: finished
6857 /// - E_VDEC_FAIL: not yet
6858 /// - E_VDEC_RET_NOT_INIT: not initial yet
6859 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
6860 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsDispFinish(void)6861 VDEC_Result MApi_VDEC_V2_IsDispFinish(void)
6862 {
6863 VDEC_Result ret;
6864
6865 if (!_Attr.bInit)
6866 {
6867 return E_VDEC_RET_NOT_INIT;
6868 }
6869
6870 switch (_Attr.eDecoder)
6871 {
6872 case E_VDEC_DECODER_MVD:
6873 if (MDrv_MVD_IsDispFinish() == E_MVD_RET_OK)
6874 ret = E_VDEC_OK;
6875 else
6876 ret = E_VDEC_FAIL;
6877 break;
6878
6879 case E_VDEC_DECODER_HVD:
6880 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsDispFinish());
6881 break;
6882
6883 case E_VDEC_DECODER_MJPEG:
6884 _BOOL_TO_VDEC_RESULT(ret, MApi_MJPEG_IsDispFinish());
6885 break;
6886
6887 case E_VDEC_DECODER_RVD:
6888 _BOOL_TO_VDEC_RESULT(ret, MDrv_RVD_IsDispFinish());
6889 break;
6890
6891 default:
6892 ret = E_VDEC_RET_UNSUPPORTED;
6893 break;
6894 }
6895
6896 return ret;
6897 }
6898
6899
6900 //------------------------------------------------------------------------------
6901 /// Set up display speed
6902 /// @param eSpeedType \b IN : display speed type
6903 /// @param eSpeed \b IN : multiple
6904 /// @return VDEC_Result
6905 //------------------------------------------------------------------------------
MApi_VDEC_SetSpeed(VDEC_SpeedType eSpeedType,VDEC_DispSpeed eSpeed)6906 VDEC_Result MApi_VDEC_SetSpeed(VDEC_SpeedType eSpeedType, VDEC_DispSpeed eSpeed)
6907 {
6908 if (pu32VDEC_Inst == NULL)
6909 {
6910 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6911 return E_VDEC_FAIL;
6912 }
6913
6914
6915 VDEC_V2_IO_Param IO_arg;
6916 VDEC_Result eRet = E_VDEC_FAIL;
6917
6918 IO_arg.param[0]= (void *)&eSpeedType;
6919 IO_arg.param[1] = (void *)&eSpeed;
6920 IO_arg.pRet = (void *)&eRet;
6921
6922 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_SPEED, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
6923 {
6924 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
6925 return E_VDEC_FAIL;
6926 }
6927 else
6928 {
6929 return eRet;
6930 }
6931 }
6932
6933
6934
6935 //------------------------------------------------------------------------------
6936 /// Set up display speed
6937 /// @param eSpeedType \b IN : display speed type
6938 /// @param eSpeed \b IN : multiple
6939 /// @return VDEC_Result
6940 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetSpeed(VDEC_SpeedType eSpeedType,VDEC_DispSpeed eSpeed)6941 VDEC_Result MApi_VDEC_V2_SetSpeed(VDEC_SpeedType eSpeedType, VDEC_DispSpeed eSpeed)
6942 {
6943 if (!_Attr.bInit)
6944 {
6945 return E_VDEC_RET_NOT_INIT;
6946 }
6947
6948 switch (_Attr.eDecoder)
6949 {
6950 case E_VDEC_DECODER_MVD:
6951 {
6952 MS_U8 u8MvdSpeed = _VDEC_Map2MVDSpeed(eSpeed);
6953
6954 if (u8MvdSpeed == 0)
6955 {
6956 return E_VDEC_RET_INVALID_PARAM;
6957 }
6958
6959 if (E_VDEC_SPEED_FAST == eSpeedType)
6960 {
6961 _MVD_RET_HANDLE(MDrv_MVD_SetSpeed(E_MVD_SPEED_FAST, u8MvdSpeed));
6962 }
6963 else if (E_VDEC_SPEED_SLOW == eSpeedType)
6964 {
6965 _MVD_RET_HANDLE(MDrv_MVD_SetSpeed(E_MVD_SPEED_SLOW, u8MvdSpeed));
6966 }
6967 else
6968 {
6969 MS_ASSERT(u8MvdSpeed == 1);
6970 _MVD_RET_HANDLE(MDrv_MVD_SetSpeed(E_MVD_SPEED_DEFAULT, 1));
6971 }
6972
6973 break;
6974 }
6975 case E_VDEC_DECODER_HVD:
6976 {
6977 MS_U8 u8Speed = _VDEC_Map2HVDSpeed(eSpeed);
6978
6979 if (E_VDEC_SPEED_FAST == eSpeedType)
6980 {
6981 switch (eSpeed)
6982 {
6983 case E_VDEC_DISP_SPEED_32X:
6984 {
6985 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_FF_32X));
6986
6987 break;
6988 }
6989 case E_VDEC_DISP_SPEED_16X:
6990 {
6991 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_FF_16X));
6992
6993 break;
6994 }
6995 case E_VDEC_DISP_SPEED_8X:
6996 {
6997 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_FF_8X));
6998
6999 break;
7000 }
7001 case E_VDEC_DISP_SPEED_4X:
7002 {
7003 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_FF_4X));
7004
7005 break;
7006 }
7007 case E_VDEC_DISP_SPEED_2X:
7008 {
7009 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_FF_2X));
7010
7011 break;
7012 }
7013 case E_VDEC_DISP_SPEED_1X:
7014 {
7015 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_NORMAL_1X));
7016
7017 break;
7018 }
7019 default:
7020 {
7021 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed((HVD_Drv_Disp_Speed) u8Speed));
7022
7023 break;
7024 }
7025 }
7026 }
7027 else if (E_VDEC_SPEED_SLOW == eSpeedType)
7028 {
7029 switch (eSpeed)
7030 {
7031 case E_VDEC_DISP_SPEED_32X:
7032 {
7033 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_SF_32X));
7034
7035 break;
7036 }
7037 case E_VDEC_DISP_SPEED_16X:
7038 {
7039 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_SF_16X));
7040
7041 break;
7042 }
7043 case E_VDEC_DISP_SPEED_8X:
7044 {
7045 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_SF_8X));
7046
7047 break;
7048 }
7049 case E_VDEC_DISP_SPEED_4X:
7050 {
7051 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_SF_4X));
7052
7053 break;
7054 }
7055 case E_VDEC_DISP_SPEED_2X:
7056 {
7057 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_SF_2X));
7058
7059 break;
7060 }
7061 default:
7062 {
7063 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed((HVD_Drv_Disp_Speed) -u8Speed));
7064
7065 break;
7066 }
7067 }
7068 }
7069 else
7070 {
7071 _HVD_RET_HANDLE(MDrv_HVD_SetDispSpeed(E_HVD_DISP_SPEED_NORMAL_1X));
7072 }
7073
7074 break;
7075 }
7076 case E_VDEC_DECODER_MJPEG:
7077 {
7078 _MJPEG_RET_HANDLE(MApi_MJPEG_SetSpeed((MJPEG_SpeedType) eSpeedType, (MJPEG_DispSpeed) eSpeed));
7079
7080 break;
7081 }
7082 case E_VDEC_DECODER_RVD:
7083 {
7084 if (E_VDEC_SPEED_FAST == eSpeedType)
7085 {
7086 switch (eSpeed)
7087 {
7088 case E_VDEC_DISP_SPEED_32X:
7089 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_FF_32X));
7090
7091 break;
7092
7093 case E_VDEC_DISP_SPEED_16X:
7094 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_FF_16X));
7095
7096 break;
7097
7098 case E_VDEC_DISP_SPEED_8X:
7099 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_FF_8X));
7100
7101 break;
7102
7103 case E_VDEC_DISP_SPEED_4X:
7104 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_FF_4X));
7105
7106 break;
7107
7108 case E_VDEC_DISP_SPEED_2X:
7109 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_FF_2X));
7110
7111 break;
7112
7113 case E_VDEC_DISP_SPEED_1X:
7114 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_NORMAL_1X));
7115
7116 break;
7117
7118 default:
7119 break;
7120 }
7121 }
7122 else if (E_VDEC_SPEED_SLOW == eSpeedType)
7123 {
7124 switch (eSpeed)
7125 {
7126 case E_VDEC_DISP_SPEED_32X:
7127 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_SF_32X));
7128
7129 break;
7130
7131 case E_VDEC_DISP_SPEED_16X:
7132 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_SF_16X));
7133
7134 break;
7135
7136 case E_VDEC_DISP_SPEED_8X:
7137 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_SF_8X));
7138
7139 break;
7140
7141 case E_VDEC_DISP_SPEED_4X:
7142 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_SF_4X));
7143
7144 break;
7145
7146 case E_VDEC_DISP_SPEED_2X:
7147 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_SF_2X));
7148
7149 break;
7150
7151 default:
7152 break;
7153 }
7154 }
7155 else
7156 {
7157 _RVD_RET_HANDLE(MDrv_RVD_SetSpeed(E_RVD_DISP_SPEED_NORMAL_1X));
7158 }
7159
7160 break;
7161 }
7162 default:
7163 break;
7164 }
7165
7166 return E_VDEC_OK;
7167 }
7168
7169 //------------------------------------------------------------------------------
7170 /// Check if the first frame is showed after play function is called
7171 /// @return VDEC_Result
7172 /// - E_VDEC_OK: ready
7173 /// - E_VDEC_FAIL: not ready
7174 /// - E_VDEC_RET_NOT_INIT: not initial yet
7175 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
7176 //------------------------------------------------------------------------------
MApi_VDEC_IsFrameRdy(void)7177 VDEC_Result MApi_VDEC_IsFrameRdy(void)
7178 {
7179 if (pu32VDEC_Inst == NULL)
7180 {
7181 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7182 return E_VDEC_FAIL;
7183 }
7184
7185 VDEC_V2_IO_Param IO_arg;
7186 VDEC_Result eRet = E_VDEC_FAIL;
7187
7188 IO_arg.pRet = (void *)&eRet;
7189
7190
7191 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_FRAME_RDY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7192 {
7193 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7194 return E_VDEC_FAIL;
7195 }
7196 else
7197 {
7198 return eRet;
7199 }
7200 }
7201
7202 //------------------------------------------------------------------------------
7203 /// Check if the first frame is showed after play function is called
7204 /// @return VDEC_Result
7205 /// - E_VDEC_OK: ready
7206 /// - E_VDEC_FAIL: not ready
7207 /// - E_VDEC_RET_NOT_INIT: not initial yet
7208 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
7209 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsFrameRdy(void)7210 VDEC_Result MApi_VDEC_V2_IsFrameRdy(void)
7211 {
7212 VDEC_Result ret = E_VDEC_FAIL;
7213
7214 if (!_Attr.bInit)
7215 {
7216 return E_VDEC_RET_NOT_INIT;
7217 }
7218
7219 switch (_Attr.eDecoder)
7220 {
7221 case E_VDEC_DECODER_MVD:
7222 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_Is1stFrmRdy());
7223 break;
7224
7225 case E_VDEC_DECODER_HVD:
7226 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_Is1stFrmRdy());
7227 break;
7228 case E_VDEC_DECODER_MJPEG:
7229 ret = E_VDEC_OK;
7230 break;
7231
7232 case E_VDEC_DECODER_RVD:
7233 _BOOL_TO_VDEC_RESULT(ret, MDrv_RVD_Is1stFrameRdy());
7234 break;
7235
7236 default:
7237 ret = E_VDEC_RET_UNSUPPORTED;
7238 break;
7239 }
7240
7241 return ret;
7242 }
7243
7244 //------------------------------------------------------------------------------
7245 /// Let FW stop updating frames when vsync, but decoding process is still going.
7246 /// @param bEnable \b IN : Enable/Disable
7247 /// @return -The result of command freeze image.
7248 //------------------------------------------------------------------------------
MApi_VDEC_SetFreezeDisp(MS_BOOL bEnable)7249 VDEC_Result MApi_VDEC_SetFreezeDisp(MS_BOOL bEnable)
7250 {
7251
7252 if (pu32VDEC_Inst == NULL)
7253 {
7254 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7255 return E_VDEC_FAIL;
7256 }
7257
7258 VDEC_V2_IO_Param IO_arg;
7259 VDEC_Result eRet = E_VDEC_FAIL;
7260
7261 IO_arg.param[0] = (void *)&bEnable;
7262 IO_arg.pRet = (void *)&eRet;
7263
7264
7265 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_FREEZE_DISP, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7266 {
7267 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7268 return E_VDEC_FAIL;
7269 }
7270 else
7271 {
7272 return eRet;
7273 }
7274
7275
7276 }
7277
7278
7279 //------------------------------------------------------------------------------
7280 /// Let FW stop updating frames when vsync, but decoding process is still going.
7281 /// @param bEnable \b IN : Enable/Disable
7282 /// @return -The result of command freeze image.
7283 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetFreezeDisp(MS_BOOL bEnable)7284 VDEC_Result MApi_VDEC_V2_SetFreezeDisp(MS_BOOL bEnable)
7285 {
7286 if (!_Attr.bInit)
7287 {
7288 return E_VDEC_RET_NOT_INIT;
7289 }
7290
7291 switch (_Attr.eDecoder)
7292 {
7293 case E_VDEC_DECODER_MVD:
7294 _MVD_RET_HANDLE(MDrv_MVD_SetFreezeDisp(bEnable));
7295 break;
7296
7297 case E_VDEC_DECODER_HVD:
7298 {
7299 _HVD_RET_HANDLE(MDrv_HVD_SetFreezeImg(bEnable));
7300
7301 break;
7302 }
7303 case E_VDEC_DECODER_MJPEG:
7304 {
7305 _MJPEG_RET_HANDLE(MApi_MJPEG_SetFreezeDisp(bEnable));
7306
7307 break;
7308 }
7309 case E_VDEC_DECODER_RVD:
7310 {
7311 _RVD_RET_HANDLE(MDrv_RVD_SetFreezeImg(bEnable));
7312
7313 break;
7314 }
7315 default:
7316 break;
7317 }
7318
7319 return E_VDEC_OK;
7320 }
7321
7322 //------------------------------------------------------------------------------
7323 /// Set blue screen on/off
7324 /// @param bOn \b IN : turn on / off blue screen
7325 /// @return VDEC_Result
7326 //------------------------------------------------------------------------------
MApi_VDEC_SetBlueScreen(MS_BOOL bOn)7327 VDEC_Result MApi_VDEC_SetBlueScreen(MS_BOOL bOn)
7328 {
7329 if (pu32VDEC_Inst == NULL)
7330 {
7331 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7332 return E_VDEC_FAIL;
7333 }
7334
7335 VDEC_V2_IO_Param IO_arg;
7336 VDEC_Result eRet = E_VDEC_FAIL;
7337
7338 IO_arg.param[0] = (void *)&bOn;
7339 IO_arg.pRet = (void *)&eRet;
7340
7341
7342 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_BLUE_SCREEN, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7343 {
7344 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7345 return E_VDEC_FAIL;
7346 }
7347 else
7348 {
7349 return eRet;
7350 }
7351 }
7352
7353
7354 //------------------------------------------------------------------------------
7355 /// Set blue screen on/off
7356 /// @param bOn \b IN : turn on / off blue screen
7357 /// @return VDEC_Result
7358 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetBlueScreen(MS_BOOL bOn)7359 VDEC_Result MApi_VDEC_V2_SetBlueScreen(MS_BOOL bOn)
7360 {
7361 VDEC_Result rst = E_VDEC_OK;
7362
7363 if (!_Attr.bInit)
7364 {
7365 return E_VDEC_RET_NOT_INIT;
7366 }
7367
7368 switch (_Attr.eDecoder)
7369 {
7370 case E_VDEC_DECODER_MVD:
7371 _BOOL_TO_VDEC_RESULT(rst, MDrv_MVD_SetBlueScreen(bOn));
7372 break;
7373
7374 case E_VDEC_DECODER_HVD:
7375 {
7376 _HVD_RET_HANDLE(MDrv_HVD_SetBlueScreen(bOn));
7377
7378 break;
7379 }
7380 case E_VDEC_DECODER_MJPEG:
7381 {
7382 _MJPEG_RET_HANDLE(MApi_MJPEG_SetBlueScreen(bOn));
7383
7384 break;
7385 }
7386 case E_VDEC_DECODER_RVD:
7387 {
7388 _RVD_RET_HANDLE(MDrv_RVD_SetBlueScreen(bOn));
7389
7390 break;
7391 }
7392 default:
7393 break;
7394 }
7395
7396 return rst;
7397 }
7398
7399 //------------------------------------------------------------------------------
7400 /// Reset PTS
7401 /// @param u32PtsBase \b IN : new PTS base value
7402 /// @return VDEC_Result
7403 //------------------------------------------------------------------------------
MApi_VDEC_ResetPTS(MS_U32 u32PtsBase)7404 VDEC_Result MApi_VDEC_ResetPTS(MS_U32 u32PtsBase)
7405 {
7406 if (pu32VDEC_Inst == NULL)
7407 {
7408 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7409 return E_VDEC_FAIL;
7410 }
7411
7412 VDEC_V2_IO_Param IO_arg;
7413 VDEC_Result eRet = E_VDEC_FAIL;
7414
7415 IO_arg.param[0] = (void *)&u32PtsBase;
7416 IO_arg.pRet = (void *)&eRet;
7417
7418
7419 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_RESET_PTS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7420 {
7421 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7422 return E_VDEC_FAIL;
7423 }
7424 else
7425 {
7426 return eRet;
7427 }
7428 }
7429
7430
7431 //------------------------------------------------------------------------------
7432 /// Reset PTS
7433 /// @param u32PtsBase \b IN : new PTS base value
7434 /// @return VDEC_Result
7435 //------------------------------------------------------------------------------
MApi_VDEC_V2_ResetPTS(MS_U32 u32PtsBase)7436 VDEC_Result MApi_VDEC_V2_ResetPTS(MS_U32 u32PtsBase)
7437 {
7438 if (!_Attr.bInit)
7439 {
7440 return E_VDEC_RET_NOT_INIT;
7441 }
7442
7443 switch (_Attr.eDecoder)
7444 {
7445 case E_VDEC_DECODER_MVD:
7446 {
7447 _MVD_RET_HANDLE(MDrv_MVD_ResetPTS(u32PtsBase));
7448
7449 break;
7450 }
7451 case E_VDEC_DECODER_HVD:
7452 {
7453 _HVD_RET_HANDLE(MDrv_HVD_RstPTS(u32PtsBase));
7454
7455 break;
7456 }
7457 case E_VDEC_DECODER_MJPEG:
7458 {
7459 _MJPEG_RET_HANDLE(MApi_MJPEG_ResetPTS(u32PtsBase));
7460
7461 break;
7462 }
7463 case E_VDEC_DECODER_RVD:
7464 break;
7465
7466 default:
7467 break;
7468 }
7469
7470 return E_VDEC_OK;
7471 }
7472
7473
7474 //------------------------------------------------------------------------------
7475 /// Switch AV sync on/off
7476 /// @param bOn \b IN : on/off
7477 /// @param u32SyncDelay \b IN : delay value
7478 /// @param u16SyncTolerance \b IN : tolerance value
7479 /// @return VDEC_Result
7480 //------------------------------------------------------------------------------
MApi_VDEC_AVSyncOn(MS_BOOL bOn,MS_U32 u32SyncDelay,MS_U16 u16SyncTolerance)7481 VDEC_Result MApi_VDEC_AVSyncOn(MS_BOOL bOn, MS_U32 u32SyncDelay, MS_U16 u16SyncTolerance)
7482 {
7483 if (pu32VDEC_Inst == NULL)
7484 {
7485 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7486 return E_VDEC_FAIL;
7487 }
7488
7489 VDEC_V2_IO_Param IO_arg;
7490 VDEC_Result eRet = E_VDEC_FAIL;
7491
7492 IO_arg.param[0] = (void *)&bOn;
7493 IO_arg.param[1] = (void *)&u32SyncDelay;
7494 IO_arg.param[2] = (void *)&u16SyncTolerance;
7495 IO_arg.pRet = (void *)&eRet;
7496
7497
7498 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_AVSYNC_ON, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7499 {
7500 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7501 return E_VDEC_FAIL;
7502 }
7503 else
7504 {
7505 return eRet;
7506 }
7507 }
7508
7509
7510 //------------------------------------------------------------------------------
7511 /// Switch AV sync on/off
7512 /// @param bOn \b IN : on/off
7513 /// @param u32SyncDelay \b IN : delay value
7514 /// @param u16SyncTolerance \b IN : tolerance value
7515 /// @return VDEC_Result
7516 //------------------------------------------------------------------------------
MApi_VDEC_V2_AVSyncOn(MS_BOOL bOn,MS_U32 u32SyncDelay,MS_U16 u16SyncTolerance)7517 VDEC_Result MApi_VDEC_V2_AVSyncOn(MS_BOOL bOn, MS_U32 u32SyncDelay, MS_U16 u16SyncTolerance)
7518 {
7519 if (!_Attr.bInit)
7520 {
7521 return E_VDEC_RET_NOT_INIT;
7522 }
7523
7524 switch (_Attr.eDecoder)
7525 {
7526 case E_VDEC_DECODER_MVD:
7527 {
7528 MDrv_MVD_SetAVSync(bOn, u32SyncDelay);
7529
7530 if ((u16SyncTolerance!=0) && (FALSE == MDrv_MVD_ChangeAVsync(bOn, u16SyncTolerance)))
7531 {
7532 return E_VDEC_FAIL;
7533 }
7534
7535 break;
7536 }
7537 case E_VDEC_DECODER_HVD:
7538 {
7539 if (bOn)
7540 {
7541 _HVD_RET_HANDLE(MDrv_HVD_SetSyncActive(TRUE));
7542 }
7543 else
7544 {
7545 _HVD_RET_HANDLE(MDrv_HVD_SetSyncActive(FALSE));
7546 }
7547
7548 if (bOn)
7549 {
7550 _HVD_RET_HANDLE(MDrv_HVD_SetSyncVideoDelay(u32SyncDelay));
7551 }
7552
7553 if (bOn)
7554 {
7555 _HVD_RET_HANDLE(MDrv_HVD_SetSyncTolerance(u16SyncTolerance));
7556 }
7557
7558 break;
7559 }
7560 case E_VDEC_DECODER_MJPEG:
7561 _MJPEG_RET_HANDLE(MApi_MJPEG_AVSyncOn(bOn, u32SyncDelay, u16SyncTolerance));
7562
7563 break;
7564
7565 case E_VDEC_DECODER_RVD:
7566 _RVD_RET_HANDLE(MDrv_RVD_AVSyncOn(bOn, u32SyncDelay, u16SyncTolerance));
7567
7568 break;
7569
7570 default:
7571 break;
7572 }
7573
7574 return E_VDEC_OK;
7575 }
7576
7577 //------------------------------------------------------------------------------
7578 /// Switch AV sync free run threshold
7579 /// @param u32Threshold \b IN : threshold value
7580 /// @return VDEC_Result
7581 //------------------------------------------------------------------------------
MApi_VDEC_SetAVSyncFreerunThreshold(MS_U32 u32Threshold)7582 VDEC_Result MApi_VDEC_SetAVSyncFreerunThreshold(MS_U32 u32Threshold )
7583 {
7584 if (pu32VDEC_Inst == NULL)
7585 {
7586 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7587 return E_VDEC_FAIL;
7588 }
7589
7590 VDEC_V2_IO_Param IO_arg;
7591 VDEC_Result eRet = E_VDEC_FAIL;
7592
7593 IO_arg.param[0] = (void *)&u32Threshold;
7594 IO_arg.pRet = (void *)&eRet;
7595
7596
7597 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_AVSYNC_FREERUN_THRESHOLD, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7598 {
7599 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7600 return E_VDEC_FAIL;
7601 }
7602 else
7603 {
7604 return eRet;
7605 }
7606 }
7607
7608 //------------------------------------------------------------------------------
7609 /// Switch AV sync free run threshold
7610 /// @param u32Threshold \b IN : threshold value
7611 /// @return VDEC_Result
7612 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetAVSyncFreerunThreshold(MS_U32 u32Threshold)7613 VDEC_Result MApi_VDEC_V2_SetAVSyncFreerunThreshold(MS_U32 u32Threshold )
7614 {
7615 VDEC_Result ret=E_VDEC_OK;
7616
7617 if (!_Attr.bInit)
7618 {
7619 return E_VDEC_RET_NOT_INIT;
7620 }
7621
7622 switch (_Attr.eDecoder)
7623 {
7624 case E_VDEC_DECODER_MVD:
7625 {
7626 MDrv_MVD_SetAVSyncFreerunThreshold( u32Threshold );
7627 break;
7628 }
7629 case E_VDEC_DECODER_HVD:
7630 {
7631 _HVD_RET_HANDLE( MDrv_HVD_SetSyncFreeRunTH( u32Threshold ) );
7632 break;
7633 }
7634 case E_VDEC_DECODER_MJPEG:
7635 break;
7636
7637 case E_VDEC_DECODER_RVD:
7638 _RVD_RET_HANDLE(MDrv_RVD_SetAVSyncFreerunThreshold(u32Threshold));
7639 break;
7640
7641 default:
7642 ret=E_VDEC_FAIL;
7643 break;
7644 }
7645
7646 return ret;
7647 }
7648
7649
7650
7651 //------------------------------------------------------------------------------
7652 /// Check if AV sync on or not
7653 /// @return VDEC_Result
7654 /// - E_VDEC_OK: AV sync on
7655 /// - E_VDEC_FAIL: freerun
7656 /// - E_VDEC_RET_NOT_INIT: not initial yet
7657 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
7658 //------------------------------------------------------------------------------
MApi_VDEC_IsAVSyncOn(void)7659 VDEC_Result MApi_VDEC_IsAVSyncOn(void)
7660 {
7661
7662 if (pu32VDEC_Inst == NULL)
7663 {
7664 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7665 return E_VDEC_FAIL;
7666 }
7667
7668 VDEC_V2_IO_Param IO_arg;
7669 VDEC_Result eRet = E_VDEC_FAIL;
7670
7671 IO_arg.pRet = (void *)&eRet;
7672
7673
7674 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_AVSYNC_ON, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7675 {
7676 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7677 return E_VDEC_FAIL;
7678 }
7679 else
7680 {
7681 return eRet;
7682 }
7683 }
7684
7685 //------------------------------------------------------------------------------
7686 /// Check if AV sync on or not
7687 /// @return VDEC_Result
7688 /// - E_VDEC_OK: AV sync on
7689 /// - E_VDEC_FAIL: freerun
7690 /// - E_VDEC_RET_NOT_INIT: not initial yet
7691 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
7692 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsAVSyncOn(void)7693 VDEC_Result MApi_VDEC_V2_IsAVSyncOn(void)
7694 {
7695 VDEC_Result ret;
7696
7697 if (!_Attr.bInit)
7698 {
7699 return E_VDEC_RET_NOT_INIT;
7700 }
7701
7702 switch (_Attr.eDecoder)
7703 {
7704 case E_VDEC_DECODER_MVD:
7705 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_GetIsAVSyncOn());
7706 break;
7707
7708 case E_VDEC_DECODER_HVD:
7709 _BOOL_TO_VDEC_RESULT(ret, (MS_BOOL) MDrv_HVD_GetPlayMode(E_HVD_GMODE_IS_SYNC_ON));
7710 break;
7711
7712 case E_VDEC_DECODER_MJPEG:
7713 _BOOL_TO_VDEC_RESULT(ret, MApi_MJPEG_IsAVSyncOn());
7714 break;
7715
7716 case E_VDEC_DECODER_RVD:
7717 _BOOL_TO_VDEC_RESULT(ret, MDrv_RVD_IsAVSyncOn());
7718 break;
7719
7720 default:
7721 ret = E_VDEC_RET_UNSUPPORTED;
7722 break;
7723 }
7724
7725 return ret;
7726 }
7727
7728 //------------------------------------------------------------------------------
7729 /// Get the PTS of current displayed frame
7730 /// @return PTS
7731 //------------------------------------------------------------------------------
MApi_VDEC_GetPTS(void)7732 MS_U32 MApi_VDEC_GetPTS(void)
7733 {
7734
7735 if (pu32VDEC_Inst == NULL)
7736 {
7737 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7738 return E_VDEC_FAIL;
7739 }
7740
7741 VDEC_V2_IO_Param IO_arg;
7742 MS_U32 u32Pts = 0;
7743
7744 IO_arg.pRet = (void *)&u32Pts;
7745
7746
7747 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_PTS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7748 {
7749 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7750 return 0;
7751 }
7752 else
7753 {
7754 return u32Pts;
7755 }
7756
7757
7758 }
7759
7760
7761
7762
7763 //------------------------------------------------------------------------------
7764 /// Get the PTS of current displayed frame
7765 /// @return PTS
7766 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetPTS(void)7767 MS_U32 MApi_VDEC_V2_GetPTS(void)
7768 {
7769 MS_U32 u32Pts = 0;
7770
7771 if (!_Attr.bInit)
7772 {
7773 return 0;
7774 }
7775
7776 switch (_Attr.eDecoder)
7777 {
7778 case E_VDEC_DECODER_MVD:
7779 u32Pts = MDrv_MVD_GetPTS()+MDrv_MVD_GetAVSyncDelay();
7780
7781 break;
7782
7783 case E_VDEC_DECODER_HVD:
7784 u32Pts = MDrv_HVD_GetPTS();
7785
7786 break;
7787
7788 case E_VDEC_DECODER_MJPEG:
7789 u32Pts = MApi_MJPEG_GetPTS();
7790
7791 break;
7792
7793 case E_VDEC_DECODER_RVD:
7794 u32Pts = MDrv_RVD_GetTimeStamp();
7795
7796 break;
7797
7798 default:
7799 u32Pts = 0;
7800 break;
7801 }
7802
7803 return u32Pts;
7804 }
7805
7806
7807 //------------------------------------------------------------------------------
7808 /// Get the PTS of next displayed frame
7809 /// @return next PTS (unit:ms)
7810 //------------------------------------------------------------------------------
MApi_VDEC_GetNextPTS(void)7811 MS_U32 MApi_VDEC_GetNextPTS(void)
7812 {
7813
7814 if (pu32VDEC_Inst == NULL)
7815 {
7816 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7817 return E_VDEC_FAIL;
7818 }
7819
7820 VDEC_V2_IO_Param IO_arg;
7821 MS_U32 u32Pts = 0;
7822
7823 IO_arg.pRet = (void *)&u32Pts;
7824
7825
7826 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_NEXT_PTS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7827 {
7828 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7829 return 0;
7830 }
7831 else
7832 {
7833 return u32Pts;
7834 }
7835 }
7836
7837
7838 //------------------------------------------------------------------------------
7839 /// Get the PTS of next displayed frame
7840 /// @return next PTS (unit:ms)
7841 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetNextPTS(void)7842 MS_U32 MApi_VDEC_V2_GetNextPTS(void)
7843 {
7844 MS_U32 u32Pts = 0;
7845
7846 if (!_Attr.bInit)
7847 {
7848 return 0;
7849 }
7850
7851 switch (_Attr.eDecoder)
7852 {
7853 case E_VDEC_DECODER_MVD:
7854 u32Pts = MDrv_MVD_GetNextPTS();
7855 break;
7856
7857 case E_VDEC_DECODER_HVD:
7858 u32Pts = MDrv_HVD_GetNextPTS();
7859 break;
7860
7861 case E_VDEC_DECODER_MJPEG:
7862 u32Pts = 0;
7863 break;
7864
7865 case E_VDEC_DECODER_RVD:
7866 u32Pts = 0;
7867 break;
7868
7869 default:
7870 u32Pts = 0;
7871 break;
7872 }
7873
7874 return u32Pts;
7875 }
7876
7877 //------------------------------------------------------------------------------
7878 /// Check if decoder is doing AV sync now
7879 /// @return VDEC_Result
7880 /// - E_VDEC_OK: doing AV sync
7881 /// - E_VDEC_FAIL: still freerun
7882 /// - E_VDEC_RET_NOT_INIT: not initial yet
7883 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
7884 //------------------------------------------------------------------------------
MApi_VDEC_IsStartSync(void)7885 VDEC_Result MApi_VDEC_IsStartSync(void)
7886 {
7887
7888 if (pu32VDEC_Inst == NULL)
7889 {
7890 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7891 return E_VDEC_FAIL;
7892 }
7893
7894 VDEC_V2_IO_Param IO_arg;
7895 VDEC_Result eRet = E_VDEC_FAIL;
7896
7897 IO_arg.pRet = (void *)&eRet;
7898
7899
7900 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_START_SYNC, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7901 {
7902 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7903 return E_VDEC_FAIL;
7904 }
7905 else
7906 {
7907 return eRet;
7908 }
7909
7910 }
7911
7912
7913 //------------------------------------------------------------------------------
7914 /// Check if decoder is doing AV sync now
7915 /// @return VDEC_Result
7916 /// - E_VDEC_OK: doing AV sync
7917 /// - E_VDEC_FAIL: still freerun
7918 /// - E_VDEC_RET_NOT_INIT: not initial yet
7919 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
7920 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsStartSync(void)7921 VDEC_Result MApi_VDEC_V2_IsStartSync(void)
7922 {
7923 VDEC_Result ret;
7924
7925 if (!_Attr.bInit)
7926 {
7927 return E_VDEC_RET_NOT_INIT;
7928 }
7929
7930 switch (_Attr.eDecoder)
7931 {
7932 case E_VDEC_DECODER_MVD:
7933 if(MDrv_MVD_GetIsSyncSkip() || MDrv_MVD_GetIsSyncRep())
7934 {
7935 ret = E_VDEC_OK;
7936 }
7937 else
7938 {
7939 ret = E_VDEC_FAIL;
7940 }
7941 break;
7942
7943 case E_VDEC_DECODER_HVD:
7944 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsSyncStart());
7945 break;
7946
7947 case E_VDEC_DECODER_MJPEG:
7948 ret = E_VDEC_RET_UNSUPPORTED;
7949 break;
7950
7951 case E_VDEC_DECODER_RVD:
7952 ret = E_VDEC_RET_UNSUPPORTED;
7953 break;
7954
7955 default:
7956 ret = E_VDEC_RET_UNSUPPORTED;
7957 break;
7958 }
7959
7960 return ret;
7961 }
7962
7963 //------------------------------------------------------------------------------
7964 /// Check if the distance of Video time stamp and STC is closed enough.
7965 /// @return VDEC_Result
7966 /// - E_VDEC_OK: sync complete
7967 /// - E_VDEC_FAIL: sync is incomplete
7968 /// - E_VDEC_RET_NOT_INIT: not initial yet
7969 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
7970 //------------------------------------------------------------------------------
MApi_VDEC_IsReachSync(void)7971 VDEC_Result MApi_VDEC_IsReachSync(void)
7972 {
7973
7974 if (pu32VDEC_Inst == NULL)
7975 {
7976 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7977 return E_VDEC_FAIL;
7978 }
7979
7980 VDEC_V2_IO_Param IO_arg;
7981 VDEC_Result eRet = E_VDEC_FAIL;
7982
7983 IO_arg.pRet = (void *)&eRet;
7984
7985
7986 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_REACH_SYNC, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
7987 {
7988 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
7989 return E_VDEC_FAIL;
7990 }
7991 else
7992 {
7993 return eRet;
7994 }
7995
7996 }
7997
7998
7999 //------------------------------------------------------------------------------
8000 /// Check if the distance of Video time stamp and STC is closed enough.
8001 /// @return VDEC_Result
8002 /// - E_VDEC_OK: sync complete
8003 /// - E_VDEC_FAIL: sync is incomplete
8004 /// - E_VDEC_RET_NOT_INIT: not initial yet
8005 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
8006 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsReachSync(void)8007 VDEC_Result MApi_VDEC_V2_IsReachSync(void)
8008 {
8009 VDEC_Result ret;
8010
8011 if (!_Attr.bInit)
8012 {
8013 return E_VDEC_RET_NOT_INIT;
8014 }
8015
8016 switch (_Attr.eDecoder)
8017 {
8018 case E_VDEC_DECODER_MVD:
8019 _BOOL_TO_VDEC_RESULT(ret, (MS_BOOL) (MDrv_MVD_GetSyncStatus()==1));
8020 break;
8021
8022 case E_VDEC_DECODER_HVD:
8023 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsSyncReach());
8024 break;
8025
8026 case E_VDEC_DECODER_MJPEG:
8027 _BOOL_TO_VDEC_RESULT(ret, MApi_MJPEG_IsReachSync());
8028 break;
8029
8030 case E_VDEC_DECODER_RVD:
8031 default:
8032 ret = E_VDEC_RET_UNSUPPORTED;
8033 break;
8034 }
8035
8036 return ret;
8037 }
8038
8039
8040 //------------------------------------------------------------------------------
8041 /// Check if decoder is avsync freerun
8042 /// @return VDEC_Result
8043 /// - E_VDEC_OK: freerun
8044 /// - E_VDEC_FAIL: not freerun
8045 /// - E_VDEC_RET_NOT_INIT: not initial yet
8046 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
8047 //------------------------------------------------------------------------------
MApi_VDEC_IsFreerun(void)8048 VDEC_Result MApi_VDEC_IsFreerun(void)
8049 {
8050
8051 if (pu32VDEC_Inst == NULL)
8052 {
8053 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8054 return E_VDEC_FAIL;
8055 }
8056
8057 VDEC_V2_IO_Param IO_arg;
8058 VDEC_Result eRet = E_VDEC_FAIL;
8059
8060 IO_arg.pRet = (void *)&eRet;
8061
8062
8063 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_FREERUN, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8064 {
8065 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8066 return E_VDEC_FAIL;
8067 }
8068 else
8069 {
8070 return eRet;
8071 }
8072
8073
8074 }
8075
8076
8077 //------------------------------------------------------------------------------
8078 /// Check if decoder is avsync freerun
8079 /// @return VDEC_Result
8080 /// - E_VDEC_OK: freerun
8081 /// - E_VDEC_FAIL: not freerun
8082 /// - E_VDEC_RET_NOT_INIT: not initial yet
8083 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
8084 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsFreerun(void)8085 VDEC_Result MApi_VDEC_V2_IsFreerun(void)
8086 {
8087 VDEC_Result ret = E_VDEC_OK;
8088
8089 if (!_Attr.bInit)
8090 {
8091 return E_VDEC_RET_NOT_INIT;
8092 }
8093
8094 switch (_Attr.eDecoder)
8095 {
8096 case E_VDEC_DECODER_MVD:
8097 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_GetIsFreerun());
8098 break;
8099
8100 case E_VDEC_DECODER_HVD:
8101 break;
8102
8103 case E_VDEC_DECODER_MJPEG:
8104 case E_VDEC_DECODER_RVD:
8105 default:
8106 ret = E_VDEC_RET_UNSUPPORTED;
8107 break;
8108 }
8109
8110 return ret;
8111 }
8112
8113 //------------------------------------------------------------------------------
8114 /// For MHEG5 MW, decode one I frame
8115 /// @param u32FrameBufAddr \b IN : output buffer address
8116 /// @param u32SrcSt \b IN : source start address
8117 /// @param u32SrcEnd \b IN : source end address
8118 /// @return VDEC_Result
8119 //------------------------------------------------------------------------------
MApi_VDEC_MHEG_DecodeIFrame(MS_PHYADDR u32FrameBufAddr,MS_PHYADDR u32SrcSt,MS_PHYADDR u32SrcEnd)8120 VDEC_Result MApi_VDEC_MHEG_DecodeIFrame(MS_PHYADDR u32FrameBufAddr,
8121 MS_PHYADDR u32SrcSt,
8122 MS_PHYADDR u32SrcEnd)
8123 {
8124 if (pu32VDEC_Inst == NULL)
8125 {
8126 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8127 return E_VDEC_FAIL;
8128 }
8129
8130 VDEC_V2_IO_Param IO_arg;
8131 VDEC_Result eRet = E_VDEC_FAIL;
8132
8133 IO_arg.param[0] = (void *)(&u32FrameBufAddr);
8134 IO_arg.param[1] = (void *)(&u32SrcSt);
8135 IO_arg.param[2] = (void *)(&u32SrcEnd);
8136 IO_arg.pRet = (void *)&eRet;
8137
8138
8139 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_MHEG_DECODE_I_FRAME, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8140 {
8141 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8142 return E_VDEC_FAIL;
8143 }
8144 else
8145 {
8146 return eRet;
8147 }
8148
8149
8150 }
8151
8152
8153 //------------------------------------------------------------------------------
8154 /// For MHEG5 MW, decode one I frame
8155 /// @param u32FrameBufAddr \b IN : output buffer address
8156 /// @param u32SrcSt \b IN : source start address
8157 /// @param u32SrcEnd \b IN : source end address
8158 /// @return VDEC_Result
8159 //------------------------------------------------------------------------------
MApi_VDEC_V2_MHEG_DecodeIFrame(MS_PHYADDR u32FrameBufAddr,MS_PHYADDR u32SrcSt,MS_PHYADDR u32SrcEnd)8160 VDEC_Result MApi_VDEC_V2_MHEG_DecodeIFrame(MS_PHYADDR u32FrameBufAddr,
8161 MS_PHYADDR u32SrcSt,
8162 MS_PHYADDR u32SrcEnd)
8163 {
8164 VDEC_Result retVal = E_VDEC_OK;;
8165
8166 if (!_Attr.bInit)
8167 {
8168 return E_VDEC_RET_NOT_INIT;
8169 }
8170
8171 switch (_Attr.eDecoder)
8172 {
8173 case E_VDEC_DECODER_MVD:
8174 {
8175 if (MDrv_MVD_DecodeIFrame(u32FrameBufAddr, u32SrcSt, u32SrcEnd))
8176 {
8177 retVal = E_VDEC_OK;
8178 }
8179 else
8180 {
8181 retVal = E_VDEC_FAIL;
8182 }
8183
8184 break;
8185 }
8186 case E_VDEC_DECODER_HVD:
8187 {
8188 if(u32VdecInitParamVersion == 0)
8189 {
8190 if (E_VDEC_SRC_MODE_DTV == _vdecInitParam.VideoInfo.eSrcMode ||
8191 E_VDEC_SRC_MODE_TS_FILE == _vdecInitParam.VideoInfo.eSrcMode)
8192 {
8193 VDEC_InitParam stVdecInitParam;
8194 _VDEC_Memcpy(&stVdecInitParam, &_vdecInitParam, sizeof(VDEC_InitParam));
8195
8196 // change to file mode
8197 stVdecInitParam.VideoInfo.eSrcMode = E_VDEC_SRC_MODE_FILE;
8198
8199 MApi_VDEC_Exit();
8200
8201 // re-init VDEC
8202 MApi_VDEC_Init(&stVdecInitParam);
8203 }
8204 }
8205 else if(u32VdecInitParamVersion == 1)
8206 {
8207 if (E_VDEC_SRC_MODE_DTV == _vdecInitParam_ex1.VideoInfo.eSrcMode ||
8208 E_VDEC_SRC_MODE_TS_FILE == _vdecInitParam_ex1.VideoInfo.eSrcMode)
8209 {
8210 VDEC_InitParam_EX1 stVdecInitParam_ex1;
8211 _VDEC_Memcpy(&stVdecInitParam_ex1, &_vdecInitParam_ex1, sizeof(VDEC_InitParam_EX1));
8212
8213 // change to file mode
8214 stVdecInitParam_ex1.VideoInfo.eSrcMode = E_VDEC_SRC_MODE_FILE;
8215
8216 MApi_VDEC_Exit();
8217
8218 // re-init VDEC
8219 MApi_VDEC_Init_EX((void *)&stVdecInitParam_ex1, sizeof(VDEC_InitParam_EX1));
8220 }
8221 }
8222
8223 if (MDrv_HVD_DecodeIFrame(u32SrcSt, (u32SrcEnd - u32SrcSt)) == E_HVD_OK)
8224 {
8225 retVal = E_VDEC_OK;
8226 }
8227 else
8228 {
8229 retVal = E_VDEC_FAIL;
8230 }
8231 break;
8232 }
8233 case E_VDEC_DECODER_MJPEG:
8234 case E_VDEC_DECODER_RVD:
8235 default:
8236 retVal = E_VDEC_RET_UNSUPPORTED;
8237
8238 break;
8239 }
8240
8241 return retVal;
8242 }
8243
8244
8245 //------------------------------------------------------------------------------
8246 /// For MHEG5 MW, check if I frame decode done
8247 /// @return VDEC_Result
8248 /// - E_VDEC_OK: decode done
8249 /// - E_VDEC_FAIL: not yet
8250 /// - E_VDEC_RET_NOT_INIT: not initial yet
8251 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
8252 //------------------------------------------------------------------------------
MApi_VDEC_MHEG_IsIFrameDecoding(void)8253 VDEC_Result MApi_VDEC_MHEG_IsIFrameDecoding(void)
8254 {
8255
8256
8257 if (pu32VDEC_Inst == NULL)
8258 {
8259 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8260 return E_VDEC_FAIL;
8261 }
8262
8263 VDEC_V2_IO_Param IO_arg;
8264 VDEC_Result eRet = E_VDEC_FAIL;
8265
8266 IO_arg.pRet = (void *)&eRet;
8267
8268
8269 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_MHEG_IS_I_FRAME_DECODING, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8270 {
8271 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8272 return E_VDEC_FAIL;
8273 }
8274 else
8275 {
8276 return eRet;
8277 }
8278 }
8279
8280 //------------------------------------------------------------------------------
8281 /// For MHEG5 MW, check if I frame decode done
8282 /// @return VDEC_Result
8283 /// - E_VDEC_OK: decode done
8284 /// - E_VDEC_FAIL: not yet
8285 /// - E_VDEC_RET_NOT_INIT: not initial yet
8286 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
8287 //------------------------------------------------------------------------------
MApi_VDEC_V2_MHEG_IsIFrameDecoding(void)8288 VDEC_Result MApi_VDEC_V2_MHEG_IsIFrameDecoding(void)
8289 {
8290 VDEC_Result ret;
8291
8292 if (!_Attr.bInit)
8293 {
8294 return E_VDEC_RET_NOT_INIT;
8295 }
8296
8297 switch (_Attr.eDecoder)
8298 {
8299 case E_VDEC_DECODER_MVD:
8300 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_GetIsIFrameDecoding());
8301 break;
8302
8303 case E_VDEC_DECODER_HVD:
8304 case E_VDEC_DECODER_MJPEG:
8305 case E_VDEC_DECODER_RVD:
8306 default:
8307 ret = E_VDEC_RET_UNSUPPORTED;
8308 break;
8309 }
8310
8311 return ret;
8312 }
8313
8314
8315 //------------------------------------------------------------------------------
8316 /// For MHEG5 MW, reset decoder after I frame decode done
8317 /// @return VDEC_Result
8318 //------------------------------------------------------------------------------
MApi_VDEC_MHEG_RstIFrameDec(void)8319 VDEC_Result MApi_VDEC_MHEG_RstIFrameDec(void)
8320 {
8321
8322 if (pu32VDEC_Inst == NULL)
8323 {
8324 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8325 return E_VDEC_FAIL;
8326 }
8327
8328 VDEC_V2_IO_Param IO_arg;
8329 VDEC_Result eRet = E_VDEC_FAIL;
8330
8331 IO_arg.pRet = (void *)&eRet;
8332
8333
8334 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_MHEG_RST_I_FRAME_DEC, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8335 {
8336 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8337 return E_VDEC_FAIL;
8338 }
8339 else
8340 {
8341 return eRet;
8342 }
8343 }
8344
8345
8346 //------------------------------------------------------------------------------
8347 /// For MHEG5 MW, reset decoder after I frame decode done
8348 /// @return VDEC_Result
8349 //------------------------------------------------------------------------------
MApi_VDEC_V2_MHEG_RstIFrameDec(void)8350 VDEC_Result MApi_VDEC_V2_MHEG_RstIFrameDec(void)
8351 {
8352 if (!_Attr.bInit)
8353 {
8354 return E_VDEC_RET_NOT_INIT;
8355 }
8356
8357 switch (_Attr.eDecoder)
8358 {
8359 case E_VDEC_DECODER_MVD:
8360 MDrv_MVD_RstIFrameDec();
8361
8362 break;
8363
8364 case E_VDEC_DECODER_HVD:
8365 case E_VDEC_DECODER_MJPEG:
8366 case E_VDEC_DECODER_RVD:
8367 default:
8368 return E_VDEC_RET_UNSUPPORTED;
8369 }
8370
8371 return E_VDEC_OK;
8372 }
8373
8374 //------------------------------------------------------------------------------
8375 /// Get error code
8376 /// @return error code
8377 //------------------------------------------------------------------------------
MApi_VDEC_GetErrCode(void)8378 MS_U32 MApi_VDEC_GetErrCode(void)
8379 {
8380
8381
8382 if (pu32VDEC_Inst == NULL)
8383 {
8384 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8385 return 0;
8386 }
8387
8388 VDEC_V2_IO_Param IO_arg;
8389 MS_U32 u32Ret = 0;
8390
8391 IO_arg.pRet = (void *)&u32Ret;
8392
8393
8394 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_ERR_CODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8395 {
8396 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8397 return 0;
8398 }
8399 else
8400 {
8401 return u32Ret;
8402 }
8403
8404 }
8405
8406
8407 //------------------------------------------------------------------------------
8408 /// Get error code
8409 /// @return error code
8410 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetErrCode(void)8411 MS_U32 MApi_VDEC_V2_GetErrCode(void)
8412 {
8413 if (!_Attr.bInit)
8414 {
8415 return 0;
8416 }
8417
8418 switch (_Attr.eDecoder)
8419 {
8420 case E_VDEC_DECODER_MVD:
8421 {
8422 MVD_ErrCode errCode=E_MVD_ERR_UNKNOWN;
8423 MVD_ErrStatus errStatus=E_MVD_ERR_STATUS_UNKOWN;
8424
8425 MDrv_MVD_GetErrInfo(&errCode, &errStatus);
8426
8427 _Attr.eErrCode = (VDEC_ErrCode) (errCode + (MS_U32) E_VDEC_MVD_ERR_CODE_BASE);
8428
8429 //Check if framerate is out of HW spec
8430 if ((E_MVD_ERR_UNKNOWN == errCode) && (MApi_VDEC_CheckDispInfoRdy() == E_VDEC_OK))
8431 {
8432 //printf("%s(%d) check MVD FrmRate eErrCode=0x%x\n", __FUNCTION__, __LINE__, _Attr.eErrCode);
8433 // only check when DispInfo is ready
8434 if (FALSE == MDrv_MVD_GetFrmRateIsSupported())
8435 {
8436 _Attr.eErrCode = E_VDEC_ERR_CODE_FRMRATE_NOT_SUPPORT;
8437 //printf("%s(%d) NS!!! eErrCode=0x%x\n", __FUNCTION__, __LINE__, _Attr.eErrCode);
8438 }
8439
8440 if ( (bIsSupportDivxPlus == FALSE) && (MDrv_MVD_GetDivxVer() != 0) )
8441 {
8442 _Attr.eErrCode = E_VDEC_ERR_CODE_DIVX_PLUS_UNSUPPORTED;
8443 }
8444 }
8445 }
8446
8447 break;
8448
8449 case E_VDEC_DECODER_HVD:
8450 {
8451 MS_U32 HVDerrCode=0;
8452 HVDerrCode = MDrv_HVD_GetErrCode();
8453 _Attr.eErrCode = (VDEC_ErrCode) ( HVDerrCode + (MS_U32) E_VDEC_HVD_ERR_CODE_BASE);
8454
8455 //Check if framerate is out of HW spec
8456 if ((HVDerrCode == 0) && (MApi_VDEC_CheckDispInfoRdy() == E_VDEC_OK))
8457 {
8458 //printf("%s(%d) check HVD FrmRate eErrCode=0x%x\n", __FUNCTION__, __LINE__, _Attr.eErrCode);
8459 // only check when DispInfo is ready
8460 if (FALSE == MDrv_HVD_GetFrmRateIsSupported())
8461 {
8462 _Attr.eErrCode = E_VDEC_ERR_CODE_FRMRATE_NOT_SUPPORT;
8463 //printf("%s(%d) NS!!! eErrCode=0x%x\n", __FUNCTION__, __LINE__, _Attr.eErrCode);
8464 }
8465 }
8466 }
8467 break;
8468
8469 case E_VDEC_DECODER_MJPEG:
8470 _Attr.eErrCode = (VDEC_ErrCode) (MApi_MJPEG_GetErrCode() + (MS_U32) E_VDEC_MJPEG_ERR_CODE_BASE);
8471
8472 break;
8473
8474 case E_VDEC_DECODER_RVD:
8475 _Attr.eErrCode = (VDEC_ErrCode) (MDrv_RVD_GetErrCode() + (MS_U32) E_VDEC_RVD_ERR_CODE_BASE);
8476
8477 break;
8478
8479 default:
8480 _Attr.eErrCode=(VDEC_ErrCode)(0);
8481 break;
8482 }
8483 if( ( (MS_U32)(_Attr.eErrCode) & 0x00ffffff) == 0 )
8484 {
8485 _Attr.eErrCode=(VDEC_ErrCode)(0);
8486 }
8487 return _Attr.eErrCode;
8488 }
8489
8490 //------------------------------------------------------------------------------
8491 /// Get accumulated error counter
8492 /// @return error counter
8493 //------------------------------------------------------------------------------
MApi_VDEC_GetErrCnt(void)8494 MS_U32 MApi_VDEC_GetErrCnt(void)
8495 {
8496
8497
8498 if (pu32VDEC_Inst == NULL)
8499 {
8500 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8501 return 0;
8502 }
8503
8504 VDEC_V2_IO_Param IO_arg;
8505 MS_U32 u32Ret = 0;
8506
8507 IO_arg.pRet = (void *)&u32Ret;
8508
8509
8510 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_ERR_CNT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8511 {
8512 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8513 return 0;
8514 }
8515 else
8516 {
8517 return u32Ret;
8518 }
8519
8520
8521 }
8522
8523
8524
8525 //------------------------------------------------------------------------------
8526 /// Get accumulated error counter
8527 /// @return error counter
8528 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetErrCnt(void)8529 MS_U32 MApi_VDEC_V2_GetErrCnt(void)
8530 {
8531 MS_U32 u32Cnt = 0;
8532
8533 if (!_Attr.bInit)
8534 {
8535 return 0;
8536 }
8537
8538 switch (_Attr.eDecoder)
8539 {
8540 case E_VDEC_DECODER_MVD:
8541 u32Cnt = MDrv_MVD_GetVldErrCount();
8542 break;
8543
8544 case E_VDEC_DECODER_HVD:
8545 u32Cnt = MDrv_HVD_GetDecErrCnt()+MDrv_HVD_GetDataErrCnt();
8546
8547 break;
8548
8549 case E_VDEC_DECODER_MJPEG:
8550 u32Cnt = MApi_MJPEG_GetErrCnt();
8551
8552 break;
8553
8554 case E_VDEC_DECODER_RVD:
8555 u32Cnt = MDrv_RVD_GetDecErrCnt() + MDrv_RVD_GetDataErrCnt();
8556
8557 break;
8558
8559 default:
8560 u32Cnt = 0;
8561 break;
8562 }
8563
8564 return u32Cnt;
8565 }
8566
8567
8568 //------------------------------------------------------------------------------
8569 /// Get codec type which be initialed
8570 /// @return VDEC_CodecType
8571 //------------------------------------------------------------------------------
MApi_VDEC_GetActiveCodecType(void)8572 VDEC_CodecType MApi_VDEC_GetActiveCodecType(void)
8573 {
8574
8575 if (pu32VDEC_Inst == NULL)
8576 {
8577 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8578 return E_VDEC_CODEC_TYPE_NONE;
8579 }
8580
8581 VDEC_V2_IO_Param IO_arg;
8582 VDEC_CodecType eRet = E_VDEC_CODEC_TYPE_NONE;
8583
8584 IO_arg.pRet = (void *)&eRet;
8585
8586
8587 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_ACTIVE_CODEC_TYPE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8588 {
8589 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8590 return 0;
8591 }
8592 else
8593 {
8594 return eRet;
8595 }
8596 }
8597
8598 //------------------------------------------------------------------------------
8599 /// Get codec type which be initialed
8600 /// @return VDEC_CodecType
8601 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetActiveCodecType(void)8602 VDEC_CodecType MApi_VDEC_V2_GetActiveCodecType(void)
8603 {
8604 return _Attr.eCodecType;
8605 }
8606
8607
8608 //------------------------------------------------------------------------------
8609 /// Get bitrate which decoder retrieved from stream
8610 /// @return bitrate
8611 //------------------------------------------------------------------------------
MApi_VDEC_GetBitsRate(void)8612 MS_U32 MApi_VDEC_GetBitsRate(void)
8613 {
8614
8615 if (pu32VDEC_Inst == NULL)
8616 {
8617 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8618 return 0;
8619 }
8620
8621 VDEC_V2_IO_Param IO_arg;
8622 MS_U32 u32Ret = 0;
8623
8624 IO_arg.pRet = (void *)&u32Ret;
8625
8626
8627 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_BITS_RATE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8628 {
8629 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8630 return 0;
8631 }
8632 else
8633 {
8634 return u32Ret;
8635 }
8636 }
8637
8638 //------------------------------------------------------------------------------
8639 /// Get bitrate which decoder retrieved from stream
8640 /// @return bitrate
8641 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetBitsRate(void)8642 MS_U32 MApi_VDEC_V2_GetBitsRate(void)
8643 {
8644 MS_U32 u32Bitrate = 0;
8645
8646 if (!_Attr.bInit)
8647 {
8648 return 0;
8649 }
8650
8651 switch (_Attr.eDecoder)
8652 {
8653 case E_VDEC_DECODER_MVD:
8654 return MDrv_MVD_GetBitsRate();
8655
8656 case E_VDEC_DECODER_HVD:
8657 case E_VDEC_DECODER_MJPEG: // unnecessary
8658 case E_VDEC_DECODER_RVD:
8659 default:
8660 u32Bitrate = 0;
8661 break;
8662 }
8663
8664 return u32Bitrate;
8665 }
8666
8667 //------------------------------------------------------------------------------
8668 /// Get 3:2 pull down flag which decoder retrieved from stream
8669 /// @return TRUE/FALSE
8670 //------------------------------------------------------------------------------
MApi_VDEC_Is32PullDown(void)8671 MS_BOOL MApi_VDEC_Is32PullDown(void)
8672 {
8673 if (pu32VDEC_Inst == NULL)
8674 {
8675 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8676 return FALSE;
8677 }
8678
8679 VDEC_V2_IO_Param IO_arg;
8680 MS_BOOL bRet = FALSE;
8681
8682 IO_arg.pRet = (void *)&bRet;
8683
8684
8685 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_32PULLDOWN, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8686 {
8687 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8688 return FALSE;
8689 }
8690 else
8691 {
8692 return bRet;
8693 }
8694 }
8695
8696
8697
8698 //------------------------------------------------------------------------------
8699 /// Get 3:2 pull down flag which decoder retrieved from stream
8700 /// @return TRUE/FALSE
8701 //------------------------------------------------------------------------------
MApi_VDEC_V2_Is32PullDown(void)8702 MS_BOOL MApi_VDEC_V2_Is32PullDown(void)
8703 {
8704 MS_BOOL bIs32PullDown = 0;
8705
8706 if (!_Attr.bInit)
8707 {
8708 return FALSE;
8709 }
8710
8711 switch (_Attr.eDecoder)
8712 {
8713 case E_VDEC_DECODER_MVD:
8714 return MDrv_MVD_GetIs32PullDown();
8715
8716 case E_VDEC_DECODER_HVD:
8717 case E_VDEC_DECODER_MJPEG:
8718 case E_VDEC_DECODER_RVD:
8719 default:
8720 bIs32PullDown = FALSE;
8721 break;
8722 }
8723
8724 return bIs32PullDown;
8725 }
8726
8727 //------------------------------------------------------------------------------
8728 /// Check whether the status of decoder is running or not.
8729 /// @return VDEC_Result: E_VDEC_OK/E_VDEC_RET_NOT_RUNNING/E_VDEC_RET_NOT_INIT
8730 //------------------------------------------------------------------------------
MApi_VDEC_IsAlive(void)8731 VDEC_Result MApi_VDEC_IsAlive(void)
8732 {
8733 if (pu32VDEC_Inst == NULL)
8734 {
8735 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8736 return E_VDEC_FAIL;
8737 }
8738
8739 VDEC_V2_IO_Param IO_arg;
8740 VDEC_Result eRet = E_VDEC_FAIL;
8741
8742 IO_arg.pRet = (void *)&eRet;
8743
8744
8745 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_ALIVE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8746 {
8747 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8748 return E_VDEC_FAIL;
8749 }
8750 else
8751 {
8752 return eRet;
8753 }
8754 }
8755
8756 //------------------------------------------------------------------------------
8757 /// Check whether the status of decoder is running or not.
8758 /// @return VDEC_Result: E_VDEC_OK/E_VDEC_RET_NOT_RUNNING/E_VDEC_RET_NOT_INIT
8759 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsAlive(void)8760 VDEC_Result MApi_VDEC_V2_IsAlive(void)
8761 {
8762 if (!_Attr.bInit)
8763 {
8764 return E_VDEC_RET_NOT_INIT;
8765 }
8766
8767 switch (_Attr.eDecoder)
8768 {
8769 case E_VDEC_DECODER_MVD:
8770 break;
8771 case E_VDEC_DECODER_HVD:
8772 if(E_HVD_RET_NOT_RUNNING == MDrv_HVD_IsAlive())
8773 {
8774 return E_VDEC_RET_NOT_RUNNING;
8775 }
8776 break;
8777 case E_VDEC_DECODER_MJPEG:
8778 case E_VDEC_DECODER_RVD:
8779 default:
8780 break;
8781 }
8782
8783 return E_VDEC_OK;
8784 }
8785
8786 //------------------------------------------------------------------------------
8787 /// Get the value of PTS - STC for video
8788 /// @return the value of PTS - STC for video
8789 //------------------------------------------------------------------------------
MApi_VDEC_GetVideoPtsStcDelta(void)8790 MS_S64 MApi_VDEC_GetVideoPtsStcDelta(void)
8791 {
8792 if (pu32VDEC_Inst == NULL)
8793 {
8794 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8795 return 0;
8796 }
8797
8798 VDEC_V2_IO_Param IO_arg;
8799 MS_S64 s64Ret = 0;
8800
8801 IO_arg.pRet = (void *)&s64Ret;
8802
8803
8804 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_VIDEO_PTS_STC_DELTA, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8805 {
8806 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8807 return 0;
8808 }
8809 else
8810 {
8811 return s64Ret;
8812 }
8813
8814 }
8815
8816 //------------------------------------------------------------------------------
8817 /// Get the value of PTS - STC for video
8818 /// @return the value of PTS - STC for video
8819 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetVideoPtsStcDelta(void)8820 MS_S64 MApi_VDEC_V2_GetVideoPtsStcDelta(void)
8821 {
8822 MS_S64 s64Pts = 0;
8823
8824 if (!_Attr.bInit)
8825 {
8826 return 0;
8827 }
8828
8829 switch (_Attr.eDecoder)
8830 {
8831 case E_VDEC_DECODER_MVD:
8832 s64Pts = MDrv_MVD_GetPtsStcDiff();
8833 //printf("s64Pts=%lld, s32=%ld\n", s64Pts, MDrv_MVD_GetPtsStcDiff());
8834 break;
8835
8836 case E_VDEC_DECODER_HVD:
8837 s64Pts = MDrv_HVD_GetPtsStcDiff();
8838
8839
8840 break;
8841
8842 case E_VDEC_DECODER_MJPEG:
8843
8844
8845 break;
8846
8847 case E_VDEC_DECODER_RVD:
8848
8849
8850 break;
8851
8852 default:
8853 s64Pts = 0;
8854 break;
8855 }
8856
8857 return s64Pts;
8858 }
8859
8860 //------------------------------------------------------------------------------
8861 /// Check if decoder got valid stream to decode
8862 /// @return TRUE or FALSE
8863 /// - TRUE: find valid stream
8864 /// - FALSE: not yet
8865 //------------------------------------------------------------------------------
MApi_VDEC_IsWithValidStream(void)8866 VDEC_Result MApi_VDEC_IsWithValidStream(void)
8867 {
8868 if (pu32VDEC_Inst == NULL)
8869 {
8870 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8871 return E_VDEC_FAIL;
8872 }
8873
8874 VDEC_V2_IO_Param IO_arg;
8875 VDEC_Result eRet = E_VDEC_FAIL;
8876
8877 IO_arg.pRet = (void *)&eRet;
8878
8879
8880 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_WITH_VALID_STREAM, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8881 {
8882 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8883 return E_VDEC_FAIL;
8884 }
8885 else
8886 {
8887 return eRet;
8888 }
8889
8890 }
8891
8892
8893 //------------------------------------------------------------------------------
8894 /// Check if decoder got valid stream to decode
8895 /// @return TRUE or FALSE
8896 /// - TRUE: find valid stream
8897 /// - FALSE: not yet
8898 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsWithValidStream(void)8899 VDEC_Result MApi_VDEC_V2_IsWithValidStream(void)
8900 {
8901 VDEC_Result retVal;
8902
8903 if (!_Attr.bInit)
8904 {
8905 return E_VDEC_RET_NOT_INIT;
8906 }
8907
8908 switch (_Attr.eDecoder)
8909 {
8910 case E_VDEC_DECODER_MVD:
8911 {
8912 if (MDrv_MVD_GetValidStreamFlag())
8913 {
8914 retVal = E_VDEC_OK;
8915 }
8916 else
8917 {
8918 retVal = E_VDEC_FAIL;
8919 }
8920
8921 break;
8922 }
8923 case E_VDEC_DECODER_HVD:
8924 case E_VDEC_DECODER_MJPEG:
8925 case E_VDEC_DECODER_RVD:
8926 default:
8927 retVal = E_VDEC_RET_UNSUPPORTED;
8928 break;
8929 }
8930
8931 return retVal;
8932 }
8933
8934 //------------------------------------------------------------------------------
8935 /// Check if decoder found I frame after reset or flush queue
8936 /// @return VDEC_Result
8937 /// - E_VDEC_OK: found
8938 /// - E_VDEC_FAIL: not found
8939 /// - E_VDEC_RET_NOT_INIT: not initial yet
8940 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
8941 //------------------------------------------------------------------------------
MApi_VDEC_IsIFrameFound(void)8942 VDEC_Result MApi_VDEC_IsIFrameFound(void)
8943 {
8944 if (pu32VDEC_Inst == NULL)
8945 {
8946 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8947 return E_VDEC_FAIL;
8948 }
8949
8950 VDEC_V2_IO_Param IO_arg;
8951 VDEC_Result eRet = E_VDEC_FAIL;
8952
8953 IO_arg.pRet = (void *)&eRet;
8954
8955
8956 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_I_FRAME_FOUND, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
8957 {
8958 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
8959 return E_VDEC_FAIL;
8960 }
8961 else
8962 {
8963 return eRet;
8964 }
8965 }
8966
8967
8968 //------------------------------------------------------------------------------
8969 /// Check if decoder found I frame after reset or flush queue
8970 /// @return VDEC_Result
8971 /// - E_VDEC_OK: found
8972 /// - E_VDEC_FAIL: not found
8973 /// - E_VDEC_RET_NOT_INIT: not initial yet
8974 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
8975 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsIFrameFound(void)8976 VDEC_Result MApi_VDEC_V2_IsIFrameFound(void)
8977 {
8978 VDEC_Result ret = E_VDEC_FAIL;
8979
8980 if (!_Attr.bInit)
8981 {
8982 return E_VDEC_RET_NOT_INIT;
8983 }
8984
8985 switch (_Attr.eDecoder)
8986 {
8987 case E_VDEC_DECODER_MVD:
8988 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_GetIsIPicFound());
8989 break;
8990
8991 case E_VDEC_DECODER_HVD:
8992 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsIFrmFound());
8993 break;
8994
8995 case E_VDEC_DECODER_MJPEG:
8996 _BOOL_TO_VDEC_RESULT(ret, MApi_MJPEG_IsIFrameFound());
8997 break;
8998
8999 case E_VDEC_DECODER_RVD:
9000 _BOOL_TO_VDEC_RESULT(ret, MDrv_RVD_IsIFrameFound());
9001 break;
9002
9003 default:
9004 ret = E_VDEC_RET_UNSUPPORTED;
9005 break;
9006 }
9007
9008 return ret;
9009 }
9010
9011 //------------------------------------------------------------------------------
9012 /// Check if input stream is with low delay flag
9013 /// @return VDEC_Result
9014 /// - E_VDEC_OK: with low delay
9015 /// - E_VDEC_FAIL: without low delay
9016 /// - E_VDEC_RET_NOT_INIT: not initial yet
9017 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
9018 //------------------------------------------------------------------------------
MApi_VDEC_IsWithLowDelay(void)9019 VDEC_Result MApi_VDEC_IsWithLowDelay(void)
9020 {
9021 if (pu32VDEC_Inst == NULL)
9022 {
9023 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9024 return E_VDEC_FAIL;
9025 }
9026
9027 VDEC_V2_IO_Param IO_arg;
9028 VDEC_Result eRet = E_VDEC_FAIL;
9029
9030 IO_arg.pRet = (void *)&eRet;
9031
9032
9033 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_WITH_LOW_DELAY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9034 {
9035 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9036 return E_VDEC_FAIL;
9037 }
9038 else
9039 {
9040 return eRet;
9041 }
9042 }
9043
9044
9045 //------------------------------------------------------------------------------
9046 /// Check if input stream is with low delay flag
9047 /// @return VDEC_Result
9048 /// - E_VDEC_OK: with low delay
9049 /// - E_VDEC_FAIL: without low delay
9050 /// - E_VDEC_RET_NOT_INIT: not initial yet
9051 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
9052 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsWithLowDelay(void)9053 VDEC_Result MApi_VDEC_V2_IsWithLowDelay(void)
9054 {
9055 VDEC_Result ret;
9056
9057 if (!_Attr.bInit)
9058 {
9059 return E_VDEC_RET_NOT_INIT;
9060 }
9061
9062 switch (_Attr.eDecoder)
9063 {
9064 case E_VDEC_DECODER_MVD:
9065 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_GetLowDelayFlag());
9066 break;
9067
9068 case E_VDEC_DECODER_HVD:
9069 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsLowDelay());
9070 break;
9071
9072 case E_VDEC_DECODER_MJPEG:
9073 _BOOL_TO_VDEC_RESULT(ret, MApi_MJPEG_IsWithLowDelay());
9074 break;
9075
9076 case E_VDEC_DECODER_RVD:
9077 ret = E_VDEC_FAIL;
9078 break;
9079
9080 default:
9081 ret = E_VDEC_RET_UNSUPPORTED;
9082 break;
9083 }
9084
9085 return ret;
9086 }
9087
9088
9089 //------------------------------------------------------------------------------
9090 /// Check if all date buffers are empty or not
9091 /// @return VDEC_Result
9092 /// - E_VDEC_OK: All of the buffers are empty
9093 /// - E_VDEC_FAIL: Some of the buffers are not empty
9094 /// - E_VDEC_RET_NOT_INIT: not initial yet
9095 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
9096 //------------------------------------------------------------------------------
MApi_VDEC_IsAllBufferEmpty(void)9097 VDEC_Result MApi_VDEC_IsAllBufferEmpty(void)
9098 {
9099
9100 if (pu32VDEC_Inst == NULL)
9101 {
9102 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9103 return E_VDEC_FAIL;
9104 }
9105
9106 VDEC_V2_IO_Param IO_arg;
9107 VDEC_Result eRet = E_VDEC_FAIL;
9108
9109 IO_arg.pRet = (void *)&eRet;
9110
9111
9112 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_ALL_BUFFER_EMPTY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9113 {
9114 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9115 return E_VDEC_FAIL;
9116 }
9117 else
9118 {
9119 return eRet;
9120 }
9121
9122 }
9123
9124
9125 //------------------------------------------------------------------------------
9126 /// Check if all date buffers are empty or not
9127 /// @return VDEC_Result
9128 /// - E_VDEC_OK: All of the buffers are empty
9129 /// - E_VDEC_FAIL: Some of the buffers are not empty
9130 /// - E_VDEC_RET_NOT_INIT: not initial yet
9131 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
9132 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsAllBufferEmpty(void)9133 VDEC_Result MApi_VDEC_V2_IsAllBufferEmpty(void)
9134 {
9135 VDEC_Result ret;
9136
9137 if (!_Attr.bInit)
9138 {
9139 return E_VDEC_RET_NOT_INIT;
9140 }
9141
9142 switch (_Attr.eDecoder)
9143 {
9144 case E_VDEC_DECODER_MVD:
9145 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_IsAllBufferEmpty());
9146 break;
9147
9148 case E_VDEC_DECODER_HVD:
9149 _BOOL_TO_VDEC_RESULT( ret , MDrv_HVD_IsAllBufferEmpty() );
9150 break;
9151
9152 case E_VDEC_DECODER_MJPEG:
9153 ret = E_VDEC_FAIL;
9154 break;
9155
9156 case E_VDEC_DECODER_RVD:
9157 ret = E_VDEC_FAIL;
9158 break;
9159
9160 default:
9161 ret = E_VDEC_RET_UNSUPPORTED;
9162 break;
9163 }
9164
9165 return ret;
9166 }
9167
9168
9169 //------------------------------------------------------------------------------
9170 /// Get picture counter of current GOP
9171 /// @return picture counter
9172 //------------------------------------------------------------------------------
MApi_VDEC_GetGOPCnt(void)9173 MS_U8 MApi_VDEC_GetGOPCnt(void)
9174 {
9175
9176 if (pu32VDEC_Inst == NULL)
9177 {
9178 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9179 return 0;
9180 }
9181
9182 VDEC_V2_IO_Param IO_arg;
9183 MS_U8 u8Ret = 0;
9184
9185 IO_arg.pRet = (void *)&u8Ret;
9186
9187
9188 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_GOP_CNT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9189 {
9190 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9191 return 0;
9192 }
9193 else
9194 {
9195 return u8Ret;
9196 }
9197 }
9198
9199 //------------------------------------------------------------------------------
9200 /// Get picture counter of current GOP
9201 /// @return picture counter
9202 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetGOPCnt(void)9203 MS_U8 MApi_VDEC_V2_GetGOPCnt(void)
9204 {
9205 MS_U8 u8Cnt = 0;
9206
9207 if (!_Attr.bInit)
9208 {
9209 return 0;
9210 }
9211
9212 switch (_Attr.eDecoder)
9213 {
9214 case E_VDEC_DECODER_MVD:
9215 u8Cnt = MDrv_MVD_GetGOPCount();
9216 break;
9217
9218 case E_VDEC_DECODER_HVD:
9219 // not supported in HVD
9220 break;
9221
9222 case E_VDEC_DECODER_MJPEG:
9223 // not supported in MJPEG
9224 break;
9225
9226 case E_VDEC_DECODER_RVD:
9227 break;
9228
9229 default:
9230 break;
9231 }
9232
9233 return u8Cnt;
9234 }
9235
9236 //-----------------------------------------------------------------------------
9237 /// Get accumulated decoded frame Count
9238 /// @return - decoded frame Count
9239 //-----------------------------------------------------------------------------
MApi_VDEC_GetFrameCnt(void)9240 MS_U32 MApi_VDEC_GetFrameCnt(void)
9241 {
9242
9243
9244 if (pu32VDEC_Inst == NULL)
9245 {
9246 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9247 return 0;
9248 }
9249
9250 VDEC_V2_IO_Param IO_arg;
9251 MS_U32 u32Ret = 0;
9252
9253 IO_arg.pRet = (void *)&u32Ret;
9254
9255
9256 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_FRAME_CNT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9257 {
9258 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9259 return 0;
9260 }
9261 else
9262 {
9263 return u32Ret;
9264 }
9265
9266 }
9267
9268
9269 //-----------------------------------------------------------------------------
9270 /// Get accumulated decoded frame Count
9271 /// @return - decoded frame Count
9272 //-----------------------------------------------------------------------------
MApi_VDEC_V2_GetFrameCnt(void)9273 MS_U32 MApi_VDEC_V2_GetFrameCnt(void)
9274 {
9275 MS_U32 u32Cnt = 0;
9276
9277 if (!_Attr.bInit)
9278 {
9279 return 0;
9280 }
9281
9282 switch (_Attr.eDecoder)
9283 {
9284 case E_VDEC_DECODER_MVD:
9285 u32Cnt = MDrv_MVD_GetPicCounter() + MDrv_MVD_GetSkipPicCounter();
9286
9287 break;
9288
9289 case E_VDEC_DECODER_HVD:
9290 u32Cnt = MDrv_HVD_GetDecodeCnt() + MDrv_HVD_GetData(E_HVD_GDATA_TYPE_SKIP_CNT);
9291
9292 break;
9293
9294 case E_VDEC_DECODER_MJPEG:
9295 u32Cnt = MApi_MJPEG_GetFrameCnt();
9296
9297 break;
9298
9299 case E_VDEC_DECODER_RVD:
9300 u32Cnt = MDrv_RVD_GetFrameCnt() + MDrv_RVD_GetSkipCnt();
9301
9302 break;
9303
9304 default:
9305 u32Cnt = 0;
9306 break;
9307 }
9308
9309 return u32Cnt;
9310 }
9311
9312
9313 //------------------------------------------------------------------------------
9314 /// Get skipped counter
9315 /// @return counter
9316 //------------------------------------------------------------------------------
MApi_VDEC_GetSkipCnt(void)9317 MS_U32 MApi_VDEC_GetSkipCnt(void)
9318 {
9319
9320 if (pu32VDEC_Inst == NULL)
9321 {
9322 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9323 return 0;
9324 }
9325
9326 VDEC_V2_IO_Param IO_arg;
9327 MS_U32 u32Ret = 0;
9328
9329 IO_arg.pRet = (void *)&u32Ret;
9330
9331
9332 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_SKIP_CNT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9333 {
9334 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9335 return 0;
9336 }
9337 else
9338 {
9339 return u32Ret;
9340 }
9341 }
9342
9343 //------------------------------------------------------------------------------
9344 /// Get skipped counter
9345 /// @return counter
9346 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetSkipCnt(void)9347 MS_U32 MApi_VDEC_V2_GetSkipCnt(void)
9348 {
9349 MS_U32 u32Cnt = 0;
9350
9351 if (!_Attr.bInit)
9352 {
9353 return 0;
9354 }
9355
9356 switch (_Attr.eDecoder)
9357 {
9358 case E_VDEC_DECODER_MVD:
9359 u32Cnt = MDrv_MVD_GetSkipPicCounter();
9360 break;
9361
9362 case E_VDEC_DECODER_HVD:
9363 u32Cnt = MDrv_HVD_GetData(E_HVD_GDATA_TYPE_SKIP_CNT);
9364 break;
9365
9366 case E_VDEC_DECODER_MJPEG:
9367 break;
9368
9369 case E_VDEC_DECODER_RVD:
9370 u32Cnt = MDrv_RVD_GetSkipCnt();
9371 break;
9372
9373 default:
9374 break;
9375 }
9376
9377 return u32Cnt;
9378 }
9379
9380 //------------------------------------------------------------------------------
9381 /// Get dropped frame counter
9382 /// @return counter
9383 //------------------------------------------------------------------------------
MApi_VDEC_GetDropCnt(void)9384 MS_U32 MApi_VDEC_GetDropCnt(void)
9385 {
9386
9387 if (pu32VDEC_Inst == NULL)
9388 {
9389 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9390 return 0;
9391 }
9392
9393 VDEC_V2_IO_Param IO_arg;
9394 MS_U32 u32Ret = 0;
9395
9396 IO_arg.pRet = (void *)&u32Ret;
9397
9398
9399 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_DROP_CNT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9400 {
9401 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9402 return 0;
9403 }
9404 else
9405 {
9406 return u32Ret;
9407 }
9408 }
9409
9410
9411 //------------------------------------------------------------------------------
9412 /// Get dropped frame counter
9413 /// @return counter
9414 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetDropCnt(void)9415 MS_U32 MApi_VDEC_V2_GetDropCnt(void)
9416 {
9417 MS_U32 u32Cnt = 0;
9418
9419 if (!_Attr.bInit)
9420 {
9421 return 0;
9422 }
9423
9424 switch (_Attr.eDecoder)
9425 {
9426 case E_VDEC_DECODER_MVD:
9427 u32Cnt = 0;
9428 break;
9429
9430 case E_VDEC_DECODER_HVD:
9431 u32Cnt = MDrv_HVD_GetData(E_HVD_GDATA_TYPE_DROP_CNT);
9432 break;
9433
9434 case E_VDEC_DECODER_MJPEG:
9435 break;
9436
9437 case E_VDEC_DECODER_RVD:
9438 u32Cnt = MDrv_RVD_GetDropCnt();
9439 break;
9440
9441 default:
9442 break;
9443 }
9444
9445 return u32Cnt;
9446 }
9447
9448
9449 //------------------------------------------------------------------------------
9450 /// Get display information
9451 /// @param pDispinfo \b OUT : pointer to display setting information
9452 /// @return VDEC_Result
9453 //------------------------------------------------------------------------------
MApi_VDEC_GetDispInfo(VDEC_DispInfo * pDispinfo)9454 VDEC_Result MApi_VDEC_GetDispInfo(VDEC_DispInfo *pDispinfo)
9455 {
9456
9457 if (pu32VDEC_Inst == NULL)
9458 {
9459 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9460 return E_VDEC_FAIL;
9461 }
9462
9463 VDEC_V2_IO_Param IO_arg;
9464 VDEC_Result eRet = E_VDEC_FAIL;
9465
9466 IO_arg.param[0] = (void *)(pDispinfo);
9467 IO_arg.pRet = (void *)&eRet;
9468
9469
9470 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_DISP_INFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9471 {
9472 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9473 return E_VDEC_FAIL;
9474 }
9475 else
9476 {
9477 return eRet;
9478 }
9479 }
9480
9481
9482 //------------------------------------------------------------------------------
9483 /// Get display information
9484 /// @param pDispinfo \b OUT : pointer to display setting information
9485 /// @return VDEC_Result
9486 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetDispInfo(VDEC_DispInfo * pDispinfo)9487 VDEC_Result MApi_VDEC_V2_GetDispInfo(VDEC_DispInfo *pDispinfo)
9488 {
9489 if (!_Attr.bInit)
9490 {
9491 return E_VDEC_RET_NOT_INIT;
9492 }
9493
9494 switch (_Attr.eDecoder)
9495 {
9496 case E_VDEC_DECODER_MVD:
9497 {
9498 MVD_FrameInfo info;
9499
9500 _VDEC_Memset(&info, 0, sizeof(MVD_FrameInfo));
9501
9502 MDrv_MVD_GetFrameInfo(&info);
9503
9504 if ((0xFFFF == info.u16HorSize) &&
9505 (0xFFFF == info.u16VerSize))
9506 {
9507 return E_VDEC_FAIL;
9508 }
9509
9510 pDispinfo->u16HorSize = info.u16HorSize;
9511 pDispinfo->u16VerSize = info.u16VerSize;
9512 pDispinfo->u32FrameRate = info.u32FrameRate;
9513 pDispinfo->u8AspectRate = info.u8AspectRate;
9514 pDispinfo->u8Interlace = info.u8Interlace;
9515 pDispinfo->u8AFD = info.u8AFD;
9516 ///VDEC SAR actually means PAR(Pixel Aspect Ratio)
9517 pDispinfo->u16SarWidth = info.u16par_width;
9518 pDispinfo->u16SarHeight = info.u16par_height;
9519 if ((pDispinfo->u16SarWidth > 1) && (pDispinfo->u16SarHeight > 1)
9520 && (pDispinfo->u16HorSize > 1 ) && (pDispinfo->u16VerSize > 1))
9521 {
9522 pDispinfo->u32AspectWidth = (MS_U32)pDispinfo->u16SarWidth * (MS_U32)pDispinfo->u16HorSize;
9523 pDispinfo->u32AspectHeight = (MS_U32)pDispinfo->u16SarHeight* (MS_U32)pDispinfo->u16VerSize;
9524 }
9525 else
9526 {
9527 pDispinfo->u32AspectWidth = pDispinfo->u16HorSize;
9528 pDispinfo->u32AspectHeight = pDispinfo->u16VerSize;
9529 }
9530 pDispinfo->u16CropRight = info.u16CropRight;
9531 pDispinfo->u16CropLeft = info.u16CropLeft;
9532 pDispinfo->u16CropBottom = info.u16CropBottom;
9533 pDispinfo->u16CropTop = info.u16CropTop;
9534 pDispinfo->u16Pitch = info.u16Pitch;
9535 pDispinfo->u16PTSInterval = info.u16PTSInterval;
9536 pDispinfo->u8MPEG1 = info.u8MPEG1;
9537 pDispinfo->u8PlayMode = info.u8PlayMode;
9538 pDispinfo->u8FrcMode = info.u8FrcMode;
9539 pDispinfo->bWithChroma = TRUE;
9540 pDispinfo->bEnableMIUSel = info.bEnableMIUSel;
9541 pDispinfo->u32DynScalingAddr = info.u32DynScalingAddr;
9542 pDispinfo->u8DynScalingDepth = info.u8DynScalingDepth;
9543 pDispinfo->u32DynScalingSize = info.u32DynScalingBufSize;
9544
9545 if (MDrv_MVD_GetVideoRange() == 1)
9546 {
9547 pDispinfo->bColorInXVYCC = TRUE;
9548 }
9549 else
9550 {
9551 pDispinfo->bColorInXVYCC = FALSE;
9552 }
9553 break;
9554 }
9555 case E_VDEC_DECODER_HVD:
9556 {
9557 HVD_Disp_Info info;
9558
9559 _VDEC_Memset(&info, 0, sizeof(HVD_Disp_Info));
9560
9561 _HVD_RET_HANDLE(MDrv_HVD_GetDispInfo(&info));
9562
9563 pDispinfo->u16HorSize = info.u16HorSize;
9564 pDispinfo->u16VerSize = info.u16VerSize;
9565 pDispinfo->u32FrameRate = info.u32FrameRate;
9566 pDispinfo->u8AspectRate = info.u8AspectRate;
9567 pDispinfo->u8Interlace = info.u8Interlace;
9568 pDispinfo->u8AFD = info.u8AFD;
9569 pDispinfo->u16SarWidth = info.u16SarWidth;
9570 pDispinfo->u16SarHeight = info.u16SarHeight;
9571 if( (pDispinfo->u16SarWidth >= 1) && (pDispinfo->u16SarHeight >= 1) &&
9572 (pDispinfo->u16HorSize > 1 ) && (pDispinfo->u16VerSize > 1) &&
9573 (( info.u16CropRight + info.u16CropLeft) < pDispinfo->u16HorSize) &&
9574 ((info.u16CropTop + info.u16CropBottom) <pDispinfo->u16VerSize))
9575 {
9576 pDispinfo->u32AspectWidth = (MS_U32)pDispinfo->u16SarWidth * (MS_U32)(pDispinfo->u16HorSize- ( info.u16CropRight + info.u16CropLeft));
9577 pDispinfo->u32AspectHeight = (MS_U32)pDispinfo->u16SarHeight * (MS_U32)(pDispinfo->u16VerSize - ( info.u16CropTop + info.u16CropBottom));
9578 }
9579 else
9580 {
9581 pDispinfo->u32AspectWidth = pDispinfo->u16HorSize;
9582 pDispinfo->u32AspectHeight = pDispinfo->u16VerSize;
9583 }
9584 pDispinfo->u16CropRight = info.u16CropRight;
9585 pDispinfo->u16CropLeft = info.u16CropLeft;
9586 pDispinfo->u16CropBottom = info.u16CropBottom;
9587 pDispinfo->u16CropTop = info.u16CropTop;
9588 pDispinfo->u16Pitch = info.u16Pitch;
9589 pDispinfo->bWithChroma = !(info.bChroma_idc_Mono);
9590 pDispinfo->bColorInXVYCC = TRUE;
9591 pDispinfo->bEnableMIUSel = MDrv_HVD_GetDynamicScalingInfo(E_HVD_DS_BUF_MIUSEL);
9592 pDispinfo->u32DynScalingAddr= MDrv_HVD_GetDynamicScalingInfo(E_HVD_DS_BUF_ADDR);
9593 pDispinfo->u8DynScalingDepth= MDrv_HVD_GetDynamicScalingInfo(E_HVD_DS_VECTOR_DEPTH);
9594 pDispinfo->u32DynScalingSize= MDrv_HVD_GetDynamicScalingInfo(E_HVD_DS_BUF_SIZE);
9595 break;
9596 }
9597 case E_VDEC_DECODER_MJPEG:
9598 {
9599 MJPEG_DISP_INFO info;
9600
9601 _VDEC_Memset(&info, 0, sizeof(MJPEG_DISP_INFO));
9602
9603 _MJPEG_RET_HANDLE(MApi_MJPEG_GetDispInfo(&info));
9604
9605 pDispinfo->u16HorSize = info.u16Width;
9606 pDispinfo->u16VerSize = info.u16Height;
9607 pDispinfo->u32FrameRate = info.u32FrameRate;
9608 pDispinfo->u8Interlace = 0; // no interlace
9609 pDispinfo->u8AFD = 0; // not used
9610 pDispinfo->u16SarWidth = 1;
9611 pDispinfo->u16SarHeight = 1;
9612 pDispinfo->u32AspectWidth = pDispinfo->u16HorSize;
9613 pDispinfo->u32AspectHeight = pDispinfo->u16VerSize;
9614 pDispinfo->u16CropRight = info.u16CropRight;
9615 pDispinfo->u16CropLeft = info.u16CropLeft;
9616 pDispinfo->u16CropBottom = info.u16CropBottom;
9617 pDispinfo->u16CropTop = info.u16CropTop;
9618 pDispinfo->u16Pitch = info.u16Pitch;
9619 pDispinfo->u16PTSInterval = 0; //not used
9620 pDispinfo->u8MPEG1 = 0; // not used
9621 pDispinfo->u8PlayMode = 0; // not used
9622 pDispinfo->u8FrcMode = 0; // not used
9623 pDispinfo->u8AspectRate = 0; // not used
9624 pDispinfo->bWithChroma = TRUE;
9625 pDispinfo->bColorInXVYCC = TRUE;
9626 pDispinfo->u32DynScalingAddr = 0; // not used
9627 pDispinfo->u8DynScalingDepth = 0; // not used
9628 pDispinfo->u32DynScalingSize = 0; // not used
9629 pDispinfo->bEnableMIUSel = FALSE; // not used
9630 break;
9631 }
9632 case E_VDEC_DECODER_RVD:
9633 {
9634 RVD_FrameInfo info;
9635
9636 _VDEC_Memset(&info, 0, sizeof(RVD_FrameInfo));
9637
9638 _RVD_RET_HANDLE(MDrv_RVD_GetDispInfo(&info));
9639
9640 pDispinfo->u16HorSize = info.u16HorSize;
9641 pDispinfo->u16VerSize = info.u16VerSize;
9642 pDispinfo->u32FrameRate = info.u16FrameRate;
9643 pDispinfo->u16SarWidth = info.u16Sar_width;
9644 pDispinfo->u16SarHeight = info.u16Sar_height;
9645 pDispinfo->u16CropRight = info.u16CropRight;
9646 pDispinfo->u16CropLeft = info.u16CropLeft;
9647 pDispinfo->u16CropBottom = info.u16CropBottom;
9648 pDispinfo->u16CropTop = info.u16CropTop;
9649 pDispinfo->bWithChroma = TRUE;
9650 pDispinfo->bColorInXVYCC = TRUE;
9651 pDispinfo->u8Interlace = 0;
9652 pDispinfo->bEnableMIUSel = info.bEnableMIUSel;
9653 pDispinfo->u32DynScalingAddr= info.u32DynScalingAddr;
9654 pDispinfo->u8DynScalingDepth= info.u8DynScalingDepth;
9655 pDispinfo->u32DynScalingSize= (MS_U32)pDispinfo->u8DynScalingDepth*16;
9656 pDispinfo->u32AspectHeight = info.u32AspectHeight;
9657 pDispinfo->u32AspectWidth = info.u32AspectWidth;
9658 break;
9659 }
9660 default:
9661 break;
9662 }
9663
9664 return E_VDEC_OK;
9665 }
9666
9667 //------------------------------------------------------------------------------
9668 /// Get current trick decode mode of decoder
9669 /// @return VDEC_TrickDec
9670 //------------------------------------------------------------------------------
MApi_VDEC_GetTrickMode(void)9671 VDEC_TrickDec MApi_VDEC_GetTrickMode(void)
9672 {
9673 if (pu32VDEC_Inst == NULL)
9674 {
9675 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9676 return E_VDEC_TRICK_DEC_ALL;
9677 }
9678
9679 VDEC_V2_IO_Param IO_arg;
9680 VDEC_TrickDec eRet = E_VDEC_TRICK_DEC_ALL;
9681
9682 IO_arg.pRet = (void *)&eRet;
9683
9684
9685 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_TRICK_MODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9686 {
9687 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9688 return E_VDEC_TRICK_DEC_ALL;
9689 }
9690 else
9691 {
9692 return eRet;
9693 }
9694
9695 }
9696
9697
9698 //------------------------------------------------------------------------------
9699 /// Get current trick decode mode of decoder
9700 /// @return VDEC_TrickDec
9701 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetTrickMode(void)9702 VDEC_TrickDec MApi_VDEC_V2_GetTrickMode(void)
9703 {
9704 VDEC_TrickDec eTrick = E_VDEC_TRICK_DEC_ALL;
9705
9706 if (!_Attr.bInit)
9707 {
9708 // FIXME
9709 return eTrick;
9710 }
9711
9712 switch (_Attr.eDecoder)
9713 {
9714 case E_VDEC_DECODER_MVD:
9715 {
9716 MVD_TrickDec dec = MDrv_MVD_GetTrickMode();
9717
9718 if (E_MVD_TRICK_DEC_ALL == dec)
9719 {
9720 return E_VDEC_TRICK_DEC_ALL;
9721 }
9722 else if (E_MVD_TRICK_DEC_IP == dec)
9723 {
9724 return E_VDEC_TRICK_DEC_IP;
9725 }
9726 else if (E_MVD_TRICK_DEC_I == dec)
9727 {
9728 return E_VDEC_TRICK_DEC_I;
9729 }
9730 else
9731 {
9732 return eTrick;
9733 }
9734
9735 break;
9736 }
9737 case E_VDEC_DECODER_HVD:
9738 {
9739 HVD_Skip_Decode dec = (HVD_Skip_Decode) MDrv_HVD_GetPlayMode(E_HVD_GMODE_SKIP_MODE);
9740
9741 if (E_HVD_SKIP_DECODE_ALL == dec)
9742 {
9743 return E_VDEC_TRICK_DEC_ALL;
9744 }
9745 else if (E_HVD_SKIP_DECODE_I == dec)
9746 {
9747 return E_VDEC_TRICK_DEC_I;
9748 }
9749 else if (E_HVD_SKIP_DECODE_IP == dec)
9750 {
9751 return E_VDEC_TRICK_DEC_IP;
9752 }
9753 else
9754 {
9755 return eTrick;
9756 }
9757
9758 break;
9759 }
9760 case E_VDEC_DECODER_MJPEG:
9761 break;
9762
9763 case E_VDEC_DECODER_RVD:
9764 {
9765 RVD_TrickMode dec = (RVD_TrickMode) MDrv_RVD_GetTrickMode();
9766
9767 if (E_RVD_TRICKMODE_DECODE_ALL == dec)
9768 {
9769 return E_VDEC_TRICK_DEC_ALL;
9770 }
9771 else if (E_RVD_TRICKMODE_DECODE_IP == dec)
9772 {
9773 return E_VDEC_TRICK_DEC_IP;
9774 }
9775 else if (E_RVD_TRICKMODE_DECODE_I == dec)
9776 {
9777 return E_VDEC_TRICK_DEC_I;
9778 }
9779 else
9780 {
9781 return eTrick;
9782 }
9783
9784 break;
9785 }
9786 default:
9787 break;
9788 }
9789
9790 return eTrick;
9791 }
9792
9793 //------------------------------------------------------------------------------
9794 /// Get stream active format which decoder retrieved
9795 /// @return active format ID
9796 //------------------------------------------------------------------------------
MApi_VDEC_GetActiveFormat(void)9797 MS_U8 MApi_VDEC_GetActiveFormat(void)
9798 {
9799
9800 if (pu32VDEC_Inst == NULL)
9801 {
9802 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9803 return E_VDEC_FAIL;
9804 }
9805
9806 VDEC_V2_IO_Param IO_arg;
9807 MS_U8 u8Ret = 0xFF;
9808
9809 IO_arg.pRet = (void *)&u8Ret;
9810
9811
9812 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_ACTIVE_FORMAT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9813 {
9814 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9815 return 0xFF;
9816 }
9817 else
9818 {
9819 return u8Ret;
9820 }
9821 }
9822
9823
9824 //------------------------------------------------------------------------------
9825 /// Get stream active format which decoder retrieved
9826 /// @return active format ID
9827 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetActiveFormat(void)9828 MS_U8 MApi_VDEC_V2_GetActiveFormat(void)
9829 {
9830 MS_U8 u8ActFmt;
9831
9832 if (!_Attr.bInit)
9833 {
9834 return 0xFF;
9835 }
9836
9837 switch (_Attr.eDecoder)
9838 {
9839 case E_VDEC_DECODER_MVD:
9840 u8ActFmt = MDrv_MVD_GetActiveFormat();
9841
9842 break;
9843
9844 case E_VDEC_DECODER_HVD:
9845 u8ActFmt = MDrv_HVD_GetActiveFormat();
9846
9847 break;
9848
9849 case E_VDEC_DECODER_MJPEG:
9850 case E_VDEC_DECODER_RVD:
9851 default:
9852 u8ActFmt = 0xFF;
9853 break;
9854 }
9855
9856 return u8ActFmt;
9857 }
9858
9859
9860 //------------------------------------------------------------------------------
9861 /// Get stream colour primaries
9862 /// @return stream colour primaries
9863 //------------------------------------------------------------------------------
MApi_VDEC_GetColourPrimaries(void)9864 MS_U8 MApi_VDEC_GetColourPrimaries(void)
9865 {
9866 if (pu32VDEC_Inst == NULL)
9867 {
9868 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9869 return E_VDEC_FAIL;
9870 }
9871
9872 VDEC_V2_IO_Param IO_arg;
9873 MS_U8 u8Ret = 0xFF;
9874
9875 IO_arg.pRet = (void *)&u8Ret;
9876
9877
9878 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_COLOUR_PRIMARIES, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9879 {
9880 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9881 return 0xFF;
9882 }
9883 else
9884 {
9885 return u8Ret;
9886 }
9887 }
9888
9889 //------------------------------------------------------------------------------
9890 /// Get stream colour primaries
9891 /// @return stream colour primaries
9892 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetColourPrimaries(void)9893 MS_U8 MApi_VDEC_V2_GetColourPrimaries(void)
9894 {
9895 MS_U8 u8ColourPrimaries;
9896
9897 if (!_Attr.bInit)
9898 {
9899 return 0xFF;
9900 }
9901
9902 switch (_Attr.eDecoder)
9903 {
9904 case E_VDEC_DECODER_MVD:
9905 u8ColourPrimaries = MDrv_MVD_GetColorFormat();
9906
9907 break;
9908
9909 case E_VDEC_DECODER_HVD:
9910 {
9911 HVD_Disp_Info info;
9912
9913 _VDEC_Memset(&info, 0, sizeof(HVD_Disp_Info));
9914
9915 if (E_HVD_OK != MDrv_HVD_GetDispInfo(&info))
9916 {
9917 u8ColourPrimaries = 0xFF;
9918 }
9919 else
9920 {
9921 u8ColourPrimaries = info.u8ColourPrimaries;
9922 }
9923
9924 break;
9925 }
9926 case E_VDEC_DECODER_MJPEG:
9927 case E_VDEC_DECODER_RVD:
9928 default:
9929 u8ColourPrimaries = 0xFF;
9930 break;
9931 }
9932
9933 return u8ColourPrimaries;
9934 }
9935
MApi_VDEC_GetHWKey(MS_U8 * pu8Key)9936 VDEC_Result MApi_VDEC_GetHWKey(MS_U8 *pu8Key)
9937 {
9938 if (pu32VDEC_Inst == NULL)
9939 {
9940 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9941 return E_VDEC_FAIL;
9942 }
9943
9944 VDEC_V2_IO_Param IO_arg;
9945 VDEC_Result eRet = E_VDEC_FAIL;
9946
9947 IO_arg.param[0] = (void *)pu8Key;
9948 IO_arg.pRet = (void *)&eRet;
9949
9950
9951 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_HW_KEY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
9952 {
9953 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9954 return E_VDEC_FAIL;
9955 }
9956 else
9957 {
9958 return eRet;
9959 }
9960 }
9961
9962
MApi_VDEC_V2_GetHWKey(MS_U8 * pu8Key)9963 VDEC_Result MApi_VDEC_V2_GetHWKey(MS_U8 *pu8Key)
9964 {
9965 VDEC_Result retVal = E_VDEC_RET_UNSUPPORTED;
9966 UNUSED(pu8Key);
9967
9968 if (!_Attr.bInit)
9969 {
9970 return E_VDEC_RET_NOT_INIT;
9971 }
9972
9973 switch (_Attr.eDecoder)
9974 {
9975 case E_VDEC_DECODER_MVD:
9976 break;
9977
9978 case E_VDEC_DECODER_HVD:
9979 case E_VDEC_DECODER_MJPEG:
9980 case E_VDEC_DECODER_RVD:
9981 retVal = E_VDEC_RET_UNSUPPORTED;
9982 break;
9983
9984 default:
9985 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
9986 break;
9987 }
9988
9989 return retVal;
9990 }
9991
9992 //------------------------------------------------------------------------------
9993 /// Check if sequence header is different from previous one
9994 /// @return VDEC_Result
9995 /// - E_VDEC_OK: changed
9996 /// - E_VDEC_FAIL: not changed
9997 /// - E_VDEC_RET_NOT_INIT: not initial yet
9998 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
9999 //------------------------------------------------------------------------------
MApi_VDEC_IsSeqChg(void)10000 VDEC_Result MApi_VDEC_IsSeqChg(void)
10001 {
10002
10003 if (pu32VDEC_Inst == NULL)
10004 {
10005 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10006 return E_VDEC_FAIL;
10007 }
10008
10009 VDEC_V2_IO_Param IO_arg;
10010 VDEC_Result eRet = E_VDEC_FAIL;
10011
10012 IO_arg.pRet = (void *)&eRet;
10013
10014
10015 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_IS_SEQ_CHG, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10016 {
10017 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10018 return E_VDEC_FAIL;
10019 }
10020 else
10021 {
10022 return eRet;
10023 }
10024 }
10025
10026
10027 //------------------------------------------------------------------------------
10028 /// Check if sequence header is different from previous one
10029 /// @return VDEC_Result
10030 /// - E_VDEC_OK: changed
10031 /// - E_VDEC_FAIL: not changed
10032 /// - E_VDEC_RET_NOT_INIT: not initial yet
10033 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
10034 //------------------------------------------------------------------------------
MApi_VDEC_V2_IsSeqChg(void)10035 VDEC_Result MApi_VDEC_V2_IsSeqChg(void)
10036 {
10037 VDEC_Result ret;
10038
10039 if (!_Attr.bInit)
10040 {
10041 return E_VDEC_RET_NOT_INIT;
10042 }
10043
10044 switch (_Attr.eDecoder)
10045 {
10046 case E_VDEC_DECODER_MVD:
10047 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_IsSeqChg());
10048 break;
10049
10050 case E_VDEC_DECODER_HVD:
10051 _BOOL_TO_VDEC_RESULT(ret, MDrv_HVD_IsDispInfoChg());
10052 break;
10053
10054 case E_VDEC_DECODER_MJPEG:
10055 ret = E_VDEC_FAIL;
10056 break;
10057
10058 case E_VDEC_DECODER_RVD:
10059 ret = E_VDEC_FAIL;
10060 break;
10061
10062 default:
10063 ret = E_VDEC_RET_UNSUPPORTED;
10064 break;
10065 }
10066
10067 return ret;
10068 }
10069
10070
10071 //------------------------------------------------------------------------------
10072 /// Set up debug message level
10073 /// @param eDbgLevel \b IN : message level
10074 /// @return VDEC_Result
10075 /// - E_VDEC_OK: Success
10076 /// - E_VDEC_FAIL: Failed
10077 //------------------------------------------------------------------------------
MApi_VDEC_SetDbgLevel(VDEC_DbgLevel eDbgLevel)10078 VDEC_Result MApi_VDEC_SetDbgLevel(VDEC_DbgLevel eDbgLevel)
10079 {
10080 if (pu32VDEC_Inst == NULL)
10081 {
10082 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10083 return E_VDEC_FAIL;
10084 }
10085
10086 VDEC_V2_IO_Param IO_arg;
10087 VDEC_Result eRet = E_VDEC_FAIL;
10088
10089 IO_arg.param[0] = (void *)&eDbgLevel;
10090 IO_arg.pRet = (void *)&eRet;
10091
10092
10093 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SET_DBG_LEVEL, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10094 {
10095 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10096 return E_VDEC_FAIL;
10097 }
10098 else
10099 {
10100 return eRet;
10101 }
10102 }
10103
10104 //------------------------------------------------------------------------------
10105 /// Set up debug message level
10106 /// @param eDbgLevel \b IN : message level
10107 /// @return VDEC_Result
10108 /// - E_VDEC_OK: Success
10109 /// - E_VDEC_FAIL: Failed
10110 //------------------------------------------------------------------------------
MApi_VDEC_V2_SetDbgLevel(VDEC_DbgLevel eDbgLevel)10111 VDEC_Result MApi_VDEC_V2_SetDbgLevel(VDEC_DbgLevel eDbgLevel)
10112 {
10113 if(E_VDEC_DBG_LEVEL_FW == eDbgLevel)
10114 {
10115 MS_U32 u32NonPMBankSize=0,u32RiuBaseAdd=0;
10116 _RET_VDEC_HVD_LINT_CHECK();
10117 if( !MDrv_MMIO_GetBASE( &u32RiuBaseAdd, &u32NonPMBankSize, MS_MODULE_HW))
10118 {
10119 printf("VDEC HVD MApi_VDEC_SetDbgLevel Err: MMIO_GetBASE failure\n");
10120 return E_VDEC_FAIL;
10121 }
10122 else
10123 {
10124 //printf("HVD:1 u32RiuBaseAdd = %lx\n", u32RiuBaseAdd);
10125 MDrv_HVD_SetOSRegBase(u32RiuBaseAdd);
10126 }
10127 MDrv_HVD_SetDbgLevel(E_HVD_UART_LEVEL_FW);
10128 }
10129
10130 switch (_Attr.eDecoder)
10131 {
10132 case E_VDEC_DECODER_MVD:
10133 _RET_VDEC_MVD_LINT_CHECK();
10134 MDrv_MVD_SetDbgLevel(eDbgLevel);
10135
10136 break;
10137
10138 case E_VDEC_DECODER_HVD:
10139 _RET_VDEC_HVD_LINT_CHECK();
10140 if (E_VDEC_DBG_LEVEL_NONE == eDbgLevel)
10141 {
10142 MDrv_HVD_SetDbgLevel(E_HVD_UART_LEVEL_NONE);
10143 }
10144 if (E_VDEC_DBG_LEVEL_ERR == eDbgLevel)
10145 {
10146 MDrv_HVD_SetDbgLevel(E_HVD_UART_LEVEL_ERR);
10147 }
10148 else if (E_VDEC_DBG_LEVEL_INFO == eDbgLevel)
10149 {
10150 MDrv_HVD_SetDbgLevel(E_HVD_UART_LEVEL_INFO);
10151 }
10152 else if (E_VDEC_DBG_LEVEL_DBG == eDbgLevel)
10153 {
10154 MDrv_HVD_SetDbgLevel(E_HVD_UART_LEVEL_DBG);
10155 }
10156 else if (E_VDEC_DBG_LEVEL_TRACE == eDbgLevel)
10157 {
10158 MDrv_HVD_SetDbgLevel(E_HVD_UART_LEVEL_TRACE);
10159 }
10160 else if (E_VDEC_DBG_LEVEL_FW == eDbgLevel)
10161 {
10162 MDrv_HVD_SetDbgLevel(E_HVD_UART_LEVEL_FW);
10163 }
10164
10165 break;
10166
10167 case E_VDEC_DECODER_MJPEG:
10168 MApi_MJPEG_DbgSetMsgLevel((MJPEG_DbgLevel)eDbgLevel);
10169
10170 break;
10171
10172 case E_VDEC_DECODER_RVD:
10173 _RET_VDEC_RVD_LINT_CHECK();
10174 if (E_VDEC_DBG_LEVEL_ERR == eDbgLevel)
10175 {
10176 MDrv_RVD_SetDbgLevel(E_RVD_DEBUG_ERR);
10177 }
10178 else if (E_VDEC_DBG_LEVEL_INFO == eDbgLevel)
10179 {
10180 MDrv_RVD_SetDbgLevel(E_RVD_DEBUG_INF);
10181 }
10182 else if (E_VDEC_DBG_LEVEL_DBG == eDbgLevel)
10183 {
10184 MDrv_RVD_SetDbgLevel(E_RVD_DEBUG_INF | E_RVD_DEBUG_ERR);
10185 }
10186 else if (E_VDEC_DBG_LEVEL_FW == eDbgLevel)
10187 {
10188 MDrv_RVD_SetDbgLevel(E_RVD_DEBUG_INF | E_RVD_DEBUG_ERR | E_RVD_DEBUG_DRV | E_RVD_DEBUG_HAL);
10189 }
10190
10191 break;
10192
10193 default:
10194 break;
10195 }
10196
10197 return E_VDEC_OK;
10198 }
10199
10200
10201 //------------------------------------------------------------------------------
10202 /// Get the information of the latest decoded frame.
10203 /// @param pFrmInfo \b IN : the information of the latest decoded frame
10204 /// @return -VDEC_Result
10205 //------------------------------------------------------------------------------
MApi_VDEC_GetDecFrameInfo(VDEC_FrameInfo * pFrmInfo)10206 VDEC_Result MApi_VDEC_GetDecFrameInfo(VDEC_FrameInfo* pFrmInfo)
10207 {
10208 if (pu32VDEC_Inst == NULL)
10209 {
10210 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10211 return E_VDEC_FAIL;
10212 }
10213
10214 VDEC_V2_IO_Param IO_arg;
10215 VDEC_Result eRet = E_VDEC_FAIL;
10216
10217 IO_arg.param[0] = (void *)pFrmInfo;
10218 IO_arg.pRet = (void *)&eRet;
10219
10220
10221 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_DEC_FRAME_INFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10222 {
10223 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10224 return E_VDEC_FAIL;
10225 }
10226 else
10227 {
10228 return eRet;
10229 }
10230 }
10231
10232 //------------------------------------------------------------------------------
10233 /// Get the information of the latest decoded frame.
10234 /// @param pFrmInfo \b IN : the information of the latest decoded frame
10235 /// @return -VDEC_Result
10236 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetDecFrameInfo(VDEC_FrameInfo * pFrmInfo)10237 VDEC_Result MApi_VDEC_V2_GetDecFrameInfo(VDEC_FrameInfo* pFrmInfo)
10238 {
10239 VDEC_Result retVal = E_VDEC_FAIL;
10240
10241 if (!_Attr.bInit)
10242 {
10243 return E_VDEC_RET_NOT_INIT;
10244 }
10245
10246 switch (_Attr.eDecoder)
10247 {
10248 case E_VDEC_DECODER_MVD:
10249 {
10250 MVD_FrmInfo stFrm;
10251 _VDEC_Memset(&stFrm, 0, sizeof(MVD_FrmInfo));
10252 _MVD_RET_HANDLE(MDrv_MVD_GetFrmInfo(E_MVD_FRMINFO_DECODE, &stFrm));
10253 pFrmInfo->eFrameType = _VDEC_MapFrmType2MVD(stFrm.eFrmType);
10254 pFrmInfo->u16Height = stFrm.u16Height;
10255 pFrmInfo->u16Width = stFrm.u16Width;
10256 pFrmInfo->u16Pitch = stFrm.u16Pitch;
10257 pFrmInfo->u32ChromaAddr = stFrm.u32ChromaAddr;
10258 pFrmInfo->u32ID_H = stFrm.u32ID_H;
10259 pFrmInfo->u32ID_L = stFrm.u32ID_L;
10260 pFrmInfo->u32LumaAddr = stFrm.u32LumaAddr;
10261 pFrmInfo->u32TimeStamp = stFrm.u32TimeStamp;
10262 pFrmInfo->eFieldType= E_VDEC_FIELDTYPE_BOTH;
10263 retVal = E_VDEC_OK;
10264 break;
10265 }
10266
10267 case E_VDEC_DECODER_HVD:
10268 {
10269 HVD_Frame_Info info;
10270
10271 _VDEC_Memset(&info, 0, sizeof(HVD_Frame_Info));
10272
10273 _HVD_RET_HANDLE(MDrv_HVD_GetFrmInfo(E_HVD_GFRMINFO_DECODE, &info));
10274
10275 pFrmInfo->eFrameType = _VDEC_MapFrmType2HVD(info.eFrmType);
10276 pFrmInfo->u16Height = info.u16Height;
10277 pFrmInfo->u16Width = info.u16Width;
10278 pFrmInfo->u16Pitch = info.u16Pitch;
10279 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
10280 pFrmInfo->u32ID_H = info.u32ID_H;
10281 pFrmInfo->u32ID_L = info.u32ID_L;
10282 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
10283 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
10284 pFrmInfo->eFieldType= (VDEC_FieldType)info.eFieldType;
10285
10286 retVal = E_VDEC_OK;
10287
10288 break;
10289 }
10290
10291 case E_VDEC_DECODER_MJPEG:
10292 {
10293 MJPEG_FrameInfo info;
10294
10295 _VDEC_Memset(&info, 0, sizeof(MJPEG_FrameInfo));
10296
10297 _MJPEG_RET_HANDLE(MApi_MJPEG_GetDecFrameInfo(&info));
10298
10299 pFrmInfo->eFrameType = _VDEC_MapFrmType2MJPEG(info.eFrameType);
10300 pFrmInfo->u16Height = info.u16Height;
10301 pFrmInfo->u16Width = info.u16Width;
10302 pFrmInfo->u16Pitch = info.u16Pitch;
10303 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
10304 pFrmInfo->u32ID_H = info.u32ID_H;
10305 pFrmInfo->u32ID_L = info.u32ID_L;
10306 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
10307 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
10308 pFrmInfo->eFieldType= E_VDEC_FIELDTYPE_BOTH;
10309
10310 retVal = E_VDEC_OK;
10311
10312 break;
10313 }
10314
10315 case E_VDEC_DECODER_RVD:
10316 {
10317 RVD_FrameBuff_Info info;
10318
10319 _VDEC_Memset(&info, 0, sizeof(RVD_FrameBuff_Info));
10320
10321 _RVD_RET_HANDLE(MDrv_RVD_GetFrameInfo(&info , 0));
10322
10323 pFrmInfo->eFrameType = (VDEC_FrameType) (info.u16FrmType);
10324 pFrmInfo->u16Height = info.u16Height;
10325 pFrmInfo->u16Width = info.u16Width;
10326 pFrmInfo->u16Pitch = info.u16Pitch;
10327 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
10328 pFrmInfo->u32ID_H = info.u32ID_H;
10329 pFrmInfo->u32ID_L = info.u32ID_L;
10330 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
10331 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
10332 pFrmInfo->eFieldType= E_VDEC_FIELDTYPE_BOTH;
10333
10334 retVal = E_VDEC_OK;
10335
10336 break;
10337 }
10338 default:
10339 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10340 break;
10341 }
10342
10343 return retVal;
10344 }
10345
10346
10347
10348 //------------------------------------------------------------------------------
10349 /// Get the information of current displaying frame.
10350 /// @param pFrmInfo \b IN : the information of displaying frame
10351 /// @return -VDEC_Result
10352 //------------------------------------------------------------------------------
MApi_VDEC_GetDispFrameInfo(VDEC_FrameInfo * pFrmInfo)10353 VDEC_Result MApi_VDEC_GetDispFrameInfo(VDEC_FrameInfo *pFrmInfo)
10354 {
10355 if (pu32VDEC_Inst == NULL)
10356 {
10357 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10358 return E_VDEC_FAIL;
10359 }
10360
10361 VDEC_V2_IO_Param IO_arg;
10362 VDEC_Result eRet = E_VDEC_FAIL;
10363
10364 IO_arg.param[0] = (void *)pFrmInfo;
10365 IO_arg.pRet = (void *)&eRet;
10366
10367
10368 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_DISP_FRAME_INFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10369 {
10370 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10371 return E_VDEC_FAIL;
10372 }
10373 else
10374 {
10375 return eRet;
10376 }
10377 }
10378
10379
10380 //------------------------------------------------------------------------------
10381 /// Get the information of current displaying frame.
10382 /// @param pFrmInfo \b IN : the information of displaying frame
10383 /// @return -VDEC_Result
10384 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetDispFrameInfo(VDEC_FrameInfo * pFrmInfo)10385 VDEC_Result MApi_VDEC_V2_GetDispFrameInfo(VDEC_FrameInfo *pFrmInfo)
10386 {
10387 VDEC_Result retVal = E_VDEC_FAIL;
10388
10389 if (!_Attr.bInit)
10390 {
10391 return E_VDEC_RET_NOT_INIT;
10392 }
10393
10394 switch (_Attr.eDecoder)
10395 {
10396 case E_VDEC_DECODER_MVD:
10397 {
10398 MVD_FrmInfo stFrm;
10399 _VDEC_Memset(&stFrm, 0, sizeof(MVD_FrmInfo));
10400 _MVD_RET_HANDLE(MDrv_MVD_GetFrmInfo(E_MVD_FRMINFO_DISPLAY, &stFrm));
10401 pFrmInfo->eFrameType = _VDEC_MapFrmType2MVD(stFrm.eFrmType);
10402 pFrmInfo->u16Height = stFrm.u16Height;
10403 pFrmInfo->u16Width = stFrm.u16Width;
10404 pFrmInfo->u16Pitch = stFrm.u16Pitch;
10405 pFrmInfo->u32ChromaAddr = stFrm.u32ChromaAddr;
10406 pFrmInfo->u32ID_H = stFrm.u32ID_H;
10407 pFrmInfo->u32ID_L = stFrm.u32ID_L;
10408 pFrmInfo->u32LumaAddr = stFrm.u32LumaAddr;
10409 pFrmInfo->u32TimeStamp = stFrm.u32TimeStamp;
10410 pFrmInfo->eFieldType= E_VDEC_FIELDTYPE_BOTH;
10411 retVal = E_VDEC_OK;
10412 break;
10413 }
10414
10415 case E_VDEC_DECODER_HVD:
10416 {
10417 HVD_Frame_Info info;
10418
10419 _VDEC_Memset(&info, 0, sizeof(HVD_Frame_Info));
10420
10421 _HVD_RET_HANDLE(MDrv_HVD_GetFrmInfo(E_HVD_GFRMINFO_DISPLAY, &info));
10422
10423 pFrmInfo->eFrameType = _VDEC_MapFrmType2HVD(info.eFrmType);
10424 pFrmInfo->u16Height = info.u16Height;
10425 pFrmInfo->u16Width = info.u16Width;
10426 pFrmInfo->u16Pitch = info.u16Pitch;
10427 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
10428 pFrmInfo->u32ID_H = info.u32ID_H;
10429 pFrmInfo->u32ID_L = info.u32ID_L;
10430 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
10431 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
10432 pFrmInfo->eFieldType = (VDEC_FieldType)info.eFieldType;
10433 retVal = E_VDEC_OK;
10434
10435 break;
10436 }
10437
10438 case E_VDEC_DECODER_MJPEG:
10439 {
10440 MJPEG_FrameInfo info;
10441
10442 _VDEC_Memset(&info, 0, sizeof(MJPEG_FrameInfo));
10443
10444 _MJPEG_RET_HANDLE(MApi_MJPEG_GetDispFrameInfo(&info));
10445
10446 pFrmInfo->eFrameType = _VDEC_MapFrmType2MJPEG(info.eFrameType);
10447 pFrmInfo->u16Height = info.u16Height;
10448 pFrmInfo->u16Width = info.u16Width;
10449 pFrmInfo->u16Pitch = info.u16Pitch;
10450 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
10451 pFrmInfo->u32ID_H = info.u32ID_H;
10452 pFrmInfo->u32ID_L = info.u32ID_L;
10453 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
10454 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
10455 pFrmInfo->eFieldType= E_VDEC_FIELDTYPE_BOTH;
10456 retVal = E_VDEC_OK;
10457
10458 break;
10459 }
10460
10461 case E_VDEC_DECODER_RVD:
10462 {
10463 RVD_FrameBuff_Info info;
10464
10465 _VDEC_Memset(&info, 0, sizeof(RVD_FrameBuff_Info));
10466
10467 _RVD_RET_HANDLE(MDrv_RVD_GetFrameInfo(&info , 1));
10468
10469 pFrmInfo->eFrameType = (VDEC_FrameType) (info.u16FrmType);
10470 pFrmInfo->u16Height = info.u16Height;
10471 pFrmInfo->u16Width = info.u16Width;
10472 pFrmInfo->u16Pitch = info.u16Pitch;
10473 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
10474 pFrmInfo->u32ID_H = info.u32ID_H;
10475 pFrmInfo->u32ID_L = info.u32ID_L;
10476 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
10477 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
10478 pFrmInfo->eFieldType= E_VDEC_FIELDTYPE_BOTH;
10479 retVal = E_VDEC_OK;
10480
10481 break;
10482 }
10483 default:
10484 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10485 break;
10486 }
10487
10488
10489 return retVal;
10490 }
10491
10492 //------------------------------------------------------------------------------
10493 /// Get the extension information of decoded frame.
10494 /// @param pExtDispinfo \b IN : the extension information of decoded frame.
10495 /// @return -VDEC_Result
10496 //------------------------------------------------------------------------------
MApi_VDEC_GetExtDispInfo(VDEC_ExtDispInfo * pExtDispinfo)10497 VDEC_Result MApi_VDEC_GetExtDispInfo(VDEC_ExtDispInfo *pExtDispinfo)
10498 {
10499 if (pu32VDEC_Inst == NULL)
10500 {
10501 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10502 return E_VDEC_FAIL;
10503 }
10504
10505 VDEC_V2_IO_Param IO_arg;
10506 VDEC_Result eRet = E_VDEC_FAIL;
10507
10508 IO_arg.param[0] = (void *)pExtDispinfo;
10509 IO_arg.pRet = (void *)&eRet;
10510
10511
10512 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_EXT_DISP_INFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10513 {
10514 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10515 return E_VDEC_FAIL;
10516 }
10517 else
10518 {
10519 return eRet;
10520 }
10521 }
10522
10523 //------------------------------------------------------------------------------
10524 /// Get the extension information of decoded frame.
10525 /// @param pExtDispinfo \b IN : the extension information of decoded frame.
10526 /// @return -VDEC_Result
10527 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetExtDispInfo(VDEC_ExtDispInfo * pExtDispinfo)10528 VDEC_Result MApi_VDEC_V2_GetExtDispInfo(VDEC_ExtDispInfo *pExtDispinfo)
10529 {
10530 VDEC_Result retVal = E_VDEC_FAIL;
10531
10532 if (!_Attr.bInit)
10533 {
10534 return E_VDEC_RET_NOT_INIT;
10535 }
10536
10537 switch (_Attr.eDecoder)
10538 {
10539 case E_VDEC_DECODER_MVD:
10540 {
10541 MVD_ExtDispInfo stExtDispInfo;
10542 _VDEC_Memset(&stExtDispInfo, 0, sizeof(MVD_ExtDispInfo));
10543 _MVD_RET_HANDLE(MDrv_MVD_GetExtDispInfo(&stExtDispInfo));
10544
10545 pExtDispinfo->u16VSize = stExtDispInfo.u16VSize;
10546 pExtDispinfo->u16HSize = stExtDispInfo.u16HSize;
10547 pExtDispinfo->s16VOffset = (MS_S16)stExtDispInfo.u16VOffset;
10548 pExtDispinfo->s16HOffset = (MS_S16)stExtDispInfo.u16HOffset;
10549 retVal = E_VDEC_OK;
10550 break;
10551 }
10552 case E_VDEC_DECODER_HVD:
10553 case E_VDEC_DECODER_MJPEG:
10554 case E_VDEC_DECODER_RVD:
10555 retVal = E_VDEC_RET_UNSUPPORTED;
10556 break;
10557
10558 default:
10559 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10560 break;
10561 }
10562 return retVal;
10563 }
10564
10565
10566 //------------------------------------------------------------------------------
10567 /// Get the time_code of the latest decoded frame.
10568 /// @param pTimeCode \b IN : the time_code of the latest decoded frame
10569 /// @return -VDEC_Result
10570 //------------------------------------------------------------------------------
MApi_VDEC_GetDecTimeCode(VDEC_TimeCode * pTimeCode)10571 VDEC_Result MApi_VDEC_GetDecTimeCode(VDEC_TimeCode* pTimeCode)
10572 {
10573 if (pu32VDEC_Inst == NULL)
10574 {
10575 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10576 return E_VDEC_FAIL;
10577 }
10578
10579 VDEC_V2_IO_Param IO_arg;
10580 VDEC_Result eRet = E_VDEC_FAIL;
10581
10582 IO_arg.param[0] = (void *)pTimeCode;
10583 IO_arg.pRet = (void *)&eRet;
10584
10585
10586 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_DEC_TIME_CODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10587 {
10588 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10589 return E_VDEC_FAIL;
10590 }
10591 else
10592 {
10593 return eRet;
10594 }
10595 }
10596
10597 //------------------------------------------------------------------------------
10598 /// Get the time_code of the latest decoded frame.
10599 /// @param pTimeCode \b IN : the time_code of the latest decoded frame
10600 /// @return -VDEC_Result
10601 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetDecTimeCode(VDEC_TimeCode * pTimeCode)10602 VDEC_Result MApi_VDEC_V2_GetDecTimeCode(VDEC_TimeCode* pTimeCode)
10603 {
10604 VDEC_Result retVal = E_VDEC_FAIL;
10605
10606 if (!_Attr.bInit)
10607 {
10608 return E_VDEC_RET_NOT_INIT;
10609 }
10610
10611 switch (_Attr.eDecoder)
10612 {
10613 case E_VDEC_DECODER_MVD:
10614 {
10615 MVD_TimeCode stTimeCode;
10616 _VDEC_Memset(&stTimeCode, 0, sizeof(MVD_TimeCode));
10617 _MVD_RET_HANDLE(MDrv_MVD_GetTimeCode(E_MVD_FRMINFO_DECODE, &stTimeCode));
10618
10619 pTimeCode->u8TimeCodeHr = stTimeCode.u8TimeCodeHr ;
10620 pTimeCode->u8TimeCodeMin = stTimeCode.u8TimeCodeMin;
10621 pTimeCode->u8TimeCodeSec = stTimeCode.u8TimeCodeSec;
10622 pTimeCode->u8TimeCodePic = stTimeCode.u8TimeCodePic;
10623 pTimeCode->u8DropFrmFlag = stTimeCode.u8DropFrmFlag;
10624
10625 retVal = E_VDEC_OK;
10626 break;
10627 }
10628
10629 case E_VDEC_DECODER_HVD:
10630 case E_VDEC_DECODER_MJPEG:
10631 case E_VDEC_DECODER_RVD:
10632 retVal = E_VDEC_RET_UNSUPPORTED;
10633 break;
10634
10635 default:
10636 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10637 break;
10638 }
10639
10640 return retVal;
10641 }
10642
10643 //------------------------------------------------------------------------------
10644 /// Get the time_code of the latest displayed frame.
10645 /// @param pTimeCode \b IN : the time_code of the latest displayed frame
10646 /// @return -VDEC_Result
10647 //------------------------------------------------------------------------------
MApi_VDEC_GetDispTimeCode(VDEC_TimeCode * pTimeCode)10648 VDEC_Result MApi_VDEC_GetDispTimeCode(VDEC_TimeCode* pTimeCode)
10649 {
10650 if (pu32VDEC_Inst == NULL)
10651 {
10652 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10653 return E_VDEC_FAIL;
10654 }
10655
10656 VDEC_V2_IO_Param IO_arg;
10657 VDEC_Result eRet = E_VDEC_FAIL;
10658
10659 IO_arg.param[0] = (void *)pTimeCode;
10660 IO_arg.pRet = (void *)&eRet;
10661
10662
10663 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GET_DISP_TIME_CODE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10664 {
10665 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10666 return E_VDEC_FAIL;
10667 }
10668 else
10669 {
10670 return eRet;
10671 }
10672 }
10673
10674
10675 //------------------------------------------------------------------------------
10676 /// Get the time_code of the latest displayed frame.
10677 /// @param pTimeCode \b IN : the time_code of the latest displayed frame
10678 /// @return -VDEC_Result
10679 //------------------------------------------------------------------------------
MApi_VDEC_V2_GetDispTimeCode(VDEC_TimeCode * pTimeCode)10680 VDEC_Result MApi_VDEC_V2_GetDispTimeCode(VDEC_TimeCode* pTimeCode)
10681 {
10682 VDEC_Result retVal = E_VDEC_FAIL;
10683
10684 if (!_Attr.bInit)
10685 {
10686 return E_VDEC_RET_NOT_INIT;
10687 }
10688
10689 switch (_Attr.eDecoder)
10690 {
10691 case E_VDEC_DECODER_MVD:
10692 {
10693 MVD_TimeCode stTimeCode;
10694 _VDEC_Memset(&stTimeCode, 0, sizeof(MVD_TimeCode));
10695 _MVD_RET_HANDLE(MDrv_MVD_GetTimeCode(E_MVD_FRMINFO_DISPLAY, &stTimeCode));
10696
10697 pTimeCode->u8TimeCodeHr = stTimeCode.u8TimeCodeHr ;
10698 pTimeCode->u8TimeCodeMin = stTimeCode.u8TimeCodeMin;
10699 pTimeCode->u8TimeCodeSec = stTimeCode.u8TimeCodeSec;
10700 pTimeCode->u8TimeCodePic = stTimeCode.u8TimeCodePic;
10701 pTimeCode->u8DropFrmFlag = stTimeCode.u8DropFrmFlag;
10702
10703 retVal = E_VDEC_OK;
10704 break;
10705 }
10706
10707 case E_VDEC_DECODER_HVD:
10708 case E_VDEC_DECODER_MJPEG:
10709 case E_VDEC_DECODER_RVD:
10710 retVal = E_VDEC_RET_UNSUPPORTED;
10711 break;
10712
10713 default:
10714 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10715 break;
10716 }
10717
10718 return retVal;
10719 }
10720
10721
10722 //------------------------------------------------------------------------------
10723 /// Start CC data parsing.
10724 /// @param pCCParam \b IN : CC configuration
10725 /// @return -VDEC_Result
10726 //------------------------------------------------------------------------------
MApi_VDEC_CC_StartParsing(VDEC_CCCfg * pCCParam)10727 VDEC_Result MApi_VDEC_CC_StartParsing(VDEC_CCCfg* pCCParam)
10728 {
10729 if (pu32VDEC_Inst == NULL)
10730 {
10731 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10732 return E_VDEC_FAIL;
10733 }
10734
10735 VDEC_V2_IO_Param IO_arg;
10736 VDEC_Result retVal = E_VDEC_FAIL;
10737
10738 IO_arg.param[0] = (void *)(pCCParam);
10739 IO_arg.pRet = (void *)&retVal;
10740
10741 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_STARTPARSING, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10742 {
10743 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10744 return E_VDEC_FAIL;
10745 }
10746 else
10747 {
10748 return retVal;
10749 }
10750
10751 }
10752
MApi_VDEC_V2_CC_StartParsing(VDEC_CCCfg * pCCParam)10753 VDEC_Result MApi_VDEC_V2_CC_StartParsing(VDEC_CCCfg* pCCParam)
10754 {
10755 VDEC_Result retVal;
10756
10757 if (!_Attr.bInit)
10758 {
10759 return E_VDEC_RET_NOT_INIT;
10760 }
10761
10762 switch (_Attr.eDecoder)
10763 {
10764 case E_VDEC_DECODER_MVD:
10765 {
10766 E_MVD_Result ret = MDrv_MVD_CCStartParsing((MVD_CCCfg*)pCCParam);
10767
10768 if(ret == E_MVD_RET_OK)
10769 {
10770 _Attr.eCCFormat = pCCParam->eFormat;
10771 retVal = E_VDEC_OK;
10772 }
10773 else
10774 {
10775 retVal = E_VDEC_FAIL;
10776 }
10777 }
10778
10779 break;
10780
10781 case E_VDEC_DECODER_HVD:
10782 case E_VDEC_DECODER_MJPEG:
10783 case E_VDEC_DECODER_RVD:
10784 retVal = E_VDEC_RET_UNSUPPORTED;
10785 break;
10786
10787 default:
10788 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10789 break;
10790 }
10791
10792 return retVal;
10793 }
10794
10795 //------------------------------------------------------------------------------
10796 /// Stop CC data parsing.
10797 /// @return -VDEC_Result
10798 //------------------------------------------------------------------------------
MApi_VDEC_CC_StopParsing(void)10799 VDEC_Result MApi_VDEC_CC_StopParsing(void)
10800 {
10801 if (pu32VDEC_Inst == NULL)
10802 {
10803 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10804 return E_VDEC_FAIL;
10805 }
10806
10807 VDEC_V2_IO_Param IO_arg;
10808 VDEC_Result retVal = E_VDEC_FAIL;
10809
10810 IO_arg.pRet = (void *)&retVal;
10811
10812 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_STOPPARSING, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10813 {
10814 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10815 return E_VDEC_FAIL;
10816 }
10817 else
10818 {
10819 return retVal;
10820 }
10821
10822 }
10823
MApi_VDEC_V2_CC_StopParsing(void)10824 VDEC_Result MApi_VDEC_V2_CC_StopParsing(void)
10825 {
10826 VDEC_Result retVal;
10827
10828 if (!_Attr.bInit)
10829 {
10830 return E_VDEC_RET_NOT_INIT;
10831 }
10832
10833 switch (_Attr.eDecoder)
10834 {
10835 case E_VDEC_DECODER_MVD:
10836 {
10837 E_MVD_Result ret = MDrv_MVD_CCStopParsing((MVD_CCFormat)_Attr.eCCFormat);
10838
10839 if(ret == E_MVD_RET_OK)
10840 {
10841 retVal = E_VDEC_OK;
10842 }
10843 else
10844 {
10845 retVal = E_VDEC_FAIL;
10846 }
10847 }
10848
10849 break;
10850
10851 case E_VDEC_DECODER_HVD:
10852 case E_VDEC_DECODER_MJPEG:
10853 case E_VDEC_DECODER_RVD:
10854 retVal = E_VDEC_RET_UNSUPPORTED;
10855 break;
10856
10857 default:
10858 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10859 break;
10860 }
10861
10862 return retVal;
10863 }
10864
10865 //------------------------------------------------------------------------------
10866 /// Get write pointer of CC data buffer.
10867 /// @param pu32Write \b OUT : current write pointer
10868 /// @return -VDEC_Result
10869 //------------------------------------------------------------------------------
MApi_VDEC_CC_GetWritePtr(MS_U32 * pu32Write)10870 VDEC_Result MApi_VDEC_CC_GetWritePtr(MS_U32* pu32Write)
10871 {
10872 if (pu32VDEC_Inst == NULL)
10873 {
10874 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10875 return E_VDEC_FAIL;
10876 }
10877
10878 VDEC_V2_IO_Param IO_arg;
10879 VDEC_Result retVal = E_VDEC_FAIL;
10880
10881 IO_arg.param[0] = (void *)pu32Write;
10882 IO_arg.pRet = (void *)&retVal;
10883
10884 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETWRITEPTR, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10885 {
10886 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10887 return E_VDEC_FAIL;
10888 }
10889 else
10890 {
10891 return retVal;
10892 }
10893
10894 }
10895
MApi_VDEC_V2_CC_GetWritePtr(MS_U32 * pu32Write)10896 VDEC_Result MApi_VDEC_V2_CC_GetWritePtr(MS_U32* pu32Write)
10897 {
10898 VDEC_Result retVal;
10899
10900 if (!_Attr.bInit)
10901 {
10902 return E_VDEC_RET_NOT_INIT;
10903 }
10904
10905 switch (_Attr.eDecoder)
10906 {
10907 case E_VDEC_DECODER_MVD:
10908 {
10909 E_MVD_Result ret = MDrv_MVD_CCGetWritePtr((MVD_CCFormat)_Attr.eCCFormat, pu32Write);
10910
10911 if(ret == E_MVD_RET_OK)
10912 {
10913 retVal = E_VDEC_OK;
10914 }
10915 else
10916 {
10917 retVal = E_VDEC_FAIL;
10918 }
10919 }
10920
10921 break;
10922
10923 case E_VDEC_DECODER_HVD:
10924 case E_VDEC_DECODER_MJPEG:
10925 case E_VDEC_DECODER_RVD:
10926 retVal = E_VDEC_RET_UNSUPPORTED;
10927 break;
10928
10929 default:
10930 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
10931 break;
10932 }
10933
10934 return retVal;
10935 }
10936
10937 //------------------------------------------------------------------------------
10938 /// Get the read pointer of CC data buffer.
10939 /// @param pu32Read \b OUT : current read pointer
10940 /// @return -VDEC_Result
10941 //------------------------------------------------------------------------------
MApi_VDEC_CC_GetReadPtr(MS_U32 * pu32Read)10942 VDEC_Result MApi_VDEC_CC_GetReadPtr(MS_U32* pu32Read)
10943 {
10944 if (pu32VDEC_Inst == NULL)
10945 {
10946 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10947 return E_VDEC_FAIL;
10948 }
10949
10950 VDEC_V2_IO_Param IO_arg;
10951 VDEC_Result retVal = E_VDEC_FAIL;
10952
10953 IO_arg.param[0] = (void *)pu32Read;
10954 IO_arg.pRet = (void *)&retVal;
10955
10956 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETREADPTR, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
10957 {
10958 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
10959 return E_VDEC_FAIL;
10960 }
10961 else
10962 {
10963 return retVal;
10964 }
10965 }
10966
MApi_VDEC_V2_CC_GetReadPtr(MS_U32 * pu32Read)10967 VDEC_Result MApi_VDEC_V2_CC_GetReadPtr(MS_U32* pu32Read)
10968 {
10969 VDEC_Result retVal;
10970
10971 if (!_Attr.bInit)
10972 {
10973 return E_VDEC_RET_NOT_INIT;
10974 }
10975
10976 switch (_Attr.eDecoder)
10977 {
10978 case E_VDEC_DECODER_MVD:
10979 {
10980 E_MVD_Result ret = MDrv_MVD_CCGetReadPtr((MVD_CCFormat)_Attr.eCCFormat, pu32Read);
10981
10982 if(ret == E_MVD_RET_OK)
10983 {
10984 retVal = E_VDEC_OK;
10985 }
10986 else
10987 {
10988 retVal = E_VDEC_FAIL;
10989 }
10990 }
10991 break;
10992
10993 case E_VDEC_DECODER_HVD:
10994 case E_VDEC_DECODER_MJPEG:
10995 case E_VDEC_DECODER_RVD:
10996 retVal = E_VDEC_RET_UNSUPPORTED;
10997 break;
10998
10999 default:
11000 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
11001 break;
11002 }
11003
11004 return retVal;
11005 }
11006
11007 //------------------------------------------------------------------------------
11008 /// Update the read pointer of CC data buffer.
11009 /// @param u32EachPacketSize \b IN : new read pointer
11010 /// @return -VDEC_Result
11011 //------------------------------------------------------------------------------
MApi_VDEC_CC_UpdateReadPtr(MS_U32 u32EachPacketSize)11012 VDEC_Result MApi_VDEC_CC_UpdateReadPtr(MS_U32 u32EachPacketSize)
11013 {
11014 if (pu32VDEC_Inst == NULL)
11015 {
11016 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11017 return E_VDEC_FAIL;
11018 }
11019
11020 VDEC_V2_IO_Param IO_arg;
11021 VDEC_Result retVal = E_VDEC_FAIL;
11022
11023 IO_arg.param[0] = (void *)&u32EachPacketSize;
11024 IO_arg.pRet = (void *)&retVal;
11025
11026 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_UPDATEREADPTR, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
11027 {
11028 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11029 return E_VDEC_FAIL;
11030 }
11031 else
11032 {
11033 return retVal;
11034 }
11035 }
11036
MApi_VDEC_V2_CC_UpdateReadPtr(MS_U32 u32EachPacketSize)11037 VDEC_Result MApi_VDEC_V2_CC_UpdateReadPtr(MS_U32 u32EachPacketSize)
11038 {
11039 VDEC_Result retVal;
11040
11041 if (!_Attr.bInit)
11042 {
11043 return E_VDEC_RET_NOT_INIT;
11044 }
11045
11046 switch (_Attr.eDecoder)
11047 {
11048 case E_VDEC_DECODER_MVD:
11049 {
11050 E_MVD_Result ret = MDrv_MVD_CCUpdateReadPtr((MVD_CCFormat)_Attr.eCCFormat, u32EachPacketSize);
11051
11052 if(ret == E_MVD_RET_OK)
11053 {
11054 retVal = E_VDEC_OK;
11055 }
11056 else
11057 {
11058 retVal = E_VDEC_FAIL;
11059 }
11060 }
11061 break;
11062
11063 case E_VDEC_DECODER_HVD:
11064 case E_VDEC_DECODER_MJPEG:
11065 case E_VDEC_DECODER_RVD:
11066 retVal = E_VDEC_RET_UNSUPPORTED;
11067 break;
11068
11069 default:
11070 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
11071 break;
11072 }
11073
11074 return retVal;
11075 }
11076
11077 //------------------------------------------------------------------------------
11078 /// Get if CC data buffer is overflow.
11079 /// @param pbOverflow \b OUT : overflow flag
11080 /// @return -VDEC_Result
11081 //------------------------------------------------------------------------------
MApi_VDEC_CC_GetIsOverflow(MS_BOOL * pbOverflow)11082 VDEC_Result MApi_VDEC_CC_GetIsOverflow(MS_BOOL* pbOverflow)
11083 {
11084 if (pu32VDEC_Inst == NULL)
11085 {
11086 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11087 return E_VDEC_FAIL;
11088 }
11089
11090 VDEC_V2_IO_Param IO_arg;
11091 VDEC_Result retVal = E_VDEC_FAIL;
11092
11093 IO_arg.param[0] = (void *)pbOverflow;
11094 IO_arg.pRet = (void *)&retVal;
11095
11096 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETISOVERFLOW, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
11097 {
11098 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11099 return E_VDEC_FAIL;
11100 }
11101 else
11102 {
11103 return retVal;
11104 }
11105 }
11106
MApi_VDEC_V2_CC_GetIsOverflow(MS_BOOL * pbOverflow)11107 VDEC_Result MApi_VDEC_V2_CC_GetIsOverflow(MS_BOOL* pbOverflow)
11108 {
11109 VDEC_Result retVal;
11110
11111 if (!_Attr.bInit)
11112 {
11113 return E_VDEC_RET_NOT_INIT;
11114 }
11115
11116 switch (_Attr.eDecoder)
11117 {
11118 case E_VDEC_DECODER_MVD:
11119 {
11120 E_MVD_Result ret = MDrv_MVD_CCGetIsOverflow((MVD_CCFormat)_Attr.eCCFormat, pbOverflow);
11121
11122 if(ret == E_MVD_RET_OK)
11123 {
11124 retVal = E_VDEC_OK;
11125 }
11126 else
11127 {
11128 retVal = E_VDEC_FAIL;
11129 }
11130 }
11131 break;
11132
11133 case E_VDEC_DECODER_HVD:
11134 case E_VDEC_DECODER_MJPEG:
11135 case E_VDEC_DECODER_RVD:
11136 retVal = E_VDEC_RET_UNSUPPORTED;
11137 break;
11138
11139 default:
11140 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
11141 break;
11142 }
11143
11144 return retVal;
11145 }
11146
MApi_VDEC_SetEvent(MS_U32 u32EnableEvent,VDEC_EventCb pfn,void * param)11147 VDEC_Result MApi_VDEC_SetEvent(MS_U32 u32EnableEvent, VDEC_EventCb pfn, void *param)
11148 {
11149 if (pu32VDEC_Inst == NULL)
11150 {
11151 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11152 return E_VDEC_FAIL;
11153 }
11154
11155 VDEC_V2_IO_Param IO_arg;
11156 VDEC_Result retVal = E_VDEC_FAIL;
11157
11158 IO_arg.param[0] = (void *)&u32EnableEvent;
11159 IO_arg.param[1] = (void *)&pfn;
11160 IO_arg.param[2] = (void *)param;
11161 IO_arg.pRet = (void *)&retVal;
11162
11163 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SETEVENT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
11164 {
11165 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11166 return E_VDEC_FAIL;
11167 }
11168 else
11169 {
11170 return retVal;
11171 }
11172 }
11173
MApi_VDEC_V2_SetEvent(MS_U32 u32EnableEvent,VDEC_EventCb pfn,void * param)11174 VDEC_Result MApi_VDEC_V2_SetEvent(MS_U32 u32EnableEvent, VDEC_EventCb pfn, void *param)
11175 {
11176 VDEC_Result retVal = E_VDEC_FAIL;
11177 MS_U32 i = 0;
11178
11179 _VDEC_MutexLock();
11180
11181 if (!_Attr.bInit)
11182 {
11183 _VDEC_MutexUnlock();
11184 return E_VDEC_RET_NOT_INIT;
11185 }
11186
11187 if ((u32EnableEvent != E_VDEC_EVENT_OFF) && (pfn == NULL))
11188 {
11189 _VDEC_MutexUnlock();
11190 return E_VDEC_RET_INVALID_PARAM;
11191 }
11192
11193 _Attr.VdecEventInfo[E_VDEC_CB_MAIN].u32EventBitMap = u32EnableEvent;
11194 _Attr.VdecEventInfo[E_VDEC_CB_MAIN].pVdecEventCb = pfn;
11195 _Attr.VdecEventInfo[E_VDEC_CB_MAIN].pParam = param;
11196
11197 #if defined(VDEC_ISR_MONITOR)
11198 _u32VdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE;
11199 #else
11200 _u32VdecIsrEventFlag = 0; //reset event flag;
11201 #endif
11202 for(i = 0; i < E_VDEC_CB_MAX_NUM; i++)
11203 {
11204 _u32VdecIsrEventFlag |= _Attr.VdecEventInfo[i].u32EventBitMap;
11205 }
11206
11207 #if defined(VDEC_ISR_MONITOR)
11208 MsOS_SetEvent(_s32VdecEventId, E_VDEC_EVENT_ISR_EVENT_CHANGE);
11209 #endif
11210
11211 switch (_Attr.eDecoder)
11212 {
11213 case E_VDEC_DECODER_MVD:
11214 {
11215 MS_U32 u32Event = 0;
11216
11217 //Set Event
11218
11219 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_ONE)
11220 {
11221 u32Event |= E_MVD_EVENT_DISP_VSYNC;
11222 }
11223
11224 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
11225 {
11226 u32Event |= E_MVD_EVENT_DISP_RDY;
11227 }
11228
11229 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
11230 {
11231 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11232 }
11233
11234 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_SEQ_HDR_FOUND)
11235 {
11236 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11237 }
11238
11239 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
11240 {
11241 #if defined(MVD_SUPPORT_X4_CC)
11242 //subscribe event "CC data found in display order"
11243 u32Event |= E_MVD_EVENT_USER_DATA_DISP;
11244 #else
11245 u32Event |= E_MVD_EVENT_USER_DATA;
11246 #endif
11247 }
11248
11249 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
11250 {
11251 u32Event |= E_MVD_EVENT_USER_DATA;
11252 }
11253
11254 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
11255 {
11256 u32Event |= E_MVD_EVENT_FIRST_FRAME;
11257 }
11258
11259 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_PIC_FOUND)
11260 {
11261 u32Event |= E_MVD_EVENT_PIC_FOUND;
11262 }
11263
11264 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
11265 {
11266 u32Event |= E_MVD_EVENT_UNMUTE;
11267 }
11268 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
11269 {
11270 u32Event |= E_MVD_EVENT_DEC_I;
11271 }
11272
11273 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11274 {
11275 _VDEC_MutexUnlock();
11276 }
11277 if(E_MVD_RET_OK != MDrv_MVD_SetIsrEvent(u32Event,(MVD_InterruptCb)_VDEC_IsrProc))
11278 {
11279 retVal = E_VDEC_FAIL;
11280 }
11281 else
11282 {
11283 retVal = E_VDEC_OK;
11284 }
11285 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11286 {
11287 _VDEC_MutexLock();
11288 }
11289 break;
11290 }
11291 case E_VDEC_DECODER_HVD:
11292 {
11293 MS_U32 eEvent = E_HVD_ISR_NONE;
11294
11295 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_ONE)
11296 {
11297 eEvent |= E_HVD_ISR_DISP_ONE;
11298 }
11299
11300 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_REPEAT)
11301 {
11302 eEvent |= E_HVD_ISR_DISP_REPEAT;
11303 }
11304
11305 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_WITH_CC)
11306 {
11307 eEvent |= E_HVD_ISR_DISP_WITH_CC;
11308 }
11309
11310 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ONE)
11311 {
11312 eEvent |= E_HVD_ISR_DEC_ONE;
11313 }
11314
11315 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
11316 {
11317 eEvent |= E_HVD_ISR_DEC_I;
11318 }
11319
11320 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ERR)
11321 {
11322 eEvent |= E_HVD_ISR_DEC_HW_ERR;
11323 }
11324
11325 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
11326 {
11327 eEvent |= E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11328 }
11329
11330 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
11331 {
11332 eEvent |= E_HVD_ISR_DEC_CC_FOUND;
11333 }
11334
11335 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
11336 {
11337 eEvent |= E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11338 }
11339
11340 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
11341 {
11342 eEvent |= E_HVD_ISR_DEC_FIRST_FRM;
11343 }
11344
11345 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
11346 {
11347 eEvent |= E_HVD_ISR_DISP_FIRST_FRM;
11348 }
11349
11350 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
11351 {
11352 eEvent |= E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11353 }
11354
11355 if (eEvent != E_HVD_ISR_NONE)
11356 {
11357 if(E_HVD_OK != MDrv_HVD_SetISREvent(eEvent, (HVD_InterruptCb) _VDEC_IsrProc))
11358 {
11359 _VDEC_MutexUnlock();
11360 return E_VDEC_FAIL;
11361 }
11362 }
11363 retVal = E_VDEC_OK;
11364 break;
11365 }
11366 case E_VDEC_DECODER_MJPEG:
11367 {
11368 retVal = E_VDEC_RET_UNSUPPORTED;
11369 break;
11370 }
11371 case E_VDEC_DECODER_RVD:
11372 {
11373 #if 1
11374 if (_u32VdecIsrEventFlag == E_VDEC_EVENT_OFF)
11375 {
11376 MDrv_RVD_SetISREvent(E_RVD_ISR_NONE,
11377 (RVD_InterruptCb) _VDEC_IsrProc);
11378 }
11379 retVal = E_VDEC_OK;
11380
11381 #else
11382 retVal = E_VDEC_RET_UNSUPPORTED;
11383 #endif
11384 break;
11385 }
11386 default:
11387 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
11388 break;
11389 }
11390
11391 _VDEC_MutexUnlock();
11392
11393 return retVal;
11394 }
11395
MApi_VDEC_UnsetEvent(MS_U32 u32EnableEvent)11396 VDEC_Result MApi_VDEC_UnsetEvent(MS_U32 u32EnableEvent)
11397 {
11398 if (pu32VDEC_Inst == NULL)
11399 {
11400 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11401 return E_VDEC_FAIL;
11402 }
11403
11404 VDEC_V2_IO_Param IO_arg;
11405 VDEC_Result retVal = E_VDEC_FAIL;
11406
11407 IO_arg.param[0] = (void *)&u32EnableEvent;
11408 IO_arg.pRet = (void *)&retVal;
11409
11410 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_UNSETEVENT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
11411 {
11412 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11413 return E_VDEC_FAIL;
11414 }
11415 else
11416 {
11417 return retVal;
11418 }
11419 }
11420
MApi_VDEC_V2_UnsetEvent(MS_U32 u32EnableEvent)11421 VDEC_Result MApi_VDEC_V2_UnsetEvent(MS_U32 u32EnableEvent)
11422 {
11423 VDEC_Result retVal = E_VDEC_FAIL;
11424 MS_U32 i = 0;
11425
11426 _VDEC_MutexLock();
11427
11428 if (!_Attr.bInit)
11429 {
11430 _VDEC_MutexUnlock();
11431 return E_VDEC_RET_NOT_INIT;
11432 }
11433
11434 if(u32EnableEvent == E_VDEC_EVENT_OFF)
11435 {
11436 _VDEC_MutexUnlock();
11437 return E_VDEC_RET_INVALID_PARAM;
11438 }
11439
11440 _Attr.VdecEventInfo[E_VDEC_CB_MAIN].u32EventBitMap &= ~u32EnableEvent;
11441
11442 if(E_VDEC_EVENT_OFF == _Attr.VdecEventInfo[E_VDEC_CB_MAIN].u32EventBitMap)
11443 {
11444 _Attr.VdecEventInfo[E_VDEC_CB_MAIN].pVdecEventCb = NULL;
11445 _Attr.VdecEventInfo[E_VDEC_CB_MAIN].pParam = NULL;
11446 }
11447
11448 #if defined(VDEC_ISR_MONITOR) //clear ISR Event flag ,
11449 _u32VdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE; //reset event flag;
11450 #else
11451 _u32VdecIsrEventFlag = 0; //reset event flag;
11452 #endif
11453 for(i = 0; i < E_VDEC_CB_MAX_NUM; i++)
11454 {
11455 _u32VdecIsrEventFlag |= _Attr.VdecEventInfo[i].u32EventBitMap;
11456 }
11457
11458 #if defined(VDEC_ISR_MONITOR)
11459 MsOS_SetEvent(_s32VdecEventId, E_VDEC_EVENT_ISR_EVENT_CHANGE);
11460 #endif
11461
11462 switch (_Attr.eDecoder)
11463 {
11464 case E_VDEC_DECODER_MVD:
11465 {
11466 MS_U32 u32Event = 0;
11467
11468 //Set Event
11469 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
11470 {
11471 u32Event |= E_MVD_EVENT_DISP_RDY;
11472 }
11473
11474 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
11475 {
11476 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11477 }
11478
11479 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_SEQ_HDR_FOUND)
11480 {
11481 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11482 }
11483
11484 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
11485 {
11486 #if defined(MVD_SUPPORT_X4_CC)
11487 u32Event |= E_MVD_EVENT_USER_DATA_DISP;
11488 #else
11489 u32Event |= E_MVD_EVENT_USER_DATA;
11490 #endif
11491 }
11492
11493 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
11494 {
11495 u32Event |= E_MVD_EVENT_USER_DATA;
11496 }
11497
11498 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
11499 {
11500 u32Event |= E_MVD_EVENT_FIRST_FRAME;
11501 }
11502
11503 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_PIC_FOUND)
11504 {
11505 u32Event |= E_MVD_EVENT_PIC_FOUND;
11506 }
11507
11508 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
11509 {
11510 u32Event |= E_MVD_EVENT_UNMUTE;
11511 }
11512 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
11513 {
11514 u32Event |= E_MVD_EVENT_DEC_I;
11515 }
11516
11517
11518 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11519 {
11520 _VDEC_MutexUnlock();
11521 }
11522 if(E_MVD_RET_OK != MDrv_MVD_SetIsrEvent(u32Event, (MVD_InterruptCb) _VDEC_IsrProc))
11523 {
11524 retVal = E_VDEC_FAIL;
11525 }
11526 else
11527 {
11528 retVal = E_VDEC_OK;
11529 }
11530 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11531 {
11532 _VDEC_MutexLock();
11533 }
11534 break;
11535 }
11536 case E_VDEC_DECODER_HVD:
11537 {
11538 HVD_ISR_Event eEvent = E_HVD_ISR_NONE;
11539
11540 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_ONE)
11541 {
11542 eEvent|=E_HVD_ISR_DISP_ONE;
11543 }
11544 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_REPEAT)
11545 {
11546 eEvent|=E_HVD_ISR_DISP_REPEAT;
11547 }
11548 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_WITH_CC)
11549 {
11550 eEvent|=E_HVD_ISR_DISP_WITH_CC;
11551 }
11552
11553 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ONE)
11554 {
11555 eEvent|=E_HVD_ISR_DEC_ONE;
11556 }
11557 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
11558 {
11559 eEvent|=E_HVD_ISR_DEC_I;
11560 }
11561 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ERR)
11562 {
11563 eEvent|=E_HVD_ISR_DEC_HW_ERR;
11564 }
11565
11566 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
11567 {
11568 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11569 }
11570
11571 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
11572 {
11573 eEvent|=E_HVD_ISR_DEC_CC_FOUND;
11574 }
11575
11576 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
11577 {
11578 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11579 }
11580
11581 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
11582 {
11583 eEvent|=E_HVD_ISR_DEC_FIRST_FRM;
11584 }
11585
11586 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
11587 {
11588 eEvent|=E_HVD_ISR_DISP_FIRST_FRM;
11589 }
11590
11591 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
11592 {
11593 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11594 }
11595
11596 if( eEvent != E_HVD_ISR_NONE )
11597 {
11598 if(E_HVD_OK !=MDrv_HVD_SetISREvent(eEvent, (HVD_InterruptCb) _VDEC_IsrProc))
11599 {
11600 _VDEC_MutexUnlock();
11601 return E_VDEC_FAIL;
11602 }
11603 }
11604 retVal = E_VDEC_OK;
11605 break;
11606 }
11607 case E_VDEC_DECODER_MJPEG:
11608 {
11609 retVal = E_VDEC_RET_UNSUPPORTED;
11610 break;
11611 }
11612 case E_VDEC_DECODER_RVD:
11613 {
11614 #if 1
11615 if (_u32VdecIsrEventFlag == E_VDEC_EVENT_OFF)
11616 {
11617 MDrv_RVD_SetISREvent(E_RVD_ISR_NONE, (RVD_InterruptCb) _VDEC_IsrProc);
11618 }
11619 retVal = E_VDEC_OK;
11620
11621 #else
11622 retVal = E_VDEC_RET_UNSUPPORTED;
11623 #endif
11624 break;
11625 }
11626 default:
11627 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
11628 break;
11629 }
11630
11631 _VDEC_MutexUnlock();
11632
11633 return retVal;
11634 }
11635
11636 //------------------------------------------------------------------------------
11637 /// set ISR event CB
11638 /// @param cb_type \b IN : The CB type for VDEC interrupt
11639 /// @param u32EnableEvent \b IN : The event flag for user data CB function
11640 /// @param pfn \b IN : user data CB function
11641 /// @param param \b IN : the param of/for user data CB function
11642 /// @return status
11643 //------------------------------------------------------------------------------
MApi_VDEC_SetEvent_EX(VDEC_CB_TYPE cb_type,MS_U32 u32EnableEvent,VDEC_EventCb pfn,void * param)11644 VDEC_Result MApi_VDEC_SetEvent_EX(VDEC_CB_TYPE cb_type, MS_U32 u32EnableEvent, VDEC_EventCb pfn, void* param)
11645 {
11646 if (pu32VDEC_Inst == NULL)
11647 {
11648 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11649 return E_VDEC_FAIL;
11650 }
11651
11652 VDEC_V2_IO_Param IO_arg;
11653 VDEC_Result retVal = E_VDEC_FAIL;
11654
11655 IO_arg.param[0] = (void *)&cb_type;
11656 IO_arg.param[1] = (void *)&u32EnableEvent;
11657 IO_arg.param[2] = (void *)&pfn;
11658 IO_arg.param[3] = (void *)param;
11659 IO_arg.pRet = (void *)&retVal;
11660
11661 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SETENVENT_EX, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
11662 {
11663 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11664 return E_VDEC_FAIL;
11665 }
11666 else
11667 {
11668 return retVal;
11669 }
11670 }
11671
MApi_VDEC_V2_SetEvent_EX(VDEC_CB_TYPE cb_type,MS_U32 u32EnableEvent,VDEC_EventCb pfn,void * param)11672 VDEC_Result MApi_VDEC_V2_SetEvent_EX(VDEC_CB_TYPE cb_type, MS_U32 u32EnableEvent, VDEC_EventCb pfn, void* param)
11673 {
11674 VDEC_Result retVal = E_VDEC_FAIL;
11675 MS_U32 i = 0;
11676
11677 _VDEC_MutexLock();
11678
11679 if (!_Attr.bInit)
11680 {
11681 _VDEC_MutexUnlock();
11682 return E_VDEC_RET_NOT_INIT;
11683 }
11684
11685 if( (u32EnableEvent != E_VDEC_EVENT_OFF) && (pfn == NULL) )
11686 {
11687 _VDEC_MutexUnlock();
11688 return E_VDEC_RET_INVALID_PARAM;
11689 }
11690
11691 _Attr.VdecEventInfo[cb_type].u32EventBitMap = u32EnableEvent;
11692 _Attr.VdecEventInfo[cb_type].pVdecEventCb = pfn;
11693 _Attr.VdecEventInfo[cb_type].pParam = param;
11694
11695 #if defined(VDEC_ISR_MONITOR)
11696 _u32VdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE;
11697 #else
11698 _u32VdecIsrEventFlag = 0; //reset event flag;
11699 #endif
11700 for(i = 0; i < E_VDEC_CB_MAX_NUM; i++)
11701 {
11702 _u32VdecIsrEventFlag |= _Attr.VdecEventInfo[cb_type].u32EventBitMap;
11703 }
11704
11705 #if defined(VDEC_ISR_MONITOR)
11706 MsOS_SetEvent(_s32VdecEventId, E_VDEC_EVENT_ISR_EVENT_CHANGE);
11707 #endif
11708
11709 switch (_Attr.eDecoder)
11710 {
11711 case E_VDEC_DECODER_MVD:
11712 {
11713 MS_U32 u32Event = 0;
11714
11715 //Set Event
11716 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
11717 {
11718 u32Event |= E_MVD_EVENT_DISP_RDY;
11719 }
11720
11721 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
11722 {
11723 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11724 }
11725
11726 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_SEQ_HDR_FOUND)
11727 {
11728 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11729 }
11730
11731 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
11732 {
11733 #if defined(MVD_SUPPORT_X4_CC)
11734 u32Event |= E_MVD_EVENT_USER_DATA_DISP;
11735 #else
11736 u32Event |= E_MVD_EVENT_USER_DATA;
11737 #endif
11738 }
11739
11740 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
11741 {
11742 u32Event |= E_MVD_EVENT_USER_DATA;
11743 }
11744
11745 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
11746 {
11747 u32Event |= E_MVD_EVENT_FIRST_FRAME;
11748 }
11749
11750 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_PIC_FOUND)
11751 {
11752 u32Event |= E_MVD_EVENT_PIC_FOUND;
11753 }
11754
11755 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
11756 {
11757 u32Event |= E_MVD_EVENT_UNMUTE;
11758 }
11759 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
11760 {
11761 u32Event |= E_MVD_EVENT_DEC_I;
11762 }
11763
11764 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11765 {
11766 _VDEC_MutexUnlock();
11767 }
11768 if(E_MVD_RET_OK != MDrv_MVD_SetIsrEvent(u32Event,(MVD_InterruptCb)_VDEC_IsrProc))
11769 {
11770 retVal = E_VDEC_FAIL;
11771 }
11772 else
11773 {
11774 retVal = E_VDEC_OK;
11775 }
11776 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11777 {
11778 _VDEC_MutexLock();
11779 }
11780 break;
11781 }
11782 case E_VDEC_DECODER_HVD:
11783 {
11784 MS_U32 eEvent = E_HVD_ISR_NONE;
11785
11786 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_ONE)
11787 {
11788 eEvent|=E_HVD_ISR_DISP_ONE;
11789 }
11790 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_REPEAT)
11791 {
11792 eEvent|=E_HVD_ISR_DISP_REPEAT;
11793 }
11794 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_WITH_CC)
11795 {
11796 eEvent|=E_HVD_ISR_DISP_WITH_CC;
11797 }
11798
11799 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ONE)
11800 {
11801 eEvent|=E_HVD_ISR_DEC_ONE;
11802 }
11803 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
11804 {
11805 eEvent|=E_HVD_ISR_DEC_I;
11806 }
11807 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ERR)
11808 {
11809 eEvent|=E_HVD_ISR_DEC_HW_ERR;
11810 }
11811
11812 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
11813 {
11814 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11815 }
11816
11817 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
11818 {
11819 eEvent|=E_HVD_ISR_DEC_CC_FOUND;
11820 }
11821
11822 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
11823 {
11824 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11825 }
11826
11827 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
11828 {
11829 eEvent|=E_HVD_ISR_DEC_FIRST_FRM;
11830 }
11831
11832 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
11833 {
11834 eEvent|=E_HVD_ISR_DISP_FIRST_FRM;
11835 }
11836
11837 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
11838 {
11839 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
11840 }
11841
11842 if( eEvent != E_HVD_ISR_NONE )
11843 {
11844 if(E_HVD_OK != MDrv_HVD_SetISREvent(eEvent, (HVD_InterruptCb) _VDEC_IsrProc))
11845 {
11846 _VDEC_MutexUnlock();
11847 return E_VDEC_FAIL;
11848 }
11849
11850 }
11851 retVal = E_VDEC_OK;
11852 break;
11853 }
11854 case E_VDEC_DECODER_MJPEG:
11855 {
11856 retVal = E_VDEC_RET_UNSUPPORTED;
11857 break;
11858 }
11859 case E_VDEC_DECODER_RVD:
11860 {
11861 #if 1
11862 if (_u32VdecIsrEventFlag == E_VDEC_EVENT_OFF)
11863 {
11864 MDrv_RVD_SetISREvent(E_RVD_ISR_NONE, (RVD_InterruptCb) _VDEC_IsrProc);
11865 }
11866 retVal = E_VDEC_OK;
11867
11868 #else
11869 retVal = E_VDEC_RET_UNSUPPORTED;
11870 #endif
11871 break;
11872 }
11873 default:
11874 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
11875 break;
11876 }
11877
11878 _VDEC_MutexUnlock();
11879
11880 return retVal;
11881 }
11882
11883 //------------------------------------------------------------------------------
11884 /// Unset ISR event CB
11885 /// @param cb_type \b IN : The CB type for VDEC interrupt
11886 /// @param u32EnableEvent \b IN : The event flag for user data CB function
11887 /// @return status
11888 //------------------------------------------------------------------------------
MApi_VDEC_UnsetEvent_EX(VDEC_CB_TYPE cb_type,MS_U32 u32EnableEvent)11889 VDEC_Result MApi_VDEC_UnsetEvent_EX(VDEC_CB_TYPE cb_type, MS_U32 u32EnableEvent)
11890 {
11891 if (pu32VDEC_Inst == NULL)
11892 {
11893 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11894 return E_VDEC_FAIL;
11895 }
11896
11897 VDEC_V2_IO_Param IO_arg;
11898 VDEC_Result retVal = E_VDEC_FAIL;
11899
11900 IO_arg.param[0] = (void *)&cb_type;
11901 IO_arg.param[1] = (void *)&u32EnableEvent;
11902 IO_arg.pRet = (void *)&retVal;
11903
11904 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_UNSETEVENT_EX, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
11905 {
11906 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
11907 return E_VDEC_FAIL;
11908 }
11909 else
11910 {
11911 return retVal;
11912 }
11913 }
11914
MApi_VDEC_V2_UnsetEvent_EX(VDEC_CB_TYPE cb_type,MS_U32 u32EnableEvent)11915 VDEC_Result MApi_VDEC_V2_UnsetEvent_EX(VDEC_CB_TYPE cb_type, MS_U32 u32EnableEvent)
11916 {
11917 VDEC_Result retVal = E_VDEC_FAIL;
11918 MS_U32 i = 0;
11919
11920 _VDEC_MutexLock();
11921
11922 if (!_Attr.bInit)
11923 {
11924 _VDEC_MutexUnlock();
11925 return E_VDEC_RET_NOT_INIT;
11926 }
11927
11928 if(u32EnableEvent == E_VDEC_EVENT_OFF)
11929 {
11930 _VDEC_MutexUnlock();
11931 return E_VDEC_RET_INVALID_PARAM;
11932 }
11933
11934 _Attr.VdecEventInfo[cb_type].u32EventBitMap &= ~u32EnableEvent;
11935
11936 if(E_VDEC_EVENT_OFF == _Attr.VdecEventInfo[cb_type].u32EventBitMap)
11937 {
11938 _Attr.VdecEventInfo[cb_type].pVdecEventCb = NULL;
11939 _Attr.VdecEventInfo[cb_type].pParam = NULL;
11940 }
11941
11942 #if defined(VDEC_ISR_MONITOR)
11943 _u32VdecIsrEventFlag = E_VDEC_EVENT_ISR_EVENT_CHANGE; //reset event flag;
11944 #else
11945 _u32VdecIsrEventFlag = 0; //reset event flag;
11946 #endif
11947 for(i = 0; i < E_VDEC_CB_MAX_NUM; i++)
11948 {
11949 _u32VdecIsrEventFlag |= _Attr.VdecEventInfo[i].u32EventBitMap;
11950 }
11951
11952 #if defined(VDEC_ISR_MONITOR)
11953 MsOS_SetEvent(_s32VdecEventId, E_VDEC_EVENT_ISR_EVENT_CHANGE);
11954 #endif
11955
11956 switch (_Attr.eDecoder)
11957 {
11958 case E_VDEC_DECODER_MVD:
11959 {
11960 MS_U32 u32Event = 0;
11961
11962 //Set Event
11963 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
11964 {
11965 u32Event |= E_MVD_EVENT_DISP_RDY;
11966 }
11967
11968 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
11969 {
11970 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11971 }
11972
11973 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_SEQ_HDR_FOUND)
11974 {
11975 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11976 }
11977
11978 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
11979 {
11980 #if defined(MVD_SUPPORT_X4_CC)
11981 u32Event |= E_MVD_EVENT_USER_DATA_DISP;
11982 #else
11983 u32Event |= E_MVD_EVENT_USER_DATA;
11984 #endif
11985 }
11986
11987 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
11988 {
11989 u32Event |= E_MVD_EVENT_USER_DATA;
11990 }
11991
11992 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
11993 {
11994 u32Event |= E_MVD_EVENT_FIRST_FRAME;
11995 }
11996
11997 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_PIC_FOUND)
11998 {
11999 u32Event |= E_MVD_EVENT_PIC_FOUND;
12000 }
12001
12002 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
12003 {
12004 u32Event |= E_MVD_EVENT_UNMUTE;
12005 }
12006 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
12007 {
12008 u32Event |= E_MVD_EVENT_DEC_I;
12009 }
12010
12011
12012 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
12013 {
12014 _VDEC_MutexUnlock();
12015 }
12016 if(E_MVD_RET_OK != MDrv_MVD_SetIsrEvent(u32Event, (MVD_InterruptCb) _VDEC_IsrProc))
12017 {
12018 retVal = E_VDEC_FAIL;
12019 }
12020 else
12021 {
12022 retVal = E_VDEC_OK;
12023 }
12024 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
12025 {
12026 _VDEC_MutexLock();
12027 }
12028 break;
12029 }
12030 case E_VDEC_DECODER_HVD:
12031 {
12032 HVD_ISR_Event eEvent = E_HVD_ISR_NONE;
12033
12034 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_ONE)
12035 {
12036 eEvent|=E_HVD_ISR_DISP_ONE;
12037 }
12038 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_REPEAT)
12039 {
12040 eEvent|=E_HVD_ISR_DISP_REPEAT;
12041 }
12042 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_WITH_CC)
12043 {
12044 eEvent|=E_HVD_ISR_DISP_WITH_CC;
12045 }
12046
12047 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ONE)
12048 {
12049 eEvent|=E_HVD_ISR_DEC_ONE;
12050 }
12051 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_I)
12052 {
12053 eEvent|=E_HVD_ISR_DEC_I;
12054 }
12055 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DEC_ERR)
12056 {
12057 eEvent|=E_HVD_ISR_DEC_HW_ERR;
12058 }
12059
12060 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_CHG)
12061 {
12062 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
12063 }
12064
12065 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_USER_DATA_FOUND)
12066 {
12067 eEvent|=E_HVD_ISR_DEC_CC_FOUND;
12068 }
12069
12070 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_DISP_INFO_RDY)
12071 {
12072 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
12073 }
12074
12075 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_FIRST_FRAME)
12076 {
12077 eEvent|=E_HVD_ISR_DEC_FIRST_FRM;
12078 }
12079
12080 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_VIDEO_UNMUTE)
12081 {
12082 eEvent|=E_HVD_ISR_DISP_FIRST_FRM;
12083 }
12084
12085 if (_u32VdecIsrEventFlag & E_VDEC_EVENT_AFD_FOUND)
12086 {
12087 eEvent|=E_HVD_ISR_DEC_DISP_INFO_CHANGE;
12088 }
12089
12090 if( eEvent != E_HVD_ISR_NONE )
12091 {
12092 if(E_HVD_OK !=MDrv_HVD_SetISREvent(eEvent, (HVD_InterruptCb) _VDEC_IsrProc))
12093 {
12094 _VDEC_MutexUnlock();
12095 return E_VDEC_FAIL;
12096 }
12097 }
12098 retVal = E_VDEC_OK;
12099 break;
12100 }
12101 case E_VDEC_DECODER_MJPEG:
12102 {
12103 retVal = E_VDEC_RET_UNSUPPORTED;
12104 break;
12105 }
12106 case E_VDEC_DECODER_RVD:
12107 {
12108 #if 1
12109 if (_u32VdecIsrEventFlag == E_VDEC_EVENT_OFF)
12110 {
12111 MDrv_RVD_SetISREvent(E_RVD_ISR_NONE, (RVD_InterruptCb) _VDEC_IsrProc);
12112 }
12113 retVal = E_VDEC_OK;
12114
12115 #else
12116 retVal = E_VDEC_RET_UNSUPPORTED;
12117 #endif
12118 break;
12119 }
12120 default:
12121 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
12122 break;
12123 }
12124
12125 _VDEC_MutexUnlock();
12126
12127 return retVal;
12128 }
12129
12130 //------------------------------------------------------------------------------
12131 /// Get ISR event status
12132 /// @return status
12133 //------------------------------------------------------------------------------
MApi_VDEC_GetEventInfo(MS_U32 * u32EventFlag)12134 VDEC_Result MApi_VDEC_GetEventInfo(MS_U32* u32EventFlag)
12135 {
12136 if (pu32VDEC_Inst == NULL)
12137 {
12138 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12139 return E_VDEC_FAIL;
12140 }
12141
12142 VDEC_V2_IO_Param IO_arg;
12143 VDEC_Result retVal = E_VDEC_FAIL;
12144
12145 IO_arg.param[0] = (void *)u32EventFlag;
12146 IO_arg.pRet = (void *)&retVal;
12147
12148 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETEVENTINFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12149 {
12150 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12151 return E_VDEC_FAIL;
12152 }
12153 else
12154 {
12155 return retVal;
12156 }
12157 }
12158
MApi_VDEC_V2_GetEventInfo(MS_U32 * u32EventFlag)12159 VDEC_Result MApi_VDEC_V2_GetEventInfo(MS_U32* u32EventFlag)
12160 {
12161 VDEC_Result retVal = E_VDEC_FAIL;
12162
12163 if (!_Attr.bInit)
12164 {
12165 return E_VDEC_RET_NOT_INIT;
12166 }
12167
12168 switch (_Attr.eDecoder)
12169 {
12170 case E_VDEC_DECODER_MVD:
12171 {
12172 retVal = E_VDEC_OK;
12173 break;
12174 }
12175 case E_VDEC_DECODER_HVD:
12176 {
12177 MS_U32 u32Event = E_HVD_ISR_NONE;
12178 if( MDrv_HVD_GetISRInfo(&u32Event) )
12179 {
12180 *u32EventFlag = E_VDEC_EVENT_OFF;
12181 if (u32Event & E_HVD_ISR_DISP_ONE)
12182 {
12183 *u32EventFlag|=E_VDEC_EVENT_DISP_ONE;
12184 }
12185 if (u32Event & E_HVD_ISR_DISP_REPEAT)
12186 {
12187 *u32EventFlag|=E_VDEC_EVENT_DISP_REPEAT;
12188 }
12189 if (u32Event & E_HVD_ISR_DISP_WITH_CC)
12190 {
12191 *u32EventFlag|=(E_VDEC_EVENT_DISP_WITH_CC | E_VDEC_EVENT_USER_DATA_FOUND);
12192 }
12193 if (u32Event & E_HVD_ISR_DISP_FIRST_FRM)
12194 {
12195 *u32EventFlag|=E_VDEC_EVENT_VIDEO_UNMUTE;
12196 }
12197 if (u32Event & E_HVD_ISR_DEC_ONE)
12198 {
12199 *u32EventFlag|=E_VDEC_EVENT_DEC_ONE;
12200 }
12201 if (u32Event & E_HVD_ISR_DEC_I)
12202 {
12203 *u32EventFlag|=E_VDEC_EVENT_DEC_I;
12204 }
12205 if (u32Event & E_HVD_ISR_DEC_HW_ERR)
12206 {
12207 *u32EventFlag|=E_VDEC_EVENT_DEC_ERR;
12208 }
12209 if (u32Event & E_HVD_ISR_DEC_CC_FOUND)
12210 {
12211 *u32EventFlag|=E_VDEC_EVENT_USER_DATA_FOUND;
12212 }
12213 if (u32Event & E_HVD_ISR_DEC_DISP_INFO_CHANGE)
12214 {
12215 MS_U8 u8Afd = MDrv_HVD_GetActiveFormat();
12216 if (u8Afd != 0)
12217 {
12218 *u32EventFlag|=E_VDEC_EVENT_AFD_FOUND;
12219 }
12220 *u32EventFlag|=(E_VDEC_EVENT_DISP_INFO_CHG | E_VDEC_EVENT_DISP_INFO_RDY);
12221 }
12222 if (u32Event & E_HVD_ISR_DEC_FIRST_FRM)
12223 {
12224 *u32EventFlag|=E_VDEC_EVENT_FIRST_FRAME;
12225 }
12226 retVal = E_VDEC_OK;
12227 }
12228 else
12229 {
12230 retVal = E_VDEC_FAIL;
12231 }
12232 break;
12233 }
12234 case E_VDEC_DECODER_MJPEG:
12235 case E_VDEC_DECODER_RVD:
12236 retVal = E_VDEC_RET_UNSUPPORTED;
12237 break;
12238 default:
12239 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
12240 break;
12241 }
12242 return retVal;
12243 }
12244
12245 //------------------------------------------------------------------------------
12246 /// Generate a special pattern to work with specific functions
12247 /// @param ePatternType \b IN : Pattern type
12248 /// @param u32Addr \b IN : Pattern buffer physical start address
12249 /// @param u32Size \b IN,OUT : Pattern buffer size
12250 /// IN: Pattern buffer size
12251 /// OUT: Used Pattern buffer size
12252 /// @return VDEC_Result
12253 //------------------------------------------------------------------------------
MDrv_VDEC_GenPattern(VDEC_PatternType ePatternType,MS_PHYADDR u32Addr,MS_U32 * u32Size)12254 VDEC_Result MDrv_VDEC_GenPattern(VDEC_PatternType ePatternType , MS_PHYADDR u32Addr , MS_U32* u32Size)
12255 {
12256 printf("VDEC Warn: MDrv_VDEC_GenPattern() will be removed. please use new API:MApi_VDEC_GenPattern()\n ");
12257 return MApi_VDEC_GenPattern( ePatternType , u32Addr , u32Size );
12258 }
12259
MApi_VDEC_GenPattern(VDEC_PatternType ePatternType,MS_PHYADDR u32Addr,MS_U32 * pu32Size)12260 VDEC_Result MApi_VDEC_GenPattern(VDEC_PatternType ePatternType, MS_PHYADDR u32Addr, MS_U32 *pu32Size)
12261 {
12262 if (pu32VDEC_Inst == NULL)
12263 {
12264 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12265 return E_VDEC_FAIL;
12266 }
12267
12268 VDEC_V2_IO_Param IO_arg;
12269 VDEC_Result ret = E_VDEC_OK;
12270
12271 IO_arg.param[0] = (void *)&ePatternType;
12272 IO_arg.param[1] = (void *)&u32Addr;
12273 IO_arg.param[2] = (void *)pu32Size;
12274 IO_arg.pRet = (void *)&ret;
12275
12276 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GENPATTERN, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12277 {
12278 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12279 return E_VDEC_FAIL;
12280 }
12281 else
12282 {
12283 return ret;
12284 }
12285 }
12286
MApi_VDEC_V2_GenPattern(VDEC_PatternType ePatternType,MS_PHYADDR u32Addr,MS_U32 * pu32Size)12287 VDEC_Result MApi_VDEC_V2_GenPattern(VDEC_PatternType ePatternType, MS_PHYADDR u32Addr, MS_U32 *pu32Size)
12288 {
12289 VDEC_Result ret = E_VDEC_OK;
12290
12291 if (!_Attr.bInit)
12292 {
12293 return E_VDEC_RET_NOT_INIT;
12294 }
12295
12296 switch (_Attr.eDecoder)
12297 {
12298 case E_VDEC_DECODER_MVD:
12299 {
12300 if (ePatternType == E_VDEC_PATTERN_FLUSH)
12301 {
12302 _MVD_RET_HANDLE(MDrv_MVD_GenPattern(E_MVD_PATTERN_FLUSH, u32Addr, pu32Size));
12303 }
12304 else if (ePatternType == E_VDEC_PATTERN_FILEEND)
12305 {
12306 _MVD_RET_HANDLE(MDrv_MVD_GenPattern(E_MVD_PATTERN_FILEEND, u32Addr, pu32Size));
12307 }
12308 else
12309 {
12310 ret = E_VDEC_RET_UNSUPPORTED;
12311 }
12312 break;
12313 }
12314 case E_VDEC_DECODER_HVD:
12315 {
12316 if (ePatternType == E_VDEC_PATTERN_FLUSH)
12317 {
12318 _HVD_RET_HANDLE(MDrv_HVD_GenPattern(E_HVD_PATTERN_FLUSH, MS_PA2KSEG1(u32Addr), pu32Size));
12319 }
12320 else if (ePatternType == E_VDEC_PATTERN_FILEEND)
12321 {
12322 _HVD_RET_HANDLE(MDrv_HVD_GenPattern(E_HVD_PATTERN_FILEEND, MS_PA2KSEG1(u32Addr), pu32Size));
12323 }
12324 else
12325 {
12326 ret = E_VDEC_RET_UNSUPPORTED;
12327 }
12328 break;
12329 }
12330 case E_VDEC_DECODER_MJPEG:
12331 ret = E_VDEC_RET_UNSUPPORTED;
12332 break;
12333
12334 case E_VDEC_DECODER_RVD:
12335 ret = E_VDEC_RET_UNSUPPORTED;
12336 break;
12337
12338 default:
12339 ret = E_VDEC_RET_UNSUPPORTED;
12340 break;
12341 }
12342
12343 return ret;
12344 }
12345
12346 //------------------------------------------------------------------------------
12347 /// Get the information of the least length of pattern used for specific function
12348 /// @param pFrmInfo \b IN : the information of the least length of pattern used for specific function
12349 /// @return -the length (Bytes)
12350 //------------------------------------------------------------------------------
MApi_VDEC_GetPatternLeastLength(VDEC_PatternType ePatternType)12351 MS_U32 MApi_VDEC_GetPatternLeastLength(VDEC_PatternType ePatternType )
12352 {
12353 if (pu32VDEC_Inst == NULL)
12354 {
12355 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12356 return E_VDEC_FAIL;
12357 }
12358
12359 VDEC_V2_IO_Param IO_arg;
12360 MS_U32 u32Ret = 0;
12361
12362 IO_arg.param[0] = (void *)&ePatternType;
12363 IO_arg.pRet = (void *)&u32Ret;
12364
12365 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GENPATTERNLEASTLENGTH, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12366 {
12367 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12368 return E_VDEC_FAIL;
12369 }
12370 else
12371 {
12372 return u32Ret;
12373 }
12374 }
12375
MApi_VDEC_V2_GetPatternLeastLength(VDEC_PatternType ePatternType)12376 MS_U32 MApi_VDEC_V2_GetPatternLeastLength(VDEC_PatternType ePatternType )
12377 {
12378 MS_U32 u32Ret = 0;
12379
12380 if (!_Attr.bInit)
12381 {
12382 return 0;
12383 }
12384
12385 switch (_Attr.eDecoder)
12386 {
12387 case E_VDEC_DECODER_MVD:
12388 u32Ret = MDrv_MVD_GetPatternInfo();
12389
12390 break;
12391
12392 case E_VDEC_DECODER_HVD:
12393 if( ePatternType == E_VDEC_PATTERN_FLUSH)
12394 {
12395 u32Ret = MDrv_HVD_GetPatternInfo( E_HVD_FLUSH_PATTERN_SIZE );
12396 }
12397 else if( ePatternType == E_VDEC_PATTERN_FILEEND)
12398 {
12399 u32Ret = MDrv_HVD_GetPatternInfo( E_HVD_DUMMY_HW_FIFO );
12400 }
12401 break;
12402
12403 case E_VDEC_DECODER_MJPEG:
12404 break;
12405
12406 case E_VDEC_DECODER_RVD:
12407 break;
12408
12409 default:
12410 break;
12411 }
12412
12413 return u32Ret;
12414 }
12415
12416 //------------------------------------------------------------------------------
12417 /// Set deblocking process on/off
12418 /// @param bOn \b IN : turn on / off deblocking process
12419 /// @return VDEC_Result
12420 //------------------------------------------------------------------------------
MApi_VDEC_DisableDeblocking(MS_BOOL bDisable)12421 VDEC_Result MApi_VDEC_DisableDeblocking(MS_BOOL bDisable)
12422 {
12423 if (pu32VDEC_Inst == NULL)
12424 {
12425 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12426 return E_VDEC_FAIL;
12427 }
12428
12429 VDEC_V2_IO_Param IO_arg;
12430 VDEC_Result rst = E_VDEC_OK;
12431
12432 IO_arg.param[0] = (void *)&bDisable;
12433 IO_arg.pRet = (void *)&rst;
12434
12435 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_DISABLEDEBLOCKING, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12436 {
12437 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12438 return E_VDEC_FAIL;
12439 }
12440 else
12441 {
12442 return rst;
12443 }
12444 }
12445
MApi_VDEC_V2_DisableDeblocking(MS_BOOL bDisable)12446 VDEC_Result MApi_VDEC_V2_DisableDeblocking(MS_BOOL bDisable)
12447 {
12448 VDEC_Result rst = E_VDEC_OK;
12449
12450 if (!_Attr.bInit)
12451 {
12452 return E_VDEC_RET_NOT_INIT;
12453 }
12454
12455 switch (_Attr.eDecoder)
12456 {
12457 case E_VDEC_DECODER_MVD:
12458 break;
12459
12460 case E_VDEC_DECODER_HVD:
12461 {
12462 _HVD_RET_HANDLE(MDrv_HVD_SetSettings_Pro(E_HVD_SSET_DISABLE_DEBLOCKING , bDisable ));
12463 break;
12464 }
12465 case E_VDEC_DECODER_MJPEG:
12466 {
12467 break;
12468 }
12469 case E_VDEC_DECODER_RVD:
12470 {
12471 break;
12472 }
12473 default:
12474 break;
12475 }
12476
12477 return rst;
12478 }
12479
12480 //------------------------------------------------------------------------------
12481 /// Set Quarter Pixel process on/off
12482 /// @param bOn \b IN : turn on / off Quarter Pixel process
12483 /// @return VDEC_Result
12484 //------------------------------------------------------------------------------
MApi_VDEC_DisableQuarterPixel(MS_BOOL bDisable)12485 VDEC_Result MApi_VDEC_DisableQuarterPixel(MS_BOOL bDisable)
12486 {
12487 if (pu32VDEC_Inst == NULL)
12488 {
12489 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12490 return E_VDEC_FAIL;
12491 }
12492
12493 VDEC_V2_IO_Param IO_arg;
12494 VDEC_Result rst = E_VDEC_OK;
12495
12496 IO_arg.param[0] = (void *)&bDisable;
12497 IO_arg.pRet = (void *)&rst;
12498
12499 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_DISABLEQUARTERPIXEL, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12500 {
12501 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12502 return E_VDEC_FAIL;
12503 }
12504 else
12505 {
12506 return rst;
12507 }
12508
12509 }
12510
MApi_VDEC_V2_DisableQuarterPixel(MS_BOOL bDisable)12511 VDEC_Result MApi_VDEC_V2_DisableQuarterPixel(MS_BOOL bDisable)
12512 {
12513 VDEC_Result rst = E_VDEC_OK;
12514
12515 if (!_Attr.bInit)
12516 {
12517 return E_VDEC_RET_NOT_INIT;
12518 }
12519
12520 switch (_Attr.eDecoder)
12521 {
12522 case E_VDEC_DECODER_MVD:
12523 break;
12524
12525 case E_VDEC_DECODER_HVD:
12526 {
12527 _HVD_RET_HANDLE(MDrv_HVD_SetSettings_Pro( E_HVD_SSET_DISABLE_QUARTER_PIXEL ,bDisable));
12528 break;
12529 }
12530 case E_VDEC_DECODER_MJPEG:
12531 {
12532 break;
12533 }
12534 case E_VDEC_DECODER_RVD:
12535 {
12536 break;
12537 }
12538 default:
12539 break;
12540 }
12541
12542 return rst;
12543 }
12544
12545 //------------------------------------------------------------------------------
12546 /// Turn on/off Auto Remove Last Zero Byte process
12547 /// @param bOn \b IN : turn on / off Auto Remove Last Zero Byte process
12548 /// @return VDEC_Result
12549 //------------------------------------------------------------------------------
MApi_VDEC_SetAutoRmLstZeroByte(MS_BOOL bOn)12550 VDEC_Result MApi_VDEC_SetAutoRmLstZeroByte(MS_BOOL bOn)
12551 {
12552 if (pu32VDEC_Inst == NULL)
12553 {
12554 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12555 return E_VDEC_FAIL;
12556 }
12557
12558 VDEC_V2_IO_Param IO_arg;
12559 VDEC_Result rst = E_VDEC_OK;
12560
12561 IO_arg.param[0] = (void *)&bOn;
12562 IO_arg.pRet = (void *)&rst;
12563
12564 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SETAUTORMLSTZEROBYTE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12565 {
12566 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12567 return E_VDEC_FAIL;
12568 }
12569 else
12570 {
12571 return rst;
12572 }
12573
12574 }
12575
MApi_VDEC_V2_SetAutoRmLstZeroByte(MS_BOOL bOn)12576 VDEC_Result MApi_VDEC_V2_SetAutoRmLstZeroByte(MS_BOOL bOn)
12577 {
12578 VDEC_Result rst = E_VDEC_OK;
12579
12580 if (!_Attr.bInit)
12581 {
12582 return E_VDEC_RET_NOT_INIT;
12583 }
12584
12585 switch (_Attr.eDecoder)
12586 {
12587 case E_VDEC_DECODER_MVD:
12588 break;
12589
12590 case E_VDEC_DECODER_HVD:
12591 {
12592 _HVD_RET_HANDLE(MDrv_HVD_SetAutoRmLstZeroByte(bOn));
12593 break;
12594 }
12595 case E_VDEC_DECODER_MJPEG:
12596 {
12597 break;
12598 }
12599 case E_VDEC_DECODER_RVD:
12600 {
12601 break;
12602 }
12603 default:
12604 break;
12605 }
12606
12607 return rst;
12608 }
12609
12610 //------------------------------------------------------------------------------
12611 /// Set the parameters of Balancing BW
12612 /// @param u8QuarPixelTH \b IN : set Quarter pixel threshold
12613 /// @param u8DeBlockingTH \b IN : set deblocking threshold
12614 /// @param u8UpperBound \b IN : set upper boundary of BW control counter
12615 /// @param u8SafeCoef \b IN : set safety coeffecient of average MB tick.
12616 /// @return VDEC_Result
12617 //------------------------------------------------------------------------------
MApi_VDEC_SetBalanceBW(MS_U8 u8QuarPixelTH,MS_U8 u8DeBlockingTH,MS_U8 u8UpperBound,MS_U8 u8SafeCoef)12618 VDEC_Result MApi_VDEC_SetBalanceBW(MS_U8 u8QuarPixelTH, MS_U8 u8DeBlockingTH, MS_U8 u8UpperBound, MS_U8 u8SafeCoef)
12619 {
12620 if (pu32VDEC_Inst == NULL)
12621 {
12622 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12623 return E_VDEC_FAIL;
12624 }
12625
12626 VDEC_V2_IO_Param IO_arg;
12627 VDEC_Result rst = E_VDEC_OK;
12628
12629 IO_arg.param[0] = (void *)&u8QuarPixelTH;
12630 IO_arg.param[1] = (void *)&u8DeBlockingTH;
12631 IO_arg.param[2] = (void *)&u8UpperBound;
12632 IO_arg.param[3] = (void *)&u8SafeCoef;
12633 IO_arg.pRet = (void *)&rst;
12634
12635 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SETBALANCEBW, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12636 {
12637 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12638 return E_VDEC_FAIL;
12639 }
12640 else
12641 {
12642 return rst;
12643 }
12644
12645 }
12646
MApi_VDEC_V2_SetBalanceBW(MS_U8 u8QuarPixelTH,MS_U8 u8DeBlockingTH,MS_U8 u8UpperBound,MS_U8 u8SafeCoef)12647 VDEC_Result MApi_VDEC_V2_SetBalanceBW(MS_U8 u8QuarPixelTH, MS_U8 u8DeBlockingTH, MS_U8 u8UpperBound, MS_U8 u8SafeCoef)
12648 {
12649 VDEC_Result rst = E_VDEC_OK;
12650
12651 if (!_Attr.bInit)
12652 {
12653 return E_VDEC_RET_NOT_INIT;
12654 }
12655
12656 switch (_Attr.eDecoder)
12657 {
12658 case E_VDEC_DECODER_MVD:
12659 break;
12660
12661 case E_VDEC_DECODER_HVD:
12662 {
12663 _HVD_RET_HANDLE(MDrv_HVD_SetBalanceBW(u8QuarPixelTH, u8DeBlockingTH, u8UpperBound));
12664 break;
12665 }
12666 case E_VDEC_DECODER_MJPEG:
12667 {
12668 break;
12669 }
12670 case E_VDEC_DECODER_RVD:
12671 {
12672 break;
12673 }
12674 default:
12675 break;
12676 }
12677
12678 return rst;
12679 }
12680
MApi_VDEC_DbgDumpStatus(void)12681 VDEC_Result MApi_VDEC_DbgDumpStatus(void)
12682 {
12683 if (pu32VDEC_Inst == NULL)
12684 {
12685 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12686 return E_VDEC_FAIL;
12687 }
12688
12689 VDEC_V2_IO_Param IO_arg;
12690 VDEC_Result eRet = E_VDEC_OK;
12691
12692 IO_arg.pRet = (void *)&eRet;
12693
12694 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_DBGDUMPSTATUS, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12695 {
12696 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12697 return E_VDEC_FAIL;
12698 }
12699 else
12700 {
12701 return eRet;
12702 }
12703 }
12704
MApi_VDEC_V2_DbgDumpStatus(void)12705 VDEC_Result MApi_VDEC_V2_DbgDumpStatus(void)
12706 {
12707 if (!_Attr.bInit)
12708 {
12709 return E_VDEC_FAIL;
12710 }
12711
12712 switch (_Attr.eDecoder)
12713 {
12714 case E_VDEC_DECODER_MVD:
12715 {
12716 MDrv_MVD_DbgDump();
12717 break;
12718 }
12719 case E_VDEC_DECODER_HVD:
12720 {
12721 MDrv_HVD_DbgDumpStatus( E_HVD_DUMP_STATUS_FW );
12722 break;
12723 }
12724 case E_VDEC_DECODER_MJPEG:
12725 {
12726 break;
12727 }
12728 case E_VDEC_DECODER_RVD:
12729 {
12730 MDrv_RVD_Dump_Status();
12731 break;
12732 }
12733 default:
12734 break;
12735 }
12736 return E_VDEC_OK;
12737 }
12738
12739 extern void HAL_VPU_InitRegBase(MS_U32 u32RegBase) __attribute__((weak));
12740 extern MS_U32 HAL_VPU_GetProgCnt(void) __attribute__((weak));
12741
MApi_VDEC_DbgGetProgCnt(void)12742 MS_U32 MApi_VDEC_DbgGetProgCnt(void)
12743 {
12744 MS_U32 u32NonPMBankSize=0,u32RiuBaseAdd=0;
12745 if( !MDrv_MMIO_GetBASE( &u32RiuBaseAdd, &u32NonPMBankSize, MS_MODULE_HW))
12746 {
12747 printf("VDEC HVD MApi_VDEC_DbgGetProgramCnt Err: MMIO_GetBASE failure\n");
12748 return 0;
12749 }
12750 else
12751 {
12752 //printf("HVD:1 u32RiuBaseAdd = %lx\n", u32RiuBaseAdd);
12753 if( HAL_VPU_InitRegBase )
12754 {
12755 HAL_VPU_InitRegBase(u32RiuBaseAdd);
12756 }
12757 else
12758 {
12759 return 0;
12760 }
12761 }
12762 if( HAL_VPU_GetProgCnt )
12763 {
12764 return HAL_VPU_GetProgCnt();
12765 }
12766 else
12767 {
12768 return 0;
12769 }
12770 }
12771
MApi_VDEC_SetControl(VDEC_User_Cmd cmd_id,MS_U32 param)12772 VDEC_Result MApi_VDEC_SetControl(VDEC_User_Cmd cmd_id, MS_U32 param)
12773 {
12774 if (pu32VDEC_Inst == NULL)
12775 {
12776 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12777 return E_VDEC_FAIL;
12778 }
12779
12780 VDEC_V2_IO_Param IO_arg;
12781 VDEC_Result eRet = E_VDEC_FAIL;
12782
12783 IO_arg.param[0] = (void *)&cmd_id;
12784 IO_arg.param[1] = (void *)¶m;
12785 IO_arg.pRet = (void *)&eRet;
12786
12787 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SETCONTROL, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12788 {
12789 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12790 return E_VDEC_FAIL;
12791 }
12792 else
12793 {
12794 return eRet;
12795 }
12796 }
12797
MApi_VDEC_V2_SetControl(VDEC_User_Cmd cmd_id,MS_U32 param)12798 VDEC_Result MApi_VDEC_V2_SetControl(VDEC_User_Cmd cmd_id, MS_U32 param)
12799 {
12800 if (!_Attr.bInit)
12801 {
12802 return E_VDEC_RET_NOT_INIT;
12803 }
12804
12805 switch (cmd_id)
12806 {
12807 case VDEC_USER_CMD_REPEAT_LAST_FIELD:
12808 return _VDEC_RepeatLastField((MS_BOOL)param);
12809 break;
12810 case VDEC_USER_CMD_AVSYNC_REPEAT_TH:
12811 return _VDEC_SetAVSyncRepeatThreshold(param);
12812 break;
12813 case VDEC_USER_CMD_DISP_ONE_FIELD:
12814 return _VDEC_DispOneField(param);
12815 break;
12816 case VDEC_USER_CMD_FD_MASK_DELAY_COUNT:
12817 return _VDEC_SetFdMaskDelayCnt(param);
12818 break;
12819 case VDEC_USER_CMD_FRC_OUTPUT:
12820 return _VDEC_FrameRateConvert((VDEC_FRC_OutputParam *)param);
12821 break;
12822 case VDEC_USER_CMD_FRC_DROP_TYPE:
12823 return _VDEC_SetFRCDropType(param);
12824 break;
12825 case VDEC_USER_CMD_FAST_DISPLAY:
12826 return _VDEC_SetFastDisplay((MS_BOOL) param);
12827 break;
12828 case VDEC_USER_CMD_IGNORE_ERR_REF:
12829 return _VDEC_SetIgnoreErrRef((MS_BOOL) param);
12830 break;
12831 case VDEC_USER_CMD_FORCE_FOLLOW_DTV_SPEC:
12832 return _VDEC_ForceFollowDTVSpec((MS_BOOL) param);
12833 break;
12834 case VDEC_USER_CMD_AVC_MIN_FRM_GAP:
12835 return _VDEC_SetMinFrameGap(param);
12836 break;
12837 case VDEC_USER_CMD_DISABLE_SEQ_CHG:
12838 return _VDEC_SetDisableSeqChange((MS_BOOL) param);
12839 case VDEC_USER_CMD_AVC_DISABLE_ANTI_VDEAD:
12840 return _VDEC_SetDisableAntiVdead(param);
12841 break;
12842 case VDEC_USER_CMD_DTV_RESET_MVD_PARSER:
12843 return _VDEC_ResetMvdParser((MS_BOOL) param);
12844 break;
12845 case VDEC_USER_CMD_PVR_FLUSH_FRAME_BUFFER://PVR used,only used in S company
12846 return _VDEC_DoFlushFrmBuffer((MS_BOOL) param);
12847 break;
12848 case VDEC_USER_CMD_SET_DTV_USER_DATA_MODE:
12849 return _VDEC_SetDTVUserDataMode(param);
12850 break;
12851 case VDEC_USER_CMD_FORCE_INTERLACE_MODE:
12852 return _VDEC_ForceInterlaceMode(param);
12853 break;
12854 case VDEC_USER_CMD_SHOW_DECODE_ORDER:
12855 return _VDEC_ShowDecodeOrder(param);
12856 break;
12857 case VDEC_USER_CMD_FORCE_AUTO_MUTE:
12858 return _VDEC_ForceAutoMute((MS_BOOL) param);
12859 break;
12860 case VDEC_USER_CMD_SET_VSIZE_ALIGN:
12861 return _VDEC_SetVSizeAlign((MS_BOOL) param);
12862 break;
12863 case VDEC_USER_CMD_AVC_DISP_IGNORE_CROP:
12864 return _VDEC_Disp_Ignore_Crop((MS_BOOL) param);
12865 break;
12866 case VDEC_USER_CMD_SET_DISP_FINISH_MODE:
12867 return _VDEC_SetDispFinishMode((MS_U8) param);
12868 break;
12869 case VDEC_USER_CMD_SET_AVSYNC_MODE:
12870 return _VDEC_SetAVSyncMode((MS_U8) param);
12871 break;
12872 case VDEC_USER_CMD_SET_CC608_INFO_ENHANCE_MODE:
12873 return _VDEC_SetCcInfoEnhanceMode((MS_BOOL) param);
12874 break;
12875 case VDEC_USER_CMD_SET_IDCT_MODE:
12876 return _VDEC_SetIdctMode((MS_U8) param);
12877 break;
12878 case VDEC_USER_CMD_DROP_ERR_FRAME:
12879 return _VDEC_DropErrFrame((MS_BOOL) param);
12880 case VDEC_USER_CMD_PUSH_DISPQ_WITH_REF_NUM:
12881 return _VDEC_PushDispQWithRefNum((MS_BOOL) param);
12882 case VDEC_USER_CMD_SHOW_FIRST_FRAME_DIRECT:
12883 return _VDEC_ShowFirstFrameDirect(param);
12884 case VDEC_USER_CMD_AUTO_EXHAUST_ES_MODE:
12885 return _VDEC_SetAutoExhaustESMode(param);
12886 break;
12887 case VDEC_USER_CMD_SET_MIN_TSP_DATA_SIZE:
12888 return _VDEC_SetMinTspDataSize(param);
12889 break;
12890 case VDEC_USER_CMD_AVC_SUPPORT_REF_NUM_OVER_MAX_DPB_SIZE:
12891 return _VDEC_AVCSupportRefNumOverMaxDBPSize((MS_BOOL)param);
12892 break;
12893 default:
12894 return E_VDEC_RET_ILLEGAL_ACCESS;
12895 break;
12896 }
12897
12898 return E_VDEC_OK;
12899 }
12900
MApi_VDEC_GetControl(VDEC_User_Cmd cmd_id,MS_U32 * param)12901 VDEC_Result MApi_VDEC_GetControl(VDEC_User_Cmd cmd_id, MS_U32 *param)
12902 {
12903 if (pu32VDEC_Inst == NULL)
12904 {
12905 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12906 return E_VDEC_FAIL;
12907 }
12908
12909 VDEC_V2_IO_Param IO_arg;
12910 VDEC_Result eRet = E_VDEC_FAIL;
12911
12912 IO_arg.param[0] = (void *)&cmd_id;
12913 IO_arg.param[1] = (void *)¶m;
12914 IO_arg.pRet = (void *)&eRet;
12915
12916 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETCONTROL, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12917 {
12918 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12919 return E_VDEC_FAIL;
12920 }
12921 else
12922 {
12923 return eRet;
12924 }
12925 }
12926
MApi_VDEC_V2_GetControl(VDEC_User_Cmd cmd_id,MS_U32 * param)12927 VDEC_Result MApi_VDEC_V2_GetControl(VDEC_User_Cmd cmd_id, MS_U32 *param)
12928 {
12929 if (!_Attr.bInit)
12930 {
12931 return E_VDEC_RET_NOT_INIT;
12932 }
12933
12934 if (param == NULL)
12935 {
12936 return E_VDEC_RET_INVALID_PARAM;
12937 }
12938
12939 switch (cmd_id)
12940 {
12941 case VDEC_USER_CMD_GET_CHROMA_TYPE:
12942 return _MApi_VDEC_IsChroma420(param);
12943 break;
12944 case VDEC_USER_CMD_GET_REAL_FRAMERATE:
12945 return _MApi_VDEC_GetRealFrameRate(param);
12946 break;
12947 case VDEC_USER_CMD_GET_COLOR_MATRIX:
12948 return _MApi_VDEC_GetColorMatrixCoef(param);
12949 break;
12950 case VDEC_USER_CMD_GET_DYNSCALE_ENABLED:
12951 return _MApi_VDEC_GetIsDynScalingEnabled(param);
12952 break;
12953 case VDEC_USER_CMD_GET_ORI_INTERLACE_MODE:
12954 return _MApi_VDEC_GetIsOriInterlaceMode(param);
12955 break;
12956 case VDEC_USER_CMD_GET_FPA_SEI:
12957 return _MApi_VDEC_GetFrmPackingArrSEI(param);
12958 break;
12959 case VDEC_USER_CMD_GET_FB_USAGE_MEM:
12960 return _MApi_VDEC_GetFBUsageMem(param);
12961 break;
12962 case VDEC_USER_CMD_GET_FLUSH_PATTEN_ENTRY_NUM:
12963 return _MApi_VDEC_GetFlushPatternEntryNum(param);
12964 break;
12965
12966 default:
12967 return E_VDEC_RET_ILLEGAL_ACCESS;
12968 break;
12969 }
12970
12971 return E_VDEC_OK;
12972 }
12973
MApi_VDEC_GetDispCnt(void)12974 MS_U32 MApi_VDEC_GetDispCnt(void)
12975 {
12976 if (pu32VDEC_Inst == NULL)
12977 {
12978 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12979 return E_VDEC_FAIL;
12980 }
12981
12982 VDEC_V2_IO_Param IO_arg;
12983 MS_U32 u32Cnt = 0;
12984
12985 IO_arg.pRet = (void *)&u32Cnt;
12986
12987 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETDISPCNT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
12988 {
12989 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
12990 return E_VDEC_FAIL;
12991 }
12992 else
12993 {
12994 return u32Cnt;
12995 }
12996 }
12997
MApi_VDEC_V2_GetDispCnt(void)12998 MS_U32 MApi_VDEC_V2_GetDispCnt(void)
12999 {
13000 MS_U32 u32Cnt = 0;
13001
13002 if (!_Attr.bInit)
13003 {
13004 return 0;
13005 }
13006
13007 switch (_Attr.eDecoder)
13008 {
13009 case E_VDEC_DECODER_MVD:
13010 u32Cnt = MDrv_MVD_GetDispCount();
13011 break;
13012
13013 case E_VDEC_DECODER_HVD:
13014 u32Cnt = MDrv_HVD_GetData(E_HVD_GDATA_TYPE_DISP_CNT);
13015 break;
13016
13017 case E_VDEC_DECODER_MJPEG:
13018 break;
13019
13020 case E_VDEC_DECODER_RVD:
13021 break;
13022
13023 default:
13024 u32Cnt = 0;
13025 break;
13026 }
13027
13028 return u32Cnt;
13029 }
13030
MApi_VDEC_GetFwVersion(VDEC_FwType eFwType)13031 MS_U32 MApi_VDEC_GetFwVersion(VDEC_FwType eFwType)
13032 {
13033 if (pu32VDEC_Inst == NULL)
13034 {
13035 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13036 return E_VDEC_FAIL;
13037 }
13038
13039 VDEC_V2_IO_Param IO_arg;
13040 MS_U32 u32FWVer = 0;
13041
13042 IO_arg.param[0] = (void *)&eFwType;
13043 IO_arg.pRet = (void *)&u32FWVer;
13044
13045 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETFWVERSION, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13046 {
13047 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13048 return E_VDEC_FAIL;
13049 }
13050 else
13051 {
13052 return u32FWVer;
13053 }
13054 }
13055
MApi_VDEC_V2_GetFwVersion(VDEC_FwType eFwType)13056 MS_U32 MApi_VDEC_V2_GetFwVersion(VDEC_FwType eFwType)
13057 {
13058 const MVD_DrvInfo* pMvdDrvInfo = NULL;
13059 MS_U32 u32FWVer = 0;
13060
13061 switch (eFwType)
13062 {
13063 case VDEC_FW_TYPE_MVD:
13064 pMvdDrvInfo = MDrv_MVD_GetInfo();
13065 u32FWVer = pMvdDrvInfo->u32FWVersion;
13066 if ((TRUE == _Attr.bInit) && (E_VDEC_DECODER_MVD == _Attr.eDecoder))
13067 {
13068 if (MDrv_MVD_GetFWVer() != 0)
13069 {
13070 u32FWVer = MDrv_MVD_GetFWVer();
13071 }
13072 }
13073 break;
13074
13075 case VDEC_FW_TYPE_HVD:
13076 u32FWVer = MDrv_HVD_GetDrvFwVer();
13077 if ((TRUE == _Attr.bInit) && (E_VDEC_DECODER_HVD == _Attr.eDecoder))
13078 {
13079 u32FWVer = MDrv_HVD_GetFwVer();
13080 }
13081 break;
13082 default:
13083 break;
13084 }
13085
13086 return u32FWVer;
13087 }
13088
MApi_VDEC_SetBlockDisplay(MS_BOOL bEnable)13089 VDEC_Result MApi_VDEC_SetBlockDisplay(MS_BOOL bEnable)
13090 {
13091 if (pu32VDEC_Inst == NULL)
13092 {
13093 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13094 return E_VDEC_FAIL;
13095 }
13096
13097 VDEC_V2_IO_Param IO_arg;
13098 VDEC_Result ret = E_VDEC_OK;
13099
13100 IO_arg.param[0] = (void *)&bEnable;
13101 IO_arg.pRet = (void *)&ret;
13102
13103 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SETBLOCKDISPLAY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13104 {
13105 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13106 return E_VDEC_FAIL;
13107 }
13108 else
13109 {
13110 return ret;
13111 }
13112 }
13113
MApi_VDEC_V2_SetBlockDisplay(MS_BOOL bEnable)13114 VDEC_Result MApi_VDEC_V2_SetBlockDisplay(MS_BOOL bEnable)
13115 {
13116 VDEC_Result ret = E_VDEC_OK;
13117
13118 if (!_Attr.bInit)
13119 {
13120 return E_VDEC_RET_NOT_INIT;
13121 }
13122 switch (_Attr.eDecoder)
13123 {
13124 case E_VDEC_DECODER_MVD:
13125 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_SetMStreamerMode(bEnable));
13126 break;
13127
13128 case E_VDEC_DECODER_HVD:
13129 _HVD_RET_HANDLE(MDrv_HVD_EnableDispQue(bEnable));
13130 break;
13131
13132 case E_VDEC_DECODER_RVD:
13133 break;
13134
13135 case E_VDEC_DECODER_MJPEG:
13136 _BOOL_TO_MJPEG_RESULT(ret, MApi_MJPEG_EnableDispCmdQ(bEnable));
13137 break;
13138 default:
13139 ret = E_VDEC_RET_UNSUPPORTED;
13140 break;
13141 }
13142 return ret;
13143 }
13144
MApi_VDEC_EnableESBuffMalloc(MS_BOOL bEnable)13145 VDEC_Result MApi_VDEC_EnableESBuffMalloc(MS_BOOL bEnable)
13146 {
13147 if (pu32VDEC_Inst == NULL)
13148 {
13149 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13150 return E_VDEC_FAIL;
13151 }
13152
13153 VDEC_V2_IO_Param IO_arg;
13154 VDEC_Result eRet = E_VDEC_FAIL;
13155
13156 IO_arg.param[0] = (void *)&bEnable;
13157 IO_arg.pRet = (void *)&eRet;
13158
13159 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_ENABLEESBUFFMALLOC, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13160 {
13161 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13162 return E_VDEC_FAIL;
13163 }
13164 else
13165 {
13166 return eRet;
13167 }
13168 }
13169
MApi_VDEC_V2_EnableESBuffMalloc(MS_BOOL bEnable)13170 VDEC_Result MApi_VDEC_V2_EnableESBuffMalloc(MS_BOOL bEnable)
13171 {
13172 //check vdec state & config
13173 if (!_Attr.bInit)
13174 {
13175 return E_VDEC_RET_NOT_INIT;
13176 }
13177 if ((E_VDEC_DECODER_MVD != _Attr.eDecoder) &&
13178 (E_VDEC_DECODER_HVD != _Attr.eDecoder) &&
13179 (E_VDEC_DECODER_MJPEG != _Attr.eDecoder) &&
13180 (E_VDEC_DECODER_RVD != _Attr.eDecoder))
13181 {
13182 return E_VDEC_RET_UNSUPPORTED;
13183 }
13184
13185 bEsBufMgmt = bEnable;
13186 return E_VDEC_OK;
13187 }
13188
MApi_VDEC_GetESBuffVacancy(void * pData)13189 MS_U32 MApi_VDEC_GetESBuffVacancy(void* pData)
13190 {
13191 if (pu32VDEC_Inst == NULL)
13192 {
13193 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13194 return E_VDEC_FAIL;
13195 }
13196
13197 VDEC_V2_IO_Param IO_arg;
13198 MS_U32 u32BuffVacancy = 0;
13199
13200 IO_arg.param[0] = (void *)pData;
13201 IO_arg.pRet = (void *)&u32BuffVacancy;
13202
13203 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETESBUFFVACANCY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13204 {
13205 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13206 return E_VDEC_FAIL;
13207 }
13208 else
13209 {
13210 return u32BuffVacancy;
13211 }
13212 }
13213
MApi_VDEC_V2_GetESBuffVacancy(void * pData)13214 MS_U32 MApi_VDEC_V2_GetESBuffVacancy(void* pData)
13215 {
13216 UNUSED(pData);
13217 return _VDEC_GetESBuffVacancy();
13218 }
13219
MApi_VDEC_GetESBuff(MS_U32 u32ReqSize,MS_U32 * u32AvailSize,MS_PHYADDR * u32Addr)13220 VDEC_Result MApi_VDEC_GetESBuff(MS_U32 u32ReqSize, MS_U32* u32AvailSize, MS_PHYADDR* u32Addr)
13221 {
13222 if (pu32VDEC_Inst == NULL)
13223 {
13224 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13225 return E_VDEC_FAIL;
13226 }
13227
13228 VDEC_V2_IO_Param IO_arg;
13229 VDEC_Result eRet = E_VDEC_FAIL;
13230
13231 IO_arg.param[0] = (void *)&u32ReqSize;
13232 IO_arg.param[1] = (void *)u32AvailSize;
13233 IO_arg.param[2] = (void *)u32Addr;
13234 IO_arg.pRet = (void *)&eRet;
13235
13236 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETESBUFFVACANCY, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13237 {
13238 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13239 return E_VDEC_FAIL;
13240 }
13241 else
13242 {
13243 return eRet;
13244 }
13245 }
13246
MApi_VDEC_V2_GetESBuff(MS_U32 u32ReqSize,MS_U32 * u32AvailSize,MS_PHYADDR * u32Addr)13247 VDEC_Result MApi_VDEC_V2_GetESBuff(MS_U32 u32ReqSize, MS_U32* u32AvailSize, MS_PHYADDR* u32Addr)
13248 {
13249 #define ES_SAFE_SIZE (0x20)
13250 MS_U32 u32ReadPtr = 0;
13251 MS_U32 u32WritePtr = 0;
13252 MS_U32 u32WritePtrNew = 0;
13253 MS_U32 u32BuffSt = 0;
13254 MS_U32 u32BuffEnd = 0;
13255 VDEC_SysCfg* pCfg = NULL;
13256
13257 if (!bEsBufMgmt)
13258 {
13259 //printf("Please EnableESBuffMalloc before use GetESBuff\n");
13260 return E_VDEC_RET_ILLEGAL_ACCESS;
13261 }
13262 //check input parameters
13263 if ((NULL==u32AvailSize) || (NULL==u32Addr))
13264 {
13265 //printf("NULL pointer for output\n");
13266 return E_VDEC_RET_INVALID_PARAM;
13267 }
13268
13269 if (_VDEC_GetESBuffVacancy() < u32ReqSize)
13270 {
13271 VDEC_INFO(printf("ESVaca(0x%lx) < ReqSize(0x%lx)\n", _VDEC_GetESBuffVacancy(), u32ReqSize));
13272 return E_VDEC_FAIL;
13273 }
13274
13275 //check DecCmdQ/BBU vacancy
13276 if (MApi_VDEC_GetDecQVacancy() == 0)
13277 {
13278 VDEC_INFO(printf("DecQ full\n"));
13279 goto _NO_ES_BUFF;
13280 }
13281
13282 #if 0//_VDEC_PTS_TABLE
13283 if (_VDEC_PtsTableIsFull())
13284 {
13285 VDEC_INFO(printf("PtsTable full\n"));
13286 goto _NO_ES_BUFF;
13287 }
13288 #endif
13289 //check ES read/write pointer
13290 pCfg = &_vdecInitParam.SysConfig;
13291
13292 if(u32VdecInitParamVersion == 1)
13293 {
13294 pCfg = &_vdecInitParam_ex1.SysConfig;
13295 }
13296 u32ReadPtr = MApi_VDEC_GetESReadPtr();
13297 u32WritePtr = MApi_VDEC_GetESWritePtr();
13298
13299 u32BuffSt = pCfg->u32DrvProcBufSize;
13300 u32BuffEnd = pCfg->u32BitstreamBufSize;
13301
13302 if (u32WritePtr == 0)
13303 {
13304 u32WritePtr = u32BuffSt;
13305 }
13306
13307 u32ReqSize += ES_SAFE_SIZE; //for safety
13308 u32WritePtrNew = u32WritePtr + u32ReqSize;
13309 if (u32ReadPtr <= u32WritePtr)
13310 {
13311 if (u32WritePtrNew >= u32BuffEnd)
13312 {
13313 u32WritePtrNew = u32BuffSt + u32ReqSize;
13314
13315 if (u32WritePtrNew > u32ReadPtr)
13316 {
13317 VDEC_INFO(printf("xRd=0x%lx, Wr=0x%lx, WrNew=0x%lx, BsBuff=0x%lx, ReqSize=0x%lx\n", u32ReadPtr, u32WritePtr,
13318 u32WritePtrNew, pCfg->u32BitstreamBufAddr, u32ReqSize));
13319 goto _NO_ES_BUFF;
13320 }
13321 u32WritePtr = u32BuffSt;
13322 }
13323 }
13324 else
13325 {
13326 if (u32WritePtrNew > u32ReadPtr)
13327 {
13328 VDEC_INFO(printf("xRd=0x%lx, Wr=0x%lx, WrNew=0x%lx, BsBuff=0x%lx, ReqSize=0x%lx\n", u32ReadPtr, u32WritePtr,
13329 u32WritePtrNew, pCfg->u32BitstreamBufAddr, u32ReqSize));
13330 goto _NO_ES_BUFF;
13331 }
13332 }
13333
13334 *u32AvailSize = u32ReqSize;
13335 *u32Addr = u32WritePtr + pCfg->u32BitstreamBufAddr;
13336 VDEC_INFO(printf("Rd=0x%lx, Wr=0x%lx, WrNew=0x%lx, BsBuff=0x%lx, ReqSize=0x%lx\n", u32ReadPtr, u32WritePtr,
13337 u32WritePtrNew, pCfg->u32BitstreamBufAddr, u32ReqSize));
13338
13339 return E_VDEC_OK;
13340
13341 _NO_ES_BUFF:
13342 *u32AvailSize = 0;
13343 *u32Addr = (MS_PHYADDR)NULL;
13344 return E_VDEC_FAIL;
13345 }
13346
MApi_VDEC_GetNextDispFrame(VDEC_DispFrame ** ppDispFrm)13347 VDEC_Result MApi_VDEC_GetNextDispFrame(VDEC_DispFrame** ppDispFrm)
13348 {
13349 if (pu32VDEC_Inst == NULL)
13350 {
13351 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13352 return E_VDEC_FAIL;
13353 }
13354
13355 VDEC_V2_IO_Param IO_arg;
13356 VDEC_Result ret = E_VDEC_OK;
13357
13358 IO_arg.param[0] = (void *)ppDispFrm;
13359 IO_arg.pRet = (void *)&ret;
13360
13361 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_GETNEXTDISPFRAME, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13362 {
13363 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13364 return E_VDEC_FAIL;
13365 }
13366 else
13367 {
13368 return ret;
13369 }
13370 }
13371
MApi_VDEC_V2_GetNextDispFrame(VDEC_DispFrame ** ppDispFrm)13372 VDEC_Result MApi_VDEC_V2_GetNextDispFrame(VDEC_DispFrame** ppDispFrm)
13373 {
13374 VDEC_Result ret = E_VDEC_OK;
13375
13376 if (!_Attr.bInit)
13377 {
13378 //printf("VDEC not_init %s\n", __FUNCTION__);
13379 return E_VDEC_RET_NOT_INIT;
13380 }
13381 if (!ppDispFrm)
13382 {
13383 //printf("NULL pointer for %s\n", __FUNCTION__);
13384 return E_VDEC_RET_INVALID_PARAM;
13385 }
13386 switch (_Attr.eDecoder)
13387 {
13388 case E_VDEC_DECODER_MVD:
13389 {
13390 MVD_FrmInfo stFrm;
13391
13392 _VDEC_Memset(&stFrm, 0, sizeof(MVD_FrmInfo));
13393 _MVD_RET_HANDLE(MDrv_MVD_GetFrmInfo(E_MVD_FRMINFO_NEXT_DISPLAY, &stFrm));
13394
13395 VDEC_DispFrame* pDispFrm = _VDEC_MallocDq(E_VDEC_STREAM_0);
13396
13397 if (!pDispFrm)
13398 {
13399 //printf("No available DispQ!!!\n");
13400 ret = E_VDEC_FAIL;
13401 break;
13402 }
13403
13404 pDispFrm->stFrmInfo.eFrameType = _VDEC_MapFrmType2MVD(stFrm.eFrmType);
13405 pDispFrm->stFrmInfo.u16Height = stFrm.u16Height;
13406 pDispFrm->stFrmInfo.u16Width = stFrm.u16Width;
13407 pDispFrm->stFrmInfo.u16Pitch = stFrm.u16Pitch;
13408 pDispFrm->stFrmInfo.u32ChromaAddr = stFrm.u32ChromaAddr;
13409 pDispFrm->stFrmInfo.u32ID_H = stFrm.u32ID_H;
13410 pDispFrm->stFrmInfo.u32ID_L = stFrm.u32ID_L;
13411 pDispFrm->stFrmInfo.u32LumaAddr = stFrm.u32LumaAddr;
13412 pDispFrm->stFrmInfo.u32TimeStamp = stFrm.u32TimeStamp;
13413 pDispFrm->stFrmInfo.eFieldType = E_VDEC_FIELDTYPE_BOTH;
13414 *ppDispFrm = pDispFrm;
13415 pDispFrm->u32PriData = stFrm.u16FrmIdx;
13416 //printf("apiVDEC_MVD pts=%ld, frmIdx=%d\n", pDispFrm->stFrmInfo.u32TimeStamp, stFrm.u16FrmIdx);
13417 #if _VDEC_PTS_TABLE
13418 pDispFrm->stFrmInfo.u32TimeStamp = _VDEC_PtsTableGet();
13419 #endif
13420 ret = E_VDEC_OK;
13421 break;
13422 }
13423 case E_VDEC_DECODER_HVD:
13424 {
13425 HVD_Frame_Info info;
13426
13427 _VDEC_Memset(&info, 0, sizeof(HVD_Frame_Info));
13428 _HVD_RET_HANDLE(MDrv_HVD_GetFrmInfo(E_HVD_GFRMINFO_NEXT_DISPLAY, &info));
13429 VDEC_DispFrame* pDispFrm = _VDEC_MallocDq(E_VDEC_STREAM_0);
13430
13431 if (!pDispFrm)
13432 {
13433 //printf("No available DispQ!!!\n");
13434 ret = E_VDEC_FAIL;
13435 break;
13436 }
13437
13438 pDispFrm->stFrmInfo.eFrameType = _VDEC_MapFrmType2HVD(info.eFrmType);
13439 pDispFrm->stFrmInfo.u16Height = info.u16Height;
13440 pDispFrm->stFrmInfo.u16Width = info.u16Width;
13441 pDispFrm->stFrmInfo.u16Pitch = info.u16Pitch;
13442 pDispFrm->stFrmInfo.u32ChromaAddr = info.u32ChromaAddr;
13443 pDispFrm->stFrmInfo.u32ID_H = info.u32ID_H;
13444 pDispFrm->stFrmInfo.u32ID_L = info.u32ID_L;
13445 pDispFrm->stFrmInfo.u32LumaAddr = info.u32LumaAddr;
13446 pDispFrm->stFrmInfo.u32TimeStamp = info.u32TimeStamp;
13447 pDispFrm->stFrmInfo.eFieldType = (VDEC_FieldType) info.eFieldType;
13448 *ppDispFrm = pDispFrm;
13449
13450 pDispFrm->u32PriData = MDrv_HVD_GetNextDispQPtr();
13451 //printf("apiVDEC pts=%ld pri=0x%lx\n", pDispFrm->stFrmInfo.u32TimeStamp, pDispFrm->u32PriData);
13452
13453 ret = E_VDEC_OK;
13454
13455 break;
13456 }
13457 case E_VDEC_DECODER_RVD:
13458 break;
13459
13460 case E_VDEC_DECODER_MJPEG:
13461 {
13462 MJPEG_FrameInfo info;
13463 _VDEC_Memset(&info, 0, sizeof(MJPEG_FrameInfo));
13464 _MJPEG_RET_HANDLE(MApi_MJPEG_GetNextDispFrame(&info));
13465 VDEC_DispFrame* pDispFrm = _VDEC_MallocDq(E_VDEC_STREAM_0);
13466
13467 if (!pDispFrm)
13468 {
13469 //printf("No available DispQ!!!\n");
13470 ret = E_VDEC_FAIL;
13471 break;
13472 }
13473 pDispFrm->stFrmInfo.eFrameType = E_VDEC_FRM_TYPE_I;
13474 pDispFrm->stFrmInfo.u16Height = info.u16Height;
13475 pDispFrm->stFrmInfo.u16Width = info.u16Width;
13476 pDispFrm->stFrmInfo.u16Pitch = info.u16Pitch;
13477 pDispFrm->stFrmInfo.u32ChromaAddr = info.u32ChromaAddr;
13478 pDispFrm->stFrmInfo.u32ID_H = info.u32ID_H;
13479 pDispFrm->stFrmInfo.u32ID_L = info.u32ID_L;
13480 pDispFrm->stFrmInfo.u32LumaAddr = info.u32LumaAddr;
13481 pDispFrm->stFrmInfo.u32TimeStamp = info.u32TimeStamp;
13482 pDispFrm->stFrmInfo.eFieldType = E_VDEC_FIELDTYPE_BOTH;
13483 *ppDispFrm = pDispFrm;
13484
13485 pDispFrm->u32PriData = MApi_MJPEG_GetNextDispQPtr();
13486 //printf("apiVDEC pts=%ld\n", pDispFrm->stFrmInfo.u32TimeStamp);
13487
13488 ret = E_VDEC_OK;
13489
13490 break;
13491 }
13492 default:
13493 ret = E_VDEC_RET_UNSUPPORTED;
13494 break;
13495 }
13496 return ret;
13497 }
13498
13499 //------------------------------------------------------------------------------
13500 /// Notify FW to display the specified frame
13501 /// @param pDispFrm \b IN : the pointer of the frame to be displayed
13502 /// @return VDEC_Result
13503 /// @retval -E_VDEC_RET_NOT_INIT: VDEC is not initialized.
13504 /// @retval -E_VDEC_RET_INVALID_PARAM: the pointer is NULL.
13505 /// @retval -E_VDEC_RET_ILLEGAL_ACCESS: the pointer is invalid.
13506 /// There might be multiple frame display/release.
13507 //------------------------------------------------------------------------------
MApi_VDEC_DisplayFrame(VDEC_DispFrame * pDispFrm)13508 VDEC_Result MApi_VDEC_DisplayFrame(VDEC_DispFrame *pDispFrm)
13509 {
13510 if (pu32VDEC_Inst == NULL)
13511 {
13512 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13513 return E_VDEC_FAIL;
13514 }
13515
13516 VDEC_V2_IO_Param IO_arg;
13517 VDEC_Result ret = E_VDEC_OK;
13518
13519 IO_arg.param[0] = (void *)pDispFrm;
13520 IO_arg.pRet = (void *)&ret;
13521
13522 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_DISPLAYFRAME, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13523 {
13524 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13525 return E_VDEC_FAIL;
13526 }
13527 else
13528 {
13529 return ret;
13530 }
13531 }
13532
MApi_VDEC_V2_DisplayFrame(VDEC_DispFrame * pDispFrm)13533 VDEC_Result MApi_VDEC_V2_DisplayFrame(VDEC_DispFrame *pDispFrm)
13534 {
13535 VDEC_Result ret = E_VDEC_OK;
13536
13537 if (!_Attr.bInit)
13538 {
13539 return E_VDEC_RET_NOT_INIT;
13540 }
13541 if (!pDispFrm)
13542 {
13543 //printf("NULL pointer for %s\n", __FUNCTION__);
13544 return E_VDEC_RET_INVALID_PARAM;
13545 }
13546
13547 if (_VDEC_IsDqValid(pDispFrm))
13548 {
13549 VDEC_INFO(printf("%s invalid pDispFrm 0x%lx\n", __FUNCTION__, pDispFrm->u32PriData));
13550 return E_VDEC_RET_ILLEGAL_ACCESS;
13551 }
13552
13553 switch (_Attr.eDecoder)
13554 {
13555 case E_VDEC_DECODER_MVD:
13556 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_FrameFlip(pDispFrm->u32PriData));
13557 _VDEC_FreeDq(E_VDEC_STREAM_0, pDispFrm);
13558 break;
13559
13560 case E_VDEC_DECODER_HVD:
13561 _HVD_RET_HANDLE(MDrv_HVD_DispFrame(pDispFrm->u32PriData));
13562 _VDEC_FreeDq(E_VDEC_STREAM_0, pDispFrm);
13563 break;
13564
13565 case E_VDEC_DECODER_RVD:
13566 break;
13567
13568 case E_VDEC_DECODER_MJPEG:
13569 _MJPEG_RET_HANDLE(MApi_MJPEG_DispFrame(pDispFrm->u32PriData));
13570 _VDEC_FreeDq(E_VDEC_STREAM_0, pDispFrm);
13571 break;
13572
13573 default:
13574 ret = E_VDEC_RET_UNSUPPORTED;
13575 break;
13576 }
13577 return ret;
13578 }
13579
MApi_VDEC_ReleaseFrame(VDEC_DispFrame * pDispFrm)13580 VDEC_Result MApi_VDEC_ReleaseFrame(VDEC_DispFrame *pDispFrm)
13581 {
13582 if (pu32VDEC_Inst == NULL)
13583 {
13584 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13585 return E_VDEC_FAIL;
13586 }
13587
13588 VDEC_V2_IO_Param IO_arg;
13589 VDEC_Result ret = E_VDEC_OK;
13590
13591 IO_arg.param[0] = (void *)pDispFrm;
13592 IO_arg.pRet = (void *)&ret;
13593
13594 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_RELEASEFRAME, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13595 {
13596 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13597 return E_VDEC_FAIL;
13598 }
13599 else
13600 {
13601 return ret;
13602 }
13603 }
13604
MApi_VDEC_V2_ReleaseFrame(VDEC_DispFrame * pDispFrm)13605 VDEC_Result MApi_VDEC_V2_ReleaseFrame(VDEC_DispFrame *pDispFrm)
13606 {
13607 VDEC_Result ret = E_VDEC_OK;
13608
13609 if (!_Attr.bInit)
13610 {
13611 return E_VDEC_RET_NOT_INIT;
13612 }
13613
13614 if (!pDispFrm)
13615 {
13616 //printf("NULL pointer for %s\n", __FUNCTION__);
13617 return E_VDEC_RET_INVALID_PARAM;
13618 }
13619
13620 if (_VDEC_IsDqValid(pDispFrm))
13621 {
13622 VDEC_INFO(printf("%s invalid pDispFrm 0x%lx\n", __FUNCTION__, pDispFrm->u32PriData));
13623 return E_VDEC_RET_INVALID_PARAM;
13624 }
13625
13626 switch (_Attr.eDecoder)
13627 {
13628 case E_VDEC_DECODER_MVD:
13629 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_FrameRelease(pDispFrm->u32PriData));
13630 _VDEC_FreeDq(E_VDEC_STREAM_0, pDispFrm);
13631 break;
13632
13633 case E_VDEC_DECODER_HVD:
13634 _HVD_RET_HANDLE(MDrv_HVD_FreeFrame(pDispFrm->u32PriData));
13635 _VDEC_FreeDq(E_VDEC_STREAM_0, pDispFrm);
13636 break;
13637
13638 case E_VDEC_DECODER_RVD:
13639 break;
13640
13641 case E_VDEC_DECODER_MJPEG:
13642 _MJPEG_RET_HANDLE(MApi_MJPEG_FreeFrame(pDispFrm->u32PriData));
13643 _VDEC_FreeDq(E_VDEC_STREAM_0, pDispFrm);
13644 break;
13645
13646 default:
13647 ret = E_VDEC_RET_ILLEGAL_ACCESS;
13648 break;
13649 }
13650 return ret;
13651 }
13652
MApi_VDEC_FlushPTSBuf(void)13653 VDEC_Result MApi_VDEC_FlushPTSBuf(void)
13654 {
13655 if (pu32VDEC_Inst == NULL)
13656 {
13657 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13658 return E_VDEC_FAIL;
13659 }
13660
13661 VDEC_V2_IO_Param IO_arg;
13662 VDEC_Result ret = E_VDEC_OK;
13663
13664 IO_arg.pRet = (void *)&ret;
13665
13666 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_FLUSHPTSBUF, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13667 {
13668 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13669 return E_VDEC_FAIL;
13670 }
13671 else
13672 {
13673 return ret;
13674 }
13675 }
13676
MApi_VDEC_V2_FlushPTSBuf(void)13677 VDEC_Result MApi_VDEC_V2_FlushPTSBuf(void)
13678 {
13679 VDEC_Result ret = E_VDEC_OK;
13680
13681 if (!_Attr.bInit)
13682 {
13683 return E_VDEC_RET_NOT_INIT;
13684 }
13685
13686 switch (_Attr.eDecoder)
13687 {
13688 case E_VDEC_DECODER_MVD:
13689 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_FlushPTSBuf());
13690 break;
13691
13692 case E_VDEC_DECODER_HVD:
13693 break;
13694
13695 case E_VDEC_DECODER_RVD:
13696 break;
13697
13698 case E_VDEC_DECODER_MJPEG:
13699 break;
13700 default:
13701 ret = E_VDEC_RET_UNSUPPORTED;
13702 break;
13703 }
13704 return ret;
13705 }
13706
MApi_VDEC_CaptureFrame(MS_U32 u32FrmPriData,MS_BOOL bEnable)13707 VDEC_Result MApi_VDEC_CaptureFrame(MS_U32 u32FrmPriData, MS_BOOL bEnable)
13708 {
13709 if (pu32VDEC_Inst == NULL)
13710 {
13711 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13712 return E_VDEC_FAIL;
13713 }
13714
13715 VDEC_V2_IO_Param IO_arg;
13716 VDEC_Result ret = E_VDEC_OK;
13717
13718 IO_arg.param[0] = (void *)&u32FrmPriData;
13719 IO_arg.param[1] = (void *)&bEnable;
13720 IO_arg.pRet = (void *)&ret;
13721
13722 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CAPTUREFRAME, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13723 {
13724 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13725 return E_VDEC_FAIL;
13726 }
13727 else
13728 {
13729 return ret;
13730 }
13731 }
13732
MApi_VDEC_V2_CaptureFrame(MS_U32 u32FrmPriData,MS_BOOL bEnable)13733 VDEC_Result MApi_VDEC_V2_CaptureFrame(MS_U32 u32FrmPriData, MS_BOOL bEnable)
13734 {
13735 VDEC_Result ret = E_VDEC_OK;
13736 static MS_U32 u32PriData = VDEC_U32_MAX;
13737
13738 if (!_Attr.bInit)
13739 {
13740 return E_VDEC_RET_NOT_INIT;
13741 }
13742 if (u32FrmPriData == VDEC_U32_MAX)
13743 {
13744 return E_VDEC_RET_INVALID_PARAM;
13745 }
13746
13747 //check the disable frame is valid
13748 if ((FALSE == bEnable) && (u32PriData != u32FrmPriData))
13749 {
13750 printf("%s: Release an uncaptured frame(0x%lx != 0x%lx)!\n",
13751 __FUNCTION__, u32FrmPriData, u32PriData);
13752 return E_VDEC_RET_INVALID_PARAM;
13753 }
13754
13755 switch (_Attr.eDecoder)
13756 {
13757 case E_VDEC_DECODER_MVD:
13758 _BOOL_TO_VDEC_RESULT(ret, MDrv_MVD_FrameCapture(u32FrmPriData, bEnable));
13759 break;
13760
13761 case E_VDEC_DECODER_HVD:
13762 break;
13763
13764 case E_VDEC_DECODER_MJPEG:
13765 break;
13766
13767 default:
13768 ret = E_VDEC_RET_UNSUPPORTED;
13769 break;
13770 }
13771
13772 if (E_VDEC_OK == ret)
13773 {
13774 if(FALSE == bEnable)
13775 {
13776 u32PriData = VDEC_U32_MAX;
13777 }
13778 else
13779 { //record the captured frame idx
13780 u32PriData = u32FrmPriData;
13781 }
13782 }
13783
13784 return ret;
13785 }
13786
MApi_VDEC_CC_Init(MS_U32 * pIn)13787 VDEC_Result MApi_VDEC_CC_Init(MS_U32 *pIn)
13788 {
13789 if (pu32VDEC_Inst == NULL)
13790 {
13791 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13792 return E_VDEC_FAIL;
13793 }
13794
13795 VDEC_V2_IO_Param IO_arg;
13796 VDEC_Result retVal = E_VDEC_FAIL;
13797
13798 IO_arg.param[0] = (void *)pIn;
13799 IO_arg.pRet = (void *)&retVal;
13800
13801 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_INIT, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13802 {
13803 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13804 return E_VDEC_FAIL;
13805 }
13806 else
13807 {
13808 return retVal;
13809 }
13810 }
13811
MApi_VDEC_V2_CC_Init(MS_U32 * pIn)13812 VDEC_Result MApi_VDEC_V2_CC_Init(MS_U32 *pIn)
13813 {
13814 VDEC_Result retVal = E_VDEC_FAIL;
13815
13816 if (!_Attr.bInit)
13817 {
13818 return E_VDEC_RET_NOT_INIT;
13819 }
13820
13821 switch (_Attr.eDecoder)
13822 {
13823 case E_VDEC_DECODER_MVD:
13824 {
13825 MDrv_CC_Init();
13826 retVal = E_VDEC_OK;
13827 }
13828 break;
13829
13830 case E_VDEC_DECODER_HVD:
13831 {
13832 retVal = MDrv_HVD_CC_Init();
13833 }
13834 break;
13835
13836 case E_VDEC_DECODER_MJPEG:
13837 case E_VDEC_DECODER_RVD:
13838 default:
13839 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
13840 break;
13841 }
13842
13843 return retVal;
13844 }
13845
MApi_VDEC_CC_SetCfg(VDEC_CCFormat eFmt,VDEC_CCType eType,MS_U32 * pIn)13846 VDEC_Result MApi_VDEC_CC_SetCfg(VDEC_CCFormat eFmt, VDEC_CCType eType, MS_U32 *pIn)
13847 {
13848 if (pu32VDEC_Inst == NULL)
13849 {
13850 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13851 return E_VDEC_FAIL;
13852 }
13853
13854 VDEC_V2_IO_Param IO_arg;
13855 VDEC_Result retVal = E_VDEC_FAIL;
13856
13857 IO_arg.param[0] = (void *)&eFmt;
13858 IO_arg.param[1] = (void *)&eType;
13859 IO_arg.param[2] = (void *)pIn;
13860 IO_arg.pRet = (void *)&retVal;
13861
13862 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_SETCFG, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13863 {
13864 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13865 return E_VDEC_FAIL;
13866 }
13867 else
13868 {
13869 return retVal;
13870 }
13871 }
13872
MApi_VDEC_V2_CC_SetCfg(VDEC_CCFormat eFmt,VDEC_CCType eType,MS_U32 * pIn)13873 VDEC_Result MApi_VDEC_V2_CC_SetCfg(VDEC_CCFormat eFmt, VDEC_CCType eType, MS_U32 *pIn)
13874 {
13875 VDEC_Result retVal = E_VDEC_FAIL;
13876
13877 if (!_Attr.bInit)
13878 {
13879 return E_VDEC_RET_NOT_INIT;
13880 }
13881 if (!pIn)
13882 {
13883 return E_VDEC_RET_INVALID_PARAM;
13884 }
13885
13886 switch (_Attr.eDecoder)
13887 {
13888 case E_VDEC_DECODER_MVD:
13889 {
13890 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
13891 MS_U8 u8Opt = _VDEC_Map2MVDCCOpt(eType);
13892 MS_U16 u16BufferSize = 0;
13893 VDEC_CC_InputPara* pInput = (VDEC_CC_InputPara*)pIn;
13894 if (pInput->u32Ver != 0)
13895 {
13896 printf("%s not supported ver %ld\n", __FUNCTION__, pInput->u32Ver);
13897 return E_VDEC_FAIL;
13898 }
13899 u16BufferSize = (MS_U16)pInput->u32Val;
13900 MDrv_CC_CM_SetParsingType(u8Opt, u16BufferSize, u8Type);
13901 retVal = E_VDEC_OK;
13902 }
13903 break;
13904 case E_VDEC_DECODER_HVD:
13905 {
13906 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
13907 MS_U8 u8Opt = _VDEC_Map2HVDCCOpt(eType);
13908 MS_U16 u16BufferSize = 0;
13909 VDEC_CC_InputPara* pInput = (VDEC_CC_InputPara*)pIn;
13910 if (pInput->u32Ver != 0)
13911 {
13912 printf("%s not supported ver %ld\n", __FUNCTION__, pInput->u32Ver);
13913 return E_VDEC_FAIL;
13914 }
13915 u16BufferSize = (MS_U16)pInput->u32Val;
13916 retVal = MDrv_HVD_CC_SetCfg(u8Opt, u16BufferSize, u8Type);
13917 }
13918 break;
13919 default:
13920 retVal = E_VDEC_RET_UNSUPPORTED;
13921 break;
13922 }
13923
13924 return retVal;
13925 }
13926
MApi_VDEC_CC_SetBuffStartAdd(VDEC_CCFormat eFmt,MS_U32 * pIn)13927 VDEC_Result MApi_VDEC_CC_SetBuffStartAdd(VDEC_CCFormat eFmt, MS_U32 *pIn)
13928 {
13929 if (pu32VDEC_Inst == NULL)
13930 {
13931 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13932 return E_VDEC_FAIL;
13933 }
13934
13935 VDEC_V2_IO_Param IO_arg;
13936 VDEC_Result retVal = E_VDEC_FAIL;
13937
13938 IO_arg.param[0] = (void *)&eFmt;
13939 IO_arg.param[1] = (void *)pIn;
13940 IO_arg.pRet = (void *)&retVal;
13941
13942 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_SETBUFFSTARTADD, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
13943 {
13944 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
13945 return E_VDEC_FAIL;
13946 }
13947 else
13948 {
13949 return retVal;
13950 }
13951 }
13952
MApi_VDEC_V2_CC_SetBuffStartAdd(VDEC_CCFormat eFmt,MS_U32 * pIn)13953 VDEC_Result MApi_VDEC_V2_CC_SetBuffStartAdd(VDEC_CCFormat eFmt, MS_U32 *pIn)
13954 {
13955 VDEC_Result retVal = E_VDEC_FAIL;
13956
13957 if (!_Attr.bInit)
13958 {
13959 return E_VDEC_RET_NOT_INIT;
13960 }
13961 if (!pIn)
13962 {
13963 return E_VDEC_RET_INVALID_PARAM;
13964 }
13965
13966 switch (_Attr.eDecoder)
13967 {
13968 case E_VDEC_DECODER_MVD:
13969 {
13970 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
13971 MS_U32 u32StartAdd = 0;
13972 VDEC_CC_InputPara* pInput = (VDEC_CC_InputPara*)pIn;
13973 if (pInput->u32Ver != 0)
13974 {
13975 printf("%s not supported ver %ld\n", __FUNCTION__, pInput->u32Ver);
13976 return E_VDEC_FAIL;
13977 }
13978 u32StartAdd = pInput->u32Val;
13979 MDrv_CC_CM_SetMVDRB_HWAddr(u32StartAdd, u8Type);
13980 retVal = E_VDEC_OK;
13981 }
13982 break;
13983
13984 case E_VDEC_DECODER_HVD:
13985 {
13986 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
13987 MS_U32 u32StartAdd = 0;
13988 VDEC_CC_InputPara* pInput = (VDEC_CC_InputPara*)pIn;
13989 if (pInput->u32Ver != 0)
13990 {
13991 printf("%s not supported ver %ld\n", __FUNCTION__, pInput->u32Ver);
13992 return E_VDEC_FAIL;
13993 }
13994 u32StartAdd = pInput->u32Val;
13995 retVal = MDrv_HVD_CC_Set_RB_StartAddr(u32StartAdd, u8Type);
13996 }
13997 break;
13998
13999 default:
14000 retVal = E_VDEC_RET_UNSUPPORTED;
14001 break;
14002 }
14003
14004 return retVal;
14005 }
14006
MApi_VDEC_CC_UpdateWriteAdd(VDEC_CCFormat eFmt,MS_U32 * pIn)14007 VDEC_Result MApi_VDEC_CC_UpdateWriteAdd(VDEC_CCFormat eFmt, MS_U32 *pIn)
14008 {
14009 if (pu32VDEC_Inst == NULL)
14010 {
14011 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14012 return E_VDEC_FAIL;
14013 }
14014
14015 VDEC_V2_IO_Param IO_arg;
14016 VDEC_Result retVal = E_VDEC_FAIL;
14017
14018 IO_arg.param[0] = (void *)&eFmt;
14019 IO_arg.param[1] = (void *)pIn;
14020 IO_arg.pRet = (void *)&retVal;
14021
14022 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_UPDATEWRITEADD, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14023 {
14024 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14025 return E_VDEC_FAIL;
14026 }
14027 else
14028 {
14029 return retVal;
14030 }
14031 }
14032
MApi_VDEC_V2_CC_UpdateWriteAdd(VDEC_CCFormat eFmt,MS_U32 * pIn)14033 VDEC_Result MApi_VDEC_V2_CC_UpdateWriteAdd(VDEC_CCFormat eFmt, MS_U32 *pIn)
14034 {
14035 VDEC_Result retVal = E_VDEC_FAIL;
14036
14037 if (!_Attr.bInit)
14038 {
14039 return E_VDEC_RET_NOT_INIT;
14040 }
14041
14042 switch (_Attr.eDecoder)
14043 {
14044 case E_VDEC_DECODER_MVD:
14045 {
14046 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14047 MDrv_CC_CM_SyncMVDRB_SWAddr2HWAddr(u8Type);
14048 retVal = E_VDEC_OK;
14049 }
14050 break;
14051
14052 case E_VDEC_DECODER_HVD:
14053 {
14054 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14055 retVal = MDrv_HVD_CC_SyncRB_RdAddr2WrAddr(u8Type);
14056 }
14057 break;
14058
14059 default:
14060 retVal = E_VDEC_RET_UNSUPPORTED;
14061 break;
14062 }
14063
14064 return retVal;
14065 }
14066
MApi_VDEC_CC_UpdateReadAdd(VDEC_CCFormat eFmt,MS_U32 * pIn)14067 VDEC_Result MApi_VDEC_CC_UpdateReadAdd(VDEC_CCFormat eFmt, MS_U32 *pIn)
14068 {
14069 if (pu32VDEC_Inst == NULL)
14070 {
14071 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14072 return E_VDEC_FAIL;
14073 }
14074
14075 VDEC_V2_IO_Param IO_arg;
14076 VDEC_Result retVal = E_VDEC_FAIL;
14077
14078 IO_arg.param[0] = (void *)&eFmt;
14079 IO_arg.param[1] = (void *)pIn;
14080 IO_arg.pRet = (void *)&retVal;
14081
14082 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_UPDATEREADADD, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14083 {
14084 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14085 return E_VDEC_FAIL;
14086 }
14087 else
14088 {
14089 return retVal;
14090 }
14091 }
14092
MApi_VDEC_V2_CC_UpdateReadAdd(VDEC_CCFormat eFmt,MS_U32 * pIn)14093 VDEC_Result MApi_VDEC_V2_CC_UpdateReadAdd(VDEC_CCFormat eFmt, MS_U32 *pIn)
14094 {
14095 VDEC_Result retVal = E_VDEC_FAIL;
14096
14097 if (!_Attr.bInit)
14098 {
14099 return E_VDEC_RET_NOT_INIT;
14100 }
14101 if (!pIn)
14102 {
14103 return E_VDEC_RET_INVALID_PARAM;
14104 }
14105
14106 switch (_Attr.eDecoder)
14107 {
14108 case E_VDEC_DECODER_MVD:
14109 {
14110 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14111 MS_U32 u32EachPktSize = 0;
14112 VDEC_CC_InputPara* pInput = (VDEC_CC_InputPara*)pIn;
14113 if (pInput->u32Ver != 0)
14114 {
14115 printf("%s not supported ver %ld\n", __FUNCTION__, pInput->u32Ver);
14116 return E_VDEC_FAIL;
14117 }
14118 u32EachPktSize = pInput->u32Val;
14119 MDrv_CC_PM_SetMVDRB_ReadAddr(u32EachPktSize, u8Type);
14120 retVal = E_VDEC_OK;
14121 }
14122 break;
14123
14124 case E_VDEC_DECODER_HVD:
14125 {
14126 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14127 MS_U32 u32EachPktSize = 0;
14128 VDEC_CC_InputPara* pInput = (VDEC_CC_InputPara*)pIn;
14129 if (pInput->u32Ver != 0)
14130 {
14131 printf("%s not supported ver %ld\n", __FUNCTION__, pInput->u32Ver);
14132 return E_VDEC_FAIL;
14133 }
14134 u32EachPktSize = pInput->u32Val;
14135 retVal = MDrv_HVD_CC_Adv_RB_ReadAddr(u32EachPktSize, u8Type);
14136 }
14137 break;
14138
14139 default:
14140 retVal = E_VDEC_RET_UNSUPPORTED;
14141 break;
14142 }
14143
14144 return retVal;
14145 }
14146
MApi_VDEC_CC_DisableParsing(VDEC_CCFormat eFmt)14147 VDEC_Result MApi_VDEC_CC_DisableParsing(VDEC_CCFormat eFmt)
14148 {
14149 if (pu32VDEC_Inst == NULL)
14150 {
14151 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14152 return E_VDEC_FAIL;
14153 }
14154
14155 VDEC_V2_IO_Param IO_arg;
14156 VDEC_Result retVal = E_VDEC_FAIL;
14157
14158 IO_arg.param[0] = (void *)&eFmt;
14159 IO_arg.pRet = (void *)&retVal;
14160
14161 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_DISABLEPARSING, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14162 {
14163 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14164 return E_VDEC_FAIL;
14165 }
14166 else
14167 {
14168 return retVal;
14169 }
14170 }
14171
MApi_VDEC_V2_CC_DisableParsing(VDEC_CCFormat eFmt)14172 VDEC_Result MApi_VDEC_V2_CC_DisableParsing(VDEC_CCFormat eFmt)
14173 {
14174 VDEC_Result retVal = E_VDEC_FAIL;
14175
14176 if (!_Attr.bInit)
14177 {
14178 return E_VDEC_RET_NOT_INIT;
14179 }
14180
14181 switch (_Attr.eDecoder)
14182 {
14183 case E_VDEC_DECODER_MVD:
14184 {
14185 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14186 MDrv_CC_CM_DisableParsing(u8Type);
14187 retVal = E_VDEC_OK;
14188 }
14189 break;
14190
14191 case E_VDEC_DECODER_HVD:
14192 {
14193 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14194 retVal = MDrv_HVD_CC_DisableParsing(u8Type);
14195 }
14196 break;
14197
14198 default:
14199 retVal = E_VDEC_RET_UNSUPPORTED;
14200 break;
14201 }
14202
14203 return retVal;
14204 }
14205
MApi_VDEC_CC_GetInfo(VDEC_CCFormat eFmt,VDEC_CCInfoCmd eCmd,MS_U32 * pOut)14206 VDEC_Result MApi_VDEC_CC_GetInfo(VDEC_CCFormat eFmt, VDEC_CCInfoCmd eCmd, MS_U32 *pOut)
14207 {
14208 if (pu32VDEC_Inst == NULL)
14209 {
14210 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14211 return E_VDEC_FAIL;
14212 }
14213
14214 VDEC_V2_IO_Param IO_arg;
14215 VDEC_Result retVal = E_VDEC_FAIL;
14216
14217 IO_arg.param[0] = (void *)&eFmt;
14218 IO_arg.param[1] = (void *)&eCmd;
14219 IO_arg.param[2] = (void *)pOut;
14220 IO_arg.pRet = (void *)&retVal;
14221
14222 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETINFO, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14223 {
14224 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14225 return E_VDEC_FAIL;
14226 }
14227 else
14228 {
14229 return retVal;
14230 }
14231 }
14232
MApi_VDEC_V2_CC_GetInfo(VDEC_CCFormat eFmt,VDEC_CCInfoCmd eCmd,MS_U32 * pOut)14233 VDEC_Result MApi_VDEC_V2_CC_GetInfo(VDEC_CCFormat eFmt, VDEC_CCInfoCmd eCmd, MS_U32 *pOut)
14234 {
14235 VDEC_Result retVal = E_VDEC_FAIL;
14236
14237 if (!_Attr.bInit)
14238 {
14239 return E_VDEC_RET_NOT_INIT;
14240 }
14241 if (!pOut)
14242 {
14243 return E_VDEC_RET_INVALID_PARAM;
14244 }
14245
14246 switch (_Attr.eDecoder)
14247 {
14248 case E_VDEC_DECODER_MVD:
14249 {
14250 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14251 EN_CC_MVD_INFO eCCInfo = CC_SELECTOR_CCMVD_RINGBUFFER;
14252 MS_U32 u32Val1=0, u32Val2=0;
14253 if (E_VDEC_CC_GET_708_ENABLE == eCmd)
14254 {
14255 eCCInfo = CC_SELECTOR_708_SW;
14256 }
14257 MDrv_CC_CM_GetInfo(eCCInfo, u8Type, &u32Val1, &u32Val2);
14258 *pOut = u32Val1;
14259 if (E_VDEC_CC_GET_BUFF_SIZE == eCmd)
14260 {
14261 *pOut = u32Val2;
14262 }
14263 retVal = E_VDEC_OK;
14264 }
14265 break;
14266
14267 case E_VDEC_DECODER_HVD:
14268 {
14269 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14270 EN_CC_MVD_INFO eCCInfo = HVD_CC_SELECTOR_RINGBUFFER;
14271 MS_U32 u32Val1=0, u32Val2=0;
14272 if (E_VDEC_CC_GET_708_ENABLE == eCmd)
14273 {
14274 eCCInfo = HVD_CC_SELECTOR_708_SW;
14275 }
14276 retVal = MDrv_HVD_CC_GetInfo(eCCInfo, u8Type, &u32Val1, &u32Val2);
14277 *pOut = u32Val1;
14278 if (E_VDEC_CC_GET_BUFF_SIZE == eCmd)
14279 {
14280 *pOut = u32Val2;
14281 }
14282 }
14283 break;
14284
14285 default:
14286 retVal = E_VDEC_RET_UNSUPPORTED;
14287 break;
14288 }
14289
14290 return retVal;
14291 }
14292
MApi_VDEC_CC_GetIsRstDone(VDEC_CCFormat eFmt)14293 VDEC_Result MApi_VDEC_CC_GetIsRstDone(VDEC_CCFormat eFmt)
14294 {
14295 if (pu32VDEC_Inst == NULL)
14296 {
14297 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14298 return E_VDEC_FAIL;
14299 }
14300
14301 VDEC_V2_IO_Param IO_arg;
14302 VDEC_Result retVal = E_VDEC_FAIL;
14303
14304
14305 IO_arg.param[0] = (void *)&eFmt;
14306 IO_arg.pRet = (void *)&retVal;
14307
14308 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETISRSTDONE, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14309 {
14310 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14311 return E_VDEC_FAIL;
14312 }
14313 else
14314 {
14315 return retVal;
14316 }
14317 }
14318
MApi_VDEC_V2_CC_GetIsRstDone(VDEC_CCFormat eFmt)14319 VDEC_Result MApi_VDEC_V2_CC_GetIsRstDone(VDEC_CCFormat eFmt)
14320 {
14321 VDEC_Result retVal = E_VDEC_FAIL;
14322
14323 if (!_Attr.bInit)
14324 {
14325 return E_VDEC_RET_NOT_INIT;
14326 }
14327
14328 switch (_Attr.eDecoder)
14329 {
14330 case E_VDEC_DECODER_MVD:
14331 {
14332 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14333 _BOOL_TO_VDEC_RESULT(retVal, MDrv_CC_CM_IsMvdRstDone(u8Type));
14334 }
14335 break;
14336
14337 case E_VDEC_DECODER_HVD:
14338 {
14339 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14340 _BOOL_TO_VDEC_RESULT(retVal, MDrv_HVD_CC_IsHvdRstDone(u8Type));
14341 }
14342 break;
14343
14344 case E_VDEC_DECODER_MJPEG:
14345 case E_VDEC_DECODER_RVD:
14346 default:
14347 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
14348 break;
14349 }
14350
14351 return retVal;
14352 }
14353
MApi_VDEC_CC_GetIsBuffOverflow(VDEC_CCFormat eFmt)14354 VDEC_Result MApi_VDEC_CC_GetIsBuffOverflow(VDEC_CCFormat eFmt)
14355 {
14356 if (pu32VDEC_Inst == NULL)
14357 {
14358 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14359 return E_VDEC_FAIL;
14360 }
14361
14362 VDEC_V2_IO_Param IO_arg;
14363 VDEC_Result retVal = E_VDEC_FAIL;
14364
14365 IO_arg.param[0] = (void *)&eFmt;
14366 IO_arg.pRet = (void *)&retVal;
14367
14368 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETISBUFFOVERFLOW, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14369 {
14370 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14371 return E_VDEC_FAIL;
14372 }
14373 else
14374 {
14375 return retVal;
14376 }
14377 }
14378
MApi_VDEC_V2_CC_GetIsBuffOverflow(VDEC_CCFormat eFmt)14379 VDEC_Result MApi_VDEC_V2_CC_GetIsBuffOverflow(VDEC_CCFormat eFmt)
14380 {
14381 VDEC_Result retVal = E_VDEC_FAIL;
14382
14383 if (!_Attr.bInit)
14384 {
14385 return E_VDEC_RET_NOT_INIT;
14386 }
14387
14388 switch (_Attr.eDecoder)
14389 {
14390 case E_VDEC_DECODER_MVD:
14391 {
14392 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14393 _BOOL_TO_VDEC_RESULT(retVal, MDrv_CC_CM_GetOverflowStatus(u8Type));
14394 }
14395 break;
14396
14397 case E_VDEC_DECODER_HVD:
14398 {
14399 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14400 _BOOL_TO_VDEC_RESULT(retVal, MDrv_HVD_CC_GetOverflowStatus(u8Type));
14401 }
14402 break;
14403
14404 case E_VDEC_DECODER_MJPEG:
14405 case E_VDEC_DECODER_RVD:
14406 default:
14407 retVal = E_VDEC_RET_ILLEGAL_ACCESS;
14408 break;
14409 }
14410
14411 return retVal;
14412 }
14413
14414 //------------------------------------------------------------------------------
14415 /// Report the physical address of write pointer
14416 /// @param eFmt \b IN : the format of closed caption
14417 /// @return MS_PHYADDR
14418 //------------------------------------------------------------------------------
MApi_VDEC_CC_GetWriteAdd(VDEC_CCFormat eFmt)14419 MS_PHYADDR MApi_VDEC_CC_GetWriteAdd(VDEC_CCFormat eFmt)
14420 {
14421 if (pu32VDEC_Inst == NULL)
14422 {
14423 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14424 return E_VDEC_FAIL;
14425 }
14426
14427 VDEC_V2_IO_Param IO_arg;
14428 MS_PHYADDR u32CCWrPtr = VDEC_U32_MAX;
14429
14430 IO_arg.param[0] = (void *)&eFmt;
14431 IO_arg.pRet = (void *)&u32CCWrPtr;
14432
14433 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETWRITEADD, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14434 {
14435 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14436 return E_VDEC_FAIL;
14437 }
14438 else
14439 {
14440 return u32CCWrPtr;
14441 }
14442 }
14443
MApi_VDEC_V2_CC_GetWriteAdd(VDEC_CCFormat eFmt)14444 MS_PHYADDR MApi_VDEC_V2_CC_GetWriteAdd(VDEC_CCFormat eFmt)
14445 {
14446 MS_PHYADDR u32CCWrPtr = VDEC_U32_MAX;
14447
14448 if (!_Attr.bInit)
14449 {
14450 return u32CCWrPtr;
14451 }
14452
14453 switch (_Attr.eDecoder)
14454 {
14455 case E_VDEC_DECODER_MVD:
14456 {
14457 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14458 u32CCWrPtr = MDrv_CC_PM_GetMVDRB_WriteAddr(u8Type);
14459 }
14460 break;
14461
14462 case E_VDEC_DECODER_HVD:
14463 {
14464 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14465 u32CCWrPtr = MDrv_HVD_CC_Get_RB_WriteAddr(u8Type);
14466 }
14467 break;
14468
14469 default:
14470 break;
14471 }
14472
14473 return u32CCWrPtr;
14474 }
14475
14476 //------------------------------------------------------------------------------
14477 /// Report the physical address of read pointer
14478 /// @param eFmt \b IN : the format of closed caption
14479 /// @return MS_PHYADDR
14480 //------------------------------------------------------------------------------
MApi_VDEC_CC_GetReadAdd(VDEC_CCFormat eFmt)14481 MS_PHYADDR MApi_VDEC_CC_GetReadAdd(VDEC_CCFormat eFmt)
14482 {
14483 if (pu32VDEC_Inst == NULL)
14484 {
14485 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14486 return E_VDEC_FAIL;
14487 }
14488
14489 VDEC_V2_IO_Param IO_arg;
14490 MS_PHYADDR u32CCRdPtr = VDEC_U32_MAX;
14491
14492 IO_arg.param[0] = (void *)&eFmt;
14493 IO_arg.pRet = (void *)&u32CCRdPtr;
14494
14495 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_CC_GETREADADD, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14496 {
14497 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14498 return E_VDEC_FAIL;
14499 }
14500 else
14501 {
14502 return u32CCRdPtr;
14503 }
14504 }
14505
MApi_VDEC_V2_CC_GetReadAdd(VDEC_CCFormat eFmt)14506 MS_PHYADDR MApi_VDEC_V2_CC_GetReadAdd(VDEC_CCFormat eFmt)
14507 {
14508 MS_PHYADDR u32CCRdPtr = VDEC_U32_MAX;
14509
14510 if (!_Attr.bInit)
14511 {
14512 return u32CCRdPtr;
14513 }
14514
14515 switch (_Attr.eDecoder)
14516 {
14517 case E_VDEC_DECODER_MVD:
14518 {
14519 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14520 u32CCRdPtr = MDrv_CC_PM_GetMVDRB_ReadAddr(u8Type);
14521 }
14522 break;
14523
14524 case E_VDEC_DECODER_HVD:
14525 {
14526 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14527 u32CCRdPtr = MDrv_HVD_CC_Get_RB_ReadAddr(u8Type);
14528 }
14529 break;
14530
14531 default:
14532 break;
14533 }
14534
14535 return u32CCRdPtr;
14536 }
14537
MApi_VDEC_SystemPreSetControl(VDEC_User_Cmd cmd_id,void * pParam)14538 VDEC_Result MApi_VDEC_SystemPreSetControl(VDEC_User_Cmd cmd_id, void *pParam)
14539 {
14540 if (pu32VDEC_Inst == NULL)
14541 {
14542 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14543 return E_VDEC_FAIL;
14544 }
14545
14546 VDEC_V2_IO_Param IO_arg;
14547 VDEC_Result eRet = E_VDEC_FAIL;
14548
14549 IO_arg.param[0] = (void *)&cmd_id;
14550 IO_arg.param[0] = (void *)pParam;
14551 IO_arg.pRet = (void *)&eRet;
14552
14553 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_SYSTEMPRESETCONTROL, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14554 {
14555 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14556 return E_VDEC_FAIL;
14557 }
14558 else
14559 {
14560 return eRet;
14561 }
14562 }
14563
MApi_VDEC_V2_SystemPreSetControl(VDEC_User_Cmd cmd_id,void * pParam)14564 VDEC_Result MApi_VDEC_V2_SystemPreSetControl(VDEC_User_Cmd cmd_id, void *pParam)
14565 {
14566 MS_U32 *pu32Param = (MS_U32 *)pParam;
14567
14568 switch (cmd_id)
14569 {
14570 case VDEC_USER_CMD_SYSTEM_PRESET_VPU_CLOCK:
14571 return _VDEC_SetVPUClockSpeed((VDEC_ClockSpeed)(*pu32Param));
14572 break;
14573
14574 case VDEC_USER_CMD_SYSTEM_PRESET_HVD_CLOCK:
14575 return _VDEC_SetHVDClockSpeed((VDEC_ClockSpeed)(*pu32Param));
14576 break;
14577
14578 case VDEC_USER_CMD_SYSTEM_PRESET_MVD_CLOCK:
14579 return _VDEC_SetMVDClockSpeed((VDEC_ClockSpeed)(*pu32Param));
14580 break;
14581
14582 default:
14583 return E_VDEC_RET_ILLEGAL_ACCESS;
14584 break;
14585 }
14586
14587 return E_VDEC_OK;
14588 }
14589
MApi_VDEC_PreSetControl(VDEC_User_Cmd cmd_id,MS_U32 param)14590 VDEC_Result MApi_VDEC_PreSetControl(VDEC_User_Cmd cmd_id, MS_U32 param)
14591 {
14592 if (pu32VDEC_Inst == NULL)
14593 {
14594 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14595 return E_VDEC_FAIL;
14596 }
14597
14598 VDEC_V2_IO_Param IO_arg;
14599 VDEC_Result ret = E_VDEC_OK;
14600
14601
14602 IO_arg.param[0] = (void *)&cmd_id;
14603 IO_arg.param[1] = (void *)¶m;
14604 IO_arg.pRet = (void *)&ret;
14605
14606 if(UtopiaIoctl(pu32VDEC_Inst,E_VDEC_V2_CMD_PRESETCONTROL, (void*)&IO_arg) != UTOPIA_STATUS_SUCCESS)
14607 {
14608 printf("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
14609 return E_VDEC_FAIL;
14610 }
14611 else
14612 {
14613 return ret;
14614 }
14615 }
14616
MApi_VDEC_V2_PreSetControl(VDEC_User_Cmd cmd_id,MS_U32 param)14617 VDEC_Result MApi_VDEC_V2_PreSetControl(VDEC_User_Cmd cmd_id, MS_U32 param)
14618 {
14619 VDEC_Result ret = E_VDEC_OK;
14620
14621 if (_Attr.bInit)
14622 {
14623 printf("VDEC Warn: PreSetControl should be called before VDEC Init\n");
14624 return E_VDEC_RET_ILLEGAL_ACCESS;
14625 }
14626
14627 switch (cmd_id)
14628 {
14629 case VDEC_USER_CMD_HVD_ONE_PENDING_BUFFER_MODE:
14630 _Pre_Ctrl.bOnePendingBuffer = (MS_BOOL)param;
14631 break;
14632 case VDEC_USER_CMD_MVD_HWBUFFER_REMAPPING_MODE:
14633 _Pre_Ctrl.bHWBufferReMapping = (MS_BOOL)param;
14634 break;
14635 case VDEC_USER_CMD_FRAMERATE_HANDLING:
14636 _Pre_Ctrl.bFrameRateHandling = TRUE;
14637 _Pre_Ctrl.u32PreSetFrameRate = param;
14638 break;
14639 default:
14640 ret = E_VDEC_RET_ILLEGAL_ACCESS;
14641 break;
14642 }
14643
14644 return ret;
14645 }
14646
14647