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
78 ///////////////////////////////////////////////////////////////////////////////////////////////////
79 ///
80 /// file apiVDEC_EX.c
81 /// @brief VDEC EXTENSION API FOR DUAL STREAMS
82 /// @author MStar Semiconductor Inc.
83 ///////////////////////////////////////////////////////////////////////////////////////////////////
84
85
86 //-------------------------------------------------------------------------------------------------
87 // Include Files
88 //-------------------------------------------------------------------------------------------------
89 #ifdef MSOS_TYPE_LINUX_KERNEL
90 #include <linux/string.h>
91 #else
92 #include <string.h>
93 #endif
94
95 #include "MsCommon.h"
96 #include "MsVersion.h"
97 #include "apiVDEC_EX.h"
98 #include "apiMJPEG_EX.h"
99 #include "drvMMIO.h"
100 #include "MsOS.h"
101 #include "utopia.h"
102 #include "vdec_ex_private.h"
103 #include "drvSYS.h"
104 #include "tee_client_api.h"
105
106 #if defined(MSOS_TYPE_LINUX)
107 #if 1
108 #define CMA_DRV_DIRECT_INIT
109 #else
110 #define CMA_FW_INIT
111 #endif
112 #endif
113
114 #ifdef MSOS_TYPE_LINUX_KERNEL
115 #include <asm/div64.h>
116 #endif
117 #ifdef _HVD_EVENT_DBG
118 #include "apiDMX.h"
119 #endif
120 #include "drvSYS.h"
121 #include "apiMBX_St.h"
122 #include "apiMBX.h"
123 #include "drvCMAPool.h"
124 #include "halCHIP.h"
125
126 #if defined(MSOS_TYPE_LINUX)
127 #include "msos/linux/mdrv_cma_pool_st.h"
128 #endif
129
130
131 //-------------------------------------------------------------------------------------------------
132 // Local Compiler Options
133 //-------------------------------------------------------------------------------------------------
134 #define VDEC_ENABLE_LINK_WEAK_SYMBOL 1
135 #define VDEC_ENABLE_MVD 1
136 #define VDEC_ENABLE_HVD 1
137 #define VDEC_ENABLE_MVC 1
138
139 #if defined(CHIP_KANO) || defined(CHIP_CURRY)
140 #define VDEC_DTV_DIRECT_STC_PATCH 0
141 #define VDEC_EXCHANGE_CIDX_PATCH 1
142 #define VDEC_DUAL_FRAME_BUFFER_MANAGEMENT 1
143 #endif
144
145 #if defined(VESTEL_FEATURE)
146 #define VESTEL_FEATURE_ENABLE 1
147 #else
148 #define VESTEL_FEATURE_ENABLE 0
149 #endif
150
151 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
152 #include "_apiVDEC_EX_weak.h"
153 #else
154 #include "../../drv/mvd_lite/drvMVD_EX.h"
155 #include "../../drv/hvd_lite/drvHVD_EX.h"
156 #endif
157
158 #if (!defined(MSOS_TYPE_NUTTX) && !defined(MSOS_TYPE_OPTEE)) || defined(SUPPORT_X_MODEL_FEATURE)
159
160 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL) || defined(MSOS_TYPE_ECOS)
161 #define VDEC_EX_ISR_MONITOR 1
162 #else
163 #define VDEC_EX_ISR_MONITOR 0
164 #endif
165
166 #ifdef VDEC_UTOPIA_2K
167 #define VDEC_DRIVER_BASE KERNEL_MODE
168 #else
169 #define VDEC_DRIVER_BASE 0
170 #endif
171
172 //-------------------------------------------------------------------------------------------------
173 // Local Defines
174 //-------------------------------------------------------------------------------------------------
175 #ifndef ANDROID
176 #if ((defined(CHIP_A1) || defined(CHIP_A7) || defined(CHIP_AMETHYST)) && defined (__aeon__))
177 #define VDEC_INFO(idx, x)
178 #define VDEC_ERR(x, ...)
179 #define VDEC_PRINT printf
180 #elif defined(MSOS_TYPE_ECOS)
181 #define VPRINTF diag_printf
182 #define VDEC_INFO diag_printf
183 #define VDEC_ERR diag_printf
184 #define VDEC_PRINT diag_printf
185 #else
186 #define VDEC_INFO(idx, x) if (pVdecExContext->_Attr[idx].eDbgMsgLevel >= E_VDEC_EX_DBG_LEVEL_INFO) { (x); }
187 #define VDEC_ERR printf
188 #define VDEC_PRINT printf
189 #endif
190 #else
191 #define VDEC_INFO(idx, x) if (pVdecExContext->_Attr[idx].eDbgMsgLevel >= E_VDEC_EX_DBG_LEVEL_INFO) { (x); }
192 #include <sys/mman.h>
193 #include <cutils/ashmem.h>
194 #include <cutils/log.h>
195 #define VDEC_PRINT ALOGD
196 #define VDEC_ERR ALOGD
197 #endif
198
199
200 #ifdef MSOS_TYPE_LINUX_KERNEL
201 #define VPRINTF printk
202 #elif defined(MSOS_TYPE_ECOS)
203 #define VPRINTF diag_printf
204 #else
205 #ifndef ANDROID
206 #define VPRINTF printf
207 #else
208 #define VPRINTF ALOGD
209 #endif
210 #endif
211
212 #ifdef VDEC3
213 #define v3_temp 1
214 #define v3_thinplayer 0
215 #else
216 #define v3_temp 0
217 #define v3_thinplayer 0
218 #endif
219
220 #define ES_BUFFER_STATUS_UNKNOWN 0
221 #define ES_BUFFER_STATUS_UNDERFLOW 1
222 #define ES_BUFFER_STATUS_OVERFLOW 2
223 #define ES_BUFFER_STATUS_NORMAL 3
224 #ifdef VDEC3
225 #define _VDEC_GET_DRV_IDX(x) (MS_U8)((x) >> 16)
226 #define VDEC_MAX_SUPPORT_STREAM_NUM 16
227 #else
228 #define VDEC_MAX_SUPPORT_STREAM_NUM 2
229 #endif
230 #define MVD_SRCMODE_MAX 5
231 #define _VDEC_GET_IDX(x) (MS_U8)((x)>>24)
232 #define _VDEC_GET_DRV_ID(x) ((x) & 0x00ffffffUL)
233 #define _VDEC_SHM_POINTER_CHECK(x) \
234 do\
235 {\
236 if (pVdecExContext == NULL)\
237 {\
238 return x;\
239 }\
240 }while(0)
241 #define _VDEC_INVALID_IDX_RET(x) \
242 do \
243 { \
244 if (x >= VDEC_MAX_SUPPORT_STREAM_NUM) \
245 { \
246 return E_VDEC_EX_RET_INVALID_PARAM; \
247 } \
248 } while(0)
249
250 #define _VDEC_INVALID_STREAM_ID_RET(x) \
251 do \
252 { \
253 if (x == 0) \
254 { \
255 return E_VDEC_EX_RET_ILLEGAL_ACCESS; \
256 } \
257 } while(0)
258
259 #define _VDEC_NOT_INIT_RET(x) \
260 do { \
261 if (!(pVdecExContext->_Attr[x].bInit)) \
262 { \
263 return E_VDEC_EX_RET_NOT_INIT; \
264 } \
265 } while(0)
266
267 #define _VDEC_INVALID_DRVID_RET(x, id) \
268 do \
269 { \
270 if (pVdecExContext->_Attr[x].u32DrvId != id) \
271 { \
272 return E_VDEC_EX_RET_INVALID_PARAM; \
273 } \
274 } while(0)
275
276 #define _VDEC_Memset(pDstAddr, u8value, u32Size) \
277 do { \
278 MS_U32 i = 0; \
279 volatile MS_U8 *dst = (volatile MS_U8 *)(pDstAddr); \
280 for (i = 0; i < (u32Size); i++) \
281 { \
282 dst[i] = (u8value); \
283 } \
284 } while (0)
285
286 #define _VDEC_Memcpy(pDstAddr, pSrcAddr, u32Size) \
287 do { \
288 MS_U32 i = 0; \
289 volatile MS_U8 *dst = (volatile MS_U8 *)(pDstAddr); \
290 volatile MS_U8 *src = (volatile MS_U8 *)(pSrcAddr); \
291 for (i = 0; i < (u32Size); i++) \
292 { \
293 dst[i] = src[i]; \
294 } \
295 } while (0)
296
297 #define _MVD_RET_HANDLE(x) \
298 do \
299 { \
300 if (E_MVD_RET_OK != (x)) \
301 { \
302 return E_VDEC_EX_FAIL; \
303 } \
304 } while (0)
305
306 #define _HVD_RET_HANDLE(x) \
307 do \
308 { \
309 if (E_HVD_EX_OK != (x)) \
310 { \
311 return E_VDEC_EX_FAIL; \
312 } \
313 } while (0)
314
315 #define _MJPEG_RET_HANDLE(x) \
316 do \
317 { \
318 _VDEC_EX_API_MutexLock();\
319 if (E_MJPEG_RET_SUCCESS != (x)) \
320 { \
321 _VDEC_EX_API_MutexUnlock();\
322 return E_VDEC_EX_FAIL; \
323 } \
324 _VDEC_EX_API_MutexUnlock();\
325 } while (0)
326
327 #define _MVD_RET_TO_VDEC_RESULT(rst, b) \
328 do \
329 { \
330 if (E_MVD_RET_OK != (b)) \
331 { \
332 rst = E_VDEC_EX_FAIL; \
333 } \
334 else \
335 { \
336 rst = E_VDEC_EX_OK; \
337 } \
338 } while (0)
339
340 #define _HVD_RET_TO_VDEC_RESULT(rst, b) \
341 do \
342 { \
343 if (E_HVD_EX_OK != (b)) \
344 { \
345 rst = E_VDEC_EX_FAIL; \
346 } \
347 else \
348 { \
349 rst = E_VDEC_EX_OK; \
350 } \
351 } while (0)
352
353 #define _MJPEG_RET_TO_VDEC_RESULT(rst, b) \
354 do \
355 { \
356 if (E_MJPEG_RET_SUCCESS != (b)) \
357 { \
358 rst = E_VDEC_EX_FAIL; \
359 } \
360 else \
361 { \
362 rst = E_VDEC_EX_OK; \
363 } \
364 } while (0)
365
366 #define _BOOL_TO_VDEC_RESULT(rst, b) \
367 do \
368 { \
369 if (TRUE != (b)) \
370 { \
371 rst = E_VDEC_EX_FAIL; \
372 } \
373 else \
374 { \
375 rst = E_VDEC_EX_OK; \
376 } \
377 } while (0)
378
379 #define _BOOL_TO_MJPEG_RESULT(rst, b) \
380 do \
381 { \
382 if (TRUE != (b)) \
383 { \
384 rst = E_VDEC_EX_FAIL; \
385 } \
386 else \
387 { \
388 rst = E_VDEC_EX_OK; \
389 } \
390 } while (0)
391
392 #define _SET_DISPLAYMODE_INVALID(u8Idx) \
393 do \
394 { \
395 pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode = 0xFF; \
396 } while (0)
397
398
399 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
400 #define _RET_VDEC_HVD_LINT_CHECK() \
401 do \
402 { \
403 if (!MDrv_HVD_EX_Init) \
404 { \
405 return E_VDEC_EX_RET_ILLEGAL_ACCESS; \
406 } \
407 } while (0)
408
409 #define _RET_VDEC_HVD_LINT_CHECK_AND_RETURN_MUTEX() \
410 do \
411 { \
412 if (!MDrv_HVD_EX_Init) \
413 { \
414 return E_VDEC_EX_RET_ILLEGAL_ACCESS; \
415 } \
416 } while (0)
417
418
419 #define _RET_VDEC_MVD_LINT_CHECK() \
420 do \
421 { \
422 if (!MDrv_MVD_Init) \
423 { \
424 return E_VDEC_EX_RET_ILLEGAL_ACCESS; \
425 } \
426 } while (0)
427
428 #define _RET_VDEC_MVD_LINT_CHECK_AND_RETURN_MUTEX() \
429 do \
430 { \
431 if (!MDrv_MVD_Init) \
432 { \
433 return E_VDEC_EX_RET_ILLEGAL_ACCESS; \
434 } \
435 } while (0)
436
437
438 #define _BOOL_VDEC_HVD_LINT_CHECK() \
439 do \
440 { \
441 if (!MDrv_HVD_EX_Init) \
442 { \
443 return FALSE; \
444 } \
445 } while (0)
446
447 #define _BOOL_VDEC_MVD_LINT_CHECK() \
448 do \
449 { \
450 if (!MDrv_MVD_Init) \
451 { \
452 return FALSE; \
453 } \
454 } while (0)
455 #else // VDEC_ENABLE_LINK_WEAK_SYMBOL
456
457 #define _RET_VDEC_MVD_LINT_CHECK()
458 #define _RET_VDEC_MVD_LINT_CHECK_AND_RETURN_MUTEX()
459 #define _RET_VDEC_HVD_LINT_CHECK()
460 #define _RET_VDEC_HVD_LINT_CHECK_AND_RETURN_MUTEX()
461 #define _BOOL_VDEC_MVD_LINT_CHECK()
462 #define _BOOL_VDEC_HVD_LINT_CHECK()
463
464 #endif //VDEC_ENABLE_LINK_WEAK_SYMBOL
465
466 #ifndef UNUSED
467 #define UNUSED(x) (void)(x)
468 #endif
469
470 #define VDEC_EX_STACK_SIZE 4096
471
472 #if (VDEC_EX_ISR_MONITOR)
473 #define E_VDEC_EX_EVENT_ISR_EVENT_CHANGE 0x80000000
474 #endif
475
476 #ifdef VDEC3
477 #define E_VDEC_EX_CB_MAX_NUM VDEC_MAX_SUPPORT_STREAM_NUM
478 #else
479 #define E_VDEC_EX_CB_MAX_NUM (E_VDEC_EX_CB_SUB + 1)
480 #endif
481 #define VDEC_U32_MAX 0xffffffffUL
482 #define VDEC_U64_MAX 0xffffffffffffffffULL
483
484 #define MAX_VDEC_DQNUM 32
485 #define VDEC_DQ_EMPTY 0xff
486 #define ES_SAFE_SIZE 0x20
487
488 #if (VDEC_DUAL_FRAME_BUFFER_MANAGEMENT)
489 #define FBLOC_FRONT_TAIL_MASK 0x01
490 #define FBLOC_TASK_FB_MASK 0x10
491 #define FBLOC_FORCE_FRONT_MASK 0xF0
492 #define FBMNG_AVC4K_SIZE 0x8200000
493 #endif
494
495 #if 0
496 #define _VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,u32Arg_num,structArg_num,struct_size,pos_u32_0,pos_u32_1,pos_u32_2,pos_u32_3,pos_struct_0)\
497 resume_data.u8Idx=u8Idx;\
498 resume_data.cmd_id=cmd_id;\
499 resume_data.param=param;\
500 resume_data.u32Arg_num=u32Arg_num;\
501 resume_data.structArg_num=structArg_num;\
502 resume_data.struct_size=struct_size;\
503 resume_data.position[0] = pos_u32_0;\
504 resume_data.position[1] = pos_u32_1;\
505 resume_data.position[2] = pos_u32_2;\
506 resume_data.position[3] = pos_u32_3;\
507 resume_data.position[4] = pos_struct_0;
508 #endif
509
510 //-------------------------------------------------------------------------------------------------
511 // Local Enum
512 //-------------------------------------------------------------------------------------------------
513 typedef enum
514 {
515 E_VDEC_EX_DECODER_MVD = 0,
516 E_VDEC_EX_DECODER_HVD,
517 E_VDEC_EX_DECODER_MJPEG,
518 E_VDEC_EX_DECODER_NONE,
519 } VDEC_EX_Decoder;
520
521 typedef enum
522 {
523 E_VDEC_EX_MVC_GET_BBU2_DECQ_VACANCY = 0,
524 E_VDEC_EX_MVC_GET_ES2_READ_PTR,
525 E_VDEC_EX_MVC_GET_ES2_WRITE_PTR,
526
527 E_VDEC_EX_MVC_SET_BBU2_PUSH_PACKET = 0x100,
528 E_VDEC_EX_MVC_SET_BBU2_FIRE_DECCMD,
529 } VDEC_MVC_Control_type;
530
531 // VDEC check capbility command
532 typedef enum
533 {
534 E_VDEC_EX_CAP_XC_NOT_SUPPORT_DS = 0,
535 E_VDEC_EX_CAP_NUM,
536 } VDEC_EX_CapCmd;
537
538 typedef enum
539 {
540 E_VDEC_EX_POWER_NONE,
541 E_VDEC_EX_POWER_SUSPEND_ING,
542 E_VDEC_EX_POWER_RESUME_ING,
543 E_VDEC_EX_POWER_RESUME_DONE,
544
545 } VDEC_EX_PowerStatus_type;
546
547 // N Decode Buffer Allocator Enum Start
548 typedef enum
549 {
550 E_VDEC_EX_CMA_POOL_BUFFER_FB1 = 0,
551 E_VDEC_EX_CMA_POOL_BUFFER_FB2 = 1,
552 E_VDEC_EX_CMA_POOL_MAX_SUPPORT_NUM = 2,
553 E_VDEC_EX_CMA_POOL_INVALID = 0xFFFFFFFF,
554
555 } VDEC_EX_CMA_POOL_SELECT;
556
557 typedef enum
558 {
559 E_VDEC_EX_ALLOCATOR_BUFFER_FB1 = 0,
560 E_VDEC_EX_ALLOCATOR_BUFFER_FB2 = 1,
561 E_VDEC_EX_ALLOCATOR_BUFFER_BS = 2,
562
563 } VDEC_EX_ALLOCATOR_BUFFER_TYPE;
564
565 //-------------------------------------------------------------------------------------------------
566 // Local Structures
567 //-------------------------------------------------------------------------------------------------
568
569 typedef struct
570 {
571 MS_U32 u32EventBitMap;
572 VDEC_EX_EventCb pVdecEventCb;
573 void *pParam;
574 } VDEC_EX_EventInfo;
575
576 #if (VDEC_EX_ISR_MONITOR)
577 // Info of Event Monitor
578 #ifdef VDEC3
579 typedef void (*MonitorISR_Proc)(MS_U8);
580 #else
581 typedef void (*MonitorISR_Proc)(void);
582 #endif
583
584 typedef struct
585 {
586 MS_U8 u8VdecExStack[VDEC_EX_STACK_SIZE];
587 MS_BOOL bVdecExIsrMntr;
588 MS_BOOL bIsSysEnable;
589 char pu8VdecExEvent[20];
590 MS_S32 s32VdecExTaskId;
591 char pu8VdecExTask[20];
592 MonitorISR_Proc pfMonISR_Proc;
593 } VDEC_EX_EventMonInfo;
594 #endif
595
596 typedef struct
597 {
598 MS_BOOL bUsed;
599 MS_BOOL bInit;
600 VDEC_EX_DbgLevel eDbgMsgLevel;
601 VDEC_EX_CodecType eCodecType;
602 VDEC_EX_Decoder eDecoder;
603 VDEC_EX_SrcMode eSrcMode;
604 VDEC_EX_ErrCode eErrCode;
605 VDEC_EX_CCFormat eCCFormat; //unused
606 VDEC_EX_EventInfo vdecExEventInfo[E_VDEC_EX_CB_MAX_NUM];
607 #if (VDEC_EX_ISR_MONITOR)
608 VDEC_EX_EventMonInfo stEventMon;
609 #endif
610 VDEC_EX_InitParam vdecExInitParam;
611 MS_U32 u32DrvId;
612 VDEC_EX_Stage eStage;
613 //MS_S32 s32VdecExMutexId; //mutex ID
614 //char pu8VdecExMutex[20]; //mutex name
615 } VDEC_EX_Attr;
616
617 typedef struct
618 {
619 //******** One Pending Buffer ********//
620 MS_BOOL bOnePendingBuffer;
621 //******** HW Buffer ReMapping ********//
622 MS_BOOL bHWBufferReMapping;
623 //******** Frame Rate Handling ********//
624 MS_BOOL bFrameRateHandling;
625 MS_U32 u32PreSetFrameRate;
626 MS_BOOL bDisableTspInBbuMode;
627 VDEC_EX_IapGnBufShareBWMode stIapGnShBWMode;
628 VDEC_EX_MFCodec_mode eMFCodecMode;
629 MS_BOOL bForce8bitMode; //Only create 8bit YUV FrameBuffer
630 VDEC_EX_Feature eVdecFeature; //BIT0=1:AP force VDEC only support HEVC Main profile file even chip spec is Main10
631 VDEC_EX_DISPLAY_MODE eDisplayMode;
632 MS_BOOL bEnableDynamicCMA; //enable dynamic cma
633 //******** N Decode *******************//
634 MS_BOOL bMonopolyBitstreamBuffer;
635 MS_BOOL bMonopolyFrameBuffer;
636 VDEC_EX_TASK_SPEC eTaskSpec;
637 MS_BOOL bCalFrameRate;
638 VDEC_EX_TotalBufRange stTotalBufRgnBS;
639 VDEC_EX_TotalBufRange stTotalBufRgnFB1;
640 VDEC_EX_TotalBufRange stTotalBufRgnFB2;
641 } VDEC_Pre_Ctrl;
642
643 // N Decode Buffer Allocator Structure Start
644
645 #define VDEC_EX_ALLOCATOR_ENABLE (TRUE)
646
647 #define VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED ((MS_U16)0xFFFF)
648 #define VDEC_EX_ALLOCAOTR_ID_UNUSED ((MS_U16)0xFFFF)
649
650 #define VDEC_EX_ALLOCAOTR_MAX_NUM_STREAM VDEC_MAX_SUPPORT_STREAM_NUM
651 #define VDEC_EX_ALLOCAOTR_MAX_NUM_BLOCK (128) // Maximun number of blocks in block pool
652 #define VDEC_EX_ALLOCAOTR_MAX_NUM_ALLOCATOR (32) // Maximun number of allocators in allocator pool
653
654 #define VDEC_EX_ALLOCAOTR_PROPERTY_DEFAULT (0)
655 #define VDEC_EX_ALLOCAOTR_PROPERTY_CAN_OVERLAP (VDEC_EX_BIT(0)) // 1
656 #define VDEC_EX_ALLOCAOTR_PROPERTY_USECMA (VDEC_EX_BIT(1)) // 2
657
658 #define VDEC_EX_ALLOCATOR_CRITERION_CHECK_NONE (0x0)
659 #define VDEC_EX_ALLOCATOR_CRITERION_CHECK_ADDRESS (VDEC_EX_BIT(0))
660 #define VDEC_EX_ALLOCATOR_CRITERION_CHECK_SIZE (VDEC_EX_BIT(1))
661
662 // Patch: N Decode doesn't allocate framebuffer2 currently
663 #define VDEC_EX_ALLOCATOR_ENABLE_NDECODE_FB2 (FALSE)
664
665 // 16 bytes
666 typedef struct
667 {
668 MS_U8 u8MIU;
669 MS_U8 u8Property;
670 MS_U16 u16Allocated;
671 MS_PHY phyAddr; // start address of this block
672 MS_SIZE szSize; // total size of this block
673
674 } VDEC_EX_Allocator_BlockInfo;
675
676 // 24 bytes
677 typedef struct
678 {
679 MS_U16 u16BlockId; //
680 MS_U16 u16BlockIdPrev; // block ID of previous block using in list
681 MS_U16 u16BlockIdNext; // block ID of next block using in list
682 MS_U16 u16AllocatorIdExt; // allocator ID of extend allocator
683 VDEC_EX_Allocator_BlockInfo stBlockInfo;
684
685 } VDEC_EX_Allocator_Block;
686
687 // 6 bytes
688 typedef struct
689 {
690 MS_U16 u16NumBlocks; // total number of blocks using in list
691 MS_U16 u16BlockIdHead; // block ID of head block using in list
692 MS_U16 u16BlockIdTail; // block ID of tail block using in list
693
694 } VDEC_EX_Allocator_BlockList;
695
696 // 24 bytes
697 typedef struct
698 {
699 MS_U16 u16AllocatorId; //
700 MS_PHY phyStartAddr; // start address of this memory section
701 MS_SIZE szTotalSize; // total size of this memory section
702 MS_SIZE szUnusedSize; // record unused size of this memory section
703 VDEC_EX_Allocator_BlockList stBlockList;
704
705 } VDEC_EX_Allocator;
706
707 typedef struct
708 {
709 MS_U16 u16BlockIdFB1Main; // Frame Buffer1 Block ID in Main Allocator
710 MS_U16 u16BlockIdFB1Sub; // Frame Buffer1 Block ID in Sub Allocator
711 MS_U16 u16BlockIdFB2Main; // Frame Buffer2 Block ID in Main Allocator
712 MS_U16 u16BlockIdFB2Sub; // Frame Buffer2 Block ID in Sub Allocator
713 MS_U16 u16BlockIdBS1Main; // Bitstream Buffer Block ID in Main Allocator
714 MS_U16 u16BlockIdBS1Sub; // Bitstream Buffer Block ID in Main Allocator
715
716 } VDEC_EX_Allocator_Record;
717
718 typedef struct
719 {
720 MS_BOOL bInit;
721 MS_U16 u16AllocatorIdMain;
722 VDEC_EX_Allocator_Record stAllocatorRecord[VDEC_MAX_SUPPORT_STREAM_NUM];
723 VDEC_EX_Allocator_Block stBlockPool[VDEC_EX_ALLOCAOTR_MAX_NUM_BLOCK];
724 VDEC_EX_Allocator stAllocatorPool[VDEC_EX_ALLOCAOTR_MAX_NUM_ALLOCATOR];
725 #ifdef CMA_DRV_DIRECT_INIT
726 struct CMA_Pool_Init_Param stCmaInitParam[E_VDEC_EX_CMA_POOL_MAX_SUPPORT_NUM];
727 MS_SIZE szCMAAllocLength[E_VDEC_EX_CMA_POOL_MAX_SUPPORT_NUM][VDEC_MAX_SUPPORT_STREAM_NUM];
728 #endif
729 } VDEC_EX_NDecAllocator;
730
731 typedef struct
732 {
733 MS_U32 u32CheckItem;
734 MS_PHY phyAddr;
735 MS_SIZE szSize;
736 MS_U32 u32Alignment;
737
738 } VDEC_EX_Allocator_Criterion;
739
740 typedef struct
741 {
742 MS_BOOL bCMA;
743 MS_BOOL bDynamicCMA;
744 MS_BOOL bNDecode;
745 MS_BOOL bUseSubAllocator;
746 MS_BOOL bUseThirdAllocator;
747 MS_BOOL bMonopoly;
748 VDEC_EX_SrcMode eSrcMode;
749 VDEC_EX_CodecType eCodecType;
750 VDEC_EX_TASK_SPEC eTaskSpec;
751
752 } VDEC_EX_NDecBufferProperty;
753
754 typedef struct
755 {
756 MS_BOOL bSetTotalBuf;
757 MS_PHY phyTotalBufAddr;
758 MS_SIZE szTotalBufSize;
759 MS_PHY phyBufAddr;
760 MS_SIZE szBufSize;
761
762 } VDEC_EX_NDecBufRangeParam;
763
764 // N Decode Buffer Allocator Structure End
765 typedef struct
766 {
767 MS_PHY VPUBufAddr;
768 MS_SIZE VPUBufSize;
769 MS_PHY BSBufAddr;
770 MS_SIZE BSBufSize;
771 MS_PHY FBufAddr;
772 MS_SIZE FBufSize;
773 MS_U32 u32streamID;
774 VDEC_EX_CodecType eCodecType;
775 } VDEC_EX_OPTEE_SecureBuffer;
776
777 typedef struct
778 {
779 MS_PHY FBuf2Addr;
780 MS_SIZE FBuf2Size;
781 MS_U32 u32streamID;
782 } VDEC_EX_OPTEE_SecureFB2;
783
784 typedef void (*VDEC_EX_IsrHandle)(MS_U32 u32Sid);
785
786 #if VDEC_DUAL_FRAME_BUFFER_MANAGEMENT
787 typedef enum
788 {
789 // 0xAB; A for FB0/1, B for Front/Tail
790 E_VDEC_EX_FB0_FRONT = 0x00,
791 E_VDEC_EX_FB0_TAIL = 0x01,
792 E_VDEC_EX_FB1_FRONT = 0x10,
793 E_VDEC_EX_FB1_TAIL = 0x11,
794 E_VDEC_EX_FB_NONE = 0xFF,
795 } VDEC_EX_FB_LOCATION;
796
797 typedef struct
798 {
799 VDEC_EX_FB_LOCATION eLocation; /// Using location.
800 MS_U8 u8Miu; //to distinguish MMAP_4K(fb on two miu) and MMAP_FHD(fb on the same miu)
801 MS_PHY u32FrameBufAddr; /// Org frame buffer info.
802 MS_SIZE u32FrameBufSize; /// Org frame buffer info.
803 } VDEC_EX_FB_MNG;
804 #endif
805
806 typedef struct
807 {
808 // variables which need use mutex to protect
809 MS_BOOL _bSingleDecodeMode;
810 MS_BOOL bTurboMode;
811
812 // variables which no need use mutex to protect
813 VDEC_EX_Attr _Attr[VDEC_MAX_SUPPORT_STREAM_NUM];
814 VDEC_EX_IsrHandle _pVdec_IsrProc[VDEC_MAX_SUPPORT_STREAM_NUM];
815 MS_BOOL _bEsBufMgmt[VDEC_MAX_SUPPORT_STREAM_NUM];
816 VDEC_EX_DispFrame _stDispQ[VDEC_MAX_SUPPORT_STREAM_NUM][MAX_VDEC_DQNUM];
817 MS_U32 _u32VdecExIsrEventFlag[VDEC_MAX_SUPPORT_STREAM_NUM];
818 #if (VDEC_EX_ISR_MONITOR)
819 MS_U32 _u32PreVdecExIsrEventFlag[VDEC_MAX_SUPPORT_STREAM_NUM];
820 #endif
821 MS_BOOL bDropErrFrm[VDEC_MAX_SUPPORT_STREAM_NUM];
822 HVD_EX_FrmPackingSEI _stFrmPacking[VDEC_MAX_SUPPORT_STREAM_NUM];
823 HVD_EX_ContentLightLevelInfoSEI _stCLLI[VDEC_MAX_SUPPORT_STREAM_NUM];
824 HVD_EX_DisplayColourVolumeSEI _stDCV[VDEC_MAX_SUPPORT_STREAM_NUM];
825 MS_BOOL _bVdecDispOutSide[VDEC_MAX_SUPPORT_STREAM_NUM];
826 MS_U32 u32PriData[VDEC_MAX_SUPPORT_STREAM_NUM];
827
828 MS_BOOL support_cc[VDEC_MAX_SUPPORT_STREAM_NUM];
829
830 MS_BOOL bFlush[VDEC_MAX_SUPPORT_STREAM_NUM];
831
832 //char _u8VDEC_Mutex[20];
833
834 // for power state
835 EN_POWER_MODE _prev_u16PowerState;
836 VDEC_EX_PowerStatus_type _power_state[VDEC_MAX_SUPPORT_STREAM_NUM];
837 MS_U32 u32ResumeStream[VDEC_MAX_SUPPORT_STREAM_NUM];
838 VDEC_EX_CodecType eCodecType[VDEC_MAX_SUPPORT_STREAM_NUM];
839 MS_U8 u8enable_store_set_cmd[VDEC_MAX_SUPPORT_STREAM_NUM];
840 VDEC_EX_RECORD_SET_CMD store_set_cmd[MAX_NUM_OF_STORE_USER_SET_CMD]; // at most 100 set command
841 MS_U8 store_set_cmd_write_pointer[MAX_NUM_OF_STORE_USER_SET_CMD];
842 MS_U8 store_set_cmd_read_pointer[MAX_NUM_OF_STORE_USER_SET_CMD];
843 VDEC_EX_FRC_OutputParam store_FRC_OutputParam[MAX_NUM_OF_STORE_USER_SET_CMD];
844 VDEC_EX_Field_Polarity store_Field_Polarity[MAX_NUM_OF_STORE_USER_SET_CMD];
845 VDEC_EX_CC_InputPara store_InputPara_setcfg[MAX_NUM_OF_STORE_USER_SET_CMD];
846 VDEC_EX_CC_InputPara store_InputPara_startaddr[MAX_NUM_OF_STORE_USER_SET_CMD];
847 VDEC_EX_CC_InputPara store_InputPara_readaddr[MAX_NUM_OF_STORE_USER_SET_CMD];
848
849 MS_BOOL bEnableAutoInsertDummyPattern[VDEC_MAX_SUPPORT_STREAM_NUM];
850
851 //pre_set
852 VDEC_Pre_Ctrl _Pre_Ctrl[VDEC_MAX_SUPPORT_STREAM_NUM];
853 VDEC_EX_DecModCfg _Pre_DecModeCfg;
854 MS_BOOL bTrickMode[VDEC_MAX_SUPPORT_STREAM_NUM];
855 #ifdef VDEC3
856 MS_BOOL bFWdecideFB;
857 MS_BOOL bDRVdecideBS;
858 MS_PHY u32BitstreamBufAddr;
859 MS_U32 u32BitstreamBufSize;
860 #endif
861
862 #ifdef VDEC3
863 MS_U32 u32FrameBaseMode[VDEC_MAX_SUPPORT_STREAM_NUM];
864 #endif
865
866 MS_BOOL bCMAUsed;
867 MS_BOOL bCMAInit;
868 #if defined(MSOS_TYPE_LINUX)
869 struct CMA_Pool_Init_Param cmaInitParam[2]; // support two MIU
870 struct CMA_Pool_Free_Param cmaFreeParam[2][VDEC_MAX_SUPPORT_STREAM_NUM];
871 MS_BOOL bCMATwoMIU[VDEC_MAX_SUPPORT_STREAM_NUM];
872 #endif
873 #ifdef CMA_DRV_DIRECT_INIT
874 MS_BOOL bCMAGetMem[2][VDEC_MAX_SUPPORT_STREAM_NUM];
875 #endif
876
877 MS_BOOL bDirectStcThreadRunning[VDEC_MAX_SUPPORT_STREAM_NUM];
878 #if (VDEC_DUAL_FRAME_BUFFER_MANAGEMENT)
879 VDEC_EX_FB_MNG _stFBMng[VDEC_MAX_SUPPORT_STREAM_NUM];
880 #endif
881
882 // N Decode Buffer Allocator
883 VDEC_EX_NDecAllocator stNDecAllocator;
884 //MS_U32 u32MVDMinTspDataSize[VDEC_MAX_SUPPORT_STREAM_NUM];
885 } VDEC_EX_CTX;
886
887 //-------------------------------------------------------------------------------------------------
888 // Global Variables
889 //-------------------------------------------------------------------------------------------------
890 VDEC_EX_CTX* pVdecExContext = NULL;
891 VDEC_EX_CTX gVdecExContext;
892 MS_S32 s32VDECMutexID = -1;
893 MS_S32 s32VDECEVENTMutexID[VDEC_MAX_SUPPORT_STREAM_NUM] = {-1,-1};
894 MS_S32 s32VdecExTaskId[VDEC_MAX_SUPPORT_STREAM_NUM] = {-1,-1};
895 #ifdef VDEC3
896 MS_S32 s32VdecDirectStcId[VDEC_MAX_SUPPORT_STREAM_NUM] = {-1,-1,-1,-1};
897 #else
898 MS_S32 s32VdecDirectStcId[VDEC_MAX_SUPPORT_STREAM_NUM] = {-1,-1};
899 #endif
900 MS_U8 u8VdecDirectSTCStack[4096];
901
902 MS_U8 u8CodecCompare[VDEC_MAX_SUPPORT_STREAM_NUM] = {0};
903 MS_BOOL bCMAInitPool[2] = {0,0}; // each process should all init CMA
904
905 MS_S32 _s32VDEC_Callback_TaskId[VDEC_MAX_SUPPORT_STREAM_NUM] = {-1,-1};
906 MS_U8 u8VdecExCallbackStack[VDEC_MAX_SUPPORT_STREAM_NUM][VDEC_EX_STACK_SIZE];
907
908 //Disable MVD parser
909 const MS_U8 bMvdParserDisable[MVD_SRCMODE_MAX] =
910 {
911 1, //E_MVD_FILE_MODE : disable
912 1, //E_MVD_SLQ_MODE : disable
913 0, //E_MVD_TS_MODE : enable
914 1, //E_MVD_SLQ_TBL_MODE: disable
915 0 //E_MVD_TS_FILE_MODE: DISABLE_PKT_LEN
916 };
917 MS_BOOL bIsSupportDivxPlus;
918 const MSIF_Version _api_vdec_version =
919 {
920 .DDI = { VDEC_EX_API_VERSION, },
921 };
922 VDEC_EX_Info _api_vdec_info;
923 void* pu32VDEC_EX_Inst = NULL;
924 VDEC_EX_DispFrame DispFrame_temp[VDEC_MAX_SUPPORT_STREAM_NUM]; // temp use for utopia 1.0, need to remove when really use utopia 2.0
925
926 MS_BOOL bSecureModeEnable = FALSE;
927 MS_BOOL bSecureModeEnableUser = FALSE;
928
929 #ifdef VDEC3
930 MS_S32 s32VdecExEventId[VDEC_MAX_SUPPORT_STREAM_NUM] = {-1,-1,-1,-1};
931 #else
932 MS_S32 s32VdecExEventId[VDEC_MAX_SUPPORT_STREAM_NUM] = {-1,-1};
933 #endif
934
935 static char* cbTaskName[4]={"VDEC_CALLBACK_TASK_0","VDEC_CALLBACK_TASK_1","VDEC_CALLBACK_TASK_2","VDEC_CALLBACK_TASK_3"};
936 //------------------------------------------------------------------------------
937 // Local Functions Prototype
938 //------------------------------------------------------------------------------
939
940
941 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL) || defined(MSOS_TYPE_ECOS)
942
943 #define _VDEC_EX_API_MutexLock()\
944 {\
945 MsOS_ObtainMutex(s32VDECMutexID, MSOS_WAIT_FOREVER);\
946 }
947
948 #define _VDEC_EX_API_MutexUnlock()\
949 {\
950 MsOS_ReleaseMutex(s32VDECMutexID);\
951 }
952
_VDEC_EX_API_MutexCreate(void)953 static MS_BOOL _VDEC_EX_API_MutexCreate(void)
954 {
955
956 #if defined(MSOS_TYPE_ECOS) // avoid creating the mutex name again for ecos project
957
958 if (s32VDECMutexID > 0) // created already
959 {
960 return TRUE;
961 }
962
963 #endif
964
965 s32VDECMutexID = MsOS_CreateMutex(E_MSOS_FIFO,"VDEC_API_Mutex",MSOS_PROCESS_SHARED);
966
967 if (s32VDECMutexID < 0)
968 {
969 return FALSE;
970 }
971 return TRUE;
972 }
973
974 #else
975 #define _VDEC_EX_API_MutexLock()
976 #define _VDEC_EX_API_MutexUnlock()
977 #endif
978
979
980 MS_BOOL _VDEC_EX_Create_BBU_Task(MS_U32 u32Idx);
981 void _VDEC_EX_Delete_BBU_Task(MS_U32 u32Idx);
982
983 //-------------------------------------------------------------------------------------------------
984 // Debug Functions
985 //-------------------------------------------------------------------------------------------------
986
_VDEC_EX_CheckStatus(MS_U8 u8Idx,MS_U32 u32DrvId,MS_U32 u32CallerId)987 static VDEC_EX_Result _VDEC_EX_CheckStatus(MS_U8 u8Idx, MS_U32 u32DrvId, MS_U32 u32CallerId)
988 {
989 VDEC_EX_Result eRet = E_VDEC_EX_OK;
990
991 if(pVdecExContext == NULL)
992 {
993 return E_VDEC_EX_RET_NOT_INIT;
994 }
995
996 if (u8Idx >= VDEC_MAX_SUPPORT_STREAM_NUM)
997 {
998 return E_VDEC_EX_RET_INVALID_PARAM;
999 }
1000
1001 if(pVdecExContext->_Attr[u8Idx].bUsed == FALSE)
1002 {
1003 VDEC_INFO(u8Idx, VDEC_PRINT("%s err: %d is not init success\n",__FUNCTION__,u8Idx));
1004 return E_VDEC_EX_RET_NOT_INIT;
1005 }
1006
1007 if (pVdecExContext->_Attr[u8Idx].u32DrvId != u32DrvId)
1008 {
1009 VDEC_INFO(u8Idx, VDEC_PRINT("%s %d err: invalid streamID u8Idx(0x%x), u32DrvId(0x%x)!=0x%x\n", __FUNCTION__, u32CallerId, u8Idx, u32DrvId, pVdecExContext->_Attr[u8Idx].u32DrvId));
1010 return E_VDEC_EX_RET_INVALID_PARAM;
1011 }
1012
1013 return eRet;
1014 }
1015
1016
MApi_VDEC_EX_DbgCmd(VDEC_StreamId * pStreamId,MS_U32 u8Cmd,MS_U32 u32CmdArg)1017 VDEC_EX_Result MApi_VDEC_EX_DbgCmd(VDEC_StreamId *pStreamId, MS_U32 u8Cmd, MS_U32 u32CmdArg)
1018 {
1019 VDEC_EX_Result eRet = E_VDEC_EX_OK;
1020 MVD_CmdArg stCmdArg;
1021 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
1022 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
1023
1024 eRet = _VDEC_EX_CheckStatus(u8Idx, u32Id, __LINE__);
1025 if (E_VDEC_EX_OK != eRet)
1026 {
1027 return eRet;
1028 }
1029
1030 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
1031 {
1032 case E_VDEC_EX_DECODER_MVD:
1033 {
1034 _VDEC_Memset(&stCmdArg, 0x00, sizeof(MVD_CmdArg));
1035
1036 if (u32CmdArg)
1037 {
1038 stCmdArg.Arg0 = (MS_U8) (u32CmdArg & 0x000000ff);
1039 stCmdArg.Arg1 = (MS_U8) ((u32CmdArg & 0x0000ff00) >> 8);
1040 stCmdArg.Arg2 = (MS_U8) ((u32CmdArg & 0x00ff0000) >> 16);
1041 stCmdArg.Arg3 = (MS_U8) ((u32CmdArg & 0xff000000) >> 24);
1042 }
1043 if (MDrv_MVD_MVDCommand(u8Cmd, &stCmdArg))
1044 {
1045 eRet = E_VDEC_EX_OK;
1046 }
1047 else
1048 {
1049 eRet = E_VDEC_EX_RET_TIMEOUT;
1050 }
1051 break;
1052 }
1053 case E_VDEC_EX_DECODER_HVD:
1054 {
1055 if (E_HVD_EX_OK == MDrv_HVD_EX_SetCmd_Dbg(u32Id, (MS_U32) u8Cmd, u32CmdArg))
1056 {
1057 eRet = E_VDEC_EX_OK;
1058 }
1059 else
1060 {
1061 eRet = E_VDEC_EX_RET_TIMEOUT;
1062 }
1063 break;
1064 }
1065 case E_VDEC_EX_DECODER_MJPEG:
1066 default:
1067 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
1068 break;
1069 }
1070
1071 return eRet;
1072 }
1073
MApi_VDEC_EX_DbgSetData(VDEC_StreamId * pStreamId,MS_VIRT u32Addr,MS_U32 u32Data)1074 VDEC_EX_Result MApi_VDEC_EX_DbgSetData(VDEC_StreamId *pStreamId, MS_VIRT u32Addr, MS_U32 u32Data)
1075 {
1076 VDEC_EX_Result eRet = E_VDEC_EX_OK;
1077 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
1078 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
1079
1080 eRet = _VDEC_EX_CheckStatus(u8Idx, u32Id, __LINE__);
1081 if (E_VDEC_EX_OK != eRet)
1082 {
1083 return eRet;
1084 }
1085
1086 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
1087 {
1088 case E_VDEC_EX_DECODER_MVD:
1089 break;
1090
1091 case E_VDEC_EX_DECODER_HVD:
1092 MDrv_HVD_EX_SetMem_Dbg(pStreamId->u32Id, u32Addr, u32Data);
1093 break;
1094
1095 case E_VDEC_EX_DECODER_MJPEG:
1096 {
1097 _VDEC_EX_API_MutexLock();
1098 if (E_MJPEG_RET_SUCCESS != MApi_MJPEG_DbgSetData(pStreamId->u32Id, u32Addr, u32Data))
1099 {
1100 eRet = E_VDEC_EX_FAIL;
1101 }
1102 _VDEC_EX_API_MutexUnlock();
1103 break;
1104 }
1105 default:
1106 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
1107 break;
1108 }
1109
1110 return eRet;
1111 }
1112
MApi_VDEC_EX_DbgGetData(VDEC_StreamId * pStreamId,MS_VIRT u32Addr,MS_U32 * u32Data)1113 VDEC_EX_Result MApi_VDEC_EX_DbgGetData(VDEC_StreamId *pStreamId, MS_VIRT u32Addr, MS_U32 *u32Data)
1114 {
1115 VDEC_EX_Result eRet = E_VDEC_EX_OK;
1116 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
1117 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
1118
1119 eRet = _VDEC_EX_CheckStatus(u8Idx, u32Id, __LINE__);
1120 if (E_VDEC_EX_OK != eRet)
1121 {
1122 return eRet;
1123 }
1124
1125 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
1126 {
1127 case E_VDEC_EX_DECODER_MVD:
1128 {
1129 E_MVD_Result ret = MDrv_MVD_DbgGetData(pStreamId->u32Id, u32Addr, u32Data);
1130
1131 if (E_MVD_RET_OK != ret)
1132 {
1133 eRet = E_VDEC_EX_FAIL;
1134 }
1135
1136 break;
1137 }
1138 case E_VDEC_EX_DECODER_HVD:
1139 {
1140 *u32Data = MDrv_HVD_EX_GetMem_Dbg(pStreamId->u32Id, u32Addr);
1141 break;
1142 }
1143 case E_VDEC_EX_DECODER_MJPEG:
1144 {
1145 _VDEC_EX_API_MutexLock();
1146 MJPEG_Result ret = MApi_MJPEG_DbgGetData(pStreamId->u32Id, u32Addr, u32Data);
1147
1148 if (E_MJPEG_RET_SUCCESS != ret)
1149 {
1150 eRet = E_VDEC_EX_FAIL;
1151 }
1152 _VDEC_EX_API_MutexUnlock();
1153
1154 break;
1155 }
1156 default:
1157 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
1158
1159 break;
1160 }
1161
1162 return eRet;
1163 }
1164
1165 //------------------------------------------------------------------------------
1166 /// @brief print vdec debug status
1167 /// @param eStream \b IN : stream type
1168 //------------------------------------------------------------------------------
MApi_VDEC_EX_DbgDumpStatus(VDEC_StreamId * pStreamId)1169 void MApi_VDEC_EX_DbgDumpStatus(VDEC_StreamId *pStreamId)
1170 {
1171 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
1172 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
1173
1174 if (u8Idx >= VDEC_MAX_SUPPORT_STREAM_NUM)
1175 {
1176 return;
1177 }
1178
1179 if(pVdecExContext == NULL)
1180 {
1181 return;
1182 }
1183
1184 if (!(pVdecExContext->_Attr[u8Idx].bInit))
1185 {
1186 return;
1187 }
1188
1189 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
1190 {
1191 case E_VDEC_EX_DECODER_MVD:
1192 {
1193 MDrv_MVD_DbgDump(u32Id);
1194 break;
1195 }
1196 case E_VDEC_EX_DECODER_HVD:
1197 {
1198 MDrv_HVD_EX_DbgDumpStatus(u32Id, E_HVD_EX_DUMP_STATUS_FW);
1199 break;
1200 }
1201 case E_VDEC_EX_DECODER_MJPEG:
1202 {
1203 break;
1204 }
1205 default:
1206 break;
1207 }
1208 }
1209
1210 extern void HAL_VPU_EX_InitRegBase(MS_VIRT u32RegBase) __attribute__((weak));
1211 extern MS_U32 HAL_VPU_GetProgCnt(void) __attribute__((weak));
1212
1213
1214 //------------------------------------------------------------------------------
1215 /// @brief Get VPU program counter for debug
1216 /// @retval program counter
1217 //------------------------------------------------------------------------------
MApi_VDEC_EX_DbgGetProgCnt(void)1218 MS_U32 MApi_VDEC_EX_DbgGetProgCnt(void)
1219 {
1220 #ifndef MSOS_TYPE_LINUX_KERNEL
1221 MS_PHY u32NonPMBankSize=0;
1222 MS_VIRT u32RiuBaseAdd=0;
1223 if( !MDrv_MMIO_GetBASE( &u32RiuBaseAdd, &u32NonPMBankSize, MS_MODULE_HW))
1224 {
1225 VDEC_PRINT("VDEC HVD MApi_VDEC_DbgGetProgramCnt Err: MMIO_GetBASE failure\n");
1226 return 0;
1227 }
1228 else
1229 {
1230 //VDEC_PRINT("HVD:1 u32RiuBaseAdd = %lx\n", u32RiuBaseAdd);
1231 if( HAL_VPU_EX_InitRegBase )
1232 {
1233 HAL_VPU_EX_InitRegBase(u32RiuBaseAdd);
1234 }
1235 else
1236 {
1237 return 0;
1238 }
1239 }
1240 if( HAL_VPU_GetProgCnt )
1241 {
1242 return HAL_VPU_GetProgCnt();
1243 }
1244 else
1245 {
1246 return 0;
1247 }
1248 #else
1249 return 0;
1250 #endif
1251 }
1252
1253
1254 //-------------------------------------------------------------------------------------------------
1255 // Local Functions
1256 //-------------------------------------------------------------------------------------------------
1257 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
_VDEC_LinkWeakSymbolPatch(void)1258 static void __attribute__((unused)) _VDEC_LinkWeakSymbolPatch(void)
1259 {
1260 #if VDEC_ENABLE_MVD
1261 MDrv_MVD_LinkWeakSymbolPatch();
1262 #endif
1263 #if VDEC_ENABLE_HVD
1264 MDrv_HVD_LinkWeakSymbolPatch();
1265 #endif
1266 }
1267 #endif
1268
1269 #define MSTAR_INTERNAL_VDEC_UUID {0x61328cc8, 0x8df1, 0x4821,{0x89, 0x01, 0x76, 0x1b, 0xb2, 0xb9, 0x11, 0x5c} }
1270 #define SYS_TEEC_OPERATION_INITIALIZER { 0 }
1271 TEEC_Context mstar_vdec_teec_ctx;
1272 TEEC_Session vdec_session = { 0 };
1273 TEEC_UUID vdec_uuid = MSTAR_INTERNAL_VDEC_UUID;
1274 TEEC_Operation vdec_op = SYS_TEEC_OPERATION_INITIALIZER;
1275 static const char optee_vdec[] = "opteearmtz00";
1276 char *_vdec_device = (char *)optee_vdec;
1277 typedef enum
1278 {
1279 E_VDEC_EX_OPTEE_GETSHMADDR = 0,
1280 E_VDEC_EX_OPTEE_LOADCODE,
1281 E_VDEC_EX_OPTEE_SECURE_BUFFER,
1282 E_VDEC_EX_OPTEE_SECURE_FB2,
1283 E_VDEC_EX_OPTEE_MAX,//max
1284 } VDEC_EX_OPTEE_CMD;
1285
1286 extern MS_U32 MDrv_SYS_TEEC_InitializeContext(const char *name, TEEC_Context *context);
1287 extern MS_U32 MDrv_SYS_TEEC_Open(TEEC_Context *context, TEEC_Session *session, const TEEC_UUID *destination, MS_U32 connection_method, const void *connection_data, TEEC_Operation *operation, MS_U32 *error_origin);
1288 extern MS_U32 MDrv_SYS_TEEC_InvokeCmd(TEEC_Session *session, MS_U32 cmd_id, TEEC_Operation *operation, MS_U32 *error_origin);
1289 extern void MDrv_SYS_TEEC_Close(TEEC_Session *session);
1290 extern void MDrv_SYS_TEEC_FinalizeContext(TEEC_Context *context);
_MApi_VDEC_EX_V2_Send_OPTEE_CMD(VDEC_EX_OPTEE_CMD eCMD,void * para,MS_U32 size)1291 MS_BOOL _MApi_VDEC_EX_V2_Send_OPTEE_CMD(VDEC_EX_OPTEE_CMD eCMD,void* para,MS_U32 size)
1292 {
1293 MS_BOOL bret = FALSE;
1294 #if defined (MSOS_TYPE_LINUX)
1295 unsigned int ret_orig = 0;
1296 if (MDrv_SYS_TEEC_InitializeContext(_vdec_device, &mstar_vdec_teec_ctx) != TEEC_SUCCESS)
1297 {
1298 VDEC_PRINT("%s %d: Init Context failed\n",__func__,__LINE__);
1299 MDrv_SYS_TEEC_FinalizeContext(&mstar_vdec_teec_ctx);
1300 return bret;
1301 }
1302
1303 if (MDrv_SYS_TEEC_Open(&mstar_vdec_teec_ctx, &vdec_session, &vdec_uuid, TEEC_LOGIN_PUBLIC, NULL, NULL, &ret_orig) != TEEC_SUCCESS)
1304 {
1305 VDEC_PRINT("%s %d: TEEC Open session failed\n",__func__,__LINE__);
1306 MDrv_SYS_TEEC_Close(&vdec_session);
1307 MDrv_SYS_TEEC_FinalizeContext(&mstar_vdec_teec_ctx);
1308 return bret;
1309 }
1310
1311 if(size == 0)
1312 {
1313 vdec_op.paramTypes = TEEC_PARAM_TYPES(TEEC_NONE, TEEC_NONE,TEEC_NONE, TEEC_NONE);
1314 }
1315 else
1316 {
1317 vdec_op.params[0].tmpref.buffer = para;
1318 vdec_op.params[0].tmpref.size = size;
1319 vdec_op.paramTypes = TEEC_PARAM_TYPES(TEEC_MEMREF_TEMP_INOUT, TEEC_NONE,TEEC_NONE, TEEC_NONE);
1320 }
1321
1322 if (MDrv_SYS_TEEC_InvokeCmd(&vdec_session, (MS_U32)eCMD, &vdec_op, &ret_orig) != TEEC_SUCCESS)
1323 {
1324 VDEC_PRINT("%s %d: TEEC Invoke command failed\n",__func__,__LINE__);
1325 }
1326 else
1327 {
1328 bret = TRUE;
1329 }
1330 MDrv_SYS_TEEC_Close(&vdec_session);
1331 MDrv_SYS_TEEC_FinalizeContext(&mstar_vdec_teec_ctx);
1332 #endif
1333 return bret;
1334 }
1335
1336 //------------------------------------------------------------------------------
1337 /// set share memory base address between driver with fw
1338 /// @param u32base \b IN : base addresss
1339 /// @return VDEC_Result
1340 //------------------------------------------------------------------------------
_VDEC_EX_Set_ShareMemory_Base(VDEC_StreamId * pStreamId,MS_VIRT u32base)1341 static VDEC_EX_Result _VDEC_EX_Set_ShareMemory_Base(VDEC_StreamId *pStreamId, MS_VIRT u32base)
1342 {
1343 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
1344 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
1345 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
1346
1347 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
1348
1349 if (pVdecExContext->_Attr[u8Idx].bInit)
1350 {
1351 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
1352 }
1353
1354 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
1355 {
1356 case E_VDEC_EX_DECODER_MVD:
1357 _MVD_RET_HANDLE(MDrv_MVD_SetShareMemoryBase(u32Id, u32base));
1358 ret = E_VDEC_EX_OK;
1359 break;
1360 case E_VDEC_EX_DECODER_HVD:
1361 ret = E_VDEC_EX_RET_UNSUPPORTED;
1362 break;
1363 case E_VDEC_EX_DECODER_MJPEG:
1364 ret = E_VDEC_EX_RET_UNSUPPORTED;
1365 break;
1366 default:
1367 ret = E_VDEC_EX_RET_UNSUPPORTED;
1368 break;
1369 }
1370
1371 return ret ;
1372
1373 }
1374
_VDEC_EX_Enable_VPU_SecurityMode(MS_BOOL enable)1375 static void _VDEC_EX_Enable_VPU_SecurityMode(MS_BOOL enable)
1376 {
1377 VPRINTF("[VDEC][TEE/OPTEE]%s,enable=%d\n",__FUNCTION__,enable);
1378 bSecureModeEnable = enable;
1379 }
1380
1381 //------------------------------------------------------------------------------
1382 /// set share memory base address between driver with fw
1383 /// @param u32base \b IN : base addresss
1384 /// @return VDEC_Result
1385 //------------------------------------------------------------------------------
_VDEC_EX_Get_ShareMemory_Base(VDEC_StreamId * pStreamId,MS_VIRT * u32base)1386 static VDEC_EX_Result _VDEC_EX_Get_ShareMemory_Base(VDEC_StreamId *pStreamId, MS_VIRT *u32base)
1387 {
1388 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
1389 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
1390 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
1391
1392 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
1393 {
1394 case E_VDEC_EX_DECODER_MVD:
1395 _MVD_RET_HANDLE(MDrv_MVD_GetShareMemoryOffset(u32Id, u32base));
1396 ret = E_VDEC_EX_OK;
1397 break;
1398 case E_VDEC_EX_DECODER_HVD:
1399 ret = E_VDEC_EX_RET_UNSUPPORTED;
1400 break;
1401 case E_VDEC_EX_DECODER_MJPEG:
1402 ret = E_VDEC_EX_RET_UNSUPPORTED;
1403 break;
1404 default:
1405 ret = E_VDEC_EX_RET_UNSUPPORTED;
1406 break;
1407 }
1408 return ret ;
1409
1410 }
1411
_VDEC_Map2MVDCCFmt(VDEC_EX_CCFormat eFmt)1412 static MS_U8 _VDEC_Map2MVDCCFmt(VDEC_EX_CCFormat eFmt)
1413 {
1414 MS_U8 u8Fmt = 0xff;
1415 u8Fmt = (E_VDEC_EX_CC_608==eFmt)?E_CC_MVD_TYPE_608:E_CC_MVD_TYPE_708;
1416 return u8Fmt;
1417 }
1418
_VDEC_Map2MVDCCOpt(VDEC_EX_CCType eType)1419 static MS_U8 _VDEC_Map2MVDCCOpt(VDEC_EX_CCType eType)
1420 {
1421 MS_U8 u8Operation = 0;
1422 switch (eType)
1423 {
1424 case E_VDEC_EX_CC_TYPE_NTSC_FIELD1:
1425 u8Operation = 0x01;
1426 break;
1427 case E_VDEC_EX_CC_TYPE_NTSC_FIELD2:
1428 u8Operation = 0x02;
1429 break;
1430 case E_VDEC_EX_CC_TYPE_NTSC_TWOFIELD:
1431 u8Operation = 0x03;
1432 break;
1433 case E_VDEC_EX_CC_TYPE_DTVCC:
1434 default:
1435 u8Operation = 0x04;
1436 break;
1437 }
1438 return u8Operation;
1439 }
1440
1441
1442
_VDEC_Map2HVDCCFmt(VDEC_EX_CCFormat eFmt)1443 static MS_U8 _VDEC_Map2HVDCCFmt(VDEC_EX_CCFormat eFmt)
1444 {
1445 MS_U8 u8Fmt = 0xff;
1446 u8Fmt = (E_VDEC_EX_CC_608==eFmt)?1:0;
1447 return u8Fmt;
1448 }
1449
_VDEC_Map2HVDCCOpt(VDEC_EX_CCType eType)1450 static MS_U8 _VDEC_Map2HVDCCOpt(VDEC_EX_CCType eType)
1451 {
1452 MS_U8 u8Operation = 0;
1453 switch (eType)
1454 {
1455 case E_VDEC_EX_CC_TYPE_NTSC_FIELD1:
1456 u8Operation = 0x01;
1457 break;
1458 case E_VDEC_EX_CC_TYPE_NTSC_FIELD2:
1459 u8Operation = 0x02;
1460 break;
1461 case E_VDEC_EX_CC_TYPE_NTSC_TWOFIELD:
1462 u8Operation = 0x03;
1463 break;
1464 case E_VDEC_EX_CC_TYPE_DTVCC:
1465 default:
1466 u8Operation = 0x04;
1467 break;
1468 }
1469 return u8Operation;
1470 }
1471
_VDEC_Map2HVDStatus(HVD_EX_GetPlayState eStatus)1472 static VDEC_EX_Stage _VDEC_Map2HVDStatus(HVD_EX_GetPlayState eStatus)
1473 {
1474 VDEC_EX_Stage eRet = E_VDEC_EX_STAGE_STOP;
1475 switch (eStatus)
1476 {
1477 case E_HVD_EX_GSTATE_INIT:
1478 eRet = E_VDEC_EX_STAGE_INIT;
1479 break;
1480 case E_HVD_EX_GSTATE_PLAY:
1481 eRet = E_VDEC_EX_STAGE_PLAY;
1482 break;
1483 case E_HVD_EX_GSTATE_PAUSE:
1484 eRet = E_VDEC_EX_STAGE_PAUSE;
1485 break;
1486 case E_HVD_EX_GSTATE_STOP:
1487 default:
1488 eRet = E_VDEC_EX_STAGE_STOP;
1489 break;
1490 }
1491 return eRet;
1492 }
1493
_VDEC_Map2HVDErrCode(MS_U32 u32ErrCode)1494 static MS_U32 _VDEC_Map2HVDErrCode(MS_U32 u32ErrCode)
1495 {
1496
1497 MS_U32 u32Ret=E_VDEC_EX_HVD_ERR_CODE_GENERAL_BASE;
1498
1499
1500 switch (u32ErrCode)
1501 {
1502 case E_HVD_EX_ERRCODE_OUT_OF_SPEC:
1503 u32Ret = E_VDEC_EX_HVD_ERR_CODE_OUT_OF_SPEC;
1504 break;
1505 case E_HVD_EX_ERRCODE_UNKNOW_ERR:
1506 u32Ret = E_VDEC_EX_HVD_ERR_CODE_UNKNOW_ERR;
1507 break;
1508 case E_HVD_EX_ERRCODE_HW_BREAK_DOWN:
1509 u32Ret = E_VDEC_EX_HVD_ERR_CODE_HW_BREAK_DOWN;
1510 break;
1511 case E_HVD_EX_ERRCODE_HW_DEC_TIMEOUT:
1512 u32Ret = E_VDEC_EX_HVD_ERR_CODE_HW_DEC_TIMEOUT;
1513 break;
1514 case E_HVD_EX_ERRCODE_OUT_OF_MEMORY:
1515 u32Ret = E_VDEC_EX_HVD_ERR_CODE_OUT_OF_MEMORY;
1516 break;
1517 case E_HVD_EX_ERRCODE_UNKNOWN_CODEC:
1518 u32Ret = E_VDEC_EX_HVD_ERR_CODE_UNKNOWN_CODEC;
1519 break;
1520 case E_HVD_EX_ERRCODE_RES_NOT_SUPPORT:
1521 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RES_NOT_SUPPORT;
1522 break;
1523 case E_HVD_EX_ERRCODE_AVC_SPS_BROKEN:
1524 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVC_SPS_BROKEN;
1525 break;
1526 case E_HVD_EX_ERRCODE_AVC_SPS_NOT_IN_SPEC:
1527 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVC_SPS_NOT_IN_SPEC;
1528 break;
1529 case E_HVD_EX_ERRCODE_AVC_SPS_NOT_ENOUGH_FRM:
1530 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVC_SPS_NOT_ENOUGH_FRM;
1531 break;
1532 case E_HVD_EX_ERRCODE_AVC_PPS_BROKEN:
1533 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVC_PPS_BROKEN;
1534 break;
1535 case E_HVD_EX_ERRCODE_AVC_REF_LIST:
1536 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVC_REF_LIST;
1537 break;
1538 case E_HVD_EX_ERRCODE_AVC_NO_REF:
1539 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVC_NO_REF;
1540 break;
1541 case E_HVD_EX_ERRCODE_AVC_RES:
1542 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVC_RES;
1543 break;
1544 case E_HVD_EX_ERRCODE_AVS_RES:
1545 u32Ret = E_VDEC_EX_HVD_ERR_CODE_AVS_RES;
1546 break;
1547 case E_HVD_EX_ERRCODE_RM_PACKET_HEADER:
1548 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_PACKET_HEADER;
1549 break;
1550 case E_HVD_EX_ERRCODE_RM_FRAME_HEADER:
1551 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_FRAME_HEADER;
1552 break;
1553 case E_HVD_EX_ERRCODE_RM_SLICE_HEADER:
1554 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_SLICE_HEADER;
1555 break;
1556 case E_HVD_EX_ERRCODE_RM_BYTE_CNT:
1557 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_BYTE_CNT;
1558 break;
1559 case E_HVD_EX_ERRCODE_RM_DISP_TIMEOUT:
1560 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_DISP_TIMEOUT;
1561 break;
1562 case E_HVD_EX_ERRCODE_RM_NO_REF:
1563 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_NO_REF;
1564 break;
1565 case E_HVD_EX_ERRCODE_RM_RES:
1566 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_RES;
1567 break;
1568 case E_HVD_EX_ERRCODE_RM_VLC:
1569 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_VLC;
1570 break;
1571 case E_HVD_EX_ERRCODE_RM_SIZE_OUT_FB_LAYOUT:
1572 u32Ret = E_VDEC_EX_HVD_ERR_CODE_RM_SIZE_OUT_FB_LAYOUT;
1573 break;
1574 default:
1575 break;
1576 }
1577 return u32Ret;
1578 }
1579
1580
1581
_VDEC_Map2ESBufStatus(MS_U32 u32ESBufStatus)1582 static MS_U32 _VDEC_Map2ESBufStatus(MS_U32 u32ESBufStatus)
1583 {
1584 MS_U32 u32Ret = ES_BUFFER_STATUS_UNKNOWN;
1585
1586 switch (u32ESBufStatus)
1587 {
1588 case E_HVD_EX_ES_BUF_STATUS_UNDERFLOW:
1589 u32Ret = ES_BUFFER_STATUS_UNDERFLOW;
1590 break;
1591 case E_HVD_EX_ES_BUF_STATUS_OVERFLOW:
1592 u32Ret = ES_BUFFER_STATUS_OVERFLOW;
1593 break;
1594 case E_HVD_EX_ES_BUF_STATUS_NORMAL:
1595 u32Ret = ES_BUFFER_STATUS_NORMAL;
1596 break;
1597 default:
1598 break;
1599 }
1600 return u32Ret;
1601
1602 }
1603
_VDEC_Map2HVDMFCodecMode(VDEC_EX_MFCodec_mode eMFCodecMode)1604 static HVD_EX_MFCodec_mode _VDEC_Map2HVDMFCodecMode(VDEC_EX_MFCodec_mode eMFCodecMode)
1605 {
1606 HVD_EX_MFCodec_mode u32Ret = E_HVD_EX_MFCODEC_DEFAULT;
1607
1608 switch (eMFCodecMode)
1609 {
1610 case E_VDEC_EX_MFCODEC_DEFAULT:
1611 u32Ret = E_HVD_EX_MFCODEC_DEFAULT;
1612 break;
1613 case E_VDEC_EX_MFCODEC_FORCE_ENABLE:
1614 u32Ret = E_HVD_EX_MFCODEC_FORCE_ENABLE;
1615 break;
1616 case E_VDEC_EX_MFCODEC_FORCE_DISABLE:
1617 u32Ret = E_HVD_EX_MFCODEC_FORCE_DISABLE;
1618 break;
1619 default:
1620 break;
1621 }
1622 return u32Ret;
1623 }
1624
_VDEC_Map2HVDDispMode(VDEC_EX_DISPLAY_MODE eDisplayMode)1625 static HVD_EX_Display_mode _VDEC_Map2HVDDispMode(VDEC_EX_DISPLAY_MODE eDisplayMode)
1626 {
1627 HVD_EX_Display_mode u32Ret = E_HVD_EX_DISPLAY_MODE_DEFAULT;
1628
1629 switch (eDisplayMode)
1630 {
1631 case E_VDEC_EX_DISPLAY_MODE_MCU:
1632 u32Ret = E_HVD_EX_DISPLAY_MODE_MCU;
1633 break;
1634 case E_VDEC_EX_DISPLAY_MODE_HARDWIRE:
1635 u32Ret = E_HVD_EX_DISPLAY_MODE_HARDWIRE;
1636 break;
1637 default:
1638 break;
1639 }
1640 return u32Ret;
1641 }
1642
_VDEC_MapUserCmd_V2(VDEC_EX_User_Cmd eUserCmd)1643 static VDEC_EX_V2_User_Cmd _VDEC_MapUserCmd_V2(VDEC_EX_User_Cmd eUserCmd)
1644 {
1645 VDEC_EX_V2_User_Cmd eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_CONTROL_BASE;
1646 switch (eUserCmd)
1647 {
1648 case E_VDEC_EX_USER_CMD_SET_CONTROL_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_CONTROL_BASE;break;
1649 case E_VDEC_EX_USER_CMD_REPEAT_LAST_FIELD : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_REPEAT_LAST_FIELD ;break;
1650 case E_VDEC_EX_USER_CMD_AVSYNC_REPEAT_TH : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVSYNC_REPEAT_TH ;break;
1651 case E_VDEC_EX_USER_CMD_DISP_ONE_FIELD : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DISP_ONE_FIELD ;break;
1652 case E_VDEC_EX_USER_CMD_FD_MASK_DELAY_COUNT : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FD_MASK_DELAY_COUNT ;break;
1653 case E_VDEC_EX_USER_CMD_FRC_OUTPUT : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FRC_OUTPUT ;break;
1654 case E_VDEC_EX_USER_CMD_FRC_DROP_TYPE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FRC_DROP_TYPE ;break;
1655 case E_VDEC_EX_USER_CMD_FAST_DISPLAY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FAST_DISPLAY ;break;
1656 case E_VDEC_EX_USER_CMD_IGNORE_ERR_REF : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_IGNORE_ERR_REF ;break;
1657 case E_VDEC_EX_USER_CMD_FORCE_FOLLOW_DTV_SPEC : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FORCE_FOLLOW_DTV_SPEC ;break;
1658 case E_VDEC_EX_USER_CMD_AVC_MIN_FRM_GAP : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVC_MIN_FRM_GAP ;break;
1659 case E_VDEC_EX_USER_CMD_DISABLE_SEQ_CHG : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DISABLE_SEQ_CHG ;break;
1660 case E_VDEC_EX_USER_CMD_SET_DISP_OUTSIDE_CTRL_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DISP_OUTSIDE_CTRL_MODE ;break;
1661 case E_VDEC_EX_USER_CMD_SET_DTV_USER_DATA_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DTV_USER_DATA_MODE ;break;
1662 case E_VDEC_EX_USER_CMD_SET_SINGLE_TASK_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_SINGLE_TASK_MODE ;break;
1663 case E_VDEC_EX_USER_CMD_AVC_DISABLE_ANTI_VDEAD : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVC_DISABLE_ANTI_VDEAD ;break;
1664 case E_VDEC_EX_USER_CMD_DTV_RESET_MVD_PARSER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DTV_RESET_MVD_PARSER ;break;
1665 case E_VDEC_EX_USER_CMD_PVR_FLUSH_FRAME_BUFFER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_PVR_FLUSH_FRAME_BUFFER ;break;
1666 case E_VDEC_EX_USER_CMD_FORCE_INTERLACE_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FORCE_INTERLACE_MODE ;break;
1667 case E_VDEC_EX_USER_CMD_RELEASE_FD_MASK : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_RELEASE_FD_MASK ;break;
1668 case E_VDEC_EX_USER_CMD_SET_DECODE_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_NULL ;break;
1669 case E_VDEC_EX_USER_CMD_SUPPORT_AVC_TO_MVC : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SUPPORT_AVC_TO_MVC ;break;
1670 case E_VDEC_EX_USER_CMD_3DLR_VIEW_EXCHANGE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_3DLR_VIEW_EXCHANGE ;break;
1671 case E_VDEC_EX_USER_CMD_SET_VSIZE_ALIGN : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_VSIZE_ALIGN ;break;
1672 case E_VDEC_EX_USER_CMD_SHOW_DECODE_ORDER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SHOW_DECODE_ORDER ;break;
1673 case E_VDEC_EX_USER_CMD_AVC_DISP_IGNORE_CROP : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVC_DISP_IGNORE_CROP ;break;
1674 case E_VDEC_EX_USER_CMD_SET_DISP_FINISH_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DISP_FINISH_MODE ;break;
1675 case E_VDEC_EX_USER_CMD_SET_AVSYNC_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_AVSYNC_MODE ;break;
1676 case E_VDEC_EX_USER_CMD_SUSPEND_DYNAMIC_SCALE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SUSPEND_DYNAMIC_SCALE ;break;
1677 case E_VDEC_EX_USER_CMD_FORCE_AUTO_MUTE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FORCE_AUTO_MUTE ;break;
1678 case E_VDEC_EX_USER_CMD_AVC_NEW_SLOW_MOTION : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVC_NEW_SLOW_MOTION ;break;
1679 case E_VDEC_EX_USER_CMD_PUSH_DISPQ_WITH_REF_NUM : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_PUSH_DISPQ_WITH_REF_NUM ;break;
1680 case E_VDEC_EX_USER_CMD_DS_RESV_N_BUFFER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DS_RESV_N_BUFFER ;break;
1681 case E_VDEC_EX_USER_CMD_RM_ENABLE_PTS_TBL : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_RM_ENABLE_PTS_TBL ;break;
1682 case E_VDEC_EX_USER_CMD_FLUSH_PTS_BUF : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FLUSH_PTS_BUF ;break;
1683 case E_VDEC_EX_USER_CMD_SET_IDCT_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_IDCT_MODE ;break;
1684 case E_VDEC_EX_USER_CMD_DROP_ERR_FRAME : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DROP_ERR_FRAME ;break;
1685 case E_VDEC_EX_USER_CMD_SET_CC608_INFO_ENHANCE_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_CC608_INFO_ENHANCE_MODE ;break;
1686 case E_VDEC_EX_USER_CMD_IGNORE_PIC_OVERRUN : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_IGNORE_PIC_OVERRUN ;break;
1687 case E_VDEC_EX_USER_CMD_SET_SELF_SEQCHANGE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_SELF_SEQCHANGE ;break;
1688 case E_VDEC_EX_USER_CMD_AUTO_EXHAUST_ES_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AUTO_EXHAUST_ES_MODE ;break;
1689 case E_VDEC_EX_USER_CMD_CTL_SPEED_IN_DISP_ONLY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_CTL_SPEED_IN_DISP_ONLY ;break;
1690 case E_VDEC_EX_USER_CMD_AVC_SUPPORT_REF_NUM_OVER_MAX_DPB_SIZE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVC_SUPPORT_REF_NUM_OVER_MAX_DPB_SIZE ;break;
1691 case E_VDEC_EX_USER_CMD_RETURN_INVALID_AFD : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_RETURN_INVALID_AFD ;break;
1692 case E_VDEC_EX_USER_CMD_FIELD_POLARITY_DISPLAY_ONE_FIELD : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FIELD_POLARITY_DISPLAY_ONE_FIELD ;break;
1693 case E_VDEC_EX_USER_CMD_AVC_FORCE_BROKEN_BY_US : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVC_FORCE_BROKEN_BY_US ;break;
1694 case E_VDEC_EX_USER_CMD_SHOW_FIRST_FRAME_DIRECT : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SHOW_FIRST_FRAME_DIRECT ;break;
1695 case E_VDEC_EX_USER_CMD_AVC_RESIZE_DOS_DISP_PEND_BUF : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AVC_RESIZE_DOS_DISP_PEND_BUF ;break;
1696 case E_VDEC_EX_USER_CMD_SET_XC_LOW_DELAY_PARA : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_XC_LOW_DELAY_PARA ;break;
1697 case E_VDEC_EX_USER_CMD_SET_SECURE_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_SECURE_MODE ;break;
1698 case E_VDEC_EX_USER_CMD_RVU_SETTING_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_RVU_SETTING_MODE ;break;
1699 case E_VDEC_EX_USER_CMD_FRAMERATE_HANDLING : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FRAMERATE_HANDLING ;break;
1700 case E_VDEC_EX_USER_CMD_DUAL_NON_BLOCK_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DUAL_NON_BLOCK_MODE ;break;
1701 case E_VDEC_EX_USER_CMD_IGNORE_PIC_STRUCT_DISPLAY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_IGNORE_PIC_STRUCT_DISPLAY ;break;
1702 case E_VDEC_EX_USER_CMD_INPUT_PTS_FREERUN_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_INPUT_PTS_FREERUN_MODE ;break;
1703 case E_VDEC_EX_USER_CMD_ERR_CONCEAL_SLICE_1ST_MB : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_ERR_CONCEAL_SLICE_1ST_MB ;break;
1704 case E_VDEC_EX_USER_CMD_SET_EXTERNAL_DS_BUFFER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_EXTERNAL_DS_BUFFER ;break;
1705 case E_VDEC_EX_USER_CMD_SET_MIN_TSP_DATA_SIZE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_MIN_TSP_DATA_SIZE ;break;
1706 case E_VDEC_EX_USER_CMD_SET_DMX_FRAMERATE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DMX_FRAMERATE ;break;
1707 case E_VDEC_EX_USER_CMD_SET_DMX_FRAMERATEBASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DMX_FRAMERATEBASE ;break;
1708 case E_VDEC_EX_USER_CMD_ENABLE_CC_608_EXTERNAL_BUFFER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_ENABLE_CC_608_EXTERNAL_BUFFER ;break;
1709 case E_VDEC_EX_USER_CMD_ENABLE_CC_708_EXTERNAL_BUFFER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_ENABLE_CC_708_EXTERNAL_BUFFER ;break;
1710 case E_VDEC_EX_USER_CMD_SET_TIME_INC_PREDICT_PARA : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_TIME_INC_PREDICT_PARA ;break;
1711 case E_VDEC_EX_USER_CMD_ENABLE_DECODE_ENGINE_TIMEOUT : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_ENABLE_DECODE_ENGINE_TIMEOUT ;break;
1712 case E_VDEC_EX_USER_CMD_AUTO_FREE_ES : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AUTO_FREE_ES ;break;
1713 case E_VDEC_EX_USER_CMD_FRAMEBUFFER_AUTO_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FRAMEBUFFER_AUTO_MODE ;break;
1714 case E_VDEC_EX_USER_CMD_SET_SMOOTH_REWIND : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_SMOOTH_REWIND ;break;
1715 case E_VDEC_EX_USER_CMD_SET_ERROR_TOLERANCE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_ERROR_TOLERANCE ;break;
1716 case E_VDEC_EX_USER_CMD_AUTO_DROP_DISPLAY_QUEUE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AUTO_DROP_DISPLAY_QUEUE ;break;
1717 case E_VDEC_EX_USER_CMD_USE_CPB_REMOVAL_DEALY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_USE_CPB_REMOVAL_DEALY ;break;
1718 case E_VDEC_EX_USER_CMD_SKIP_N_FRAME : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SKIP_N_FRAME ;break;
1719 case E_VDEC_EX_USER_CMD_SET_PTS_US_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_PTS_US_MODE ;break;
1720 case E_VDEC_EX_USER_CMD_AUTO_INSERT_DUMMY_DATA : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AUTO_INSERT_DUMMY_DATA ;break;
1721 case E_VDEC_EX_USER_CMD_DROP_ONE_PTS : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DROP_ONE_PTS ;break;
1722 case E_VDEC_EX_USER_CMD_PVR_TIMESHIFT_SEAMLESS_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_PVR_TIMESHIFT_SEAMLESS_MODE ;break;
1723 case E_VDEC_EX_USER_CMD_AUTO_REDUCE_ES_DATA : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AUTO_REDUCE_ES_DATA ;break;
1724 case E_VDEC_EX_USER_CMD_RM_FORCE_MCU_MODE_ES : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_RM_FORCE_MCU_MODE_ES ;break;
1725 case E_VDEC_EX_USER_CMD_FORCE_PROGRESSIVE_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FORCE_PROGRESSIVE_MODE ;break;
1726 case E_VDEC_EX_USER_CMD_SET_FRAMEBUFF2 : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_FRAMEBUFF2 ;break;
1727 case E_VDEC_EX_USER_CMD_ENABLE_PTS_DECTECTOR : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_ENABLE_PTS_DECTECTOR ;break;
1728 case E_VDEC_EX_USER_CMD_DISABLE_PBFRAME_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DISABLE_PBFRAME_MODE ;break;
1729 case E_VDEC_EX_USER_CMD_SET_SLOW_SYNC : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_SLOW_SYNC;break;
1730 case E_VDEC_EX_USER_CMD_SET_TRICKPLAY_2X_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_TRICKPLAY_2X_MODE ;break;
1731 case E_VDEC_EX_USER_CMD_FRC_ONLY_SHOW_TOP_FIELD : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FRC_ONLY_SHOW_TOP_FIELD;break;
1732 case E_VDEC_EX_USER_CMD_DIRECT_STC_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DIRECT_STC_MODE;break;
1733 case E_VDEC_EX_USER_CMD_DISABLE_ES_FULL_STOP : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DISABLE_ES_FULL_STOP ;break;
1734
1735 case E_VDEC_EX_USER_CMD_MVC_SET_CMD_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_MVC_SET_CMD_BASE ;break;
1736 case E_VDEC_EX_USER_CMD_MVC_BBU2_PUSH_PACKET : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_MVC_BBU2_PUSH_PACKET ;break;
1737 case E_VDEC_EX_USER_CMD_MVC_BBU2_FIRE_DECCMD : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_MVC_BBU2_FIRE_DECCMD ;break;
1738
1739 case E_VDEC_EX_USER_CMD_UT_SET_CMD_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_UT_SET_CMD_BASE ;break;
1740 case E_VDEC_EX_USER_CMD_UT_SET_DBG_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_UT_SET_DBG_MODE ;break;
1741 case E_VDEC_EX_USER_CMD_UT_CLR_DBG_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_UT_CLR_DBG_MODE ;break;
1742 case E_VDEC_EX_USER_CMD_SET_DV_XC_SHM_ADDR : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DV_XC_SHM_ADDR ;break;
1743 #ifdef VDEC_CAP_DV_OTT_API
1744 case E_VDEC_EX_USER_CMD_SET_DV_INFO : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DV_INFO ;break;
1745 #endif
1746
1747 //Group2:Get Control command================================
1748
1749 case E_VDEC_EX_USER_CMD_GET_CONTROL_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_CONTROL_BASE ;break;
1750 case E_VDEC_EX_USER_CMD_GET_CHROMA_TYPE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_CHROMA_TYPE ;break;
1751 case E_VDEC_EX_USER_CMD_GET_REAL_FRAMERATE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_REAL_FRAMERATE ;break;
1752 case E_VDEC_EX_USER_CMD_GET_COLOR_MATRIX : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_COLOR_MATRIX ;break;
1753 case E_VDEC_EX_USER_CMD_GET_MAIN_STREAM_ID : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_MAIN_STREAM_ID ;break;
1754 case E_VDEC_EX_USER_CMD_GET_SUB_STREAM_ID : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_SUB_STREAM_ID ;break;
1755 case E_VDEC_EX_USER_CMD_GET_DYNSCALE_ENABLED : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DYNSCALE_ENABLED ;break;
1756 case E_VDEC_EX_USER_CMD_GET_FPA_SEI : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FPA_SEI ;break;
1757 case E_VDEC_EX_USER_CMD_GET_DCV_SEI : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DCV_SEI ;break;
1758 case E_VDEC_EX_USER_CMD_GET_VUI_DISP_INFO : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_VUI_DISP_INFO ;break;
1759 case E_VDEC_EX_USER_CMD_GET_CLLI_SEI : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_CLLI_SEI ;break;
1760 case E_VDEC_EX_USER_CMD_GET_CODEC_CAP : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_CODEC_CAP ;break;
1761 case E_VDEC_EX_USER_CMD_GET_U64PTS : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_U64PTS ;break;
1762 case E_VDEC_EX_USER_CMD_GET_PRE_PAS_U64PTS : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_PRE_PAS_U64PTS ;break;
1763 case E_VDEC_EX_USER_CMD_GET_PVRSEAMLESS_INFO : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_PVRSEAMLESS_INFO ;break;
1764 case E_VDEC_EX_USER_CMD_GET_SEQ_CHANGE_INFO : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_SEQ_CHANGE_INFO;break;
1765 case E_VDEC_EX_USER_CMD_GET_ORI_INTERLACE_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ORI_INTERLACE_MODE ;break;
1766 case E_VDEC_EX_USER_CMD_GET_MBS_ONLY_FLAG : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_MBS_ONLY_FLAG ;break;
1767 case E_VDEC_EX_USER_CMD_GET_CRC_VALUE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_CRC_VALUE ;break;
1768 case E_VDEC_EX_USER_CMD_GET_BBU_Q_NUM : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_BBU_Q_NUM ;break;
1769 case E_VDEC_EX_USER_CMD_GET_DISP_FRAME_NUM : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DISP_FRAME_NUM ;break;
1770 case E_VDEC_EX_USER_CMD_GET_FPA_SEI_EX : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FPA_SEI_EX ;break;
1771 case E_VDEC_EX_USER_CMD_GET_ES_BUFFER_STATUS : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ES_BUFFER_STATUS ;break;
1772 case E_VDEC_EX_USER_CMD_GET_CODEC_TYPE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_CODEC_TYPE ;break;
1773 case E_VDEC_EX_USER_CMD_GET_SHAREMEMORY_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_SHAREMEMORY_BASE ;break;
1774 case E_VDEC_EX_USER_CMD_GET_IS_LEAST_DISPQ_SIZE_FLAG: eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_IS_LEAST_DISPQ_SIZE_FLAG ;break;
1775 case E_VDEC_EX_USER_CMD_GET_FIELD_PIC_FLAG : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FIELD_PIC_FLAG ;break;
1776 case E_VDEC_EX_USER_CMD_GET_SUPPORT_2ND_MVOP_INTERFACE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_SUPPORT_2ND_MVOP_INTERFACE ;break;
1777 case E_VDEC_EX_USER_CMD_GET_FB_USAGE_MEM : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FB_USAGE_MEM ;break;
1778 case E_VDEC_EX_USER_CMD_GET_XC_LOW_DELAY_INT_STATE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_XC_LOW_DELAY_INT_STATE ;break;
1779 case E_VDEC_EX_USER_CMD_GET_VSYNC_BRIDGE_ADDR : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_VSYNC_BRIDGE_ADDR ;break;
1780 case E_VDEC_EX_USER_CMD_GET_FRAME_INFO_EX : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FRAME_INFO_EX ;break;
1781 case E_VDEC_EX_USER_CMD_GET_FLUSH_PATTEN_ENTRY_NUM : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FLUSH_PATTEN_ENTRY_NUM ;break;
1782 case E_VDEC_EX_USER_CMD_GET_DS_BUF_MIU_SEL : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DS_BUF_MIU_SEL ;break;
1783 case E_VDEC_EX_USER_CMD_GET_FW_STATUS_FLAG : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FW_STATUS_FLAG ;break;
1784 case E_VDEC_EX_USER_CMD_GET_HW_MAX_PIXEL : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_HW_MAX_PIXEL ;break;
1785 case E_VDEC_EX_USER_CMD_GET_FLOW_CONTROL_U64PTS_DIFF : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FLOW_CONTROL_U64PTS_DIFF ;break;
1786 case E_VDEC_EX_USER_CMD_GET_NEXT_DISP_FRAME_INFO_EXT : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_NEXT_DISP_FRAME_INFO_EXT ;break;
1787 case E_VDEC_EX_USER_CMD_GET_VSYNC_BRIDGE_EXT_ADDR : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_VSYNC_BRIDGE_EXT_ADDR ;break;
1788 case E_VDEC_EX_USER_CMD_GET_DISP_QUEUE_EMPTY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DISP_QUEUE_EMPTY ;break;
1789 case E_VDEC_EX_USER_CMD_GET_NOT_SUPPORT_INFO : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_NOT_SUPPORT_INFO ;break;
1790 case E_VDEC_EX_USER_CMD_GET_MIN_TSP_DATA_SIZE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_MIN_TSP_DATA_SIZE ;break;
1791
1792 //MVC Get Control command================================
1793 case E_VDEC_EX_USER_CMD_MVC_GET_CMD_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_MVC_GET_CMD_BASE ;break;
1794 case E_VDEC_EX_USER_CMD_GET_MVC_SUB_FRAME_DISP_INFO : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_MVC_SUB_FRAME_DISP_INFO ;break;
1795 case E_VDEC_EX_USER_CMD_GET_MVC_BBU2_DECQ_VACANCY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_MVC_BBU2_DECQ_VACANCY ;break;
1796 case E_VDEC_EX_USER_CMD_GET_MVC_ES2_READ_PTR : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_MVC_ES2_READ_PTR ;break;
1797 case E_VDEC_EX_USER_CMD_GET_MVC_ES2_WRITE_PTR : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_MVC_ES2_WRITE_PTR ;break;
1798 case E_VDEC_EX_USER_CMD_GET_ES_QUANTITY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ES_QUANTITY ;break;
1799 case E_VDEC_EX_USER_CMD_GET_ES2_QUANTITY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ES2_QUANTITY ;break;
1800
1801 //Group3:System Preset Control command======================
1802 //Group3-1:Common system Preset Control command
1803 case E_VDEC_EX_USER_CMD_SYSTEM_PRESET_CONTROL_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_CONTROL_BASE ;break;
1804 case E_VDEC_EX_USER_CMD_SYSTEM_PRESET_VPU_CLOCK : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_VPU_CLOCK ;break;
1805
1806 //Group3-2:HVD System Preset Control command
1807 case E_VDEC_EX_USER_CMD_SYSTEM_PRESET_HVD_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_HVD_BASE ;break;
1808 case E_VDEC_EX_USER_CMD_SYSTEM_PRESET_HVD_CLOCK : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_HVD_CLOCK ;break;
1809
1810 //Group3-3:MVD System Preset Control command
1811 case E_VDEC_EX_USER_CMD_SYSTEM_PRESET_MVD_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_MVD_BASE ;break;
1812 case E_VDEC_EX_USER_CMD_SYSTEM_PRESET_MVD_CLOCK : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_MVD_CLOCK ;break;
1813 case E_VDEC_EX_USER_CMD_VPU_SECURITY_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_VPU_SECURITY_MODE ;break;
1814
1815 //Group3-4:Preset Control command=============================
1816 case E_VDEC_EX_USER_CMD_PRESET_CONTROL_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_PRESET_CONTROL_BASE ;break;
1817 case E_VDEC_EX_USER_CMD_HVD_ONE_PENDING_BUFFER_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_HVD_ONE_PENDING_BUFFER_MODE ;break;
1818 case E_VDEC_EX_USER_CMD_MVD_HWBUFFER_REMAPPING_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_MVD_HWBUFFER_REMAPPING_MODE ;break;
1819 case E_VDEC_EX_USER_CMD_SET_SHAREMEMORY_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_SHAREMEMORY_BASE ;break;
1820 case E_VDEC_EX_USER_CMD_HVD_COL_BBU_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_HVD_COL_BBU_MODE ;break;
1821 case E_VDEC_EX_USER_CMD_HVD_IAPGN_BUF_SHARE_BW_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_HVD_IAPGN_BUF_SHARE_BW_MODE ;break;
1822 case E_VDEC_EX_USER_CMD_DTV_DEBUG_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DTV_DEBUG_MODE ;break;
1823 case E_VDEC_EX_USER_CMD_HVD_TS_IN_BBU_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_HVD_TS_IN_BBU_MODE ;break;
1824 case E_VDEC_EX_USER_CMD_AUTO_ARRANGE_FRAMEBUFFER_USAGE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_AUTO_ARRANGE_FRAMEBUFFER_USAGE ;break;
1825 case E_VDEC_EX_USER_CMD_THUMBNAIL_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_THUMBNAIL_MODE ;break;
1826 case E_VDEC_EX_USER_CMD_FORCE_8BIT_DEC_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FORCE_8BIT_DEC_MODE ;break;
1827 case E_VDEC_EX_USER_CMD_MFCODEC_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_MFCODEC_MODE ;break;
1828 case E_VDEC_EX_USER_CMD_VDEC_FEATURE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_VDEC_FEATURE ;break;
1829 case E_VDEC_EX_USER_CMD_DYNAMIC_CMA_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_DYNAMIC_CMA_MODE ;break;
1830 case E_VDEC_EX_USER_CMD_SET_DISPLAY_MODE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DISPLAY_MODE ;break;
1831 case E_VDEC_EX_USER_CMD_PRESET_STC : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_PRESET_STC ;break;
1832 case E_VDEC_EX_USER_CMD_CONNECT_INPUT_TSP : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_CONNECT_INPUT_TSP ;break;
1833 case E_VDEC_EX_USER_CMD_CONNECT_DISPLAY_PATH : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_CONNECT_DISPLAY_PATH ;break;
1834 case E_VDEC_EX_USER_CMD_BITSTREAMBUFFER_MONOPOLY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_BITSTREAMBUFFER_MONOPOLY ;break;
1835 case E_VDEC_EX_USER_CMD_FRAMEBUFFER_MONOPOLY : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_FRAMEBUFFER_MONOPOLY ;break;
1836 case E_VDEC_EX_USER_CMD_SPECIFY_TASK_SPEC : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SPECIFY_TASK_SPEC ;break;
1837 case E_VDEC_EX_USER_CMD_CAL_FRAMERATE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_CAL_FRAMERATE ;break;
1838 case E_VDEC_EX_USER_CMD_SET_TOTALRANGE_BITSTREAMBUFFER : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_TOTALRANGE_BITSTREAMBUFFER ;break;
1839 case E_VDEC_EX_USER_CMD_SET_TOTALRANGE_FRAMEBUFFER1 : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_TOTALRANGE_FRAMEBUFFER1 ;break;
1840 case E_VDEC_EX_USER_CMD_SET_TOTALRANGE_FRAMEBUFFER2 : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SET_TOTALRANGE_FRAMEBUFFER2 ;break;
1841
1842 //Group4:System Postset Control command======================
1843 case E_VDEC_EX_USER_CMD_SYSTEM_POSTSET_CONTROL_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_POSTSET_CONTROL_BASE ;break;
1844 case E_VDEC_EX_USER_CMD_SYSTEM_POSTSET_CLEAR_PROCESS_RELATED : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_POSTSET_CLEAR_PROCESS_RELATED ;break;
1845
1846 //Group5:PreGet Control command======================
1847 case E_VDEC_EX_USER_CMD_SYSTEM_PREGET_CONTROL_BASE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_CONTROL_BASE ;break;
1848 case E_VDEC_EX_USER_CMD_SYSTEM_PREGET_FB_MEMORY_USAGE_SIZE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_FB_MEMORY_USAGE_SIZE ;break;
1849
1850 #ifdef VDEC_CAP_SYSTEM_PREGET_API
1851 #ifdef VDEC_CAP_DV_OTT_API
1852 //Group5:System PreGet Control command======================
1853 //Group5-1:Common system Preget Control command
1854 case E_VDEC_EX_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_PROFILE : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_PROFILE ;break;
1855 case E_VDEC_EX_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_LEVEL : eEXUserCmd = E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_LEVEL ;break;
1856 #endif
1857 #endif
1858 default:
1859 break;
1860 }
1861 return eEXUserCmd;
1862 }
1863
1864 // N Decode Buffer Allocator Functions Start
1865
1866 #define ENABLE_ALLOCATOR_ERROR 1
1867 #define ENABLE_ALLOCATOR_DEBUG 0
1868 #define ENABLE_ALLOCATOR_TRACE 0
1869
1870 #if ENABLE_ALLOCATOR_ERROR
1871 #define ALLOCATOR_PRINTF_ERR(format,args...) VPRINTF(format, ##args)
1872 #else
1873 #define ALLOCATOR_PRINTF_ERR(format,args...)
1874 #endif
1875
1876 #if ENABLE_ALLOCATOR_DEBUG
1877 #define ALLOCATOR_PRINTF_DBG(format,args...) VPRINTF(format, ##args)
1878 #else
1879 #define ALLOCATOR_PRINTF_DBG(format,args...)
1880 #endif
1881
1882 // Functions of BlockInfo
_VDEC_EX_Allocator_BlockInfoReset(VDEC_EX_Allocator_BlockInfo * pstBlockInfo)1883 static void _VDEC_EX_Allocator_BlockInfoReset(VDEC_EX_Allocator_BlockInfo *pstBlockInfo)
1884 {
1885 pstBlockInfo->u8MIU = 0;
1886 pstBlockInfo->u8Property = VDEC_EX_ALLOCAOTR_PROPERTY_DEFAULT;
1887 pstBlockInfo->u16Allocated = 0;
1888 pstBlockInfo->phyAddr = 0;
1889 pstBlockInfo->szSize = 0;
1890 return;
1891 }
1892
_VDEC_EX_Allocator_BlockInfoCopy(VDEC_EX_Allocator_BlockInfo * pstBlockInfoDst,VDEC_EX_Allocator_BlockInfo * pstBlockInfoSrc)1893 static void _VDEC_EX_Allocator_BlockInfoCopy(VDEC_EX_Allocator_BlockInfo *pstBlockInfoDst,
1894 VDEC_EX_Allocator_BlockInfo *pstBlockInfoSrc)
1895 {
1896 memcpy(pstBlockInfoDst, pstBlockInfoSrc, sizeof(VDEC_EX_Allocator_BlockInfo));
1897 return;
1898 }
1899
1900 // Functions of Block
_VDEC_EX_Allocator_BlockReset(VDEC_EX_Allocator_Block * pstBlock,MS_U16 u16Id)1901 static void _VDEC_EX_Allocator_BlockReset(VDEC_EX_Allocator_Block *pstBlock, MS_U16 u16Id)
1902 {
1903 pstBlock->u16BlockId = u16Id;
1904 pstBlock->u16BlockIdPrev = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
1905 pstBlock->u16BlockIdNext = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
1906 pstBlock->u16AllocatorIdExt = VDEC_EX_ALLOCAOTR_ID_UNUSED;
1907 _VDEC_EX_Allocator_BlockInfoReset(&(pstBlock->stBlockInfo));
1908 return;
1909 }
1910
_VDEC_EX_Allocator_BlockIsValidId(MS_U16 u16BlockID)1911 static inline MS_BOOL _VDEC_EX_Allocator_BlockIsValidId(MS_U16 u16BlockID)
1912 {
1913 return (u16BlockID < VDEC_EX_ALLOCAOTR_MAX_NUM_BLOCK) ? TRUE : FALSE;
1914 }
1915
_VDEC_EX_Allocator_BlockGetAddressById(MS_U16 u16BlockID)1916 static VDEC_EX_Allocator_Block *_VDEC_EX_Allocator_BlockGetAddressById(MS_U16 u16BlockID)
1917 {
1918 VDEC_EX_Allocator_Block *pstBlockPool =
1919 &(pVdecExContext->stNDecAllocator.stBlockPool[0]);
1920 VDEC_EX_Allocator_Block *pstBlock = NULL;
1921
1922 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockID) == FALSE)
1923 {
1924 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid block ID: %d\n", __FUNCTION__, __LINE__, u16BlockID);
1925 goto exit;
1926 }
1927
1928 pstBlock = &(pstBlockPool[u16BlockID]);
1929
1930 exit:
1931 return pstBlock;
1932 }
1933
_VDEC_EX_Allocator_BlockGetNewId(void)1934 static MS_U16 _VDEC_EX_Allocator_BlockGetNewId(void)
1935 {
1936 VDEC_EX_Allocator_Block *pstBlockPool =
1937 &(pVdecExContext->stNDecAllocator.stBlockPool[0]);
1938 MS_U16 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
1939 MS_U16 u16Id;
1940
1941 for(u16Id = 0; u16Id < VDEC_EX_ALLOCAOTR_MAX_NUM_BLOCK; u16Id++)
1942 {
1943 VDEC_EX_Allocator_Block *pstBlock = &(pstBlockPool[u16Id]);
1944 if(pstBlock->u16BlockId == VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED)
1945 {
1946 u16BlockIdNew = u16Id;
1947 _VDEC_EX_Allocator_BlockReset(pstBlock, u16Id);
1948 break;
1949 }
1950 }
1951
1952 return u16BlockIdNew;
1953 }
1954
1955 #if ENABLE_ALLOCATOR_TRACE
_VDEC_EX_Allocator_BlockPrint(VDEC_EX_Allocator_Block * pstBlock)1956 static void _VDEC_EX_Allocator_BlockPrint(VDEC_EX_Allocator_Block *pstBlock)
1957 {
1958 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG] pstBlock(%p):\n", pstBlock);
1959
1960 if(pstBlock == NULL)
1961 {
1962 return;
1963 }
1964
1965 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG] \tId=%d, PrevId=%d, NextId=%d, AllocatorIdExt=%d\n",
1966 pstBlock->u16BlockId,
1967 pstBlock->u16BlockIdPrev,
1968 pstBlock->u16BlockIdNext,
1969 pstBlock->u16AllocatorIdExt);
1970
1971 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG] \tMIU=%d, Property=0x%x, Allocated=%d, Addr=0x%llx, Size=0x%x\n",
1972 pstBlock->stBlockInfo.u8MIU,
1973 pstBlock->stBlockInfo.u8Property,
1974 pstBlock->stBlockInfo.u16Allocated,
1975 pstBlock->stBlockInfo.phyAddr,
1976 pstBlock->stBlockInfo.szSize);
1977
1978 return;
1979 }
1980
_VDEC_EX_Allocator_BlockListPrint(VDEC_EX_Allocator_BlockList * pstBlockList)1981 static void _VDEC_EX_Allocator_BlockListPrint(VDEC_EX_Allocator_BlockList *pstBlockList)
1982 {
1983 VDEC_EX_Allocator_Block *pstBlockCurr;
1984 MS_U16 u16BlockIdCurr;
1985
1986 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG] pstBlockList(%p):\n", pstBlockList);
1987
1988 if(pstBlockList == NULL)
1989 {
1990 return;
1991 }
1992
1993 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG] \tnumblocks=%d, HeadId=%d, TailId=%d\n",
1994 pstBlockList->u16NumBlocks, pstBlockList->u16BlockIdHead, pstBlockList->u16BlockIdTail);
1995
1996 u16BlockIdCurr = pstBlockList->u16BlockIdHead;
1997 while(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == TRUE)
1998 {
1999 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2000
2001 _VDEC_EX_Allocator_BlockPrint(pstBlockCurr);
2002
2003 u16BlockIdCurr = pstBlockCurr->u16BlockIdNext;
2004 }
2005
2006 return;
2007 }
2008
_VDEC_EX_Allocator_Print(VDEC_EX_Allocator * pstAllocator)2009 static void _VDEC_EX_Allocator_Print(VDEC_EX_Allocator *pstAllocator)
2010 {
2011 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG] pstAllocator(%p):\n", pstAllocator);
2012
2013 if(pstAllocator == NULL)
2014 {
2015 return;
2016 }
2017
2018 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG] \tAllocatorId=%d, Addr=0x%llx, Size=0x%x, UnuseSize=0x%x\n",
2019 pstAllocator->u16AllocatorId, pstAllocator->phyStartAddr,
2020 pstAllocator->szTotalSize, pstAllocator->szUnusedSize);
2021
2022 _VDEC_EX_Allocator_BlockListPrint(&(pstAllocator->stBlockList));
2023
2024 return;
2025 }
2026 #endif
2027
2028 // Functions of BlockList
_VDEC_EX_Allocator_BlockListReset(VDEC_EX_Allocator_BlockList * pstBlockList)2029 static void _VDEC_EX_Allocator_BlockListReset(VDEC_EX_Allocator_BlockList *pstBlockList)
2030 {
2031 pstBlockList->u16NumBlocks = 0;
2032 pstBlockList->u16BlockIdHead = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2033 pstBlockList->u16BlockIdTail = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2034 return;
2035 }
2036
_VDEC_EX_Allocator_BlockListAddtoHead(VDEC_EX_Allocator_BlockList * pstBlockList,VDEC_EX_Allocator_BlockInfo * pstBlockInfoRef)2037 static MS_U16 _VDEC_EX_Allocator_BlockListAddtoHead(VDEC_EX_Allocator_BlockList *pstBlockList,
2038 VDEC_EX_Allocator_BlockInfo *pstBlockInfoRef)
2039 {
2040 MS_U16 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2041 VDEC_EX_Allocator_Block *pstBlockNew;
2042
2043 if((pstBlockList == NULL) || (pstBlockInfoRef == NULL))
2044 {
2045 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2046 goto exit;
2047 }
2048
2049 // get new block
2050 u16BlockIdNew = _VDEC_EX_Allocator_BlockGetNewId();
2051 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdNew) == FALSE)
2052 {
2053 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockGetNewId failed\n", __FUNCTION__, __LINE__);
2054 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2055 goto exit;
2056 }
2057
2058 // initial the block info of this new block
2059 pstBlockNew = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdNew);
2060 _VDEC_EX_Allocator_BlockInfoCopy(&(pstBlockNew->stBlockInfo), pstBlockInfoRef);
2061
2062 // add this new block to the head of list
2063 if(pstBlockList->u16NumBlocks == 0)
2064 {
2065 pstBlockNew->u16BlockIdPrev = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2066 pstBlockNew->u16BlockIdNext = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2067
2068 pstBlockList->u16BlockIdHead = u16BlockIdNew;
2069 pstBlockList->u16BlockIdTail = u16BlockIdNew;
2070 }
2071 else
2072 {
2073 VDEC_EX_Allocator_Block *pstBlockTemp;
2074
2075 pstBlockNew->u16BlockIdPrev = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2076 pstBlockNew->u16BlockIdNext = pstBlockList->u16BlockIdHead;
2077
2078 pstBlockTemp = _VDEC_EX_Allocator_BlockGetAddressById(pstBlockList->u16BlockIdHead);
2079 pstBlockTemp->u16BlockIdPrev = u16BlockIdNew;
2080 pstBlockList->u16BlockIdHead = u16BlockIdNew;
2081 }
2082
2083 // update counter
2084 pstBlockList->u16NumBlocks += 1;
2085
2086 exit:
2087 return u16BlockIdNew;
2088 }
2089
_VDEC_EX_Allocator_BlockListAddtoTail(VDEC_EX_Allocator_BlockList * pstBlockList,VDEC_EX_Allocator_BlockInfo * pstBlockInfoRef)2090 static MS_U16 _VDEC_EX_Allocator_BlockListAddtoTail(VDEC_EX_Allocator_BlockList *pstBlockList,
2091 VDEC_EX_Allocator_BlockInfo *pstBlockInfoRef)
2092 {
2093 MS_U16 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2094 VDEC_EX_Allocator_Block *pstBlockNew;
2095
2096 if((pstBlockList == NULL) || (pstBlockInfoRef == NULL))
2097 {
2098 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2099 goto exit;
2100 }
2101
2102 // get new block
2103 u16BlockIdNew = _VDEC_EX_Allocator_BlockGetNewId();
2104 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdNew) == FALSE)
2105 {
2106 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockGetNewId failed\n", __FUNCTION__, __LINE__);
2107 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2108 goto exit;
2109 }
2110
2111 // initial the block info of this new block
2112 pstBlockNew = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdNew);
2113 _VDEC_EX_Allocator_BlockInfoCopy(&(pstBlockNew->stBlockInfo), pstBlockInfoRef);
2114
2115 // add this new block to the head of list
2116 if(pstBlockList->u16NumBlocks == 0)
2117 {
2118 pstBlockNew->u16BlockIdPrev = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2119 pstBlockNew->u16BlockIdNext = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2120
2121 pstBlockList->u16BlockIdHead = u16BlockIdNew;
2122 pstBlockList->u16BlockIdTail = u16BlockIdNew;
2123 }
2124 else
2125 {
2126 VDEC_EX_Allocator_Block *pstBlockTemp;
2127
2128 pstBlockNew->u16BlockIdPrev = pstBlockList->u16BlockIdTail;
2129 pstBlockNew->u16BlockIdNext = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2130
2131 pstBlockTemp = _VDEC_EX_Allocator_BlockGetAddressById(pstBlockList->u16BlockIdTail);
2132 pstBlockTemp->u16BlockIdNext = u16BlockIdNew;
2133 pstBlockList->u16BlockIdTail = u16BlockIdNew;
2134 }
2135
2136 // update counter
2137 pstBlockList->u16NumBlocks += 1;
2138
2139 exit:
2140 return u16BlockIdNew;
2141 }
2142
_VDEC_EX_Allocator_BlockListInsertBefore(VDEC_EX_Allocator_BlockList * pstBlockList,VDEC_EX_Allocator_BlockInfo * pstBlockInfoRef,MS_U16 u16BlockIdCurr)2143 static MS_U16 _VDEC_EX_Allocator_BlockListInsertBefore(VDEC_EX_Allocator_BlockList *pstBlockList,
2144 VDEC_EX_Allocator_BlockInfo *pstBlockInfoRef, MS_U16 u16BlockIdCurr)
2145 {
2146 MS_U16 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2147 VDEC_EX_Allocator_Block *pstBlockNew = NULL;
2148 VDEC_EX_Allocator_Block *pstBlockCurr = NULL;
2149 VDEC_EX_Allocator_Block *pstBlockUpper = NULL;
2150
2151 if(pstBlockList == NULL || pstBlockInfoRef == NULL ||
2152 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == FALSE)
2153 {
2154 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2155 goto exit;
2156 }
2157
2158 if(pstBlockList->u16NumBlocks <= 1 ||
2159 pstBlockList->u16BlockIdHead == u16BlockIdCurr)
2160 {
2161 u16BlockIdNew = _VDEC_EX_Allocator_BlockListAddtoHead(pstBlockList, pstBlockInfoRef);
2162 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdNew) == FALSE)
2163 {
2164 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockListAddtoHead failed\n", __FUNCTION__, __LINE__);
2165 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2166 goto exit;
2167 }
2168 }
2169 else
2170 {
2171 // get new block
2172 u16BlockIdNew = _VDEC_EX_Allocator_BlockGetNewId();
2173 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdNew) == FALSE)
2174 {
2175 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockGetNewId failed\n", __FUNCTION__, __LINE__);
2176 u16BlockIdNew = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2177 goto exit;
2178 }
2179
2180 pstBlockNew = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdNew);
2181 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2182 pstBlockUpper = _VDEC_EX_Allocator_BlockGetAddressById(pstBlockCurr->u16BlockIdPrev);
2183
2184 // initial new block header by pRefBlockInfo
2185 _VDEC_EX_Allocator_BlockInfoCopy(&(pstBlockNew->stBlockInfo), pstBlockInfoRef);
2186
2187 // add to list, before current block
2188
2189 pstBlockUpper->u16BlockIdNext = u16BlockIdNew;
2190 pstBlockNew->u16BlockIdPrev = pstBlockCurr->u16BlockIdPrev;
2191
2192 pstBlockNew->u16BlockIdNext = u16BlockIdCurr;
2193 pstBlockCurr->u16BlockIdPrev = u16BlockIdNew;
2194
2195 // update counter
2196 pstBlockList->u16NumBlocks += 1;
2197 }
2198
2199 exit:
2200 return u16BlockIdNew;
2201 }
2202
_VDEC_EX_Allocator_BlockListRemove(VDEC_EX_Allocator_BlockList * pstBlockList,MS_U16 u16BlockIdCurr)2203 static VDEC_EX_Result _VDEC_EX_Allocator_BlockListRemove(VDEC_EX_Allocator_BlockList *pstBlockList,
2204 MS_U16 u16BlockIdCurr)
2205 {
2206 VDEC_EX_Result eRet = E_VDEC_EX_OK;
2207 VDEC_EX_Allocator_Block *pstBlockCurr = NULL;
2208 VDEC_EX_Allocator_Block *pstBlockPrev = NULL;
2209 VDEC_EX_Allocator_Block *pstBlockNext = NULL;
2210
2211 if((pstBlockList == NULL) ||
2212 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == FALSE)
2213 {
2214 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2215 eRet = E_VDEC_EX_RET_INVALID_PARAM;
2216 goto exit;
2217 }
2218
2219 // update counter
2220 if(pstBlockList->u16NumBlocks == 0)
2221 {
2222 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] u16NumBlocks = 0\n", __FUNCTION__, __LINE__);
2223 eRet = E_VDEC_EX_FAIL;
2224 goto exit;
2225 }
2226 pstBlockList->u16NumBlocks -= 1;
2227
2228 // remove current block from list
2229 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2230 pstBlockCurr->u16BlockId = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2231
2232 // re-link BlockPrev and BlockNext
2233 if(_VDEC_EX_Allocator_BlockIsValidId(pstBlockCurr->u16BlockIdPrev) == TRUE)
2234 {
2235 pstBlockPrev = _VDEC_EX_Allocator_BlockGetAddressById(pstBlockCurr->u16BlockIdPrev);
2236 }
2237 if(_VDEC_EX_Allocator_BlockIsValidId(pstBlockCurr->u16BlockIdNext) == TRUE)
2238 {
2239 pstBlockNext = _VDEC_EX_Allocator_BlockGetAddressById(pstBlockCurr->u16BlockIdNext);
2240 }
2241
2242 if(pstBlockPrev == NULL && pstBlockNext == NULL)
2243 {
2244 // currrnt block is the last block
2245 pstBlockList->u16BlockIdHead = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2246 pstBlockList->u16BlockIdTail = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2247 }
2248 else if(pstBlockPrev == NULL && pstBlockNext != NULL)
2249 {
2250 // current block is head block
2251 pstBlockNext->u16BlockIdPrev = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2252 pstBlockList->u16BlockIdHead = pstBlockCurr->u16BlockIdNext;
2253 }
2254 else if(pstBlockPrev != NULL && pstBlockNext == NULL)
2255 {
2256 // current block is tail block
2257 pstBlockPrev->u16BlockIdNext = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2258 pstBlockList->u16BlockIdTail = pstBlockCurr->u16BlockIdPrev;
2259 }
2260 else
2261 {
2262 // current block is located between 2 blocks
2263 pstBlockPrev->u16BlockIdNext = pstBlockCurr->u16BlockIdNext;
2264 pstBlockNext->u16BlockIdPrev = pstBlockCurr->u16BlockIdPrev;
2265 }
2266
2267 exit:
2268 return eRet;
2269 }
2270
2271 // Functions of Allocator
_VDEC_EX_Allocator_Reset(VDEC_EX_Allocator * pstAllocator,MS_U16 u16Id)2272 static void _VDEC_EX_Allocator_Reset(VDEC_EX_Allocator *pstAllocator, MS_U16 u16Id)
2273 {
2274 pstAllocator->u16AllocatorId = u16Id;
2275 pstAllocator->phyStartAddr = 0;
2276 pstAllocator->szTotalSize = 0;
2277 pstAllocator->szUnusedSize = 0;
2278 _VDEC_EX_Allocator_BlockListReset(&(pstAllocator->stBlockList));
2279 return;
2280 }
2281
_VDEC_EX_Allocator_IsValidId(MS_U16 u16AllocatorId)2282 static inline MS_BOOL _VDEC_EX_Allocator_IsValidId(MS_U16 u16AllocatorId)
2283 {
2284 return (u16AllocatorId < VDEC_EX_ALLOCAOTR_MAX_NUM_ALLOCATOR) ? TRUE : FALSE;
2285 }
2286
_VDEC_EX_Allocator_CountUsedAllocators(VDEC_EX_NDecAllocator * pstNDecAllocator)2287 static MS_U16 _VDEC_EX_Allocator_CountUsedAllocators(VDEC_EX_NDecAllocator *pstNDecAllocator)
2288 {
2289 MS_U16 u16Cnt = 0;
2290 int i;
2291 for(i = 0; i < VDEC_EX_ALLOCAOTR_MAX_NUM_ALLOCATOR; i++)
2292 {
2293 MS_U16 u16AllocatorId = pstNDecAllocator->stAllocatorPool[i].u16AllocatorId;
2294 if(_VDEC_EX_Allocator_IsValidId(u16AllocatorId) == TRUE)
2295 {
2296 u16Cnt++;
2297 }
2298 }
2299 return u16Cnt;
2300 }
2301
_VDEC_EX_Allocator_CountUsedBlocks(VDEC_EX_NDecAllocator * pstNDecAllocator)2302 static MS_U16 _VDEC_EX_Allocator_CountUsedBlocks(VDEC_EX_NDecAllocator *pstNDecAllocator)
2303 {
2304 MS_U16 u16Cnt = 0;
2305 int i;
2306 for(i = 0; i < VDEC_EX_ALLOCAOTR_MAX_NUM_BLOCK; i++)
2307 {
2308 MS_U16 u16BlockId = pstNDecAllocator->stBlockPool[i].u16BlockId;
2309 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockId) == TRUE)
2310 {
2311 u16Cnt++;
2312 }
2313 }
2314 return u16Cnt;
2315 }
2316
_VDEC_EX_Allocator_GetAddressById(MS_U16 u16ID)2317 static VDEC_EX_Allocator *_VDEC_EX_Allocator_GetAddressById(MS_U16 u16ID)
2318 {
2319 VDEC_EX_Allocator *pstAllocatorPool =
2320 &(pVdecExContext->stNDecAllocator.stAllocatorPool[0]);
2321 VDEC_EX_Allocator *pstAllocator = NULL;
2322
2323 if(_VDEC_EX_Allocator_IsValidId(u16ID) == FALSE)
2324 {
2325 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid u16ID: %d\n", __FUNCTION__, __LINE__, u16ID);
2326 goto exit;
2327 }
2328
2329 pstAllocator = &(pstAllocatorPool[u16ID]);
2330
2331 exit:
2332 return pstAllocator;
2333 }
2334
_VDEC_EX_Allocator_GetNewId(void)2335 static MS_U16 _VDEC_EX_Allocator_GetNewId(void)
2336 {
2337 VDEC_EX_Allocator *pstAllocatorPool =
2338 &(pVdecExContext->stNDecAllocator.stAllocatorPool[0]);
2339 MS_U16 u16NewAllocatorId = VDEC_EX_ALLOCAOTR_ID_UNUSED;
2340 MS_U16 u16Id;
2341
2342 for(u16Id = 0; u16Id < VDEC_EX_ALLOCAOTR_MAX_NUM_ALLOCATOR; u16Id++)
2343 {
2344 VDEC_EX_Allocator *pstAllocator = &(pstAllocatorPool[u16Id]);
2345 if(pstAllocator->u16AllocatorId == VDEC_EX_ALLOCAOTR_ID_UNUSED)
2346 {
2347 u16NewAllocatorId = u16Id;
2348 _VDEC_EX_Allocator_Reset(pstAllocator, u16Id);
2349 break;
2350 }
2351 }
2352
2353 return u16NewAllocatorId;
2354 }
2355
_VDEC_EX_Allocator_Init(VDEC_EX_Allocator * pstAllocator,VDEC_EX_Allocator_BlockInfo * pstBlockInfo)2356 static VDEC_EX_Result _VDEC_EX_Allocator_Init(VDEC_EX_Allocator *pstAllocator, VDEC_EX_Allocator_BlockInfo *pstBlockInfo)
2357 {
2358 VDEC_EX_Result eRet = E_VDEC_EX_OK;
2359 MS_U16 u16BlockId;
2360
2361 if(pstAllocator == NULL)
2362 {
2363 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2364 eRet = E_VDEC_EX_RET_INVALID_PARAM;
2365 goto exit;
2366 }
2367
2368 pstAllocator->phyStartAddr = pstBlockInfo->phyAddr;
2369 pstAllocator->szTotalSize = pstBlockInfo->szSize;
2370 pstAllocator->szUnusedSize = pstBlockInfo->szSize;
2371
2372 u16BlockId = _VDEC_EX_Allocator_BlockListAddtoTail(&(pstAllocator->stBlockList), pstBlockInfo);
2373 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockId) == FALSE)
2374 {
2375 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockListAddtoTail failed\n", __FUNCTION__, __LINE__);
2376 eRet = E_VDEC_EX_FAIL;
2377 goto exit;
2378 }
2379
2380 exit:
2381 return eRet;
2382 }
2383
_VDEC_EX_Allocator_CheckMergePrevious(VDEC_EX_Allocator * pstAllocator,MS_U16 u16BlockIdCurr)2384 static MS_U16 _VDEC_EX_Allocator_CheckMergePrevious(VDEC_EX_Allocator *pstAllocator,
2385 MS_U16 u16BlockIdCurr)
2386 {
2387 MS_U16 u16BlockIdMerge = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2388 MS_U16 u16BlockIdPrev = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2389 VDEC_EX_Allocator_Block *pstBlockPrev = NULL;
2390 VDEC_EX_Allocator_Block *pstBlockCurr = NULL;
2391 MS_SIZE szMergeSize;
2392
2393 if(pstAllocator == NULL ||
2394 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == FALSE)
2395 {
2396 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2397 goto exit;
2398 }
2399
2400 u16BlockIdMerge = u16BlockIdCurr;
2401 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2402 u16BlockIdPrev = pstBlockCurr->u16BlockIdPrev;
2403
2404 if(pstBlockCurr->stBlockInfo.u16Allocated == 1 ||
2405 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdPrev) == FALSE)
2406 {
2407 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't merge\n", __FUNCTION__, __LINE__);
2408 goto exit;
2409 }
2410
2411 pstBlockPrev = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdPrev);
2412
2413 if(pstBlockPrev->stBlockInfo.u8MIU != pstBlockCurr->stBlockInfo.u8MIU ||
2414 pstBlockPrev->stBlockInfo.u8Property != pstBlockCurr->stBlockInfo.u8Property ||
2415 pstBlockPrev->stBlockInfo.u16Allocated == 1 ||
2416 pstBlockPrev->stBlockInfo.szSize == 0)
2417 {
2418 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't merge\n", __FUNCTION__, __LINE__);
2419 goto exit;
2420 }
2421
2422 // start merge
2423 szMergeSize = pstBlockCurr->stBlockInfo.szSize;
2424
2425 if(E_VDEC_EX_OK != _VDEC_EX_Allocator_BlockListRemove(&(pstAllocator->stBlockList), u16BlockIdCurr))
2426 {
2427 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockListRemove failed\n", __FUNCTION__, __LINE__);
2428 goto exit;
2429 }
2430
2431 pstBlockPrev->stBlockInfo.szSize += szMergeSize;
2432 u16BlockIdMerge = u16BlockIdPrev;
2433
2434 exit:
2435 return u16BlockIdMerge;
2436 }
2437
_VDEC_EX_Allocator_CheckMergeNext(VDEC_EX_Allocator * pstAllocator,MS_U16 u16BlockIdCurr)2438 static MS_U16 _VDEC_EX_Allocator_CheckMergeNext(VDEC_EX_Allocator *pstAllocator,
2439 MS_U16 u16BlockIdCurr)
2440 {
2441 MS_U16 u16BlockIdMerge = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2442 MS_U16 u16BlockIdNext = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2443 VDEC_EX_Allocator_Block *pstBlockCurr = NULL;
2444 VDEC_EX_Allocator_Block *pstBlockNext = NULL;
2445
2446 if(pstAllocator == NULL ||
2447 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == FALSE)
2448 {
2449 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2450 goto exit;
2451 }
2452
2453 u16BlockIdMerge = u16BlockIdCurr;
2454 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2455 u16BlockIdNext = pstBlockCurr->u16BlockIdNext;
2456
2457 if(pstBlockCurr->stBlockInfo.u16Allocated == 1 ||
2458 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdNext) == FALSE)
2459 {
2460 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't merge\n", __FUNCTION__, __LINE__);
2461 goto exit;
2462 }
2463
2464 pstBlockNext = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdNext);
2465
2466 if(pstBlockNext->stBlockInfo.u8MIU != pstBlockCurr->stBlockInfo.u8MIU ||
2467 pstBlockNext->stBlockInfo.u8Property != pstBlockCurr->stBlockInfo.u8Property ||
2468 pstBlockNext->stBlockInfo.u16Allocated == 1 ||
2469 pstBlockNext->stBlockInfo.szSize == 0)
2470 {
2471 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't merge\n", __FUNCTION__, __LINE__);
2472 goto exit;
2473 }
2474
2475 // start merge
2476 u16BlockIdMerge = _VDEC_EX_Allocator_CheckMergePrevious(pstAllocator, u16BlockIdNext);
2477
2478 exit:
2479 return u16BlockIdMerge;
2480 }
2481
2482 #define SPLIT_FLAG_BITS_DEFAULT 0x0
2483 #define SPLIT_FLAG_BITS_MERGE_UPPER VDEC_EX_BIT(0)
2484 #define SPLIT_FLAG_BITS_MERGE_BELOW VDEC_EX_BIT(1)
2485 #define SPLIT_FLAG_BITS_RETURN_BELOW VDEC_EX_BIT(2)
_VDEC_EX_Allocator_BlockSplitBySize(VDEC_EX_Allocator * pstAllocator,MS_U16 u16BlockIdCurr,MS_SIZE szUpperBlockSize,MS_U32 u32Flag)2486 MS_U16 _VDEC_EX_Allocator_BlockSplitBySize(VDEC_EX_Allocator *pstAllocator,
2487 MS_U16 u16BlockIdCurr, MS_SIZE szUpperBlockSize, MS_U32 u32Flag)
2488 {
2489 MS_U16 u16BlockIdReturn = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2490 MS_U16 u16BlockIdUpper = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2491 MS_U16 u16BlockIdBelow = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2492 VDEC_EX_Allocator_Block *pstBlockCurr = NULL;
2493 VDEC_EX_Allocator_BlockInfo stBlockInfoRef;
2494
2495 if(pstAllocator == NULL ||
2496 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == FALSE)
2497 {
2498 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2499 goto exit;
2500 }
2501
2502 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2503 if(szUpperBlockSize > pstBlockCurr->stBlockInfo.szSize)
2504 {
2505 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] No enough size to split\n", __FUNCTION__, __LINE__);
2506 goto exit;
2507 }
2508
2509 if(szUpperBlockSize == 0 ||
2510 szUpperBlockSize == pstBlockCurr->stBlockInfo.szSize)
2511 {
2512 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't split\n", __FUNCTION__, __LINE__);
2513 u16BlockIdReturn = u16BlockIdCurr;
2514 goto exit;
2515 }
2516 else
2517 {
2518 // insert new block before pstBlockCurr
2519 stBlockInfoRef.u8MIU = pstBlockCurr->stBlockInfo.u8MIU;
2520 stBlockInfoRef.u8Property = pstBlockCurr->stBlockInfo.u8Property;
2521 stBlockInfoRef.u16Allocated = pstBlockCurr->stBlockInfo.u16Allocated;
2522 stBlockInfoRef.phyAddr = pstBlockCurr->stBlockInfo.phyAddr;
2523 stBlockInfoRef.szSize = szUpperBlockSize;
2524 u16BlockIdUpper = _VDEC_EX_Allocator_BlockListInsertBefore(&(pstAllocator->stBlockList), &stBlockInfoRef, u16BlockIdCurr);
2525 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdUpper) == FALSE)
2526 {
2527 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockListInsertBefore failed\n", __FUNCTION__, __LINE__);
2528 goto exit;
2529 }
2530
2531 // update info of pstBlockCurr
2532 pstBlockCurr->stBlockInfo.phyAddr += szUpperBlockSize;
2533 pstBlockCurr->stBlockInfo.szSize -= szUpperBlockSize;
2534
2535 u16BlockIdBelow = u16BlockIdCurr;
2536
2537 // check merge
2538 if(u32Flag & SPLIT_FLAG_BITS_MERGE_UPPER)
2539 {
2540 u16BlockIdUpper = _VDEC_EX_Allocator_CheckMergePrevious(pstAllocator, u16BlockIdUpper);
2541 }
2542 if(u32Flag & SPLIT_FLAG_BITS_MERGE_BELOW)
2543 {
2544 u16BlockIdBelow = _VDEC_EX_Allocator_CheckMergeNext(pstAllocator, u16BlockIdBelow);
2545 }
2546 }
2547
2548 if(u32Flag & SPLIT_FLAG_BITS_RETURN_BELOW)
2549 {
2550 u16BlockIdReturn = u16BlockIdBelow;
2551 }
2552 else
2553 {
2554 // default will run here
2555 u16BlockIdReturn = u16BlockIdUpper;
2556 }
2557
2558 exit:
2559 return u16BlockIdReturn;
2560 }
2561
_VDEC_EX_Allocator_BlockCheckMatch(VDEC_EX_Allocator * pstAllocator,VDEC_EX_Allocator_Criterion * pstCriterion,MS_U16 u16BlockIdCurr)2562 static MS_U16 _VDEC_EX_Allocator_BlockCheckMatch(VDEC_EX_Allocator *pstAllocator,
2563 VDEC_EX_Allocator_Criterion *pstCriterion, MS_U16 u16BlockIdCurr)
2564 {
2565 VDEC_EX_Allocator_Block *pstBlockCurr = NULL;
2566 MS_U16 u16BlockIdMatch = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2567 MS_SIZE szBlockSize;
2568 MS_PHY phyBlockStartAddr, phyBlockEndAddr;
2569 MS_SIZE szCheckSize;
2570 MS_PHY phyCheckStartAddr, phyCheckEndAddr;
2571 MS_PHY phyAlignShift = 0;
2572
2573 if(pstAllocator == NULL || pstCriterion == NULL ||
2574 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == FALSE)
2575 {
2576 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2577 goto exit;
2578 }
2579
2580 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2581 if((pstCriterion->szSize == 0) ||
2582 (pstBlockCurr->stBlockInfo.szSize == 0) ||
2583 ((pstBlockCurr->stBlockInfo.u16Allocated == 1) &&
2584 ((pstBlockCurr->stBlockInfo.u8Property & VDEC_EX_ALLOCAOTR_PROPERTY_CAN_OVERLAP) == 0)))
2585 {
2586 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Pre condition doesn't match\n", __FUNCTION__, __LINE__);
2587 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tpstCriterion->szSize = 0x%x\n", pstCriterion->szSize);
2588 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tpstBlockCurr->stBlockInfo.szSize = 0x%x\n", pstBlockCurr->stBlockInfo.szSize);
2589 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tpstBlockCurr->stBlockInfo.u16Allocated=0x%x\n", pstBlockCurr->stBlockInfo.u16Allocated);
2590 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tpstBlockCurr->stBlockInfo.u8Property = 0x%x\n", pstBlockCurr->stBlockInfo.u8Property);
2591 goto exit;
2592 }
2593
2594 // boundary and size condition
2595 szCheckSize = pstCriterion->szSize;
2596 phyCheckStartAddr = pstCriterion->phyAddr;
2597 phyCheckEndAddr = phyCheckStartAddr + szCheckSize;
2598
2599 szBlockSize = pstBlockCurr->stBlockInfo.szSize;
2600 phyBlockStartAddr = pstBlockCurr->stBlockInfo.phyAddr;
2601 phyBlockEndAddr = phyBlockStartAddr + szBlockSize;
2602
2603 #if 1
2604 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] CSize=0x%x, CStart=0x%llx, CEnd=0x%llx\n", __FUNCTION__, __LINE__,
2605 szCheckSize, phyCheckStartAddr, phyCheckEndAddr);
2606 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] BSize=0x%x, BStart=0x%llx, BEnd=0x%llx\n", __FUNCTION__, __LINE__,
2607 szBlockSize, phyBlockStartAddr, phyBlockEndAddr);
2608 #endif
2609
2610 // check alignment
2611 if(pstCriterion->u32Alignment != 0)
2612 {
2613 phyAlignShift = phyBlockStartAddr & ((MS_PHY)(pstCriterion->u32Alignment - 1));
2614 if(phyAlignShift != 0)
2615 {
2616 phyAlignShift = pstCriterion->u32Alignment - phyAlignShift;
2617 }
2618
2619 if(phyAlignShift >= szBlockSize)
2620 {
2621 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Alignment shift larger than current block size\n", __FUNCTION__, __LINE__);
2622 goto exit;
2623 }
2624
2625 phyBlockStartAddr += phyAlignShift;
2626 szBlockSize -= phyAlignShift;
2627 }
2628
2629 // start checking
2630
2631 if(pstCriterion->u32CheckItem & VDEC_EX_ALLOCATOR_CRITERION_CHECK_SIZE)
2632 {
2633 if(pstCriterion->u32CheckItem & VDEC_EX_ALLOCATOR_CRITERION_CHECK_ADDRESS)
2634 {
2635 if((phyCheckStartAddr >= phyBlockStartAddr) &&
2636 (phyCheckEndAddr <= phyBlockEndAddr ))
2637 {
2638 u16BlockIdMatch = u16BlockIdCurr;
2639 }
2640 }
2641 else
2642 {
2643 if(szCheckSize <= szBlockSize)
2644 {
2645 u16BlockIdMatch = u16BlockIdCurr;
2646 }
2647 }
2648 }
2649
2650 // if aligment
2651 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMatch) == TRUE && phyAlignShift != 0)
2652 {
2653 u16BlockIdMatch = _VDEC_EX_Allocator_BlockSplitBySize(pstAllocator, u16BlockIdMatch,
2654 phyAlignShift, SPLIT_FLAG_BITS_RETURN_BELOW);
2655 }
2656
2657 exit:
2658 return u16BlockIdMatch;
2659 }
2660
_VDEC_EX_Allocator_BlockListSearch(VDEC_EX_Allocator * pstAllocator,VDEC_EX_Allocator_Criterion * pstCriterion)2661 static MS_U16 _VDEC_EX_Allocator_BlockListSearch(VDEC_EX_Allocator *pstAllocator,
2662 VDEC_EX_Allocator_Criterion *pstCriterion)
2663 {
2664 VDEC_EX_Allocator_BlockList *pstBlockList = NULL;
2665 VDEC_EX_Allocator_Block *pstBlockCurr = NULL;
2666 MS_U16 u16BlockIdCurr = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2667 MS_U16 u16BlockIdMatch = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2668
2669 if(pstAllocator == NULL || pstCriterion == NULL)
2670 {
2671 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2672 goto exit;
2673 }
2674
2675 pstBlockList = &(pstAllocator->stBlockList);
2676 u16BlockIdCurr = pstBlockList->u16BlockIdHead;
2677
2678 while(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdCurr) == TRUE)
2679 {
2680 u16BlockIdMatch = _VDEC_EX_Allocator_BlockCheckMatch(pstAllocator, pstCriterion, u16BlockIdCurr);
2681 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMatch) == TRUE)
2682 {
2683 break;
2684 }
2685
2686 pstBlockCurr = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdCurr);
2687 u16BlockIdCurr = pstBlockCurr->u16BlockIdNext;
2688 }
2689
2690 exit:
2691 return u16BlockIdMatch;
2692 }
2693
_VDEC_EX_Allocator_Assign(VDEC_EX_Allocator * pstAllocator,VDEC_EX_Allocator_Criterion * pstCriterion,MS_U16 u16BlockIdMatch)2694 static MS_U16 _VDEC_EX_Allocator_Assign(VDEC_EX_Allocator *pstAllocator,
2695 VDEC_EX_Allocator_Criterion *pstCriterion, MS_U16 u16BlockIdMatch)
2696 {
2697 MS_U16 u16BlockIdAssign = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2698 VDEC_EX_Allocator_Block *pstBlockMatch = NULL;
2699 MS_SIZE szAssignSize;
2700 MS_PHY phyAssignStartAddr, phyAssignEndAddr;
2701
2702 if(pstAllocator == NULL || pstCriterion == NULL ||
2703 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMatch) == FALSE)
2704 {
2705 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2706 goto exit;
2707 }
2708 pstBlockMatch = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMatch);
2709
2710 szAssignSize = pstCriterion->szSize;
2711 phyAssignStartAddr = pstCriterion->phyAddr;
2712 if(phyAssignStartAddr == 0)
2713 {
2714 phyAssignStartAddr = pstBlockMatch->stBlockInfo.phyAddr;
2715 }
2716
2717 if(szAssignSize == 0 ||
2718 pstBlockMatch->stBlockInfo.u16Allocated == 1 ||
2719 pstBlockMatch->stBlockInfo.szSize == 0)
2720 {
2721 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't assign\n", __FUNCTION__, __LINE__);
2722 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] szAssignSize=0x%x, u16Allocated=%d, szSize=0x%x\n", __FUNCTION__, __LINE__,
2723 szAssignSize, pstBlockMatch->stBlockInfo.u16Allocated, pstBlockMatch->stBlockInfo.szSize);
2724 goto exit;
2725 }
2726
2727 phyAssignEndAddr = phyAssignStartAddr + szAssignSize;
2728 if((phyAssignStartAddr < pstBlockMatch->stBlockInfo.phyAddr) ||
2729 (phyAssignEndAddr > (pstBlockMatch->stBlockInfo.phyAddr + pstBlockMatch->stBlockInfo.szSize)))
2730 {
2731 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't assign\n", __FUNCTION__, __LINE__);
2732 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] phyAssignStartAddr=0x%llx, phyAssignEndAddr=0x%llx\n", __FUNCTION__, __LINE__,
2733 phyAssignStartAddr, phyAssignEndAddr);
2734 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] stBlockInfo.phyAddr=0x%llx, stBlockInfo.szSize=0x%x\n", __FUNCTION__, __LINE__,
2735 pstBlockMatch->stBlockInfo.phyAddr, pstBlockMatch->stBlockInfo.szSize);
2736 goto exit;
2737 }
2738
2739 if(phyAssignStartAddr > pstBlockMatch->stBlockInfo.phyAddr)
2740 {
2741 MS_PHY phyAddrDiff = phyAssignStartAddr - pstBlockMatch->stBlockInfo.phyAddr;
2742 if(sizeof(MS_PHY) == 8 && (phyAddrDiff >> 32))
2743 {
2744 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Overflow\n", __FUNCTION__, __LINE__);
2745 goto exit;
2746 }
2747
2748 u16BlockIdMatch = _VDEC_EX_Allocator_BlockSplitBySize(pstAllocator, u16BlockIdMatch,
2749 (MS_U32)phyAddrDiff, SPLIT_FLAG_BITS_MERGE_UPPER | SPLIT_FLAG_BITS_RETURN_BELOW);
2750 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMatch) == FALSE)
2751 {
2752 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockSplitBySize failed\n", __FUNCTION__, __LINE__);
2753 goto exit;
2754 }
2755 pstBlockMatch = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMatch);
2756 }
2757
2758 if(szAssignSize != pstBlockMatch->stBlockInfo.szSize)
2759 {
2760 u16BlockIdMatch = _VDEC_EX_Allocator_BlockSplitBySize(pstAllocator, u16BlockIdMatch,
2761 szAssignSize, SPLIT_FLAG_BITS_DEFAULT);
2762 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMatch) == FALSE)
2763 {
2764 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockSplitBySize failed\n", __FUNCTION__, __LINE__);
2765 goto exit;
2766 }
2767 pstBlockMatch = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMatch);
2768 }
2769
2770 // update Allocator info
2771 pstBlockMatch->stBlockInfo.u16Allocated = 1;
2772 pstAllocator->szUnusedSize -= pstBlockMatch->stBlockInfo.szSize;
2773 u16BlockIdAssign = u16BlockIdMatch;
2774
2775 exit:
2776 return u16BlockIdAssign;
2777 }
2778
_VDEC_EX_Allocator_MallocStart(VDEC_EX_Allocator * pstAllocator,VDEC_EX_Allocator_Criterion * pstCriterion)2779 static MS_U16 _VDEC_EX_Allocator_MallocStart(VDEC_EX_Allocator *pstAllocator,
2780 VDEC_EX_Allocator_Criterion *pstCriterion)
2781 {
2782 VDEC_EX_Allocator_Block *pstBlockMatch = NULL;
2783 MS_U16 u16BlockIdMatch = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2784
2785 if(pstAllocator == NULL || pstCriterion == NULL)
2786 {
2787 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2788 goto exit;
2789 }
2790
2791 u16BlockIdMatch = _VDEC_EX_Allocator_BlockListSearch(pstAllocator, pstCriterion);
2792 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMatch) == FALSE)
2793 {
2794 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] BlockListSearch find none\n", __FUNCTION__, __LINE__);
2795 u16BlockIdMatch = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2796 goto exit;
2797 }
2798
2799 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Find u16BlockIdMatch=%d\n", __FUNCTION__, __LINE__, u16BlockIdMatch);
2800
2801 pstBlockMatch = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMatch);
2802
2803 if((pstBlockMatch->stBlockInfo.u8Property & VDEC_EX_ALLOCAOTR_PROPERTY_CAN_OVERLAP) == 0)
2804 {
2805 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Start Assign\n", __FUNCTION__, __LINE__);
2806
2807 u16BlockIdMatch = _VDEC_EX_Allocator_Assign(pstAllocator, pstCriterion, u16BlockIdMatch);
2808 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMatch) == FALSE)
2809 {
2810 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Allocator_Assign failed\n", __FUNCTION__, __LINE__);
2811 u16BlockIdMatch = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2812 goto exit;
2813 }
2814 }
2815
2816 exit:
2817 return u16BlockIdMatch;
2818 }
2819
_VDEC_EX_Allocator_Free(VDEC_EX_Allocator * pstAllocator,MS_U16 u16BlockIdFree)2820 static MS_U16 _VDEC_EX_Allocator_Free(VDEC_EX_Allocator *pstAllocator, MS_U16 u16BlockIdFree)
2821 {
2822 MS_U16 u16BlockIdMerge = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
2823 VDEC_EX_Allocator_Block *pstBlockFree = NULL;
2824
2825 if(pstAllocator == NULL ||
2826 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdFree) == FALSE)
2827 {
2828 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
2829 goto exit;
2830 }
2831
2832 pstBlockFree = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdFree);
2833
2834 if(pstBlockFree->stBlockInfo.u16Allocated == 0)
2835 {
2836 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Doesn't free\n", __FUNCTION__, __LINE__);
2837 u16BlockIdMerge = u16BlockIdFree;
2838 goto exit;
2839 }
2840
2841 pstAllocator->szUnusedSize += pstBlockFree->stBlockInfo.szSize;
2842
2843 pstBlockFree->stBlockInfo.u16Allocated = 0;
2844
2845 // check merge upper block
2846 u16BlockIdMerge = _VDEC_EX_Allocator_CheckMergePrevious(pstAllocator, u16BlockIdFree);
2847 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMerge) == TRUE)
2848 {
2849 u16BlockIdFree = u16BlockIdMerge;
2850 }
2851
2852 // check merge lower block
2853 u16BlockIdMerge = _VDEC_EX_Allocator_CheckMergeNext(pstAllocator, u16BlockIdFree);
2854 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMerge) == TRUE)
2855 {
2856 u16BlockIdFree = u16BlockIdMerge;
2857 }
2858
2859 exit:
2860 return u16BlockIdMerge;
2861 }
2862
2863 // N Decode Allocator Functions
_VDEC_EX_NDecAllocator_Init(VDEC_EX_NDecAllocator * pstNDecAllocator)2864 static VDEC_EX_Result _VDEC_EX_NDecAllocator_Init(VDEC_EX_NDecAllocator *pstNDecAllocator)
2865 {
2866 VDEC_EX_Result eRet = E_VDEC_EX_OK;
2867 MS_U16 i;
2868
2869 if(pstNDecAllocator->bInit == FALSE)
2870 {
2871 // only initial NDec Allocator onece
2872 pstNDecAllocator->bInit = TRUE;
2873
2874 // initial Allocator Record for each decoding task
2875 for(i = 0; i < VDEC_MAX_SUPPORT_STREAM_NUM; i++)
2876 {
2877 VDEC_EX_Allocator_Record *pstRecord = &(pstNDecAllocator->stAllocatorRecord[i]);
2878 pstRecord->u16BlockIdFB1Main = VDEC_EX_ALLOCAOTR_ID_UNUSED;
2879 pstRecord->u16BlockIdFB1Sub = VDEC_EX_ALLOCAOTR_ID_UNUSED;
2880 pstRecord->u16BlockIdFB2Main = VDEC_EX_ALLOCAOTR_ID_UNUSED;
2881 pstRecord->u16BlockIdFB2Sub = VDEC_EX_ALLOCAOTR_ID_UNUSED;
2882 pstRecord->u16BlockIdBS1Main = VDEC_EX_ALLOCAOTR_ID_UNUSED;
2883 pstRecord->u16BlockIdBS1Sub = VDEC_EX_ALLOCAOTR_ID_UNUSED;
2884 #ifdef CMA_DRV_DIRECT_INIT
2885 pstNDecAllocator->szCMAAllocLength[E_VDEC_EX_CMA_POOL_BUFFER_FB1][i] = 0;
2886 pstNDecAllocator->szCMAAllocLength[E_VDEC_EX_CMA_POOL_BUFFER_FB2][i] = 0;
2887 #endif
2888 }
2889
2890 // initial Block Pool
2891 for(i = 0; i < VDEC_EX_ALLOCAOTR_MAX_NUM_BLOCK; i++)
2892 {
2893 VDEC_EX_Allocator_Block *pstBlock = &(pstNDecAllocator->stBlockPool[i]);
2894 _VDEC_EX_Allocator_BlockReset(pstBlock, VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED);
2895 }
2896
2897 // initial Allocator Pool
2898 for(i = 0; i < VDEC_EX_ALLOCAOTR_MAX_NUM_ALLOCATOR; i++)
2899 {
2900 VDEC_EX_Allocator *pstAllocator = &(pstNDecAllocator->stAllocatorPool[i]);
2901 _VDEC_EX_Allocator_Reset(pstAllocator, VDEC_EX_ALLOCAOTR_ID_UNUSED);
2902 }
2903
2904 // Get a valid allocator from allocator pool
2905 pstNDecAllocator->u16AllocatorIdMain = _VDEC_EX_Allocator_GetNewId();
2906 if(_VDEC_EX_Allocator_IsValidId(pstNDecAllocator->u16AllocatorIdMain) == FALSE)
2907 {
2908 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Get Main Allocator Failed\n", __FUNCTION__, __LINE__);
2909 eRet = E_VDEC_EX_FAIL;
2910 goto exit;
2911 }
2912 else
2913 {
2914 MS_U16 u16BlockId;
2915 VDEC_EX_Allocator *pstAllocatorMain;
2916 VDEC_EX_Allocator_BlockInfo stBlockInfoRef;
2917
2918 // TODO: Allocator Add block Module
2919
2920 // Initial Allocator Main with block MIU0
2921 stBlockInfoRef.u8MIU = 0;
2922 stBlockInfoRef.u8Property = VDEC_EX_ALLOCAOTR_PROPERTY_DEFAULT;
2923 stBlockInfoRef.u16Allocated = 0;
2924 stBlockInfoRef.phyAddr = 0;
2925 stBlockInfoRef.szSize = 0x80000000;
2926 pstAllocatorMain = _VDEC_EX_Allocator_GetAddressById(pstNDecAllocator->u16AllocatorIdMain);
2927 eRet = _VDEC_EX_Allocator_Init(pstAllocatorMain, &stBlockInfoRef);
2928 if(eRet != E_VDEC_EX_OK)
2929 {
2930 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Allocator_Init failed\n", __FUNCTION__, __LINE__);
2931 eRet = E_VDEC_EX_FAIL;
2932 goto exit;
2933 }
2934
2935 // Add block MIU1
2936 stBlockInfoRef.u8MIU = 1;
2937 stBlockInfoRef.u8Property = VDEC_EX_ALLOCAOTR_PROPERTY_DEFAULT;
2938 stBlockInfoRef.u16Allocated = 0;
2939 stBlockInfoRef.phyAddr = 0x80000000;
2940 stBlockInfoRef.szSize = 0x80000000 - 1; // prevent size(32bits) overflow
2941 u16BlockId = _VDEC_EX_Allocator_BlockListAddtoTail(&(pstAllocatorMain->stBlockList), &stBlockInfoRef);
2942 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockId) == FALSE)
2943 {
2944 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BlockListAddtoTail failed\n", __FUNCTION__, __LINE__);
2945 goto exit;
2946 }
2947 pstAllocatorMain->szTotalSize += stBlockInfoRef.szSize;
2948 pstAllocatorMain->szUnusedSize += stBlockInfoRef.szSize;
2949
2950 #if 0
2951 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After NDecAllocator_Init, pstAllocatorMain:\n", __FUNCTION__, __LINE__);
2952 _VDEC_EX_Allocator_Print(pstAllocatorMain);
2953 #endif
2954 }
2955 }
2956
2957 exit:
2958 return eRet;
2959 }
2960
_VDEC_EX_NdecAllocator_IsNDecode(void)2961 static MS_BOOL _VDEC_EX_NdecAllocator_IsNDecode(void)
2962 {
2963 return pVdecExContext->bDRVdecideBS;
2964 }
2965
_VDEC_EX_NdecAllocator_GetBitstreamBufferProperty(MS_U8 u8Idx,VDEC_EX_NDecBufferProperty * pstProperty)2966 static VDEC_EX_Result _VDEC_EX_NdecAllocator_GetBitstreamBufferProperty(MS_U8 u8Idx, VDEC_EX_NDecBufferProperty *pstProperty)
2967 {
2968 MS_BOOL bNDecode = _VDEC_EX_NdecAllocator_IsNDecode();
2969 MS_BOOL bMonoPoly = pVdecExContext->_Pre_Ctrl[u8Idx].bMonopolyBitstreamBuffer;
2970 MS_BOOL bSetTotalBuf = pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnBS.bSetTotalBuf;
2971 VDEC_EX_SrcMode eSrcMode = pVdecExContext->_Attr[u8Idx].eSrcMode;
2972 VDEC_EX_CodecType eCodecType = pVdecExContext->_Attr[u8Idx].eCodecType;
2973 MS_BOOL bUseSubAllocator = FALSE;
2974
2975 if(bNDecode == FALSE)
2976 {
2977 if(bSetTotalBuf == TRUE)
2978 {
2979 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] bSetTotalBuf only valid in NDecode\n", __FUNCTION__, __LINE__);
2980 return E_VDEC_EX_FAIL;
2981 }
2982 }
2983
2984 if(bNDecode == TRUE)
2985 {
2986 if(bMonoPoly == FALSE || bSetTotalBuf == TRUE)
2987 {
2988 bUseSubAllocator = TRUE;
2989 }
2990 }
2991
2992 pstProperty->bCMA = FALSE;
2993 pstProperty->bDynamicCMA = FALSE;
2994 pstProperty->bNDecode = bNDecode;
2995 pstProperty->bUseSubAllocator = bUseSubAllocator;
2996 pstProperty->bUseThirdAllocator = FALSE;
2997 pstProperty->bMonopoly = bMonoPoly;
2998 pstProperty->eSrcMode = eSrcMode;
2999 pstProperty->eCodecType = eCodecType;
3000 pstProperty->eTaskSpec = E_VDEC_EX_SPEC_DEFAULT;
3001
3002 return E_VDEC_EX_OK;
3003 }
3004
_VDEC_EX_NdecAllocator_GetFrameBufferProperty(MS_U8 u8Idx,VDEC_EX_NDecBufferProperty * pstProperty)3005 static VDEC_EX_Result _VDEC_EX_NdecAllocator_GetFrameBufferProperty(MS_U8 u8Idx, VDEC_EX_NDecBufferProperty *pstProperty)
3006 {
3007 MS_BOOL bCMA = pVdecExContext->bCMAUsed;
3008 MS_BOOL bCMADynamic = FALSE/*pVdecExContext->_Pre_Ctrl[u8Idx].bEnableDynamicCMA*/;
3009 MS_BOOL bNDecode = _VDEC_EX_NdecAllocator_IsNDecode();
3010 MS_BOOL bMonoPoly = pVdecExContext->_Pre_Ctrl[u8Idx].bMonopolyFrameBuffer;
3011 VDEC_EX_SrcMode eSrcMode = pVdecExContext->_Attr[u8Idx].eSrcMode;
3012 VDEC_EX_CodecType eCodecType = pVdecExContext->_Attr[u8Idx].eCodecType;
3013 MS_BOOL bUseSubAllocator = FALSE;
3014 MS_BOOL bUseThirdAllocator = FALSE;
3015
3016 if(bNDecode == TRUE)
3017 {
3018 // If monopoly, disable NDecode
3019 if(bMonoPoly == TRUE)
3020 {
3021 bNDecode = FALSE;
3022 }
3023 }
3024 else
3025 {
3026 // If not N decode, only stream 0 will use CMA
3027 if(u8Idx != 0)
3028 {
3029 bCMA = FALSE;
3030 }
3031 }
3032
3033 // only HEVC and HVD will use CMA_Dynamic
3034 //if((bCMA == FALSE) ||
3035 // (eCodecType != E_VDEC_EX_CODEC_TYPE_HEVC && eCodecType != E_VDEC_EX_CODEC_TYPE_H264))
3036 {
3037 bCMADynamic = FALSE;
3038 }
3039
3040 if(((bNDecode == TRUE) && (bMonoPoly == FALSE)) || (bCMADynamic == TRUE))
3041 {
3042 bUseSubAllocator = TRUE;
3043 }
3044
3045 if((bNDecode == TRUE) && (bCMADynamic == TRUE))
3046 {
3047 bUseThirdAllocator = TRUE;
3048 }
3049
3050 pstProperty->bCMA = bCMA;
3051 pstProperty->bDynamicCMA = bCMADynamic;
3052 pstProperty->bNDecode = bNDecode;
3053 pstProperty->bUseSubAllocator = bUseSubAllocator;
3054 pstProperty->bUseThirdAllocator = bUseThirdAllocator;
3055 pstProperty->bMonopoly = bMonoPoly;
3056 pstProperty->eSrcMode = eSrcMode;
3057 pstProperty->eCodecType = eCodecType;
3058 pstProperty->eTaskSpec = pVdecExContext->_Pre_Ctrl[u8Idx].eTaskSpec;
3059
3060 return E_VDEC_EX_OK;
3061 }
3062
_VDEC_EX_NdecAllocator_CMAPoolSelect(VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType)3063 static VDEC_EX_CMA_POOL_SELECT _VDEC_EX_NdecAllocator_CMAPoolSelect(VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType)
3064 {
3065 VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect = E_VDEC_EX_CMA_POOL_INVALID;
3066
3067 switch(eBufType)
3068 {
3069 case E_VDEC_EX_ALLOCATOR_BUFFER_FB1:
3070 eCMAPoolSelect = E_VDEC_EX_CMA_POOL_BUFFER_FB1;
3071 break;
3072
3073 case E_VDEC_EX_ALLOCATOR_BUFFER_FB2:
3074 eCMAPoolSelect = E_VDEC_EX_CMA_POOL_BUFFER_FB2;
3075 break;
3076
3077 default:
3078 break;
3079 }
3080
3081 return eCMAPoolSelect;
3082 }
3083
3084 #ifdef CMA_DRV_DIRECT_INIT
_VDEC_EX_NdecAllocator_CMAInit(VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect,MS_PHY phyBufAddr,MS_PHY * pphyCMAStartAddr,MS_SIZE * pszCMAHeapLength,MS_PHY * pphyUnUseSize)3085 static VDEC_EX_Result _VDEC_EX_NdecAllocator_CMAInit(VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect, MS_PHY phyBufAddr,
3086 MS_PHY *pphyCMAStartAddr, MS_SIZE *pszCMAHeapLength, MS_PHY *pphyUnUseSize)
3087 {
3088 VDEC_EX_Result eRet = E_VDEC_EX_OK;
3089 struct CMA_Pool_Init_Param *pstCmaInitParam = &(pVdecExContext->stNDecAllocator.stCmaInitParam[eCMAPoolSelect]);
3090 MS_PHY phyCMAStartAddr;
3091 MS_PHY phyUnUseSize = 0;
3092
3093 //if(bCMAInitPool[eCMAPoolSelect] == FALSE)
3094 {
3095 memset(pstCmaInitParam, 0, sizeof(struct CMA_Pool_Init_Param));
3096
3097 pstCmaInitParam->heap_id = (eCMAPoolSelect == E_VDEC_EX_CMA_POOL_BUFFER_FB1) ? ION_VDEC_HEAP_ID : ION_VDEC_HEAP_ID + 1;
3098 pstCmaInitParam->flags = CMA_FLAG_MAP_VMA | CMA_FLAG_CACHED;
3099
3100 if (MApi_CMA_Pool_Init(pstCmaInitParam) == FALSE)
3101 {
3102 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] MApi_CMA_Pool_Init(0x%x) failed\n", __FUNCTION__, __LINE__, pstCmaInitParam->heap_id);
3103 eRet = E_VDEC_EX_FAIL;
3104 goto exit;
3105 }
3106
3107 bCMAInitPool[eCMAPoolSelect] = TRUE;
3108 }
3109
3110 _miu_offset_to_phy(pstCmaInitParam->miu, pstCmaInitParam->heap_miu_start_offset, phyCMAStartAddr);
3111
3112 if(phyBufAddr != 0)
3113 {
3114 phyUnUseSize = phyBufAddr - phyCMAStartAddr;
3115 if((sizeof(MS_PHY) == 8) && (phyUnUseSize >> 32))
3116 {
3117 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] phyUnUseSize(0x%llx) overflow\n", __FUNCTION__, __LINE__, phyUnUseSize);
3118 goto exit;
3119 }
3120 }
3121
3122 *pphyCMAStartAddr = phyCMAStartAddr;
3123 *pszCMAHeapLength = pstCmaInitParam->heap_length;
3124 *pphyUnUseSize = phyUnUseSize;
3125
3126 VPRINTF("[ALLOC][DBG][%s][%d] MApi_CMA_Pool_Init(%d): id=0x%x, miu=%d, offset=0x%llx, length=0x%x, BufAddr=0x%llx, UnUseSize=0x%llx\n",
3127 __FUNCTION__, __LINE__, eCMAPoolSelect,
3128 pstCmaInitParam->pool_handle_id,
3129 pstCmaInitParam->miu,
3130 pstCmaInitParam->heap_miu_start_offset,
3131 pstCmaInitParam->heap_length,
3132 phyBufAddr,
3133 phyUnUseSize);
3134
3135 exit:
3136 return eRet;
3137 }
3138
_VDEC_EX_NdecAllocator_CMAAlloc(VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect,MS_PHY phyBufAddr,MS_SIZE szBufSize)3139 static VDEC_EX_Result _VDEC_EX_NdecAllocator_CMAAlloc(VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect, MS_PHY phyBufAddr, MS_SIZE szBufSize)
3140 {
3141 VDEC_EX_Result eRet = E_VDEC_EX_OK;
3142
3143 if(bCMAInitPool[eCMAPoolSelect] == FALSE)
3144 {
3145 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] bCMAInit[%d] == FALSE\n", __FUNCTION__, __LINE__, eCMAPoolSelect);
3146 eRet = E_VDEC_EX_FAIL;
3147 }
3148 else
3149 {
3150 struct CMA_Pool_Alloc_Param stAllocParam;
3151 struct CMA_Pool_Init_Param *pstCmaInitParam = &(pVdecExContext->stNDecAllocator.stCmaInitParam[eCMAPoolSelect]);
3152 MS_U64 u64offset;
3153 MS_U8 u8MIU;
3154
3155 memset(&stAllocParam, 0, sizeof(struct CMA_Pool_Alloc_Param));
3156
3157 _phy_to_miu_offset(u8MIU, u64offset, phyBufAddr);
3158
3159 if(u64offset < pstCmaInitParam->heap_miu_start_offset)
3160 {
3161 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] MApi_CMA_Pool_GetMem(%d) fail\n", __FUNCTION__, __LINE__, eCMAPoolSelect);
3162 eRet = E_VDEC_EX_FAIL;
3163 goto exit;
3164 }
3165
3166 stAllocParam.pool_handle_id = pstCmaInitParam->heap_id;
3167 stAllocParam.flags = CMA_FLAG_VIRT_ADDR;
3168 stAllocParam.offset_in_pool = u64offset - pstCmaInitParam->heap_miu_start_offset;
3169 stAllocParam.length = szBufSize;
3170
3171 VPRINTF("[ALLOC][DBG][%s][%d] MApi_CMA_Pool_GetMem(%d): id=0x%x, flags=0x%x, offset_in_pool=0x%llx, length=0x%x\n",
3172 __FUNCTION__, __LINE__, eCMAPoolSelect,
3173 stAllocParam.pool_handle_id,
3174 stAllocParam.flags,
3175 stAllocParam.offset_in_pool,
3176 stAllocParam.length);
3177
3178 if(MApi_CMA_Pool_GetMem(&stAllocParam) == FALSE)
3179 {
3180 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] MApi_CMA_Pool_GetMem(%d) fail\n", __FUNCTION__, __LINE__, eCMAPoolSelect);
3181 eRet = E_VDEC_EX_FAIL;
3182 goto exit;
3183 }
3184 }
3185
3186 exit:
3187 return eRet;
3188 }
3189
_VDEC_EX_NdecAllocator_CMAFree(VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect,MS_PHY phyBufAddr,MS_SIZE szBufSize)3190 static VDEC_EX_Result _VDEC_EX_NdecAllocator_CMAFree(VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect, MS_PHY phyBufAddr, MS_SIZE szBufSize)
3191 {
3192 VDEC_EX_Result eRet = E_VDEC_EX_OK;
3193
3194 if(bCMAInitPool[eCMAPoolSelect] == FALSE)
3195 {
3196 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] bCMAInit[%d] == FALSE\n", __FUNCTION__, __LINE__, eCMAPoolSelect);
3197 eRet = E_VDEC_EX_FAIL;
3198 }
3199 else
3200 {
3201 struct CMA_Pool_Free_Param stCmaFreeParam;
3202 struct CMA_Pool_Init_Param *pstCmaInitParam = &(pVdecExContext->stNDecAllocator.stCmaInitParam[eCMAPoolSelect]);
3203 MS_U64 u64offset;
3204 MS_U8 u8MIU;
3205
3206 memset(&stCmaFreeParam, 0, sizeof(struct CMA_Pool_Free_Param));
3207
3208 _phy_to_miu_offset(u8MIU, u64offset, phyBufAddr);
3209
3210 if(u64offset < pstCmaInitParam->heap_miu_start_offset)
3211 {
3212 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] MApi_CMA_Pool_PutMem(%d) fail\n", __FUNCTION__, __LINE__, eCMAPoolSelect);
3213 eRet = E_VDEC_EX_FAIL;
3214 goto exit;
3215 }
3216
3217 stCmaFreeParam.pool_handle_id = pstCmaInitParam->heap_id;
3218 stCmaFreeParam.offset_in_pool = u64offset - pstCmaInitParam->heap_miu_start_offset;
3219 stCmaFreeParam.length = szBufSize;
3220
3221 VPRINTF("[ALLOC][DBG][%s][%d] MApi_CMA_Pool_PutMem(%d): id=0x%x, offset_in_pool=0x%llx, length=0x%x\n",
3222 __FUNCTION__, __LINE__, eCMAPoolSelect,
3223 stCmaFreeParam.pool_handle_id,
3224 stCmaFreeParam.offset_in_pool,
3225 stCmaFreeParam.length);
3226
3227 if(MApi_CMA_Pool_PutMem(&stCmaFreeParam) == FALSE)
3228 {
3229 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] MApi_CMA_Pool_PutMem(%d) fail\n", __FUNCTION__, __LINE__, eCMAPoolSelect);
3230 eRet = E_VDEC_EX_FAIL;
3231 goto exit;
3232 }
3233 }
3234
3235 exit:
3236 return eRet;
3237 }
3238 #endif
3239
3240 #define MEGA(v) ((v)*1024*1024)
_VDEC_EX_NdecAllocator_GetTaskSpecSize(VDEC_EX_TASK_SPEC eTaskSpec,VDEC_EX_CodecType eCodecType)3241 static MS_SIZE _VDEC_EX_NdecAllocator_GetTaskSpecSize(VDEC_EX_TASK_SPEC eTaskSpec, VDEC_EX_CodecType eCodecType)
3242 {
3243 MS_SIZE szFrameBufferSize = 0;
3244
3245 if(eTaskSpec == E_VDEC_EX_SPEC_DEFAULT)
3246 {
3247 szFrameBufferSize = MDrv_HVD_EX_GetFrameBufferDefaultSize(eCodecType);
3248 }
3249 else
3250 {
3251 // FIXME: Table value
3252 switch(eTaskSpec)
3253 {
3254 case E_VDEC_EX_SPEC_HEVC_HD_LEVEL41:
3255 szFrameBufferSize = MEGA(100);
3256 break;
3257 case E_VDEC_EX_SPEC_HEVC_FHD_LEVEL41:
3258 szFrameBufferSize = MEGA(100);
3259 break;
3260 case E_VDEC_EX_SPEC_HEVC_FHD_LEVEL51:
3261 szFrameBufferSize = MEGA(160);
3262 break;
3263 case E_VDEC_EX_SPEC_HEVC_UHD_LEVEL51:
3264 szFrameBufferSize = MEGA(160);
3265 break;
3266 case E_VDEC_EX_SPEC_H264_HD_LEVEL40:
3267 szFrameBufferSize = MEGA(16);
3268 break;
3269 case E_VDEC_EX_SPEC_H264_FHD_LEVEL40:
3270 szFrameBufferSize = MEGA(27);
3271 break;
3272 case E_VDEC_EX_SPEC_H264_UHD_LEVEL50:
3273 szFrameBufferSize = MEGA(150);
3274 break;
3275 default:
3276 szFrameBufferSize = 0;
3277 break;
3278 }
3279 }
3280
3281 return szFrameBufferSize;
3282 }
3283
_VDEC_EX_NdecAllocator_GetMainBlock(VDEC_EX_NDecAllocator * pNDecAllocator,VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType,VDEC_EX_NDecBufRangeParam * pstBufRgn,VDEC_EX_NDecBufferProperty * pstProperty)3284 static MS_U16 _VDEC_EX_NdecAllocator_GetMainBlock(VDEC_EX_NDecAllocator *pNDecAllocator,
3285 VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType, VDEC_EX_NDecBufRangeParam *pstBufRgn, VDEC_EX_NDecBufferProperty *pstProperty)
3286 {
3287 VDEC_EX_Allocator_Criterion stCriterion;
3288 VDEC_EX_Allocator *pstAllocatorMain;
3289 MS_U16 u16BlockIdMain = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3290 MS_PHY phyMainBlockAddr = 0;
3291 MS_SIZE szMainBlockSize = 0;
3292
3293 if(pNDecAllocator == NULL)
3294 {
3295 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
3296 goto exit;
3297 }
3298
3299 if(_VDEC_EX_Allocator_IsValidId(pNDecAllocator->u16AllocatorIdMain) == FALSE)
3300 {
3301 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid u16AllocatorIdMain\n", __FUNCTION__, __LINE__);
3302 goto exit;
3303 }
3304
3305 // If setting total buffer, use it first
3306 if(pstBufRgn->bSetTotalBuf == TRUE)
3307 {
3308 phyMainBlockAddr = pstBufRgn->phyTotalBufAddr;
3309 szMainBlockSize = pstBufRgn->szTotalBufSize;
3310 }
3311 else
3312 {
3313 if(pstProperty->bCMA == FALSE)
3314 {
3315 phyMainBlockAddr = pstBufRgn->phyBufAddr;
3316 szMainBlockSize = pstBufRgn->szBufSize;
3317 }
3318 #ifdef CMA_DRV_DIRECT_INIT
3319 else // If using CMA, get CMA phyBufAddr and szBufSize
3320 {
3321 VDEC_EX_Result eRet;
3322 MS_PHY phyCMAStartAddr = 0;
3323 MS_SIZE szCMAHeapLength = 0;
3324 MS_PHY phyUnUseSize = 0;
3325 VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect = _VDEC_EX_NdecAllocator_CMAPoolSelect(eBufType);
3326
3327 if(eCMAPoolSelect == E_VDEC_EX_CMA_POOL_INVALID)
3328 {
3329 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] eCMAPoolSelect Wrong Buf Type\n", __FUNCTION__, __LINE__);
3330 goto exit;
3331 }
3332
3333 eRet = _VDEC_EX_NdecAllocator_CMAInit(eCMAPoolSelect, pstBufRgn->phyBufAddr, &phyCMAStartAddr, &szCMAHeapLength, &phyUnUseSize);
3334 if(eRet != E_VDEC_EX_OK)
3335 {
3336 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] CMAInit failed\n", __FUNCTION__, __LINE__);
3337 goto exit;
3338 }
3339
3340 if(pstProperty->bNDecode == FALSE && eBufType != E_VDEC_EX_ALLOCATOR_BUFFER_FB2)
3341 {
3342 // If not N Decode, get CMA size by MDrv_HVD_EX_GetCMAMemSize()
3343
3344 VDEC_EX_CodecType eCodecType = pstProperty->eCodecType;
3345 VDEC_EX_SrcMode eSrcMode = pstProperty->eSrcMode;
3346 MS_U64 u64AllocOffset = 0;
3347 MS_SIZE szAlloclength = 0;
3348
3349 eRet = MDrv_HVD_EX_GetCMAMemSize(eCodecType, eSrcMode, &u64AllocOffset, &szAlloclength, szCMAHeapLength, phyUnUseSize);
3350 if(eRet == FALSE)
3351 {
3352 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] MDrv_HVD_EX_GetCMAMemSize failed\n", __FUNCTION__, __LINE__);
3353 goto exit;
3354 }
3355
3356 szMainBlockSize = pstBufRgn->szBufSize;
3357 if(szMainBlockSize == 0 || szMainBlockSize > szAlloclength)
3358 {
3359 szMainBlockSize = szAlloclength;
3360 }
3361
3362 phyMainBlockAddr = phyCMAStartAddr - phyUnUseSize;
3363 }
3364 else
3365 {
3366 // If N Decode or FrameBuffer2, use whole CMA size
3367
3368 phyMainBlockAddr = phyCMAStartAddr - phyUnUseSize;
3369 szMainBlockSize = szCMAHeapLength - phyUnUseSize;
3370 }
3371 }
3372 #endif
3373 }
3374
3375 // initial search criterion
3376 stCriterion.u32CheckItem =
3377 VDEC_EX_ALLOCATOR_CRITERION_CHECK_ADDRESS |
3378 VDEC_EX_ALLOCATOR_CRITERION_CHECK_SIZE;
3379 stCriterion.phyAddr = phyMainBlockAddr;
3380 stCriterion.szSize = szMainBlockSize;
3381 stCriterion.u32Alignment = 0;
3382
3383 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] stCriterion.phyAddr=0x%llx, szSize=0x%x\n", __FUNCTION__, __LINE__, stCriterion.phyAddr, stCriterion.szSize);
3384
3385 // start search a valid region
3386 pstAllocatorMain = _VDEC_EX_Allocator_GetAddressById(pNDecAllocator->u16AllocatorIdMain);
3387 u16BlockIdMain = _VDEC_EX_Allocator_MallocStart(pstAllocatorMain, &stCriterion);
3388 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMain) == FALSE)
3389 {
3390 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] MallocStart failed\n", __FUNCTION__, __LINE__);
3391 goto exit;
3392 }
3393
3394 if(pstProperty->bUseSubAllocator == TRUE && pstProperty->bNDecode == TRUE)
3395 {
3396 VDEC_EX_Allocator_Block *pstBlockMain = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMain);
3397 pstBlockMain->stBlockInfo.u8Property |= VDEC_EX_ALLOCAOTR_PROPERTY_CAN_OVERLAP;
3398 }
3399
3400 exit:
3401 return u16BlockIdMain;
3402 }
3403
_VDEC_EX_NdecAllocator_GetExtendAllocator(VDEC_EX_Allocator_Block * pstBlock)3404 static MS_U16 _VDEC_EX_NdecAllocator_GetExtendAllocator(VDEC_EX_Allocator_Block *pstBlock)
3405 {
3406 MS_U16 u16AllocatorIdExt = VDEC_EX_ALLOCAOTR_ID_UNUSED;
3407
3408 if(pstBlock == NULL)
3409 {
3410 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid Input\n", __FUNCTION__, __LINE__);
3411 goto exit;
3412 }
3413
3414 if(_VDEC_EX_Allocator_IsValidId(pstBlock->u16AllocatorIdExt) == FALSE)
3415 {
3416 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Create Extend Allocator\n", __FUNCTION__, __LINE__);
3417
3418 VDEC_EX_Allocator_BlockInfo stBlockInfoRef;
3419 VDEC_EX_Allocator *pstAllocatorExt;
3420
3421 u16AllocatorIdExt = _VDEC_EX_Allocator_GetNewId();
3422
3423 if(_VDEC_EX_Allocator_IsValidId(u16AllocatorIdExt) == FALSE)
3424 {
3425 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Allocator_GetNewId failed\n", __FUNCTION__, __LINE__);
3426 goto exit;
3427 }
3428 pstAllocatorExt = _VDEC_EX_Allocator_GetAddressById(u16AllocatorIdExt);
3429
3430 stBlockInfoRef.u8MIU = pstBlock->stBlockInfo.u8MIU;
3431 stBlockInfoRef.u8Property = VDEC_EX_ALLOCAOTR_PROPERTY_DEFAULT;
3432 stBlockInfoRef.u16Allocated = 0;
3433 stBlockInfoRef.phyAddr = pstBlock->stBlockInfo.phyAddr;
3434 stBlockInfoRef.szSize = pstBlock->stBlockInfo.szSize;
3435
3436 if(_VDEC_EX_Allocator_Init(pstAllocatorExt, &stBlockInfoRef) != E_VDEC_EX_OK)
3437 {
3438 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Allocator_Init failed\n", __FUNCTION__, __LINE__);
3439 goto exit;
3440 }
3441
3442 pstBlock->u16AllocatorIdExt = u16AllocatorIdExt;
3443 }
3444
3445 u16AllocatorIdExt = pstBlock->u16AllocatorIdExt;
3446
3447 exit:
3448 return u16AllocatorIdExt;
3449 }
3450
_VDEC_EX_NdecAllocator_GetSubBlock(VDEC_EX_Allocator_Block * pstBlockMain,VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType,VDEC_EX_NDecBufRangeParam * pstBufRgn,VDEC_EX_NDecBufferProperty * pstProperty)3451 static MS_U16 _VDEC_EX_NdecAllocator_GetSubBlock(VDEC_EX_Allocator_Block *pstBlockMain,
3452 VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType, VDEC_EX_NDecBufRangeParam *pstBufRgn, VDEC_EX_NDecBufferProperty *pstProperty)
3453 {
3454 MS_U16 u16BlockIdSub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3455 MS_U16 u16AllocatorIdExt = VDEC_EX_ALLOCAOTR_ID_UNUSED;
3456 VDEC_EX_Allocator *pstAllocatorSub = NULL;
3457
3458 if(pstBlockMain == NULL)
3459 {
3460 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
3461 goto exit;
3462 }
3463
3464 u16AllocatorIdExt = _VDEC_EX_NdecAllocator_GetExtendAllocator(pstBlockMain);
3465 if(_VDEC_EX_Allocator_IsValidId(u16AllocatorIdExt) == FALSE)
3466 {
3467 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] GetExtendAllocator failed\n", __FUNCTION__, __LINE__);
3468 goto exit;
3469 }
3470 pstAllocatorSub = _VDEC_EX_Allocator_GetAddressById(u16AllocatorIdExt);
3471
3472 #if ENABLE_ALLOCATOR_TRACE
3473 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] pstAllocatorSub:\n", __FUNCTION__, __LINE__);
3474 _VDEC_EX_Allocator_Print(pstAllocatorSub);
3475 #endif
3476
3477 if(pstProperty->bNDecode == TRUE)
3478 {
3479 VDEC_EX_Allocator_Criterion stCriterion;
3480
3481 _VDEC_Memset(&stCriterion, 0, sizeof(VDEC_EX_Allocator_Criterion));
3482
3483 if(pstProperty->bMonopoly == FALSE)
3484 {
3485 stCriterion.u32CheckItem =
3486 VDEC_EX_ALLOCATOR_CRITERION_CHECK_SIZE;
3487 stCriterion.phyAddr = 0;
3488 stCriterion.szSize = _VDEC_EX_NdecAllocator_GetTaskSpecSize(pstProperty->eTaskSpec, pstProperty->eCodecType);
3489
3490 if(eBufType == E_VDEC_EX_ALLOCATOR_BUFFER_FB1)
3491 {
3492 // patch for without Dynamic CMA
3493 stCriterion.szSize = MEGA(32);
3494 }
3495 else if(eBufType == E_VDEC_EX_ALLOCATOR_BUFFER_FB2)
3496 {
3497 stCriterion.szSize = stCriterion.szSize >> 2;
3498 }
3499
3500 stCriterion.u32Alignment = 0x100000;
3501
3502 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] bMono=%d, TaskSpec=0x%x, stCriterion.szSize=0x%x\n", __FUNCTION__, __LINE__,
3503 pstProperty->bMonopoly, pstProperty->eTaskSpec, stCriterion.szSize);
3504 }
3505 else
3506 {
3507 stCriterion.u32CheckItem =
3508 VDEC_EX_ALLOCATOR_CRITERION_CHECK_SIZE |
3509 VDEC_EX_ALLOCATOR_CRITERION_CHECK_ADDRESS;
3510 stCriterion.phyAddr = pstBufRgn->phyBufAddr;
3511 stCriterion.szSize = pstBufRgn->szBufSize;
3512 stCriterion.u32Alignment = 0;
3513
3514 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] bMono=%d, stCriterion.phyBufAddr=0x%llx, stCriterion.szSize=0x%x\n", __FUNCTION__, __LINE__,
3515 pstProperty->bMonopoly, stCriterion.phyAddr, stCriterion.szSize);
3516 }
3517
3518 u16BlockIdSub = _VDEC_EX_Allocator_MallocStart(pstAllocatorSub, &stCriterion);
3519 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdSub) == FALSE)
3520 {
3521 ALLOCATOR_PRINTF_ERR("[ALLOC][DBG][%s][%d] MallocStart failed\n", __FUNCTION__, __LINE__);
3522 goto exit;
3523 }
3524 }
3525 else
3526 {
3527 u16BlockIdSub = pstAllocatorSub->stBlockList.u16BlockIdHead;
3528 }
3529
3530 #if ENABLE_ALLOCATOR_TRACE
3531 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] pstAllocatorSub:\n", __FUNCTION__, __LINE__);
3532 _VDEC_EX_Allocator_Print(pstAllocatorSub);
3533 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] u16BlockIdTask = %d\n", __FUNCTION__, __LINE__, u16BlockIdSub);
3534 #endif
3535
3536 exit:
3537 return u16BlockIdSub;
3538 }
3539
_VDEC_EX_NdecAllocator_GetThirdBlock(VDEC_EX_Allocator_Block * pstBlockSub)3540 static MS_U16 _VDEC_EX_NdecAllocator_GetThirdBlock(VDEC_EX_Allocator_Block *pstBlockSub)
3541 {
3542 MS_U16 u16BlockIdThird = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3543 MS_U16 u16AllocatorIdExt = VDEC_EX_ALLOCAOTR_ID_UNUSED;
3544 VDEC_EX_Allocator *pstAllocatorThird = NULL;
3545
3546 if(pstBlockSub == NULL)
3547 {
3548 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
3549 goto exit;
3550 }
3551
3552 u16AllocatorIdExt = _VDEC_EX_NdecAllocator_GetExtendAllocator(pstBlockSub);
3553 if(_VDEC_EX_Allocator_IsValidId(u16AllocatorIdExt) == FALSE)
3554 {
3555 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] GetExtendAllocator failed\n", __FUNCTION__, __LINE__);
3556 goto exit;
3557 }
3558 pstAllocatorThird = _VDEC_EX_Allocator_GetAddressById(u16AllocatorIdExt);
3559
3560 u16BlockIdThird = pstAllocatorThird->stBlockList.u16BlockIdHead;
3561
3562 exit:
3563 return u16BlockIdThird;
3564 }
3565
_VDEC_EX_NdecAllocator_GetBitstreamBufferTotalAddrSize(MS_PHY * pphyBSTotalAddrStart,MS_SIZE * pszBSToltalSize)3566 static VDEC_EX_Result _VDEC_EX_NdecAllocator_GetBitstreamBufferTotalAddrSize(MS_PHY *pphyBSTotalAddrStart, MS_SIZE *pszBSToltalSize)
3567 {
3568 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
3569 VDEC_EX_NDecAllocator *pstNDecAllocator = &(pVdecExContext->stNDecAllocator);
3570 MS_PHY phyBSTotalAddrStart = 0;
3571 MS_PHY phyBSTotalAddrEnd = 0;
3572 MS_SIZE szBSToltalSize = 0;
3573 MS_BOOL bFind = FALSE;
3574 int i;
3575
3576 if(pphyBSTotalAddrStart == NULL || pszBSToltalSize == NULL)
3577 {
3578 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input", __FUNCTION__, __LINE__);
3579 goto exit;
3580 }
3581
3582 // search BS Buffer record
3583 for(i = 0; i < VDEC_EX_ALLOCAOTR_MAX_NUM_STREAM; i++)
3584 {
3585 MS_PHY phySizeDiff;
3586 VDEC_EX_Allocator_Block *pstBlockBS;
3587 MS_U16 u16BlockIdBS1Main = pstNDecAllocator->stAllocatorRecord[i].u16BlockIdBS1Main;
3588 MS_U16 u16BlockIdBS1Sub = pstNDecAllocator->stAllocatorRecord[i].u16BlockIdBS1Sub;
3589
3590 //ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] i=%d, IdBS1Main=%d, IdBS1Sub=%d", __FUNCTION__, __LINE__, i, u16BlockIdBS1Main, u16BlockIdBS1Sub);
3591
3592 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdBS1Main) == FALSE &&
3593 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdBS1Sub) == FALSE)
3594 {
3595 continue;
3596 }
3597
3598 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdBS1Sub) == TRUE)
3599 {
3600 pstBlockBS = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdBS1Sub);
3601 }
3602 else
3603 {
3604 pstBlockBS = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdBS1Main);
3605 }
3606
3607 if(bFind == FALSE)
3608 {
3609 bFind = TRUE;
3610 phyBSTotalAddrStart = pstBlockBS->stBlockInfo.phyAddr;
3611 phyBSTotalAddrEnd = pstBlockBS->stBlockInfo.phyAddr + pstBlockBS->stBlockInfo.szSize;
3612 }
3613 else
3614 {
3615 if(phyBSTotalAddrStart > pstBlockBS->stBlockInfo.phyAddr)
3616 {
3617 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Warnning: phyBSTotalAddrStart Changed !!", __FUNCTION__, __LINE__);
3618 phyBSTotalAddrStart = pstBlockBS->stBlockInfo.phyAddr;
3619 }
3620 if(phyBSTotalAddrEnd < (pstBlockBS->stBlockInfo.phyAddr + pstBlockBS->stBlockInfo.szSize))
3621 {
3622 phyBSTotalAddrEnd = pstBlockBS->stBlockInfo.phyAddr + pstBlockBS->stBlockInfo.szSize;
3623 }
3624 }
3625
3626 phySizeDiff = phyBSTotalAddrEnd - phyBSTotalAddrStart;
3627
3628 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] start=0x%llx, end=0x%llx, diff=0x%llx", __FUNCTION__, __LINE__,
3629 phyBSTotalAddrStart, phyBSTotalAddrEnd, phySizeDiff);
3630
3631 if(sizeof(MS_PHY) == 8 && (phySizeDiff >> 32))
3632 {
3633 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Fail: phySizeDiff may be overflow !!", __FUNCTION__, __LINE__);
3634 //goto exit;
3635 }
3636 szBSToltalSize = (MS_SIZE)phySizeDiff;
3637
3638 //ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] i=%d, phyBSTotalAddrStart=0x%llx, szBSToltalSize=0x%x\n",
3639 // __FUNCTION__, __LINE__, i, phyBSTotalAddrStart, szBSToltalSize);
3640 }
3641
3642 if(bFind == TRUE)
3643 {
3644 // output result
3645 *pphyBSTotalAddrStart = phyBSTotalAddrStart;
3646 *pszBSToltalSize = szBSToltalSize;
3647
3648 // all success
3649 eRet = E_VDEC_EX_OK;
3650
3651 //ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] phyBSTotalAddrStart=0x%llx, szBSToltalSize=0x%x\n",
3652 // __FUNCTION__, __LINE__, phyBSTotalAddrStart, szBSToltalSize);
3653 }
3654
3655 exit:
3656 return eRet;
3657 }
3658
_VDEC_EX_NdecAllocator_MallocBitstreamBuffer(MS_U8 u8Idx,VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType,VDEC_EX_NDecBufRangeParam * pstBufRgn,VDEC_EX_Allocator_Block ** ppstBlockResult)3659 static VDEC_EX_Result _VDEC_EX_NdecAllocator_MallocBitstreamBuffer(MS_U8 u8Idx,
3660 VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType, VDEC_EX_NDecBufRangeParam *pstBufRgn, VDEC_EX_Allocator_Block **ppstBlockResult)
3661 {
3662 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
3663 VDEC_EX_NDecAllocator *pstNDecAllocator = &(pVdecExContext->stNDecAllocator);
3664 VDEC_EX_NDecBufferProperty stBufProperty;
3665 VDEC_EX_Allocator_Block *pstBlockTask = NULL;
3666 VDEC_EX_Allocator_Block *pstBlockMain = NULL;
3667 VDEC_EX_Allocator_Block *pstBlockSub = NULL;
3668 MS_U16 u16BlockIdTask = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3669 MS_U16 u16BlockIdMain = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3670 MS_U16 u16BlockIdSub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3671
3672 // initial N Decode Allocator
3673 if(_VDEC_EX_NDecAllocator_Init(pstNDecAllocator) != E_VDEC_EX_OK)
3674 {
3675 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] NDecAllocator_Init failed\n", __FUNCTION__, __LINE__);
3676 goto exit;
3677 }
3678
3679 #if ENABLE_ALLOCATOR_TRACE
3680 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After NDecAllocator_Init, pstAllocatorMain:\n", __FUNCTION__, __LINE__);
3681 VDEC_EX_Allocator *pstAllocatorMain = _VDEC_EX_Allocator_GetAddressById(pstNDecAllocator->u16AllocatorIdMain);
3682 _VDEC_EX_Allocator_Print(pstAllocatorMain);
3683 #endif
3684
3685 if(_VDEC_EX_NdecAllocator_GetBitstreamBufferProperty(u8Idx, &stBufProperty) != E_VDEC_EX_OK)
3686 {
3687 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] GetBitstreamBufferProperty failed\n", __FUNCTION__, __LINE__);
3688 goto exit;
3689 }
3690
3691 #if ENABLE_ALLOCATOR_DEBUG
3692 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After GetBitstreamBufferProperty, stBufProperty:\n", __FUNCTION__, __LINE__);
3693 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tbNDec=%d, bSubAlloc=%d\n", stBufProperty.bNDecode, stBufProperty.bUseSubAllocator);
3694 #endif
3695
3696 u16BlockIdMain = _VDEC_EX_NdecAllocator_GetMainBlock(pstNDecAllocator, eBufType, pstBufRgn, &stBufProperty);
3697 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMain) == FALSE)
3698 {
3699 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] GetMainBlock failed\n", __FUNCTION__, __LINE__);
3700 goto exit;
3701 }
3702 pstBlockMain = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMain);
3703
3704 #if ENABLE_ALLOCATOR_TRACE
3705 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After GetMainBlock, pstAllocatorMain:\n", __FUNCTION__, __LINE__);
3706 _VDEC_EX_Allocator_Print(pstAllocatorMain);
3707 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] u16BlockIdMain = %d\n", __FUNCTION__, __LINE__, u16BlockIdMain);
3708 #endif
3709
3710 if(stBufProperty.bUseSubAllocator == FALSE)
3711 {
3712 u16BlockIdTask = u16BlockIdMain;
3713 pstBlockTask = pstBlockMain;
3714 }
3715 else
3716 {
3717 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Start GetSubBlock\n", __FUNCTION__, __LINE__);
3718
3719 u16BlockIdSub = _VDEC_EX_NdecAllocator_GetSubBlock(pstBlockMain, eBufType, pstBufRgn, &stBufProperty);
3720 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdSub) == FALSE)
3721 {
3722 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] GetSubBlock failed\n", __FUNCTION__, __LINE__);
3723 goto exit;
3724 }
3725 pstBlockSub = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdSub);
3726
3727 u16BlockIdTask = u16BlockIdSub;
3728 pstBlockTask = pstBlockSub;
3729
3730 #if ENABLE_ALLOCATOR_TRACE
3731 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] pstAllocatorSub:\n", __FUNCTION__, __LINE__);
3732 if(_VDEC_EX_Allocator_IsValidId(pstBlockMain->u16AllocatorIdExt) == TRUE)
3733 {
3734 VDEC_EX_Allocator *pstAllocatorSub = _VDEC_EX_Allocator_GetAddressById(pstBlockMain->u16AllocatorIdExt);
3735 _VDEC_EX_Allocator_Print(pstAllocatorSub);
3736 }
3737 #endif
3738 }
3739
3740 // record
3741 if(pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Main != VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED ||
3742 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Sub != VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED)
3743 {
3744 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] BS: stAllocatorRecord[%d] in used\n", __FUNCTION__, __LINE__, u8Idx);
3745 goto exit;
3746 }
3747 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Main = u16BlockIdMain;
3748 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Sub = u16BlockIdSub;
3749
3750 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] BS: stAllocatorRecord[%d]:\n", __FUNCTION__, __LINE__, u8Idx);
3751 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tIdBS1Main=%d, IdBS1Sub=%d\n", u16BlockIdMain, u16BlockIdSub);
3752
3753 // output result
3754 *ppstBlockResult = pstBlockTask;
3755
3756 // all success
3757 eRet = E_VDEC_EX_OK;
3758
3759 #if ENABLE_ALLOCATOR_TRACE
3760 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] BS pstAllocatorMain:\n", __FUNCTION__, __LINE__);
3761 _VDEC_EX_Allocator_Print(pstAllocatorMain);
3762 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] BS pstAllocatorSub:\n", __FUNCTION__, __LINE__);
3763 if(_VDEC_EX_Allocator_IsValidId(pstBlockMain->u16AllocatorIdExt) == TRUE)
3764 {
3765 VDEC_EX_Allocator *pstAllocatorSub = _VDEC_EX_Allocator_GetAddressById(pstBlockMain->u16AllocatorIdExt);
3766 _VDEC_EX_Allocator_Print(pstAllocatorSub);
3767 }
3768 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] BS *ppstBlockResult:\n", __FUNCTION__, __LINE__);
3769 _VDEC_EX_Allocator_BlockPrint(*ppstBlockResult);
3770 #endif
3771
3772 exit:
3773 return eRet;
3774 }
3775
_VDEC_EX_NdecAllocator_MallocFrameBuffer(MS_U8 u8Idx,VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType,VDEC_EX_NDecBufRangeParam * pstBufRgn,VDEC_EX_Allocator_Block ** ppstBlockResult)3776 static VDEC_EX_Result _VDEC_EX_NdecAllocator_MallocFrameBuffer(MS_U8 u8Idx,
3777 VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType, VDEC_EX_NDecBufRangeParam *pstBufRgn, VDEC_EX_Allocator_Block **ppstBlockResult)
3778 {
3779 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
3780 VDEC_EX_NDecAllocator *pstNDecAllocator = &(pVdecExContext->stNDecAllocator);
3781 VDEC_EX_NDecBufferProperty stBufProperty;
3782 VDEC_EX_Allocator_Block *pstBlockTask = NULL;
3783 VDEC_EX_Allocator_Block *pstBlockMain = NULL;
3784 VDEC_EX_Allocator_Block *pstBlockSub = NULL;
3785 VDEC_EX_Allocator_Block *pstBlockThird= NULL;
3786 //VDEC_EX_Allocator *pstAllocatorMain = NULL;
3787 //VDEC_EX_Allocator *pstAllocatorSub = NULL;
3788 MS_U16 u16BlockIdTask = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3789 MS_U16 u16BlockIdMain = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3790 MS_U16 u16BlockIdSub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3791 MS_U16 u16BlockIdThird= VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3792
3793 // initial N Decode Allocator
3794 if(_VDEC_EX_NDecAllocator_Init(pstNDecAllocator) != E_VDEC_EX_OK)
3795 {
3796 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] NDecAllocator_Init failed\n", __FUNCTION__, __LINE__);
3797 goto exit;
3798 }
3799
3800 #if ENABLE_ALLOCATOR_TRACE
3801 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After NDecAllocator_Init, pstAllocatorMain:\n", __FUNCTION__, __LINE__);
3802 VDEC_EX_Allocator *pstAllocatorMain = _VDEC_EX_Allocator_GetAddressById(pstNDecAllocator->u16AllocatorIdMain);
3803 _VDEC_EX_Allocator_Print(pstAllocatorMain);
3804 #endif
3805
3806 _VDEC_EX_NdecAllocator_GetFrameBufferProperty(u8Idx, &stBufProperty);
3807
3808 #if ENABLE_ALLOCATOR_DEBUG
3809 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After GetFrameBufferProperty, stBufProperty:\n", __FUNCTION__, __LINE__);
3810 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tbCMA=%d, bDCMA=%d, bNDec=%d, bUseSubAllocator=%d\n",
3811 stBufProperty.bCMA,
3812 stBufProperty.bDynamicCMA,
3813 stBufProperty.bNDecode,
3814 stBufProperty.bUseSubAllocator);
3815 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tbUseThirdAllocator=%d, eSrcMode=%d, eCodecType=%d\n",
3816 stBufProperty.bUseThirdAllocator,
3817 stBufProperty.eSrcMode,
3818 stBufProperty.eCodecType);
3819 #endif
3820
3821 u16BlockIdMain = _VDEC_EX_NdecAllocator_GetMainBlock(pstNDecAllocator, eBufType, pstBufRgn, &stBufProperty);
3822 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMain) == FALSE)
3823 {
3824 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] GetMainBlock failed\n", __FUNCTION__, __LINE__);
3825 goto exit;
3826 }
3827 pstBlockMain = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMain);
3828
3829 #if ENABLE_ALLOCATOR_TRACE
3830 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After GetMainBlock, pstAllocatorMain:\n", __FUNCTION__, __LINE__);
3831 _VDEC_EX_Allocator_Print(pstAllocatorMain);
3832 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] u16BlockIdMain = %d\n", __FUNCTION__, __LINE__, u16BlockIdMain);
3833 #endif
3834
3835 if(stBufProperty.bUseSubAllocator == FALSE)
3836 {
3837 u16BlockIdTask = u16BlockIdMain;
3838 pstBlockTask = pstBlockMain;
3839 }
3840 else
3841 {
3842 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Start GetSubBlock\n", __FUNCTION__, __LINE__);
3843
3844 u16BlockIdSub = _VDEC_EX_NdecAllocator_GetSubBlock(pstBlockMain, eBufType, pstBufRgn, &stBufProperty);
3845 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdSub) == FALSE)
3846 {
3847 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] GetSubBlock failed\n", __FUNCTION__, __LINE__);
3848 goto exit;
3849 }
3850 pstBlockSub = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdSub);
3851
3852 #if ENABLE_ALLOCATOR_TRACE
3853 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] pstAllocatorSub:\n", __FUNCTION__, __LINE__);
3854 if(_VDEC_EX_Allocator_IsValidId(pstBlockMain->u16AllocatorIdExt) == TRUE)
3855 {
3856 VDEC_EX_Allocator *pstAllocatorSub = _VDEC_EX_Allocator_GetAddressById(pstBlockMain->u16AllocatorIdExt);
3857 _VDEC_EX_Allocator_Print(pstAllocatorSub);
3858 }
3859 #endif
3860
3861 if(stBufProperty.bUseThirdAllocator == FALSE)
3862 {
3863 u16BlockIdTask = u16BlockIdSub;
3864 pstBlockTask = pstBlockSub;
3865 }
3866 else
3867 {
3868 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Start GetThirdBlock\n", __FUNCTION__, __LINE__);
3869
3870 u16BlockIdThird = _VDEC_EX_NdecAllocator_GetThirdBlock(pstBlockSub);
3871 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdThird) == FALSE)
3872 {
3873 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] NdecAllocator_GetThirdBlock failed\n", __FUNCTION__, __LINE__);
3874 goto exit;
3875 }
3876 pstBlockThird = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdThird);
3877
3878 u16BlockIdTask = u16BlockIdThird;
3879 pstBlockTask = pstBlockThird;
3880
3881 #if ENABLE_ALLOCATOR_TRACE
3882 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] pstAllocatorThird:\n", __FUNCTION__, __LINE__);
3883 if(_VDEC_EX_Allocator_IsValidId(pstBlockSub->u16AllocatorIdExt) == TRUE)
3884 {
3885 VDEC_EX_Allocator *pstAllocatorThird = _VDEC_EX_Allocator_GetAddressById(pstBlockSub->u16AllocatorIdExt);
3886 _VDEC_EX_Allocator_Print(pstAllocatorThird);
3887 }
3888 #endif
3889 }
3890 }
3891
3892 #ifdef CMA_DRV_DIRECT_INIT
3893 if(stBufProperty.bCMA == TRUE && stBufProperty.bDynamicCMA == FALSE)
3894 {
3895 VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect = _VDEC_EX_NdecAllocator_CMAPoolSelect(eBufType);
3896
3897 if(eCMAPoolSelect == E_VDEC_EX_CMA_POOL_INVALID)
3898 {
3899 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] eCMAPoolSelect Wrong Buf Type\n", __FUNCTION__, __LINE__);
3900 goto exit;
3901 }
3902
3903 if(_VDEC_EX_NdecAllocator_CMAAlloc(eCMAPoolSelect, pstBlockTask->stBlockInfo.phyAddr, pstBlockTask->stBlockInfo.szSize) != E_VDEC_EX_OK)
3904 {
3905 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] CMAAlloc failed\n", __FUNCTION__, __LINE__);
3906 goto exit;
3907 }
3908 pstBlockTask->stBlockInfo.u8Property |= VDEC_EX_ALLOCAOTR_PROPERTY_USECMA;
3909 }
3910 #endif
3911
3912 // record
3913 if(eBufType != E_VDEC_EX_ALLOCATOR_BUFFER_FB2)
3914 {
3915 if(pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Main != VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED ||
3916 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Sub != VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED)
3917 {
3918 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] FB: stAllocatorRecord[%d] in used\n", __FUNCTION__, __LINE__, u8Idx);
3919 goto exit;
3920 }
3921 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Main = u16BlockIdMain;
3922 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Sub = u16BlockIdSub;
3923 if((stBufProperty.bNDecode == FALSE) && (stBufProperty.bDynamicCMA == TRUE))
3924 {
3925 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Not NDec + DCMA, Not save SB:\n", __FUNCTION__, __LINE__);
3926 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Sub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3927 }
3928
3929 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] FB: stAllocatorRecord[%d]:\n", __FUNCTION__, __LINE__, u8Idx);
3930 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tIdFB1Main=%d, IdFB1Sub=%d\n",
3931 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Main,
3932 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Sub);
3933 }
3934 else
3935 {
3936 if(pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Main != VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED ||
3937 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Sub != VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED)
3938 {
3939 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] FB2: stAllocatorRecord[%d] in used\n", __FUNCTION__, __LINE__, u8Idx);
3940 goto exit;
3941 }
3942 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Main = u16BlockIdMain;
3943 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Sub = u16BlockIdSub;
3944 if((stBufProperty.bNDecode == FALSE) && (stBufProperty.bDynamicCMA == TRUE))
3945 {
3946 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Not NDec + DCMA, Not save SB:\n", __FUNCTION__, __LINE__);
3947 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Sub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
3948 }
3949
3950 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] FB2: stAllocatorRecord[%d]:\n", __FUNCTION__, __LINE__, u8Idx);
3951 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG]\tIdFB2Main=%d, IdFB2Sub=%d\n",
3952 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Main,
3953 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Sub);
3954 }
3955
3956 // output result
3957 *ppstBlockResult = pstBlockTask;
3958
3959 // all success
3960 eRet = E_VDEC_EX_OK;
3961
3962 #if ENABLE_ALLOCATOR_TRACE
3963 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] FB pstAllocatorMain:\n", __FUNCTION__, __LINE__);
3964 _VDEC_EX_Allocator_Print(pstAllocatorMain);
3965 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] FB pstAllocatorSub:\n", __FUNCTION__, __LINE__);
3966 if(_VDEC_EX_Allocator_IsValidId(pstBlockMain->u16AllocatorIdExt) == TRUE)
3967 {
3968 VDEC_EX_Allocator *pstAllocatorSub = _VDEC_EX_Allocator_GetAddressById(pstBlockMain->u16AllocatorIdExt);
3969 _VDEC_EX_Allocator_Print(pstAllocatorSub);
3970 }
3971 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] FB *ppstBlockResult:\n", __FUNCTION__, __LINE__);
3972 _VDEC_EX_Allocator_BlockPrint(*ppstBlockResult);
3973 #endif
3974
3975 exit:
3976 return eRet;
3977 }
3978
_VDEC_EX_NdecAllocator_FreeBlock(VDEC_EX_Allocator * pstAllocatorFree,MS_U16 u16BlockIdFree,VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect)3979 static VDEC_EX_Result _VDEC_EX_NdecAllocator_FreeBlock(VDEC_EX_Allocator *pstAllocatorFree, MS_U16 u16BlockIdFree, VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect)
3980 {
3981 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
3982 VDEC_EX_Allocator_Block *pstBlockFree;
3983
3984 if(pstAllocatorFree == NULL ||
3985 _VDEC_EX_Allocator_BlockIsValidId(u16BlockIdFree) == FALSE)
3986 {
3987 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invalid input\n", __FUNCTION__, __LINE__);
3988 goto exit;
3989 }
3990 pstBlockFree = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdFree);
3991
3992 if(_VDEC_EX_Allocator_IsValidId(pstBlockFree->u16AllocatorIdExt) == TRUE)
3993 {
3994 VDEC_EX_Allocator *pstAllocatorExt = _VDEC_EX_Allocator_GetAddressById(pstBlockFree->u16AllocatorIdExt);
3995 VDEC_EX_Allocator_Block *pstBlockExt;
3996 MS_U16 u16BlockIdExt;
3997
3998 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Start Free pstAllocatorExt\n", __FUNCTION__, __LINE__);
3999
4000 u16BlockIdExt = pstAllocatorExt->stBlockList.u16BlockIdHead;
4001 while(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdExt) == TRUE)
4002 {
4003 pstBlockExt = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdExt);
4004
4005 #if ENABLE_ALLOCATOR_TRACE
4006 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] pstBlockExt:\n", __FUNCTION__, __LINE__);
4007 _VDEC_EX_Allocator_BlockPrint(pstBlockExt);
4008 #endif
4009
4010 if(pstBlockExt->stBlockInfo.u16Allocated == 1)
4011 {
4012 #ifdef CMA_DRV_DIRECT_INIT
4013 // free CMA
4014 if(pstBlockExt->stBlockInfo.u8Property & VDEC_EX_ALLOCAOTR_PROPERTY_USECMA)
4015 {
4016 if(_VDEC_EX_NdecAllocator_CMAFree(eCMAPoolSelect, pstBlockExt->stBlockInfo.phyAddr, pstBlockExt->stBlockInfo.szSize) != E_VDEC_EX_OK)
4017 {
4018 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] NdecAllocator_CMAFree failed\n", __FUNCTION__, __LINE__);
4019 goto exit;
4020 }
4021 pstBlockExt->stBlockInfo.u8Property &= ~VDEC_EX_ALLOCAOTR_PROPERTY_USECMA;
4022 }
4023 #endif
4024 // free block
4025 u16BlockIdExt = _VDEC_EX_Allocator_Free(pstAllocatorExt, u16BlockIdExt);
4026 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdExt) == FALSE)
4027 {
4028 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Allocator_Free failed\n", __FUNCTION__, __LINE__);
4029 goto exit;
4030 }
4031 }
4032
4033 // if already free all blocks
4034 if(pstAllocatorExt->szUnusedSize == pstAllocatorExt->szTotalSize)
4035 {
4036 break;
4037 }
4038 pstBlockExt = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdExt);
4039 u16BlockIdExt = pstBlockExt->u16BlockIdNext;
4040 }
4041
4042 // remove extend allocator
4043 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] u16BlockIdExt=%d\n", __FUNCTION__, __LINE__, u16BlockIdExt);
4044 if(u16BlockIdExt != pstAllocatorExt->stBlockList.u16BlockIdHead)
4045 {
4046 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Should not run here\n", __FUNCTION__, __LINE__);
4047 goto exit;
4048 }
4049
4050 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdExt) == FALSE)
4051 {
4052 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] remove extend allocator failed\n", __FUNCTION__, __LINE__);
4053 goto exit;
4054 }
4055 pstBlockExt = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdExt);
4056
4057 pstBlockExt->u16BlockId = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4058 pstAllocatorExt->u16AllocatorId = VDEC_EX_ALLOCAOTR_ID_UNUSED;
4059 pstBlockFree->u16AllocatorIdExt = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4060 }
4061
4062 #ifdef CMA_DRV_DIRECT_INIT
4063 // free CMA
4064 if(pstBlockFree->stBlockInfo.u8Property & VDEC_EX_ALLOCAOTR_PROPERTY_USECMA)
4065 {
4066 if(_VDEC_EX_NdecAllocator_CMAFree(eCMAPoolSelect, pstBlockFree->stBlockInfo.phyAddr, pstBlockFree->stBlockInfo.szSize) != E_VDEC_EX_OK)
4067 {
4068 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] NdecAllocator_CMAFree failed\n", __FUNCTION__, __LINE__);
4069 goto exit;
4070 }
4071 pstBlockFree->stBlockInfo.u8Property &= ~VDEC_EX_ALLOCAOTR_PROPERTY_USECMA;
4072 }
4073 #endif
4074
4075 // free block
4076 u16BlockIdFree = _VDEC_EX_Allocator_Free(pstAllocatorFree, u16BlockIdFree);
4077 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdFree) == FALSE)
4078 {
4079 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Allocator_Free failed\n", __FUNCTION__, __LINE__);
4080 goto exit;
4081 }
4082
4083 // all success
4084 eRet = E_VDEC_EX_OK;
4085 exit:
4086 return eRet;
4087 }
4088
_VDEC_EX_NdecAllocator_FreeBuffer(MS_U8 u8Idx,VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType)4089 static VDEC_EX_Result _VDEC_EX_NdecAllocator_FreeBuffer(MS_U8 u8Idx, VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType)
4090 {
4091 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
4092 VDEC_EX_NDecAllocator *pstNDecAllocator = &(pVdecExContext->stNDecAllocator);
4093 VDEC_EX_Allocator *pstAllocatorMain;
4094 MS_U16 u16BlockIdMain;
4095 MS_U16 u16BlockIdSub;
4096 VDEC_EX_CMA_POOL_SELECT eCMAPoolSelect = E_VDEC_EX_CMA_POOL_BUFFER_FB1; // initial
4097
4098 switch(eBufType)
4099 {
4100 case E_VDEC_EX_ALLOCATOR_BUFFER_FB1:
4101 eCMAPoolSelect = E_VDEC_EX_CMA_POOL_BUFFER_FB1;
4102 u16BlockIdMain = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Main;
4103 u16BlockIdSub = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Sub;
4104 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Main = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4105 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Sub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4106 #ifdef CMA_DRV_DIRECT_INIT
4107 pstNDecAllocator->szCMAAllocLength[eCMAPoolSelect][u8Idx] = 0;
4108 #endif
4109 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Free FB1 Start, MB=%d, SB=%d\n", __FUNCTION__, __LINE__, u16BlockIdMain, u16BlockIdSub);
4110 break;
4111 case E_VDEC_EX_ALLOCATOR_BUFFER_FB2:
4112 eCMAPoolSelect = E_VDEC_EX_CMA_POOL_BUFFER_FB2;
4113 u16BlockIdMain = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Main;
4114 u16BlockIdSub = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Sub;
4115 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Main = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4116 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Sub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4117 #ifdef CMA_DRV_DIRECT_INIT
4118 pstNDecAllocator->szCMAAllocLength[eCMAPoolSelect][u8Idx] = 0;
4119 #endif
4120 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Free FB2 Start, MB=%d, SB=%d\n", __FUNCTION__, __LINE__, u16BlockIdMain, u16BlockIdSub);
4121 break;
4122 case E_VDEC_EX_ALLOCATOR_BUFFER_BS:
4123 u16BlockIdMain = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Main;
4124 u16BlockIdSub = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Sub;
4125 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Main = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4126 pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdBS1Sub = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4127 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Free BS Start, MB=%d, SB=%d\n", __FUNCTION__, __LINE__, u16BlockIdMain, u16BlockIdSub);
4128 break;
4129 default:
4130 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Input type not define\n", __FUNCTION__, __LINE__);
4131 goto exit;
4132 break;
4133 }
4134
4135 pstAllocatorMain = _VDEC_EX_Allocator_GetAddressById(pstNDecAllocator->u16AllocatorIdMain);
4136
4137 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMain) == TRUE)
4138 {
4139 VDEC_EX_Allocator_Block *pstBlockMain = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdMain);
4140
4141 // Case of Dynamic CMA using in original Main stream
4142 if((pstBlockMain->u16AllocatorIdExt != VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED) &&
4143 (_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdSub) == FALSE))
4144 {
4145 #if ENABLE_ALLOCATOR_TRACE
4146 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Before FreeBuffer, pstAllocatorMain:\n", __FUNCTION__, __LINE__);
4147 _VDEC_EX_Allocator_Print(pstAllocatorMain);
4148 #endif
4149
4150 if(_VDEC_EX_NdecAllocator_FreeBlock(pstAllocatorMain, u16BlockIdMain, eCMAPoolSelect) != E_VDEC_EX_OK)
4151 {
4152 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] NdecAllocator_FreeBlock failed\n", __FUNCTION__, __LINE__);
4153 goto exit;
4154 }
4155 }
4156 else
4157 {
4158 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdSub) == TRUE)
4159 {
4160 VDEC_EX_Allocator *pstAllocatorSub = _VDEC_EX_Allocator_GetAddressById(pstBlockMain->u16AllocatorIdExt);
4161
4162 #if ENABLE_ALLOCATOR_TRACE
4163 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Before Free pstAllocatorSub block %d:\n", __FUNCTION__, __LINE__, u16BlockIdSub);
4164 _VDEC_EX_Allocator_Print(pstAllocatorSub);
4165 #endif
4166
4167 if(_VDEC_EX_NdecAllocator_FreeBlock(pstAllocatorSub, u16BlockIdSub, eCMAPoolSelect) != E_VDEC_EX_OK)
4168 {
4169 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] NdecAllocator_FreeBlock failed\n", __FUNCTION__, __LINE__);
4170 goto exit;
4171 }
4172
4173 #if ENABLE_ALLOCATOR_TRACE
4174 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] After Free pstAllocatorSub block %d:\n", __FUNCTION__, __LINE__, u16BlockIdSub);
4175 _VDEC_EX_Allocator_Print(pstAllocatorSub);
4176 #endif
4177
4178 // check remove sub allocator
4179 if(pstAllocatorSub->szUnusedSize == pstAllocatorSub->szTotalSize)
4180 {
4181 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Start Remove pstAllocatorSub\n", __FUNCTION__, __LINE__);
4182
4183 VDEC_EX_Allocator_Block *pstBlock = _VDEC_EX_Allocator_BlockGetAddressById(pstAllocatorSub->stBlockList.u16BlockIdHead);
4184 pstBlock->u16BlockId = VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED;
4185 pstAllocatorSub->u16AllocatorId = VDEC_EX_ALLOCAOTR_ID_UNUSED;
4186 pstBlockMain->u16AllocatorIdExt = VDEC_EX_ALLOCAOTR_ID_UNUSED;
4187 pstBlockMain->stBlockInfo.u8Property &= ~VDEC_EX_ALLOCAOTR_PROPERTY_CAN_OVERLAP;
4188 }
4189 }
4190
4191 if(pstBlockMain->u16AllocatorIdExt == VDEC_EX_ALLOCAOTR_BLOCK_ID_UNUSED)
4192 {
4193 #if ENABLE_ALLOCATOR_TRACE
4194 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Before FreeBuffer, pstAllocatorMain:\n", __FUNCTION__, __LINE__);
4195 _VDEC_EX_Allocator_Print(pstAllocatorMain);
4196 #endif
4197
4198 if(_VDEC_EX_NdecAllocator_FreeBlock(pstAllocatorMain, u16BlockIdMain, eCMAPoolSelect) != E_VDEC_EX_OK)
4199 {
4200 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] _VDEC_EX_NdecAllocator_FreeBlock fail\n", __FUNCTION__, __LINE__);
4201 goto exit;
4202 }
4203 }
4204 }
4205 }
4206
4207 #if ENABLE_ALLOCATOR_TRACE
4208 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] Final pstAllocatorMain:\n", __FUNCTION__, __LINE__);
4209 _VDEC_EX_Allocator_Print(pstAllocatorMain);
4210 #endif
4211 VPRINTF("[ALLOC][DBG][%s][%d] Used Allocators:%d, Used Blocks:%d\n", __FUNCTION__, __LINE__,
4212 _VDEC_EX_Allocator_CountUsedAllocators(pstNDecAllocator),
4213 _VDEC_EX_Allocator_CountUsedBlocks(pstNDecAllocator));
4214
4215 eRet = E_VDEC_EX_OK;
4216
4217 exit:
4218 return eRet;
4219 }
4220 /*
4221 static VDEC_EX_Result _VDEC_EX_NdecAllocator_GetFrameBufferBlock(MS_U8 u8Idx, VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType,
4222 VDEC_EX_Allocator_Block **ppstBlockFB)
4223 {
4224 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
4225 VDEC_EX_NDecAllocator *pstNDecAllocator = &(pVdecExContext->stNDecAllocator);
4226 VDEC_EX_Allocator_Block *pstBlockTask;
4227 MS_U16 u16BlockIdTask;
4228 MS_U16 u16BlockIdMain;
4229 MS_U16 u16BlockIdSub;
4230
4231 switch(eBufType)
4232 {
4233 case E_VDEC_EX_ALLOCATOR_BUFFER_FB1:
4234 u16BlockIdMain = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Main;
4235 u16BlockIdSub = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB1Sub;
4236 break;
4237 case E_VDEC_EX_ALLOCATOR_BUFFER_FB2:
4238 u16BlockIdMain = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Main;
4239 u16BlockIdSub = pstNDecAllocator->stAllocatorRecord[u8Idx].u16BlockIdFB2Sub;
4240 break;
4241 default:
4242 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Input type not support\n", __FUNCTION__, __LINE__);
4243 break;
4244 }
4245
4246 if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdSub) == TRUE)
4247 {
4248 u16BlockIdTask = u16BlockIdSub;
4249 }
4250 else if(_VDEC_EX_Allocator_BlockIsValidId(u16BlockIdMain) == TRUE)
4251 {
4252 u16BlockIdTask = u16BlockIdMain;
4253 }
4254 else
4255 {
4256 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] No valid task block\n", __FUNCTION__, __LINE__);
4257 goto exit;
4258 }
4259
4260 pstBlockTask = _VDEC_EX_Allocator_BlockGetAddressById(u16BlockIdTask);
4261 *ppstBlockFB = pstBlockTask;
4262
4263 // all success
4264 eRet = E_VDEC_EX_OK;
4265
4266 exit:
4267 return eRet;
4268 }
4269
4270 static VDEC_EX_Result _VDEC_EX_NdecAllocator_GetFrameBufferSize(MS_U8 u8Idx,
4271 MS_SIZE *pszFrameBuf1, MS_SIZE *pszFrameBuf2)
4272 {
4273 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
4274 VDEC_EX_Allocator_Block *pstBlockFB1 = NULL;
4275 VDEC_EX_Allocator_Block *pstBlockFB2 = NULL;
4276
4277 if(pszFrameBuf1 == NULL || pszFrameBuf2 == NULL)
4278 {
4279 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] Invaild input\n", __FUNCTION__, __LINE__);
4280 goto exit;
4281 }
4282
4283 if(_VDEC_EX_NdecAllocator_GetFrameBufferBlock(u8Idx, E_VDEC_EX_ALLOCATOR_BUFFER_FB1, &pstBlockFB1) == E_VDEC_EX_OK)
4284 {
4285 *pszFrameBuf1 = pstBlockFB1->stBlockInfo.szSize;
4286 }
4287 else
4288 {
4289 *pszFrameBuf1 = 0;
4290 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d] No Frame Buf1 Info\n", __FUNCTION__, __LINE__);
4291 }
4292
4293 if(_VDEC_EX_NdecAllocator_GetFrameBufferBlock(u8Idx, E_VDEC_EX_ALLOCATOR_BUFFER_FB2, &pstBlockFB2) == E_VDEC_EX_OK)
4294 {
4295 *pszFrameBuf2 = pstBlockFB2->stBlockInfo.szSize;
4296 }
4297 else
4298 {
4299 *pszFrameBuf2 = 0;
4300 ALLOCATOR_PRINTF_DBG("[ALLOC][DBG][%s][%d] No Frame Buf2 Info\n", __FUNCTION__, __LINE__);
4301 }
4302
4303 // all success
4304 eRet = E_VDEC_EX_OK;
4305
4306 exit:
4307 return eRet;
4308 }
4309 */
4310 // N Decode Buffer Allocator Functions End
4311
_VDEC_EX_InitDq(MS_U8 u8StreamNum)4312 static void _VDEC_EX_InitDq(MS_U8 u8StreamNum)
4313 {
4314 MS_U32 i = 0;
4315
4316 for (i = 0; i < MAX_VDEC_DQNUM; i++)
4317 {
4318 pVdecExContext->_stDispQ[u8StreamNum][i].u32Idx = VDEC_DQ_EMPTY;
4319 }
4320
4321 }
4322
_VDEC_EX_MallocDq(MS_U8 u8StreamNum)4323 static VDEC_EX_DispFrame *_VDEC_EX_MallocDq(MS_U8 u8StreamNum)
4324 {
4325 VDEC_EX_DispFrame *pDisp = NULL;
4326 MS_U32 i = 0;
4327
4328 if (u8StreamNum >= VDEC_MAX_SUPPORT_STREAM_NUM)
4329 {
4330 return NULL;
4331 }
4332
4333 for (i = 0; i < MAX_VDEC_DQNUM; i++)
4334 {
4335 if (pVdecExContext->_stDispQ[u8StreamNum][i].u32Idx == VDEC_DQ_EMPTY)
4336 {
4337 pVdecExContext->_stDispQ[u8StreamNum][i].u32Idx = i;
4338 pDisp = &(pVdecExContext->_stDispQ[u8StreamNum][i]);
4339 //VDEC_PRINT("_VDEC_EX_MallocDq %ld\n", i);
4340 break;
4341 }
4342 }
4343
4344 return pDisp;
4345 }
4346
_VDEC_EX_FreeDq(MS_U8 u8StreamNum,VDEC_EX_DispFrame * pDq)4347 static void _VDEC_EX_FreeDq(MS_U8 u8StreamNum, VDEC_EX_DispFrame *pDq)
4348 {
4349 if (pDq && pDq->u32Idx != VDEC_DQ_EMPTY)
4350 {
4351 pVdecExContext->_stDispQ[u8StreamNum][pDq->u32Idx].u32Idx = VDEC_DQ_EMPTY;
4352 }
4353 }
4354
_VDEC_EX_IsDqValid(VDEC_EX_DispFrame * pDq)4355 static MS_BOOL _VDEC_EX_IsDqValid(VDEC_EX_DispFrame *pDq)
4356 {
4357 MS_BOOL bRet = FALSE;
4358
4359 if (pDq)
4360 {
4361 bRet = (pDq->u32Idx == VDEC_DQ_EMPTY);
4362 }
4363
4364 return bRet;
4365 }
4366
4367
4368
_VDEC_EX_InitLocalVar(MS_U32 u8Idx)4369 static void _VDEC_EX_InitLocalVar(MS_U32 u8Idx)
4370 {
4371 MS_U32 cb_idx = 0;
4372 VDEC_EX_Attr* pAttr = &(pVdecExContext->_Attr[u8Idx]);
4373 pAttr->bInit = FALSE;
4374 pAttr->eDbgMsgLevel = VDEC_EX_DEFAULT_DBG_MSG_LEVEL;
4375 pAttr->eCodecType = E_VDEC_EX_CODEC_TYPE_NONE;
4376 pAttr->eDecoder = E_VDEC_EX_DECODER_NONE;
4377 pAttr->eErrCode = E_VDEC_EX_ERR_CODE_BASE;
4378 pVdecExContext->u8enable_store_set_cmd[u8Idx] = FALSE;
4379 pVdecExContext->store_set_cmd_write_pointer[u8Idx] = 0;
4380
4381 #if (VDEC_EX_ISR_MONITOR)
4382 MsOS_ClearEvent(s32VdecExEventId[u8Idx], VDEC_U32_MAX);
4383 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
4384 pVdecExContext->_u32PreVdecExIsrEventFlag[u8Idx] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
4385 MsOS_SetEvent(s32VdecExEventId[u8Idx], E_VDEC_EX_EVENT_ISR_EVENT_CHANGE);
4386 #else
4387 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = 0;
4388 #endif
4389
4390 pVdecExContext->_pVdec_IsrProc[u8Idx] = NULL;
4391 for (cb_idx=0; cb_idx<E_VDEC_EX_CB_MAX_NUM; cb_idx++)
4392 {
4393 VDEC_EX_EventInfo* pEventInfo = &pAttr->vdecExEventInfo[cb_idx];
4394 pEventInfo->u32EventBitMap = 0;
4395 pEventInfo->pVdecEventCb = NULL;
4396 pEventInfo->pParam = NULL;
4397 }
4398
4399 //_VDEC_Memset(&pAttr->vdecExInitParam, 0, sizeof(VDEC_EX_InitParam));
4400
4401 _VDEC_EX_InitDq(u8Idx);
4402 }
4403
_VDEC_EX_Map2MVDCodecType(VDEC_EX_CodecType vdecCodecType)4404 static MVD_CodecType _VDEC_EX_Map2MVDCodecType(VDEC_EX_CodecType vdecCodecType)
4405 {
4406 MVD_CodecType mvdCodecType = E_MVD_CODEC_UNKNOWN;
4407
4408 switch (vdecCodecType)
4409 {
4410 case E_VDEC_EX_CODEC_TYPE_MPEG2:
4411 mvdCodecType = E_MVD_CODEC_MPEG2;
4412 break;
4413
4414 case E_VDEC_EX_CODEC_TYPE_H263:
4415 mvdCodecType = E_MVD_CODEC_MPEG4_SHORT_VIDEO_HEADER;
4416 break;
4417
4418 case E_VDEC_EX_CODEC_TYPE_MPEG4:
4419 case E_VDEC_EX_CODEC_TYPE_DIVX412:
4420 mvdCodecType = E_MVD_CODEC_MPEG4;
4421 break;
4422
4423 case E_VDEC_EX_CODEC_TYPE_DIVX311:
4424 mvdCodecType = E_MVD_CODEC_DIVX311;
4425 break;
4426
4427 case E_VDEC_EX_CODEC_TYPE_FLV:
4428 mvdCodecType = E_MVD_CODEC_FLV;
4429 break;
4430
4431 case E_VDEC_EX_CODEC_TYPE_VC1_ADV:
4432 mvdCodecType = E_MVD_CODEC_VC1_ADV;
4433 break;
4434
4435 case E_VDEC_EX_CODEC_TYPE_VC1_MAIN:
4436 mvdCodecType = E_MVD_CODEC_VC1_MAIN;
4437 break;
4438
4439 default:
4440 mvdCodecType = E_MVD_CODEC_UNKNOWN;
4441 break;
4442 }
4443
4444 return mvdCodecType;
4445 }
4446
_VDEC_EX_Map2HVDCodecType(VDEC_EX_CodecType vdecCodecType)4447 static HVD_EX_Codec _VDEC_EX_Map2HVDCodecType(VDEC_EX_CodecType vdecCodecType)
4448 {
4449 HVD_EX_Codec hvdCodecType = E_HVD_EX_NONE;
4450
4451 switch (vdecCodecType)
4452 {
4453 case E_VDEC_EX_CODEC_TYPE_RV8:
4454 case E_VDEC_EX_CODEC_TYPE_RV9:
4455 hvdCodecType = E_HVD_EX_RM;
4456 break;
4457
4458 case E_VDEC_EX_CODEC_TYPE_H264:
4459 hvdCodecType = E_HVD_EX_AVC;
4460 break;
4461
4462 case E_VDEC_EX_CODEC_TYPE_AVS:
4463 hvdCodecType = E_HVD_EX_AVS;
4464 break;
4465
4466 case E_VDEC_EX_CODEC_TYPE_MVC:
4467 hvdCodecType = E_HVD_EX_MVC;
4468 break;
4469
4470 case E_VDEC_EX_CODEC_TYPE_VP8:
4471 hvdCodecType = E_HVD_EX_VP8;
4472 break;
4473
4474 case E_VDEC_EX_CODEC_TYPE_HEVC:
4475 hvdCodecType = E_HVD_EX_HEVC;
4476 break;
4477
4478 case E_VDEC_EX_CODEC_TYPE_VP9:
4479 hvdCodecType = E_HVD_EX_VP9;
4480 break;
4481
4482 default:
4483 hvdCodecType = E_HVD_EX_NONE;
4484 break;
4485 }
4486
4487 return hvdCodecType;
4488 }
4489
_VDEC_EX_Map2MVDSrcMode(VDEC_EX_SrcMode vdecSrcMode)4490 static MVD_SrcMode _VDEC_EX_Map2MVDSrcMode(VDEC_EX_SrcMode vdecSrcMode)
4491 {
4492 MVD_SrcMode mvdSrcMode = E_MVD_TS_MODE;
4493
4494 switch (vdecSrcMode)
4495 {
4496 case E_VDEC_EX_SRC_MODE_DTV:
4497 mvdSrcMode = E_MVD_TS_MODE;
4498 break;
4499
4500 case E_VDEC_EX_SRC_MODE_TS_FILE:
4501 mvdSrcMode = E_MVD_TS_FILE_MODE;
4502 break;
4503
4504 case E_VDEC_EX_SRC_MODE_FILE:
4505 mvdSrcMode = E_MVD_SLQ_TBL_MODE;
4506 break;
4507
4508 default:
4509 mvdSrcMode = E_MVD_TS_MODE;
4510 break;
4511 }
4512
4513 return mvdSrcMode;
4514 }
4515
_VDEC_EX_MapFrmType2MVD(MVD_PicType vdecPicType)4516 static VDEC_EX_FrameType _VDEC_EX_MapFrmType2MVD(MVD_PicType vdecPicType)
4517 {
4518 VDEC_EX_FrameType mvdFrmType = E_VDEC_EX_FRM_TYPE_NUM;
4519
4520 switch (vdecPicType)
4521 {
4522 case E_MVD_PIC_I:
4523 mvdFrmType = E_VDEC_EX_FRM_TYPE_I;
4524 break;
4525
4526 case E_MVD_PIC_P:
4527 mvdFrmType = E_VDEC_EX_FRM_TYPE_P;
4528 break;
4529
4530 case E_MVD_PIC_B:
4531 mvdFrmType = E_VDEC_EX_FRM_TYPE_B;
4532 break;
4533
4534 case E_MVD_PIC_UNKNOWN:
4535 mvdFrmType = E_VDEC_EX_FRM_TYPE_OTHER;
4536 break;
4537
4538 default:
4539 mvdFrmType = E_VDEC_EX_FRM_TYPE_NUM;
4540 break;
4541 }
4542
4543 return mvdFrmType;
4544 }
4545
_VDEC_EX_MapFrmType2HVD(HVD_EX_FrmType vdecFrmType)4546 static VDEC_EX_FrameType _VDEC_EX_MapFrmType2HVD(HVD_EX_FrmType vdecFrmType)
4547 {
4548 VDEC_EX_FrameType hvdFrmType = E_VDEC_EX_FRM_TYPE_NUM;
4549
4550 switch (vdecFrmType)
4551 {
4552 case E_HVD_EX_FRM_TYPE_I:
4553 hvdFrmType = E_VDEC_EX_FRM_TYPE_I;
4554 break;
4555
4556 case E_HVD_EX_FRM_TYPE_P:
4557 hvdFrmType = E_VDEC_EX_FRM_TYPE_P;
4558 break;
4559
4560 case E_HVD_EX_FRM_TYPE_B:
4561 hvdFrmType = E_VDEC_EX_FRM_TYPE_B;
4562 break;
4563
4564 case E_HVD_EX_FRM_TYPE_OTHER:
4565 hvdFrmType = E_VDEC_EX_FRM_TYPE_OTHER;
4566 break;
4567
4568 default:
4569 hvdFrmType = E_VDEC_EX_FRM_TYPE_NUM;
4570 break;
4571 }
4572
4573 return hvdFrmType;
4574 }
4575
_VDEC_EX_MapFrmType2MJPEG(MJPEG_FrameType vdecFrmType)4576 static VDEC_EX_FrameType _VDEC_EX_MapFrmType2MJPEG(MJPEG_FrameType vdecFrmType)
4577 {
4578 VDEC_EX_FrameType mjpegFrmType = E_VDEC_EX_FRM_TYPE_NUM;
4579
4580 switch (vdecFrmType)
4581 {
4582 case E_MJPEG_FRM_TYPE_I:
4583 mjpegFrmType = E_VDEC_EX_FRM_TYPE_I;
4584 break;
4585
4586 case E_MJPEG_FRM_TYPE_OTHER:
4587 mjpegFrmType = E_VDEC_EX_FRM_TYPE_OTHER;
4588 break;
4589
4590 default:
4591 mjpegFrmType = E_VDEC_EX_FRM_TYPE_NUM;
4592 break;
4593 }
4594
4595 return mjpegFrmType;
4596 }
4597
4598
_VDEC_EX_MapFieldType2HVD(HVD_EX_FieldType vdecFieldType)4599 static VDEC_EX_FieldType _VDEC_EX_MapFieldType2HVD(HVD_EX_FieldType vdecFieldType)
4600 {
4601 VDEC_EX_FieldType hvdFieldType = E_VDEC_EX_FIELDTYPE_NONE;
4602
4603 switch (vdecFieldType)
4604 {
4605 case E_HVD_EX_FIELDTYPE_NONE:
4606 hvdFieldType = E_VDEC_EX_FIELDTYPE_NONE;
4607 break;
4608
4609 case E_HVD_EX_FIELDTYPE_TOP:
4610 hvdFieldType = E_VDEC_EX_FIELDTYPE_TOP;
4611 break;
4612
4613 case E_HVD_EX_FIELDTYPE_BOTTOM:
4614 hvdFieldType = E_VDEC_EX_FIELDTYPE_BOTTOM;
4615 break;
4616
4617 case E_HVD_EX_FIELDTYPE_BOTH:
4618 hvdFieldType = E_VDEC_EX_FIELDTYPE_BOTH;
4619 break;
4620
4621 default:
4622 hvdFieldType = E_VDEC_EX_FIELDTYPE_NUM;
4623 break;
4624 }
4625
4626 return hvdFieldType;
4627 }
4628
_VDEC_EX_MVDCfgDivX(MS_U32 u32Id,VDEC_EX_CodecType vdecCodecType)4629 static void _VDEC_EX_MVDCfgDivX(MS_U32 u32Id, VDEC_EX_CodecType vdecCodecType)
4630 {
4631 switch (vdecCodecType)
4632 {
4633 case E_VDEC_EX_CODEC_TYPE_MPEG4:
4634 MDrv_MVD_SetDivXCfg(u32Id, 0x01, 0x01);
4635 break;
4636
4637 case E_VDEC_EX_CODEC_TYPE_DIVX412:
4638 MDrv_MVD_SetDivXCfg(u32Id, 0x11, 0x01);
4639 break;
4640
4641 case E_VDEC_EX_CODEC_TYPE_DIVX311:
4642 MDrv_MVD_SetDivXCfg(u32Id, 0x00, 0x00);
4643 break;
4644
4645 default:
4646 break;
4647 }
4648
4649 return;
4650 }
4651
_VDEC_EX_IsIdle(VDEC_StreamId * pStreamId)4652 MS_BOOL _VDEC_EX_IsIdle(VDEC_StreamId *pStreamId)
4653 {
4654 MS_BOOL bRet;
4655 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4656
4657 _VDEC_INVALID_IDX_RET(u8Idx);
4658
4659 if (!(pVdecExContext->_Attr[u8Idx].bInit))
4660 {
4661 return FALSE;
4662 }
4663
4664 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4665 {
4666 case E_VDEC_EX_DECODER_MVD:
4667 bRet = MDrv_MVD_IsIdle(pStreamId->u32Id);
4668 break;
4669
4670 case E_VDEC_EX_DECODER_HVD:
4671 bRet = MDrv_HVD_EX_IsIdle(pStreamId->u32Id);
4672 break;
4673
4674 case E_VDEC_EX_DECODER_MJPEG:
4675 _VDEC_EX_API_MutexLock();
4676 bRet = MApi_MJPEG_IsIdle(pStreamId->u32Id);
4677 _VDEC_EX_API_MutexUnlock();
4678 break;
4679
4680 default:
4681 bRet = FALSE;
4682 break;
4683 }
4684
4685 return bRet;
4686 }
4687
_VDEC_EX_Map2MVDSpeed(VDEC_EX_DispSpeed eSpeed)4688 static MS_U8 _VDEC_EX_Map2MVDSpeed(VDEC_EX_DispSpeed eSpeed)
4689 {
4690 MS_U8 u8Speed = 0;
4691 switch (eSpeed)
4692 {
4693 case E_VDEC_EX_DISP_SPEED_32X:
4694 u8Speed = 32;
4695 break;
4696
4697 case E_VDEC_EX_DISP_SPEED_16X:
4698 u8Speed = 16;
4699 break;
4700
4701 case E_VDEC_EX_DISP_SPEED_8X:
4702 u8Speed = 8;
4703 break;
4704
4705 case E_VDEC_EX_DISP_SPEED_4X:
4706 u8Speed = 4;
4707 break;
4708
4709 case E_VDEC_EX_DISP_SPEED_2X:
4710 u8Speed = 2;
4711 break;
4712
4713 case E_VDEC_EX_DISP_SPEED_1X:
4714 u8Speed = 1;
4715 break;
4716
4717 default:
4718 u8Speed = 0;
4719 break;
4720 }
4721 return u8Speed;
4722 }
4723
4724 //------------------------------------------------------------------------------
4725 /// Enable to let decoder force to display repeat last field
4726 /// @param bEnable \b IN : TRUE - enable; FALSE - disable
4727 /// @return VDEC_EX_Result
4728 //------------------------------------------------------------------------------
_VDEC_EX_RepeatLastField(VDEC_StreamId * pStreamId,MS_BOOL bEnable)4729 static VDEC_EX_Result _VDEC_EX_RepeatLastField(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
4730 {
4731 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4732 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4733 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4734
4735 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4736 {
4737 case E_VDEC_EX_DECODER_MVD:
4738 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_DispRepeatField(u32Id, bEnable));
4739 break;
4740 case E_VDEC_EX_DECODER_HVD:
4741 {
4742 _HVD_RET_HANDLE(MDrv_HVD_EX_SetDispRepeatField(u32Id, bEnable));
4743 break;
4744 }
4745 case E_VDEC_EX_DECODER_MJPEG:
4746 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4747 break;
4748 default:
4749 break;
4750 }
4751
4752 return eRet;
4753 }
4754
4755 //------------------------------------------------------------------------------
4756 /// Set the maximum repeat times for one frame when av is not sync.
4757 /// @param -u32Th \b IN : repeat times. 0x01 ~ 0xFF
4758 /// 0xff - repeat current frame until STC catch up PTS.
4759 /// @return -The result of command set sync repeat threashold
4760 //------------------------------------------------------------------------------
_VDEC_EX_SetAVSyncRepeatThreshold(VDEC_StreamId * pStreamId,MS_U32 u32Th)4761 static VDEC_EX_Result _VDEC_EX_SetAVSyncRepeatThreshold(VDEC_StreamId *pStreamId, MS_U32 u32Th)
4762 {
4763 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
4764 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4765 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4766
4767 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4768 {
4769 case E_VDEC_EX_DECODER_MVD:
4770 MDrv_MVD_SetAVSyncThreshold(u32Id, u32Th);
4771 eRet = E_VDEC_EX_OK;
4772 break;
4773 case E_VDEC_EX_DECODER_HVD:
4774 {
4775 _HVD_RET_HANDLE(MDrv_HVD_EX_SetSyncRepeatTH(u32Id, u32Th));
4776 eRet = E_VDEC_EX_OK;
4777 break;
4778 }
4779 case E_VDEC_EX_DECODER_MJPEG:
4780 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4781 break;
4782 default:
4783 break;
4784 }
4785
4786 return eRet;
4787 }
4788
4789 //------------------------------------------------------------------------------
4790 /// Enable FW only show one field.
4791 /// @param bEnable \b IN : TRUE - show one field; FALSE - disable
4792 /// @return VDEC_EX_Result
4793 //------------------------------------------------------------------------------
_VDEC_EX_DispOneField(VDEC_StreamId * pStreamId,MS_U32 u32Arg)4794 static VDEC_EX_Result _VDEC_EX_DispOneField(VDEC_StreamId *pStreamId, MS_U32 u32Arg)
4795 {
4796 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4797 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4798 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4799
4800 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4801 {
4802 case E_VDEC_EX_DECODER_MVD:
4803 _MVD_RET_HANDLE(MDrv_MVD_EnableDispOneField(u32Id, (MS_BOOL) u32Arg));
4804 break;
4805
4806 case E_VDEC_EX_DECODER_HVD:
4807 _HVD_RET_HANDLE(MDrv_HVD_EX_SetDispOneField(u32Id, (MS_BOOL) u32Arg));
4808 break;
4809
4810 case E_VDEC_EX_DECODER_MJPEG:
4811 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4812 break;
4813
4814 default:
4815 break;
4816 }
4817
4818 return eRet;
4819 }
4820
4821 //------------------------------------------------------------------------------
4822 /// Set fd mask delay count.
4823 /// @param u32Arg \b IN : unit is in vsync base for muting the fd_mask
4824 /// @return VDEC_EX_Result
4825 //------------------------------------------------------------------------------
_VDEC_EX_SetFdMaskDelayCnt(VDEC_StreamId * pStreamId,MS_U32 u32Arg)4826 static VDEC_EX_Result _VDEC_EX_SetFdMaskDelayCnt(VDEC_StreamId *pStreamId, MS_U32 u32Arg)
4827 {
4828 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4829 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4830 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4831
4832 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4833 {
4834 case E_VDEC_EX_DECODER_MVD:
4835 _MVD_RET_HANDLE(MDrv_MVD_SetFdMaskDelayCount(u32Id, (MS_U16)u32Arg));
4836 break;
4837
4838 case E_VDEC_EX_DECODER_HVD:
4839 _HVD_RET_HANDLE(MDrv_HVD_EX_SetFdMaskDelayCnt(u32Id, (MS_U8)u32Arg));
4840 break;
4841
4842 case E_VDEC_EX_DECODER_MJPEG:
4843 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4844 break;
4845
4846 default:
4847 break;
4848 }
4849
4850 return eRet;
4851 }
4852
4853
4854 //------------------------------------------------------------------------------
4855 /// Set frame rate convert output mode
4856 /// @param pFRC \b IN : the address of VDEC_FRC_OutputParam
4857 /// @return VDEC_EX_Result
4858 //------------------------------------------------------------------------------
_VDEC_EX_FrameRateConvert(VDEC_StreamId * pStreamId,VDEC_EX_FRC_OutputParam * pFRC)4859 static VDEC_EX_Result _VDEC_EX_FrameRateConvert(VDEC_StreamId *pStreamId, VDEC_EX_FRC_OutputParam *pFRC)
4860 {
4861 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4862 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4863 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4864
4865 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4866 {
4867 case E_VDEC_EX_DECODER_MVD:
4868 _MVD_RET_HANDLE(MDrv_MVD_SetOutputFRCMode(u32Id, (MS_U8)(pFRC->u32OutputFrameRate), pFRC->u8Interlace));
4869 break;
4870
4871 case E_VDEC_EX_DECODER_HVD:
4872 _HVD_RET_HANDLE(MDrv_HVD_EX_SetOutputFRCMode(u32Id, (MS_U8)(pFRC->u32OutputFrameRate), pFRC->u8Interlace));
4873 break;
4874
4875 case E_VDEC_EX_DECODER_MJPEG:
4876 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4877 break;
4878
4879 default:
4880 break;
4881 }
4882
4883 return eRet;
4884 }
4885
4886 //------------------------------------------------------------------------------
4887 /// Set ignore error reference
4888 /// @param bIgnore \b IN : turn on / off.
4889 /// @return VDEC_EX_Result
4890 //------------------------------------------------------------------------------
_VDEC_EX_SetIgnoreErrRef(VDEC_StreamId * pStreamId,MS_BOOL bIgnore)4891 static VDEC_EX_Result _VDEC_EX_SetIgnoreErrRef(VDEC_StreamId *pStreamId, MS_BOOL bIgnore)
4892 {
4893 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4894 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4895 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4896
4897 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4898 {
4899 case E_VDEC_EX_DECODER_HVD:
4900 _HVD_RET_HANDLE(MDrv_HVD_EX_SetIgnoreErrRef(u32Id, bIgnore));
4901 break;
4902 case E_VDEC_EX_DECODER_MVD:
4903 case E_VDEC_EX_DECODER_MJPEG:
4904 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4905 break;
4906 default:
4907 break;
4908 }
4909
4910 return eRet;
4911 }
4912
4913 //------------------------------------------------------------------------------
4914 /// Set ignore error reference
4915 /// @param bIgnore \b IN : turn on / off.
4916 /// @return VDEC_EX_Result
4917 //------------------------------------------------------------------------------
4918
_VDEC_EX_SetCcInfoEnhanceMode(VDEC_StreamId * pStreamId,MS_BOOL bEnable)4919 static VDEC_EX_Result _VDEC_EX_SetCcInfoEnhanceMode(VDEC_StreamId *pStreamId,MS_BOOL bEnable)
4920 {
4921 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4922 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4923 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4924
4925 if(pVdecExContext->support_cc[u8Idx] == FALSE)
4926 {
4927 return E_VDEC_EX_RET_UNSUPPORTED;
4928 }
4929
4930 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4931 {
4932 case E_VDEC_EX_DECODER_MVD:
4933 eRet = (MDrv_CC_InfoEnhanceMode(u32Id,bEnable)) ? E_VDEC_EX_OK : E_VDEC_EX_FAIL ;
4934 break;
4935
4936 case E_VDEC_EX_DECODER_HVD:
4937 eRet = (MDrv_HVD_EX_CC_InfoEnhanceMode(u32Id, bEnable)) ? E_VDEC_EX_OK : E_VDEC_EX_FAIL ;
4938 break;
4939
4940 case E_VDEC_EX_DECODER_MJPEG:
4941 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4942 break;
4943
4944 default:
4945 break;
4946 }
4947
4948 return eRet;
4949 }
4950
4951
_VDEC_EX_ForceFollowDTVSpec(VDEC_StreamId * pStreamId,MS_BOOL bEnable)4952 static VDEC_EX_Result _VDEC_EX_ForceFollowDTVSpec(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
4953 {
4954 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4955 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4956 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4957
4958 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4959 {
4960 case E_VDEC_EX_DECODER_HVD:
4961 _HVD_RET_HANDLE(MDrv_HVD_EX_ForceFollowDTVSpec(u32Id, bEnable));
4962 break;
4963 case E_VDEC_EX_DECODER_MVD:
4964 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4965 break;
4966 case E_VDEC_EX_DECODER_MJPEG:
4967 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4968 break;
4969 default:
4970 break;
4971 }
4972
4973 return eRet;
4974 }
4975
4976 //------------------------------------------------------------------------------
4977 /// Set the theshold of H264 frame gap, 0xFFFFFFFF don't care frame gap
4978 /// @param u32FrmGap \b IN : frame gap
4979 /// @return VDEC_EX_Result
4980 //------------------------------------------------------------------------------
_VDEC_EX_AvcMinFrameGap(VDEC_StreamId * pStreamId,MS_U32 u32FrmGap)4981 static VDEC_EX_Result _VDEC_EX_AvcMinFrameGap(VDEC_StreamId *pStreamId, MS_U32 u32FrmGap)
4982 {
4983 VDEC_EX_Result eRet = E_VDEC_EX_OK;
4984 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
4985 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
4986
4987 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
4988 {
4989 case E_VDEC_EX_DECODER_HVD:
4990 _HVD_RET_HANDLE(MDrv_HVD_EX_SetSettings_Pro(u32Id, E_HVD_EX_SSET_MIN_FRAME_GAP, u32FrmGap));
4991 break;
4992 case E_VDEC_EX_DECODER_MVD:
4993 case E_VDEC_EX_DECODER_MJPEG:
4994 eRet = E_VDEC_EX_RET_UNSUPPORTED;
4995 break;
4996 default:
4997 break;
4998 }
4999
5000 return eRet;
5001 }
5002
5003 //------------------------------------------------------------------------------
5004 /// Set fast display, not caring av-sync
5005 /// @param bFastDisplay \b IN : turn on / off.
5006 /// @return VDEC_EX_Result
5007 //------------------------------------------------------------------------------
_VDEC_EX_SetFastDisplay(VDEC_StreamId * pStreamId,MS_BOOL bFastDisplay)5008 static VDEC_EX_Result _VDEC_EX_SetFastDisplay(VDEC_StreamId *pStreamId, MS_BOOL bFastDisplay)
5009 {
5010 VDEC_EX_Result eRet = E_VDEC_EX_OK;
5011 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5012 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5013
5014 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5015 {
5016 case E_VDEC_EX_DECODER_HVD:
5017 _HVD_RET_HANDLE(MDrv_HVD_EX_SetFastDisplay(u32Id, bFastDisplay));
5018 break;
5019 case E_VDEC_EX_DECODER_MVD:
5020 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5021 break;
5022 case E_VDEC_EX_DECODER_MJPEG:
5023 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5024 break;
5025 default:
5026 break;
5027 }
5028
5029 return eRet;
5030 }
5031
5032 //------------------------------------------------------------------------------
5033 /// Set frame rate convert drop type
5034 /// @param u32DropType \b IN : FRC drop type.
5035 /// @return VDEC_EX_Result
5036 //------------------------------------------------------------------------------
_VDEC_EX_SetFRCDropType(VDEC_StreamId * pStreamId,MS_U32 u32DropType)5037 static VDEC_EX_Result _VDEC_EX_SetFRCDropType(VDEC_StreamId *pStreamId, MS_U32 u32DropType)
5038 {
5039 VDEC_EX_Result eRet = E_VDEC_EX_OK;
5040 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5041 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5042
5043 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5044 {
5045 case E_VDEC_EX_DECODER_MVD:
5046 _MVD_RET_HANDLE(MDrv_MVD_SetFRCDropType(u32Id, (MS_U8)u32DropType));
5047 break;
5048
5049 case E_VDEC_EX_DECODER_HVD:
5050 _HVD_RET_HANDLE(MDrv_HVD_EX_SetFRCDropType(u32Id, (MS_U8)u32DropType));
5051 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5052 break;
5053
5054 case E_VDEC_EX_DECODER_MJPEG:
5055 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5056 break;
5057
5058 default:
5059 break;
5060 }
5061
5062 return eRet;
5063 }
5064
5065 //------------------------------------------------------------------------------
5066 /// Set disable resolution change
5067 /// @param bEnable \b IN : turn on / off.
5068 /// @return VDEC_EX_Result
5069 //------------------------------------------------------------------------------
_VDEC_EX_SetDisableSeqChange(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5070 static VDEC_EX_Result _VDEC_EX_SetDisableSeqChange(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5071 {
5072 VDEC_EX_Result eRet = E_VDEC_EX_OK;
5073 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5074 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5075
5076 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5077 {
5078 case E_VDEC_EX_DECODER_MVD:
5079 _MVD_RET_HANDLE(MDrv_MVD_SetDisableSeqChange(u32Id, bEnable));
5080 break;
5081 case E_VDEC_EX_DECODER_HVD:
5082 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5083 break;
5084 case E_VDEC_EX_DECODER_MJPEG:
5085 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5086 break;
5087 default:
5088 break;
5089 }
5090
5091 return eRet;
5092 }
5093
5094 //------------------------------------------------------------------------------
5095 /// Reset MVD parser
5096 /// @param bEnable \b IN : turn on / off.
5097 /// @return VDEC_EX_Result
5098 //------------------------------------------------------------------------------
_VDEC_EX_ResetMvdParser(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5099 static VDEC_EX_Result _VDEC_EX_ResetMvdParser(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5100 {
5101 VDEC_EX_Result eRet = E_VDEC_EX_OK;
5102 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5103 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5104
5105 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5106 {
5107 case E_VDEC_EX_DECODER_MVD:
5108 _MVD_RET_HANDLE(MDrv_MVD_ParserRstDone(u32Id, bEnable));
5109 break;
5110 case E_VDEC_EX_DECODER_HVD:
5111 case E_VDEC_EX_DECODER_MJPEG:
5112 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5113 break;
5114 default:
5115 break;
5116 }
5117
5118 return eRet;
5119 }
5120
5121
5122 //------------------------------------------------------------------------------
5123 /// Force into interlace mode
5124 /// @param u32Mode \b IN : 0: Disable, 1: Enable
5125 /// @return VDEC_Result
5126 //------------------------------------------------------------------------------
_VDEC_EX_ForceInterlaceMode(VDEC_StreamId * pStreamId,MS_U32 u32Mode)5127 static VDEC_EX_Result _VDEC_EX_ForceInterlaceMode(VDEC_StreamId *pStreamId, MS_U32 u32Mode)
5128 {
5129 VDEC_EX_Result eRet = E_VDEC_EX_OK;
5130 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5131 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5132
5133 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5134 {
5135 case E_VDEC_EX_DECODER_MVD:
5136 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5137 break;
5138
5139 case E_VDEC_EX_DECODER_HVD:
5140 _HVD_RET_HANDLE(MDrv_HVD_EX_ForceInterlaceMode(u32Id, (MS_U8)u32Mode));
5141 break;
5142
5143 case E_VDEC_EX_DECODER_MJPEG:
5144 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5145 break;
5146
5147 default:
5148 break;
5149 }
5150
5151 return eRet;
5152 }
5153
_VDEC_EX_IsChroma420(VDEC_StreamId * pStreamId,MS_U32 * param)5154 static VDEC_EX_Result _VDEC_EX_IsChroma420(VDEC_StreamId *pStreamId, MS_U32* param)
5155 {
5156 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5157 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5158 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5159
5160 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5161 {
5162 case E_VDEC_EX_DECODER_MVD:
5163 if (MDrv_MVD_GetChromaFormat(u32Id) <= 1)
5164 {
5165 *param = TRUE;
5166 }
5167 else
5168 {
5169 *param = FALSE;
5170 }
5171 eRet = E_VDEC_EX_OK;
5172 break;
5173
5174 case E_VDEC_EX_DECODER_HVD:
5175 case E_VDEC_EX_DECODER_MJPEG:
5176 *param = TRUE;
5177 eRet = E_VDEC_EX_OK;
5178 break;
5179
5180 default:
5181 *param = FALSE;
5182 break;
5183 }
5184
5185 return eRet;
5186 }
5187
_VDEC_EX_GetRealFrameRate(VDEC_StreamId * pStreamId,MS_U32 * param)5188 static VDEC_EX_Result _VDEC_EX_GetRealFrameRate(VDEC_StreamId *pStreamId, MS_U32 *param)
5189 {
5190 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5191 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5192 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5193
5194 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5195 {
5196 case E_VDEC_EX_DECODER_HVD:
5197 {
5198 if (E_HVD_EX_OK == MDrv_HVD_EX_CheckDispInfoRdy(u32Id))
5199 {
5200 *param = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_REAL_FRAMERATE);
5201 eRet = E_VDEC_EX_OK;
5202 }
5203 else
5204 {
5205 eRet = E_VDEC_EX_RET_NOT_READY;
5206 }
5207 break;
5208 }
5209 case E_VDEC_EX_DECODER_MVD:
5210 {
5211 if (0 != MDrv_MVD_GetDispRdy(u32Id))
5212 {
5213 MVD_FrameInfo info;
5214 _VDEC_Memset(&info, 0, sizeof(MVD_FrameInfo));
5215 MDrv_MVD_GetFrameInfo(u32Id, &info);
5216 *param = info.u32FrameRate;
5217 eRet = E_VDEC_EX_OK;
5218 }
5219 else
5220 {
5221 eRet = E_VDEC_EX_RET_NOT_READY;
5222 }
5223 break;
5224 }
5225 case E_VDEC_EX_DECODER_MJPEG:
5226 {
5227 _VDEC_EX_API_MutexLock();
5228 if(E_MJPEG_RET_SUCCESS == MApi_MJPEG_CheckDispInfoRdy(u32Id))
5229 {
5230 MJPEG_DISP_INFO info;
5231 _VDEC_Memset(&info, 0, sizeof(MJPEG_DISP_INFO));
5232 MApi_MJPEG_GetDispInfo(u32Id, &info);
5233 *param = info.u32FrameRate;
5234 eRet = E_VDEC_EX_OK;
5235 }
5236 else
5237 {
5238 eRet = E_VDEC_EX_RET_NOT_READY;
5239 }
5240 _VDEC_EX_API_MutexUnlock();
5241 break;
5242 }
5243 default:
5244 {
5245 eRet = E_VDEC_EX_RET_INVALID_PARAM;
5246 break;
5247 }
5248 }
5249
5250 return eRet;
5251 }
5252
_VDEC_EX_DISP_OUTSIDE_MODE(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5253 static VDEC_EX_Result _VDEC_EX_DISP_OUTSIDE_MODE(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5254 {
5255 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5256 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5257 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5258
5259 pVdecExContext->_bVdecDispOutSide[u8Idx] = bEnable;
5260 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5261 {
5262 case E_VDEC_EX_DECODER_MVD:
5263 _MVD_RET_HANDLE(MDrv_MVD_SetMcuMode(u32Id, bEnable));
5264 #ifdef VDEC3
5265 if(bEnable == TRUE)
5266 {
5267 pVdecExContext->u32FrameBaseMode[u8Idx] = TRUE;
5268 }
5269 else
5270 {
5271 pVdecExContext->u32FrameBaseMode[u8Idx] = FALSE;
5272 }
5273 #endif
5274 eRet = E_VDEC_EX_OK;
5275 break;
5276 case E_VDEC_EX_DECODER_HVD:
5277 _HVD_RET_HANDLE(MDrv_HVD_EX_DispOutsideMode(u32Id, bEnable));
5278 eRet = E_VDEC_EX_OK;
5279 break;
5280 case E_VDEC_EX_DECODER_MJPEG:
5281 _MJPEG_RET_HANDLE(MApi_MJPEG_SetControl(u32Id, E_MJPEG_VDEC_CMD_SET_DISPLAY_OUTSIDE_MODE, (MS_U32)bEnable));
5282 break;
5283 default:
5284 break;
5285 }
5286
5287 return eRet;
5288 }
5289
5290 //------------------------------------------------------------------------------
5291 /// Set DTV User Data packet mode
5292 /// @param u32Mode \b IN : User Data Packet Mode, 0: DVB normal, 1: ATSC DirectTV. default:0.
5293 /// @return VDEC_Result
5294 //------------------------------------------------------------------------------
_VDEC_EX_SetDTVUserDataMode(VDEC_StreamId * pStreamId,MS_U32 u32Mode)5295 static VDEC_EX_Result _VDEC_EX_SetDTVUserDataMode(VDEC_StreamId *pStreamId, MS_U32 u32Mode)
5296 {
5297 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5298 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5299 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5300
5301 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5302 {
5303 case E_VDEC_EX_DECODER_HVD:
5304 _HVD_RET_HANDLE(MDrv_HVD_EX_SetDTVUserDataMode(u32Id, (MS_U8)u32Mode));
5305 eRet = E_VDEC_EX_OK;
5306 break;
5307
5308 case E_VDEC_EX_DECODER_MVD:
5309 case E_VDEC_EX_DECODER_MJPEG:
5310 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5311 break;
5312
5313 default:
5314 break;
5315 }
5316
5317 return eRet;
5318 }
5319
5320 //------------------------------------------------------------------------------
5321 /// Release fd mask
5322 /// To fix the garbage when zooming at slow motion
5323 /// @param bRelease \b IN : 1: update a new frame to release fd mask as slow-motion. default:0.
5324 /// @return VDEC_Result
5325 //------------------------------------------------------------------------------
_VDEC_EX_ReleaseFdMask(VDEC_StreamId * pStreamId,MS_BOOL bRelease)5326 static VDEC_EX_Result _VDEC_EX_ReleaseFdMask(VDEC_StreamId *pStreamId, MS_BOOL bRelease)
5327 {
5328 VDEC_EX_Result eRet = E_VDEC_EX_OK;
5329 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5330 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5331
5332 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5333 {
5334 case E_VDEC_EX_DECODER_MVD:
5335 _MVD_RET_HANDLE(MDrv_MVD_ReleaseFdMask(u32Id, bRelease));
5336 break;
5337 case E_VDEC_EX_DECODER_HVD:
5338 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5339 break;
5340 case E_VDEC_EX_DECODER_MJPEG:
5341 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5342 break;
5343 default:
5344 break;
5345 }
5346
5347 return eRet;
5348 }
5349
_VDEC_EX_SetVSizeAlign(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5350 static VDEC_EX_Result _VDEC_EX_SetVSizeAlign(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5351 {
5352 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5353 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5354 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5355
5356 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5357 {
5358 case E_VDEC_EX_DECODER_MVD:
5359 _MVD_RET_HANDLE(MDrv_MVD_SetVSizeAlign(u32Id, bEnable));
5360 eRet = E_VDEC_EX_OK;
5361 break;
5362
5363 case E_VDEC_EX_DECODER_HVD:
5364 _HVD_RET_HANDLE(MDrv_HVD_EX_EnableVSizeAlign(u32Id, bEnable));
5365 eRet = E_VDEC_EX_OK;
5366 break;
5367
5368 case E_VDEC_EX_DECODER_MJPEG:
5369 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5370 break;
5371
5372 default:
5373 break;
5374 }
5375
5376 return eRet;
5377 }
5378
_VDEC_EX_ShowDecodeOrder(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5379 static VDEC_EX_Result _VDEC_EX_ShowDecodeOrder(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5380 {
5381 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5382 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5383 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5384
5385 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5386 {
5387 case E_VDEC_EX_DECODER_MVD:
5388 _MVD_RET_HANDLE(MDrv_MVD_ShowDecodeOrder(u32Id, bEnable));
5389 eRet = E_VDEC_EX_OK;
5390 break;
5391
5392 case E_VDEC_EX_DECODER_HVD:
5393 _HVD_RET_HANDLE(MDrv_HVD_EX_ShowDecodeOrder(u32Id, bEnable));
5394 eRet = E_VDEC_EX_OK;
5395 break;
5396
5397 case E_VDEC_EX_DECODER_MJPEG:
5398 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5399 break;
5400
5401 default:
5402 break;
5403 }
5404
5405 return eRet;
5406 }
5407
5408 //------------------------------------------------------------------------------
5409 /// Set Disp Ignore Crop : force ignore crop when input steam has SEI info
5410 /// @param bEnable \b IN : turn on / off.
5411 /// @return VDEC_EX_Result
5412 //------------------------------------------------------------------------------
_VDEC_EX_Disp_Ignore_Crop(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5413 static VDEC_EX_Result _VDEC_EX_Disp_Ignore_Crop(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5414 {
5415 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5416 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5417 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5418
5419 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5420 {
5421 case E_VDEC_EX_DECODER_HVD:
5422 _HVD_RET_HANDLE(MDrv_HVD_EX_Disp_Ignore_Crop(u32Id, bEnable));
5423 eRet = E_VDEC_EX_OK;
5424 break;
5425 case E_VDEC_EX_DECODER_MVD:
5426 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5427 break;
5428 case E_VDEC_EX_DECODER_MJPEG:
5429 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5430 break;
5431 default:
5432 break;
5433 }
5434
5435 return eRet;
5436 }
5437
_VDEC_EX_SuspendDynamicScale(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5438 static VDEC_EX_Result _VDEC_EX_SuspendDynamicScale(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5439 {
5440 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5441 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5442 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5443
5444 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5445 {
5446 case E_VDEC_EX_DECODER_MVD:
5447 _MVD_RET_HANDLE(MDrv_MVD_SuspendDynamicScale(u32Id, bEnable));
5448 eRet = E_VDEC_EX_OK;
5449 break;
5450
5451 case E_VDEC_EX_DECODER_HVD:
5452 _HVD_RET_HANDLE(MDrv_HVD_EX_SuspendDynamicScale(u32Id, bEnable));
5453 eRet = E_VDEC_EX_OK;
5454 break;
5455
5456 case E_VDEC_EX_DECODER_MJPEG:
5457 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5458 break;
5459
5460 default:
5461 break;
5462 }
5463
5464 return eRet;
5465 }
5466
_VDEC_EX_RmEnablePtsTbl(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5467 static VDEC_EX_Result _VDEC_EX_RmEnablePtsTbl(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5468 {
5469 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5470 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5471 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5472
5473 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5474 {
5475 case E_VDEC_EX_DECODER_MVD:
5476 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5477 break;
5478
5479 case E_VDEC_EX_DECODER_HVD:
5480 if((pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_RV8) && (pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_RV9) )
5481 {
5482 return E_VDEC_EX_RET_UNSUPPORTED;
5483 }
5484
5485 _HVD_RET_HANDLE(MDrv_HVD_EX_RmEnablePtsTbl(u32Id, bEnable));
5486 eRet = E_VDEC_EX_OK;
5487 break;
5488
5489 case E_VDEC_EX_DECODER_MJPEG:
5490 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5491 break;
5492
5493 default:
5494 break;
5495 }
5496
5497 return eRet;
5498 }
5499
5500 //------------------------------------------------------------------------------
5501 /// Force set FW to mute if resolution change
5502 /// @param u32Mode \b IN : 0: Disable(default), 1: Enable
5503 /// @return VDEC_Result
5504 //------------------------------------------------------------------------------
_VDEC_EX_ForceAutoMute(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5505 static VDEC_EX_Result _VDEC_EX_ForceAutoMute(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5506 {
5507 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5508 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5509 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5510
5511 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5512 {
5513 case E_VDEC_EX_DECODER_MVD:
5514 _MVD_RET_HANDLE(MDrv_MVD_SetAutoMute(u32Id, bEnable));
5515 eRet = E_VDEC_EX_OK;
5516 break;
5517
5518 case E_VDEC_EX_DECODER_HVD:
5519 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5520 break;
5521
5522 case E_VDEC_EX_DECODER_MJPEG:
5523 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5524 break;
5525
5526 default:
5527 break;
5528 }
5529
5530 return eRet;
5531 }
5532
_VDEC_EX_SetDispFinishMode(VDEC_StreamId * pStreamId,MS_U8 u8Mode)5533 static VDEC_EX_Result _VDEC_EX_SetDispFinishMode(VDEC_StreamId *pStreamId, MS_U8 u8Mode)
5534 {
5535 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5536 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5537 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5538
5539 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5540 {
5541 case E_VDEC_EX_DECODER_MVD:
5542 _MVD_RET_HANDLE(MDrv_MVD_SetDispFinishMode(u32Id, u8Mode));
5543 eRet = E_VDEC_EX_OK;
5544 break;
5545
5546 case E_VDEC_EX_DECODER_HVD:
5547 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5548 break;
5549
5550 case E_VDEC_EX_DECODER_MJPEG:
5551 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5552 break;
5553
5554 default:
5555 break;
5556 }
5557
5558 return eRet;
5559 }
5560
_VDEC_EX_SetAVSyncMode(VDEC_StreamId * pStreamId,MS_U8 u8Mode)5561 static VDEC_EX_Result _VDEC_EX_SetAVSyncMode(VDEC_StreamId *pStreamId, MS_U8 u8Mode)
5562 {
5563 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5564 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5565 //MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5566
5567 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5568 {
5569 case E_VDEC_EX_DECODER_MVD:
5570 //_MVD_RET_HANDLE(MDrv_MVD_SetAVSyncMode(u32Id, u8Mode));
5571 //eRet = E_VDEC_EX_OK;
5572 break;
5573
5574 case E_VDEC_EX_DECODER_HVD:
5575 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5576 break;
5577
5578 case E_VDEC_EX_DECODER_MJPEG:
5579 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5580 break;
5581
5582 default:
5583 break;
5584 }
5585
5586 return eRet;
5587 }
5588
5589 //------------------------------------------------------------------------------
5590 /// Push Disp Q with Ref Number
5591 /// @param u32Mode \b IN : 0: Disable, 1: Enable
5592 /// @return VDEC_Result
5593 //------------------------------------------------------------------------------
_VDEC_EX_PushDispQWithRefNum(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5594 static VDEC_EX_Result _VDEC_EX_PushDispQWithRefNum(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5595 {
5596 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5597 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5598 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5599
5600 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5601 {
5602 case E_VDEC_EX_DECODER_HVD:
5603 _HVD_RET_HANDLE(MDrv_HVD_EX_PushDispQWithRefNum(u32Id, bEnable));
5604 eRet = E_VDEC_EX_OK;
5605 break;
5606 case E_VDEC_EX_DECODER_MVD:
5607 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5608 break;
5609 case E_VDEC_EX_DECODER_MJPEG:
5610 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5611 break;
5612 default:
5613 break;
5614 }
5615
5616 return eRet;
5617 }
5618
_VDEC_EX_SetIdctMode(VDEC_StreamId * pStreamId,MS_U8 u8Mode)5619 static VDEC_EX_Result _VDEC_EX_SetIdctMode(VDEC_StreamId *pStreamId, MS_U8 u8Mode)
5620 {
5621 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5622 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5623 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5624
5625 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5626 {
5627 case E_VDEC_EX_DECODER_MVD:
5628 _MVD_RET_HANDLE(MDrv_MVD_SetIdctMode(u32Id, u8Mode));
5629 eRet = E_VDEC_EX_OK;
5630 break;
5631 case E_VDEC_EX_DECODER_HVD:
5632 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5633 break;
5634 case E_VDEC_EX_DECODER_MJPEG:
5635 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5636 break;
5637 default:
5638 break;
5639 }
5640
5641 return eRet;
5642 }
5643
5644 //------------------------------------------------------------------------------
5645 /// Push First
5646 /// @param u32Mode \b IN : 0: Disable, 1: Enable
5647 /// @return VDEC_Result
5648 //------------------------------------------------------------------------------
_VDEC_EX_ShowFirstFrameDirect(VDEC_StreamId * pStreamId,MS_U32 u32Mode)5649 static VDEC_EX_Result _VDEC_EX_ShowFirstFrameDirect(VDEC_StreamId *pStreamId,MS_U32 u32Mode)
5650 {
5651 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5652 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5653 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5654
5655 if ((u32Mode != 0) && (u32Mode != 1))
5656 return eRet;
5657
5658 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5659 {
5660 case E_VDEC_EX_DECODER_MVD:
5661 _MVD_RET_HANDLE(MDrv_MVD_ShowFirstFrameDirect(u32Id,u32Mode));
5662 eRet = E_VDEC_EX_OK;
5663 break;
5664 case E_VDEC_EX_DECODER_HVD:
5665 _HVD_RET_HANDLE(MDrv_HVD_EX_ShowFirstFrameDirect(u32Id, u32Mode));
5666 eRet = E_VDEC_EX_OK;
5667 break;
5668 case E_VDEC_EX_DECODER_MJPEG:
5669 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5670 break;
5671 default:
5672 break;
5673 }
5674
5675 return eRet;
5676 }
5677
5678 //------------------------------------------------------------------------------
5679 /// Set xc_low_delay parameter
5680 /// @param u32Para \b IN :
5681 /// @return VDEC_Result
5682 //------------------------------------------------------------------------------
_VDEC_EX_SetXcLowDelayPara(VDEC_StreamId * pStreamId,MS_U32 u32Para)5683 static VDEC_EX_Result _VDEC_EX_SetXcLowDelayPara(VDEC_StreamId *pStreamId,MS_U32 u32Para)
5684 {
5685 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5686 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5687 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5688
5689 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5690 {
5691 case E_VDEC_EX_DECODER_HVD:
5692 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5693 break;
5694
5695 case E_VDEC_EX_DECODER_MVD:
5696 _MVD_RET_HANDLE(MDrv_MVD_SetXCLowDelayPara(u32Id,u32Para));
5697 eRet = E_VDEC_EX_OK;
5698 break;
5699
5700 case E_VDEC_EX_DECODER_MJPEG:
5701 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5702 break;
5703
5704 default:
5705 break;
5706 }
5707
5708 return eRet;
5709 }
5710
5711 //------------------------------------------------------------------------------
5712 /// @return XC_LOW_DELAY int state
5713 //------------------------------------------------------------------------------
_VDEC_EX_GetXcLowDelayIntState(VDEC_StreamId * pStreamId,MS_U32 * param)5714 VDEC_EX_Result _VDEC_EX_GetXcLowDelayIntState(VDEC_StreamId *pStreamId,MS_U32* param)
5715 {
5716 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5717 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5718 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5719
5720 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5721 {
5722 case E_VDEC_EX_DECODER_MVD:
5723 *param = MDrv_MVD_GetXcLowDelayIntState(u32Id);
5724 eRet = E_VDEC_EX_OK;
5725 break;
5726
5727 case E_VDEC_EX_DECODER_HVD:
5728 case E_VDEC_EX_DECODER_MJPEG:
5729 default:
5730 *param = VDEC_EX_XC_LOW_DELAY_NONE;
5731 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5732 break;
5733 }
5734
5735 return eRet;
5736 }
5737
_VDEC_EX_AVCResizeDosDispPendBuf(VDEC_StreamId * pStreamId,MS_U32 u32Size)5738 static VDEC_EX_Result _VDEC_EX_AVCResizeDosDispPendBuf(VDEC_StreamId *pStreamId,MS_U32 u32Size)
5739 {
5740 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5741 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5742 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5743
5744
5745 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5746 {
5747 case E_VDEC_EX_DECODER_MVD:
5748 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5749 break;
5750 case E_VDEC_EX_DECODER_HVD:
5751 _HVD_RET_HANDLE(MDrv_HVD_EX_AVCResizeDosDispPendBuf(u32Id, u32Size));
5752 eRet = E_VDEC_EX_OK;
5753 break;
5754 case E_VDEC_EX_DECODER_MJPEG:
5755 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5756 break;
5757 default:
5758 break;
5759 }
5760
5761 return eRet;
5762 }
5763
_VDEC_EX_IgnorePicOverrun(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5764 static VDEC_EX_Result _VDEC_EX_IgnorePicOverrun(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5765 {
5766 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5767 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5768 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5769
5770 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5771 {
5772 case E_VDEC_EX_DECODER_MVD:
5773 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5774 break;
5775 case E_VDEC_EX_DECODER_HVD:
5776 _HVD_RET_HANDLE(MDrv_HVD_EX_IgnorePicOverrun(u32Id, bEnable));
5777 eRet = E_VDEC_EX_OK;
5778 break;
5779 case E_VDEC_EX_DECODER_MJPEG:
5780 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5781 break;
5782 default:
5783 break;
5784 }
5785
5786 return eRet;
5787 }
5788
5789
_VDEC_EX_SetAutoExhaustESMode(VDEC_StreamId * pStreamId,MS_U32 u32ESBound)5790 static VDEC_EX_Result _VDEC_EX_SetAutoExhaustESMode(VDEC_StreamId *pStreamId, MS_U32 u32ESBound)
5791 {
5792 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5793 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5794 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5795
5796 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5797 {
5798 case E_VDEC_EX_DECODER_MVD:
5799 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5800 break;
5801 case E_VDEC_EX_DECODER_HVD:
5802
5803 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_H264)
5804 {
5805 return E_VDEC_EX_RET_UNSUPPORTED;
5806 }
5807 _HVD_RET_HANDLE(MDrv_HVD_EX_AutoExhaustESMode(u32Id, u32ESBound));
5808 eRet = E_VDEC_EX_OK;
5809 break;
5810 case E_VDEC_EX_DECODER_MJPEG:
5811 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5812 break;
5813 default:
5814 break;
5815 }
5816
5817 return eRet;
5818 }
5819
5820
5821
_VDEC_EX_SetMinTspDataSize(VDEC_StreamId * pStreamId,MS_U32 u32Size)5822 static VDEC_EX_Result _VDEC_EX_SetMinTspDataSize(VDEC_StreamId *pStreamId, MS_U32 u32Size)
5823 {
5824 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5825 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5826 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5827
5828 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5829 {
5830 case E_VDEC_EX_DECODER_MVD:
5831 if(TRUE == MDrv_MVD_SetPrebufferSize(u32Id,u32Size))
5832 {
5833 eRet = E_VDEC_EX_OK;
5834 }
5835 break;
5836 case E_VDEC_EX_DECODER_HVD:
5837
5838 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_H264)
5839 {
5840 return E_VDEC_EX_RET_UNSUPPORTED;
5841 }
5842 _HVD_RET_HANDLE(MDrv_HVD_EX_SetMinTspSize(u32Id, u32Size));
5843 eRet = E_VDEC_EX_OK;
5844 break;
5845 case E_VDEC_EX_DECODER_MJPEG:
5846 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5847 break;
5848 default:
5849 break;
5850 }
5851
5852 return eRet;
5853 }
5854
5855
_VDEC_EX_CtlSpeedInDispOnly(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5856 static VDEC_EX_Result _VDEC_EX_CtlSpeedInDispOnly(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5857 {
5858 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5859 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5860 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5861
5862 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5863 {
5864 case E_VDEC_EX_DECODER_MVD:
5865 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5866 break;
5867 case E_VDEC_EX_DECODER_HVD:
5868 _HVD_RET_HANDLE(MDrv_HVD_EX_CtlSpeedInDispOnly(u32Id, bEnable));
5869 eRet = E_VDEC_EX_OK;
5870 break;
5871 case E_VDEC_EX_DECODER_MJPEG:
5872 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5873 break;
5874 default:
5875 break;
5876 }
5877
5878 return eRet;
5879 }
5880
_VDEC_EX_AVCSupportRefNumOverMaxDBPSize(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5881 static VDEC_EX_Result _VDEC_EX_AVCSupportRefNumOverMaxDBPSize(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5882 {
5883 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5884 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5885 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5886
5887 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5888 {
5889 case E_VDEC_EX_DECODER_MVD:
5890 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5891 break;
5892 case E_VDEC_EX_DECODER_HVD:
5893 _HVD_RET_HANDLE(MDrv_HVD_EX_AVCSupportRefNumOverMaxDBPSize(u32Id, bEnable));
5894 eRet = E_VDEC_EX_OK;
5895 break;
5896 case E_VDEC_EX_DECODER_MJPEG:
5897 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5898 break;
5899 default:
5900 break;
5901 }
5902
5903 return eRet;
5904 }
5905
5906
_VDEC_EX_ReturnInvalidAFD(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5907 static VDEC_EX_Result _VDEC_EX_ReturnInvalidAFD(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5908 {
5909 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5910 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5911 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5912
5913 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5914 {
5915 case E_VDEC_EX_DECODER_MVD:
5916 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5917 break;
5918 case E_VDEC_EX_DECODER_HVD:
5919 _HVD_RET_HANDLE(MDrv_HVD_EX_ReturnInvalidAFD(u32Id, bEnable));
5920 eRet = E_VDEC_EX_OK;
5921 break;
5922 case E_VDEC_EX_DECODER_MJPEG:
5923 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5924 break;
5925 default:
5926 break;
5927 }
5928
5929 return eRet;
5930 }
5931
_VDEC_EX_SetDmxFrameRate(VDEC_StreamId * pStreamId,MS_U32 u32Value)5932 static VDEC_EX_Result _VDEC_EX_SetDmxFrameRate(VDEC_StreamId *pStreamId, MS_U32 u32Value)
5933 {
5934 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5935 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5936 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5937
5938 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5939 {
5940 case E_VDEC_EX_DECODER_MVD:
5941 MDrv_MVD_SetDmxFrameRate(u32Id,u32Value);
5942 eRet = E_VDEC_EX_OK;
5943 break;
5944 case E_VDEC_EX_DECODER_HVD:
5945 _HVD_RET_HANDLE(MDrv_HVD_EX_SetDmxFrameRate(u32Id, u32Value));
5946 eRet = E_VDEC_EX_OK;
5947 break;
5948 case E_VDEC_EX_DECODER_MJPEG:
5949 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5950 break;
5951 default:
5952 break;
5953 }
5954
5955 return eRet;
5956 }
5957
_VDEC_EX_SetDmxFrameRateBase(VDEC_StreamId * pStreamId,MS_U32 u32Value)5958 static VDEC_EX_Result _VDEC_EX_SetDmxFrameRateBase(VDEC_StreamId *pStreamId, MS_U32 u32Value)
5959 {
5960 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5961 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5962 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5963
5964 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5965 {
5966 case E_VDEC_EX_DECODER_MVD:
5967 MDrv_MVD_SetDmxFrameRateBase(u32Id,u32Value);
5968 eRet = E_VDEC_EX_OK;
5969 break;
5970 case E_VDEC_EX_DECODER_HVD:
5971 _HVD_RET_HANDLE(MDrv_HVD_EX_SetDmxFrameRateBase(u32Id, u32Value));
5972 eRet = E_VDEC_EX_OK;
5973 break;
5974 case E_VDEC_EX_DECODER_MJPEG:
5975 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5976 break;
5977 default:
5978 break;
5979 }
5980
5981 return eRet;
5982 }
5983
_VDEC_EX_AVCForceBrokenByUs(VDEC_StreamId * pStreamId,MS_BOOL bEnable)5984 static VDEC_EX_Result _VDEC_EX_AVCForceBrokenByUs(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
5985 {
5986 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
5987 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
5988 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
5989
5990 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
5991 {
5992 case E_VDEC_EX_DECODER_MVD:
5993 eRet = E_VDEC_EX_RET_UNSUPPORTED;
5994 break;
5995
5996 case E_VDEC_EX_DECODER_HVD:
5997 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_H264)
5998 {
5999 return E_VDEC_EX_RET_UNSUPPORTED;
6000 }
6001
6002 _HVD_RET_HANDLE(MDrv_HVD_EX_AVCForceBrokenByUs(u32Id, bEnable));
6003 eRet = E_VDEC_EX_OK;
6004 break;
6005
6006 case E_VDEC_EX_DECODER_MJPEG:
6007 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6008 break;
6009
6010 default:
6011 break;
6012 }
6013
6014 return eRet;
6015 }
6016
_VDEC_EX_Map2HVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)6017 static HVD_EX_ClockSpeed _VDEC_EX_Map2HVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)
6018 {
6019 HVD_EX_ClockSpeed hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_NONE;
6020
6021 switch(ClockSpeed)
6022 {
6023 case E_VDEC_EX_CLOCK_SPEED_HIGHEST:
6024 hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_HIGHEST;
6025 break;
6026 case E_VDEC_EX_CLOCK_SPEED_HIGH:
6027 hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_HIGH;
6028 break;
6029 case E_VDEC_EX_CLOCK_SPEED_MEDIUM:
6030 hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_MEDIUM;
6031 break;
6032 case E_VDEC_EX_CLOCK_SPEED_LOW:
6033 hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_LOW;
6034 break;
6035 case E_VDEC_EX_CLOCK_SPEED_LOWEST:
6036 hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_LOWEST;
6037 break;
6038 case E_VDEC_EX_CLOCK_SPEED_DEFAULT:
6039 hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_DEFAULT;
6040 break;
6041 default:
6042 hvdClockSpeed = E_HVD_EX_CLOCK_SPEED_NONE;
6043 break;
6044 }
6045
6046 return hvdClockSpeed;
6047 }
6048
_VDEC_EX_Map2MVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)6049 static MVD_EX_ClockSpeed _VDEC_EX_Map2MVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)
6050 {
6051 MVD_EX_ClockSpeed mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_NONE;
6052
6053 switch(ClockSpeed)
6054 {
6055 case E_VDEC_EX_CLOCK_SPEED_HIGHEST:
6056 mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_HIGHEST;
6057 break;
6058 case E_VDEC_EX_CLOCK_SPEED_HIGH:
6059 mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_HIGH;
6060 break;
6061 case E_VDEC_EX_CLOCK_SPEED_MEDIUM:
6062 mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_MEDIUM;
6063 break;
6064 case E_VDEC_EX_CLOCK_SPEED_LOW:
6065 mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_LOW;
6066 break;
6067 case E_VDEC_EX_CLOCK_SPEED_LOWEST:
6068 mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_LOWEST;
6069 break;
6070 case E_VDEC_EX_CLOCK_SPEED_DEFAULT:
6071 mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_DEFAULT;
6072 break;
6073 default:
6074 mvdClockSpeed = E_MVD_EX_CLOCK_SPEED_NONE;
6075 break;
6076 }
6077
6078 return mvdClockSpeed;
6079 }
6080
6081
_VDEC_EX_SetVPUClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)6082 static VDEC_EX_Result _VDEC_EX_SetVPUClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)
6083 {
6084 _HVD_RET_HANDLE(MDrv_HVD_EX_SetVPUClockSpeed(_VDEC_EX_Map2HVDClockSpeed(ClockSpeed)));
6085
6086 return E_VDEC_EX_OK;
6087 }
6088
6089
_VDEC_EX_SetHVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)6090 static VDEC_EX_Result _VDEC_EX_SetHVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)
6091 {
6092 _HVD_RET_HANDLE(MDrv_HVD_EX_SetHVDClockSpeed(_VDEC_EX_Map2HVDClockSpeed(ClockSpeed)));
6093
6094 return E_VDEC_EX_OK;
6095 }
6096
6097
_VDEC_EX_SetMVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)6098 static VDEC_EX_Result _VDEC_EX_SetMVDClockSpeed(VDEC_EX_ClockSpeed ClockSpeed)
6099 {
6100 _MVD_RET_HANDLE(MDrv_MVD_EX_SetMVDClockSpeed(_VDEC_EX_Map2MVDClockSpeed(ClockSpeed)));
6101
6102 return E_VDEC_EX_OK;
6103 }
6104
_VDEC_EX_SetHVDColBBUMode(VDEC_StreamId * pStreamId,MS_BOOL bEnable)6105 static VDEC_EX_Result _VDEC_EX_SetHVDColBBUMode(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
6106 {
6107 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6108 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6109 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6110
6111 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
6112
6113 if (pVdecExContext->_Attr[u8Idx].bInit)
6114 {
6115 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
6116 }
6117
6118 _HVD_RET_HANDLE(MDrv_HVD_EX_SetHVDColBBUMode(u32Id, bEnable));
6119 eRet = E_VDEC_EX_OK;
6120
6121 return eRet;
6122 }
6123
_VDEC_EX_SetSelfSeqChange(VDEC_StreamId * pStreamId,MS_BOOL bEnable)6124 static VDEC_EX_Result _VDEC_EX_SetSelfSeqChange(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
6125 {
6126 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6127 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6128 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6129
6130 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6131 {
6132 case E_VDEC_EX_DECODER_MVD:
6133 _MVD_RET_HANDLE(MDrv_MVD_SetSelfSeqChange(u32Id, bEnable));
6134 eRet = E_VDEC_EX_OK;
6135 break;
6136 case E_VDEC_EX_DECODER_HVD:
6137 _HVD_RET_HANDLE(MDrv_HVD_EX_DSReportDispInfoChange(u32Id, bEnable));
6138 eRet = E_VDEC_EX_OK;
6139 break;
6140 case E_VDEC_EX_DECODER_MJPEG:
6141 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6142 break;
6143 default:
6144 break;
6145 }
6146
6147 return eRet;
6148
6149 }
6150
6151 //------------------------------------------------------------------------------
6152 /// Enable FW PTS abnormal detect.
6153 /// @param bEnable \b IN : TRUE - show one field; FALSE - disable
6154 /// @return VDEC_EX_Result
6155 //------------------------------------------------------------------------------
_VDEC_EX_EnablePTSDetector(VDEC_StreamId * pStreamId,MS_U32 u32Arg)6156 static VDEC_EX_Result _VDEC_EX_EnablePTSDetector(VDEC_StreamId *pStreamId, MS_U32 u32Arg)
6157 {
6158 VDEC_EX_Result eRet = E_VDEC_EX_OK;
6159 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6160 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6161
6162 _VDEC_INVALID_IDX_RET(u8Idx);
6163
6164 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6165 {
6166 case E_VDEC_EX_DECODER_MVD:
6167 _MVD_RET_HANDLE(MDrv_MVD_EnablePTSDetector(u32Id, (MS_BOOL) u32Arg));
6168 break;
6169
6170 case E_VDEC_EX_DECODER_HVD:
6171 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6172 break;
6173
6174 case E_VDEC_EX_DECODER_MJPEG:
6175 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6176 break;
6177
6178 default:
6179 break;
6180 }
6181
6182 return eRet;
6183 }
6184
_VDEC_EX_DisablePBFrameMode(VDEC_StreamId * pStreamId,MS_U32 u32Arg)6185 static VDEC_EX_Result _VDEC_EX_DisablePBFrameMode(VDEC_StreamId * pStreamId, MS_U32 u32Arg)
6186 {
6187 VDEC_EX_Result eRet = E_VDEC_EX_OK;
6188 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6189 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6190
6191 _VDEC_INVALID_IDX_RET(u8Idx);
6192
6193 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6194 {
6195 case E_VDEC_EX_DECODER_MVD:
6196 _MVD_RET_HANDLE(MDrv_MVD_DisablePBFrameMode(u32Id, (MS_BOOL) u32Arg));
6197 break;
6198
6199 case E_VDEC_EX_DECODER_HVD:
6200 break;
6201
6202 case E_VDEC_EX_DECODER_MJPEG:
6203 break;
6204
6205 default:
6206 break;
6207 }
6208
6209 return eRet;
6210 }
6211
_VDEC_EX_SetSecureMode(VDEC_StreamId * pStreamId,MS_U32 u32SecureMode)6212 static VDEC_EX_Result _VDEC_EX_SetSecureMode(VDEC_StreamId *pStreamId, MS_U32 u32SecureMode)
6213 {
6214 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6215 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6216 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6217
6218 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6219 {
6220 case E_VDEC_EX_DECODER_MVD:
6221 eRet = E_VDEC_EX_OK;
6222 break;
6223 case E_VDEC_EX_DECODER_HVD:
6224 _HVD_RET_HANDLE(MDrv_HVD_EX_SetSecureMode(u32Id, u32SecureMode));
6225 eRet = E_VDEC_EX_OK;
6226 break;
6227 case E_VDEC_EX_DECODER_MJPEG:
6228 eRet = E_VDEC_EX_OK;
6229 break;
6230 default:
6231 break;
6232 }
6233
6234 return eRet;
6235 }
6236
6237 //------------------------------------------------------------------------------
6238 /// Set RVU setting mode : Settings for RVU mode.
6239 /// @param bEnable \u32 IN : 0: Disable, 1: Drop B-frame and force IDR.
6240 /// @return VDEC_EX_Result
6241 //------------------------------------------------------------------------------
_VDEC_EX_RVU_Setting_Mode(VDEC_StreamId * pStreamId,MS_U32 u32Param)6242 static VDEC_EX_Result _VDEC_EX_RVU_Setting_Mode(VDEC_StreamId *pStreamId, MS_U32 u32Param)
6243 {
6244 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6245 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6246 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6247
6248 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6249 {
6250 case E_VDEC_EX_DECODER_HVD:
6251 _HVD_RET_HANDLE(MDrv_HVD_EX_RVU_Setting_Mode(u32Id, u32Param));
6252 eRet = E_VDEC_EX_OK;
6253 break;
6254 case E_VDEC_EX_DECODER_MVD:
6255 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6256 break;
6257 case E_VDEC_EX_DECODER_MJPEG:
6258 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6259 break;
6260 default:
6261 break;
6262 }
6263
6264 return eRet;
6265 }
6266
_VDEC_EX_FramerateHandling(VDEC_StreamId * pStreamId,MS_U32 u32Framerate)6267 static VDEC_EX_Result _VDEC_EX_FramerateHandling(VDEC_StreamId *pStreamId, MS_U32 u32Framerate)
6268 {
6269 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6270 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6271 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6272
6273 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6274 {
6275 case E_VDEC_EX_DECODER_MVD:
6276 eRet = E_VDEC_EX_OK;
6277 break;
6278 case E_VDEC_EX_DECODER_HVD:
6279 _HVD_RET_HANDLE(MDrv_HVD_EX_FramerateHandling(u32Id, u32Framerate));
6280 eRet = E_VDEC_EX_OK;
6281 break;
6282 case E_VDEC_EX_DECODER_MJPEG:
6283 eRet = E_VDEC_EX_OK;
6284 break;
6285 default:
6286 break;
6287 }
6288
6289 return eRet;
6290 }
6291
6292
6293 //------------------------------------------------------------------------------
6294 /// Set _VDEC_EX_DualNonBlockMode
6295 /// @param bEnable \b IN : turn on / off.
6296 /// @return VDEC_EX_Result
6297 //------------------------------------------------------------------------------
_VDEC_EX_DualNonBlockMode(VDEC_StreamId * pStreamId,MS_BOOL bEnable)6298 static VDEC_EX_Result _VDEC_EX_DualNonBlockMode(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
6299 {
6300 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
6301 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6302 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6303
6304 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6305 {
6306 case E_VDEC_EX_DECODER_HVD:
6307 _HVD_RET_HANDLE(MDrv_HVD_EX_DualNonBlockMode(u32Id, bEnable));
6308 ret = E_VDEC_EX_OK;
6309 break;
6310 case E_VDEC_EX_DECODER_MVD:
6311 ret = E_VDEC_EX_RET_UNSUPPORTED;
6312 break;
6313 case E_VDEC_EX_DECODER_MJPEG:
6314 ret = E_VDEC_EX_RET_UNSUPPORTED;
6315 break;
6316 default:
6317 break;
6318 }
6319
6320 return ret;
6321 }
6322
_VDEC_EX_ClearProcessRelated(MS_U32 param)6323 static VDEC_EX_Result _VDEC_EX_ClearProcessRelated(MS_U32 param)
6324 {
6325 MS_U8 u8Idx = 0;
6326
6327 if(pVdecExContext == NULL)
6328 {
6329 VDEC_PRINT("Err,%s,pVdecExContext is Null\n",__FUNCTION__);
6330 return E_VDEC_EX_FAIL;
6331 }
6332
6333 for(u8Idx = 0; u8Idx < VDEC_MAX_SUPPORT_STREAM_NUM; u8Idx++)
6334 {
6335 #if 0
6336 if(pVdecExContext->_Attr[u8Idx].s32VdecExMutexId != -1)
6337 {
6338 pVdecExContext->_Attr[u8Idx].s32VdecExMutexId = -1;
6339 }
6340 #endif
6341 #if (VDEC_EX_ISR_MONITOR)
6342 if(s32VdecExEventId[u8Idx] != -1)
6343 {
6344 s32VdecExEventId[u8Idx] = -1;
6345 }
6346
6347 if(s32VdecExTaskId[u8Idx] != -1)
6348 {
6349 s32VdecExTaskId[u8Idx] = -1;
6350 }
6351 #endif
6352 }
6353
6354 return E_VDEC_EX_OK;
6355 }
6356
6357
6358
6359 //------------------------------------------------------------------------------
6360 /// Set debug mode
6361 /// @param u32Mode \b IN :
6362 /// @return VDEC_Result
6363 //------------------------------------------------------------------------------
_VDEC_EX_DbgMode(VDEC_StreamId * pStreamId,VDEC_EX_DbgMode eDbgMode,MS_BOOL bEn)6364 static VDEC_EX_Result _VDEC_EX_DbgMode(VDEC_StreamId *pStreamId, VDEC_EX_DbgMode eDbgMode, MS_BOOL bEn)
6365 {
6366 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6367 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6368 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6369
6370 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6371 {
6372 case E_VDEC_EX_DECODER_MVD:
6373 switch (eDbgMode)
6374 {
6375 case E_VDEC_EX_DBG_MODE_BYPASS_INSERT_START_CODE:
6376 {
6377 _MVD_RET_HANDLE(MDrv_MVD_SetDbgMode(u32Id, E_MVD_EX_DBG_MODE_BYPASS_INSERT_START_CODE, bEn));
6378 eRet = E_VDEC_EX_OK;
6379 }
6380 break;
6381 case E_VDEC_EX_DBG_MODE_BYPASS_DIVX_MC_PATCH:
6382 {
6383 _MVD_RET_HANDLE(MDrv_MVD_SetDbgMode(u32Id, E_MVD_EX_DBG_MODE_BYPASS_DIVX_MC_PATCH, bEn));
6384 eRet = E_VDEC_EX_OK;
6385 }
6386 break;
6387 default:
6388 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6389 break;
6390 }
6391 break;
6392 case E_VDEC_EX_DECODER_HVD:
6393 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6394 break;
6395 case E_VDEC_EX_DECODER_MJPEG:
6396 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6397 break;
6398 default:
6399 break;
6400 }
6401
6402 return eRet;
6403 }
6404
_VDEC_EX_SetSTCMode(VDEC_StreamId * pStreamId,VDEC_EX_STCMode STCmode)6405 static VDEC_EX_Result _VDEC_EX_SetSTCMode(VDEC_StreamId *pStreamId, VDEC_EX_STCMode STCmode)
6406 {
6407 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6408
6409 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6410 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6411
6412 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
6413
6414 if (pVdecExContext->_Attr[u8Idx].bInit)
6415 {
6416 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
6417 }
6418 _HVD_RET_HANDLE(MDrv_HVD_SetSTCMode(u32Id,STCmode));
6419 eRet = E_VDEC_EX_OK;
6420
6421 return eRet;
6422 }
6423
_VDEC_EX_SetDecodeMode(VDEC_StreamId * pStreamId,VDEC_EX_DecModCfg * pDecModCfg)6424 static VDEC_EX_Result _VDEC_EX_SetDecodeMode(VDEC_StreamId *pStreamId, VDEC_EX_DecModCfg *pDecModCfg)
6425 {
6426 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6427 HVD_EX_DecModCfg stHvdDecModCfg;
6428 MS_U8 i = 0;
6429
6430 if (pDecModCfg == NULL)
6431 {
6432 return E_VDEC_EX_RET_INVALID_PARAM;
6433 }
6434
6435 if(pDecModCfg->eDecMod != E_VDEC_EX_DEC_MODE_DUAL_INDIE)
6436 {
6437 for (i=0; i<VDEC_MAX_SUPPORT_STREAM_NUM; i++)
6438 {
6439 if (TRUE == pVdecExContext->_Attr[i].bInit)
6440 {
6441 //VDEC_PRINT("%s must be set before init all tasks (%d)\n", __FUNCTION__, i);
6442 return E_VDEC_EX_FAIL;
6443 }
6444 }
6445 }
6446
6447 switch (pDecModCfg->eDecMod)
6448 {
6449 case E_VDEC_EX_DEC_MODE_MVC: //E_VDEC_EX_DEC_MODE_SINGLE
6450 if (pDecModCfg->u8ArgSize == sizeof(MS_BOOL))
6451 {
6452 MS_BOOL bSingleDecMode = TRUE;
6453 bSingleDecMode = (MS_BOOL)pDecModCfg->u32Arg;
6454 eRet = MApi_VDEC_EX_SetSingleDecode(bSingleDecMode);
6455 }
6456 break;
6457 case E_VDEC_EX_DEC_MODE_DUAL_INDIE:
6458 stHvdDecModCfg.u8DecMod = (MS_U8)pDecModCfg->eDecMod;
6459 stHvdDecModCfg.u8CodecCnt = pDecModCfg->u8CodecCnt;
6460 for (i=0; ((i<pDecModCfg->u8CodecCnt)&&(i<VDEC_MAX_DEC_NUM)); i++)
6461 {
6462 stHvdDecModCfg.u8CodecType[i] = (MS_U8)pDecModCfg->pstCodecInfo[i].eCodecType;
6463 }
6464 stHvdDecModCfg.u8ArgSize = pDecModCfg->u8ArgSize;
6465 stHvdDecModCfg.u32Arg = pDecModCfg->u32Arg;
6466 //--> HVD --> VPU
6467 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_SetDecodeMode(pStreamId->u32Id, &stHvdDecModCfg));
6468 break;
6469 case E_VDEC_EX_DEC_MODE_DUAL_3D:
6470 if (pDecModCfg->u8CodecCnt == 2)
6471 {
6472 if ((E_VDEC_EX_CODEC_TYPE_MPEG2 == pDecModCfg->pstCodecInfo[0].eCodecType) &&
6473 (E_VDEC_EX_CODEC_TYPE_H264 == pDecModCfg->pstCodecInfo[1].eCodecType))
6474 {
6475 VDEC_PRINT("3D_TV\n");
6476 }
6477 else if (((E_VDEC_EX_CODEC_TYPE_VC1_ADV == pDecModCfg->pstCodecInfo[0].eCodecType) &&
6478 (E_VDEC_EX_CODEC_TYPE_VC1_ADV == pDecModCfg->pstCodecInfo[1].eCodecType)) ||
6479 ((E_VDEC_EX_CODEC_TYPE_VC1_MAIN == pDecModCfg->pstCodecInfo[0].eCodecType) &&
6480 (E_VDEC_EX_CODEC_TYPE_VC1_MAIN == pDecModCfg->pstCodecInfo[1].eCodecType)))
6481 {
6482 VDEC_PRINT("3D_WMV\n");
6483 }
6484
6485 stHvdDecModCfg.u8DecMod = (MS_U8)pDecModCfg->eDecMod;
6486 stHvdDecModCfg.u8CodecCnt = pDecModCfg->u8CodecCnt;
6487 for (i=0; ((i<pDecModCfg->u8CodecCnt)&&(i<VDEC_MAX_DEC_NUM)); i++)
6488 {
6489 stHvdDecModCfg.u8CodecType[i] = (MS_U8)pDecModCfg->pstCodecInfo[i].eCodecType;
6490 }
6491 stHvdDecModCfg.u8ArgSize = pDecModCfg->u8ArgSize;
6492 stHvdDecModCfg.u32Arg = pDecModCfg->u32Arg;
6493 //--> HVD --> VPU
6494 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_SetDecodeMode(pStreamId->u32Id, &stHvdDecModCfg));
6495 }
6496 else
6497 {
6498 VDEC_PRINT("%s invalid u8CodecCnt(%d)\n", __FUNCTION__, pDecModCfg->u8CodecCnt);
6499 eRet = E_VDEC_EX_RET_INVALID_PARAM;
6500 }
6501 break;
6502 default:
6503 break;
6504 }
6505
6506 return eRet;
6507 }
6508
_VDEC_EX_FlushPTSBuf(VDEC_StreamId * pStreamId,MS_BOOL bEnable)6509 static VDEC_EX_Result _VDEC_EX_FlushPTSBuf(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
6510 {
6511 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
6512 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
6513 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
6514
6515 switch(pVdecExContext->_Attr[u8Idx].eDecoder)
6516 {
6517 case E_VDEC_EX_DECODER_MVD:
6518 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_FlushPTSBuf(u32Id, bEnable));
6519 break;
6520 case E_VDEC_EX_DECODER_HVD:
6521 case E_VDEC_EX_DECODER_MJPEG:
6522 eRet = E_VDEC_EX_RET_UNSUPPORTED;
6523 break;
6524 default:
6525 break;
6526 }
6527
6528 return eRet;
6529 }
6530
6531 #if (VDEC_EX_ISR_MONITOR)
_VDEC_EX_SYS_Init(MS_U8 u8Idx)6532 static MS_BOOL _VDEC_EX_SYS_Init(MS_U8 u8Idx)
6533 {
6534 VDEC_EX_Attr* pAttr = &(pVdecExContext->_Attr[u8Idx]);
6535 //MS_S32* ps32VdecExMutexId = &pAttr->s32VdecExMutexId;
6536
6537 char* pu8VdecExEvent = pAttr->stEventMon.pu8VdecExEvent;
6538 //MS_S32* ps32VdecExTaskId = &pAttr->stEventMon.s32VdecExTaskId;
6539 char* pu8VdecExTask = pAttr->stEventMon.pu8VdecExTask;
6540
6541 #if 0
6542 //Create Mutex
6543 *ps32VdecExMutexId = MsOS_CreateMutex(E_MSOS_FIFO, (char *)pAttr->pu8VdecExMutex, MSOS_PROCESS_SHARED);
6544
6545 if (*ps32VdecExMutexId < 0)
6546 {
6547 VDEC_PRINT("MsOS_CreateMutex failed!!\n");
6548 return FALSE;
6549 }
6550 #endif
6551
6552 if(s32VdecExEventId[u8Idx] == -1)
6553 {
6554 //Create Event Group
6555 s32VdecExEventId[u8Idx] = MsOS_CreateEventGroup(pu8VdecExEvent);
6556
6557 if (s32VdecExEventId[u8Idx] < 0)
6558 {
6559 VDEC_PRINT("MsOS_CreateEventGroup failed!!\n");
6560 //MsOS_DeleteMutex(*ps32VdecExMutexId);
6561 return FALSE;
6562 }
6563 }
6564
6565 if(s32VdecExTaskId[u8Idx] == -1)
6566 {
6567 //Create Vdec event monitor Task
6568 pAttr->stEventMon.bVdecExIsrMntr = TRUE;
6569 //create corresponding tasks to monitor ISR for each task
6570 //task0: _VDEC_EX_MonitorISR_Proc; task1: _VDEC_EX_MonitorSubISR_Proc
6571 s32VdecExTaskId[u8Idx] = MsOS_CreateTask((TaskEntry) pAttr->stEventMon.pfMonISR_Proc,
6572 #ifdef VDEC3
6573 (MS_U32) u8Idx,
6574 #else
6575 (MS_U32) NULL,
6576 #endif
6577 E_TASK_PRI_MEDIUM,
6578 TRUE,
6579 (void *)pAttr->stEventMon.u8VdecExStack,
6580 VDEC_EX_STACK_SIZE,
6581 pu8VdecExTask);
6582 if (s32VdecExTaskId[u8Idx] < 0)
6583 {
6584 VDEC_PRINT("MsOS_CreateTask failed!!\n");
6585 MsOS_DeleteEventGroup(s32VdecExEventId[u8Idx]);
6586 // MsOS_DeleteMutex(*ps32VdecExMutexId);
6587 return FALSE;
6588 }
6589 }
6590
6591 return TRUE;
6592 }
6593 #else
6594 #if 0
6595 static MS_BOOL _VDEC_EX_MutexInit(MS_U8 u8Idx)
6596 {
6597 pVdecExContext->_Attr[u8Idx].s32VdecExMutexId =
6598 MsOS_CreateMutex(E_MSOS_FIFO,
6599 (char *)pVdecExContext->_Attr[u8Idx].pu8VdecExMutex,
6600 MSOS_PROCESS_SHARED);
6601
6602 return (pVdecExContext->_Attr[u8Idx].s32VdecExMutexId != -1);
6603 }
6604 #endif
6605 #endif
6606
6607
6608 #if 0
6609 // Mutex function for VDEC API
6610 static MS_BOOL _VDEC_EX_MutexLock(MS_U8 u8Idx)
6611 {
6612 MS_S32 _s32VdecExMutexId = pVdecExContext->_Attr[u8Idx].s32VdecExMutexId;
6613 if (_s32VdecExMutexId != -1)
6614 {
6615 //VDEC_PRINT("____%s____\n", __FUNCTION__);
6616 return MsOS_ObtainMutex(_s32VdecExMutexId, MSOS_WAIT_FOREVER);
6617 }
6618 else
6619 {
6620 return FALSE;
6621 }
6622 }
6623
6624 static MS_BOOL _VDEC_EX_MutexUnlock(MS_U8 u8Idx)
6625 {
6626 MS_S32 _s32VdecExMutexId = pVdecExContext->_Attr[u8Idx].s32VdecExMutexId;
6627 if (_s32VdecExMutexId != -1)
6628 {
6629 //VDEC_PRINT("____%s____\n", __FUNCTION__);
6630 return MsOS_ReleaseMutex(_s32VdecExMutexId);
6631 }
6632 else
6633 {
6634 return FALSE;
6635 }
6636 }
6637 #endif
6638
_VDEC_EX_GetDecoderByCodecType(VDEC_EX_CodecType eCodecType)6639 static VDEC_EX_Decoder _VDEC_EX_GetDecoderByCodecType(VDEC_EX_CodecType eCodecType)
6640 {
6641 VDEC_EX_Decoder eDecoder;
6642
6643 switch (eCodecType)
6644 {
6645 case E_VDEC_EX_CODEC_TYPE_MPEG2:
6646 case E_VDEC_EX_CODEC_TYPE_H263:
6647 case E_VDEC_EX_CODEC_TYPE_MPEG4:
6648 #if (!VESTEL_FEATURE_ENABLE)
6649 case E_VDEC_EX_CODEC_TYPE_DIVX311:
6650 case E_VDEC_EX_CODEC_TYPE_DIVX412:
6651 case E_VDEC_EX_CODEC_TYPE_FLV:
6652 case E_VDEC_EX_CODEC_TYPE_VC1_ADV:
6653 case E_VDEC_EX_CODEC_TYPE_VC1_MAIN:
6654 #endif
6655 eDecoder = E_VDEC_EX_DECODER_MVD;
6656 bIsSupportDivxPlus = TRUE;
6657 break;
6658
6659 case E_VDEC_EX_CODEC_TYPE_RV8:
6660 case E_VDEC_EX_CODEC_TYPE_RV9:
6661 #if VDEC_ENABLE_HVD
6662 eDecoder = E_VDEC_EX_DECODER_HVD;
6663 #else
6664 eDecoder = E_VDEC_EX_DECODER_NONE;
6665 #endif
6666 break;
6667 #if (!VESTEL_FEATURE_ENABLE)
6668 case E_VDEC_EX_CODEC_TYPE_H264:
6669 case E_VDEC_EX_CODEC_TYPE_AVS:
6670 case E_VDEC_EX_CODEC_TYPE_MVC: /// SUPPORT_MVC
6671 case E_VDEC_EX_CODEC_TYPE_VP8:
6672 case E_VDEC_EX_CODEC_TYPE_HEVC:
6673 case E_VDEC_EX_CODEC_TYPE_VP9:
6674 eDecoder = E_VDEC_EX_DECODER_HVD;
6675 break;
6676 #endif
6677 case E_VDEC_EX_CODEC_TYPE_MJPEG:
6678 eDecoder = E_VDEC_EX_DECODER_MJPEG;
6679
6680 break;
6681
6682 default:
6683 eDecoder = E_VDEC_EX_DECODER_NONE;
6684
6685 break;
6686 }
6687
6688 return eDecoder;
6689 }
6690
6691
6692 #if (VDEC_EX_ISR_MONITOR)
6693 #ifdef VDEC3
_VDEC_EX_MonitorNStreamISR_Proc(MS_U8 u8Idx)6694 static void _VDEC_EX_MonitorNStreamISR_Proc(MS_U8 u8Idx)
6695 {
6696 #if 0//!defined(VDEC_UTOPIA_2K)
6697 MS_U32 u32VdecEventFlag = 0;
6698 MS_U32 cb_idx = 0;
6699 VDEC_EX_Attr* pAttr = &(pVdecExContext->_Attr[u8Idx]);
6700
6701 while (pAttr->stEventMon.bVdecExIsrMntr == TRUE)
6702 {
6703 if(pVdecExContext->_u32PreVdecExIsrEventFlag[u8Idx] != pVdecExContext->_u32VdecExIsrEventFlag[u8Idx])
6704 {
6705 MsOS_ClearEvent(s32VdecExEventId[u8Idx], VDEC_U32_MAX);
6706 pVdecExContext->_u32PreVdecExIsrEventFlag[u8Idx] = pVdecExContext->_u32VdecExIsrEventFlag[u8Idx];
6707 }
6708
6709 MsOS_WaitEvent(s32VdecExEventId[u8Idx],
6710 pVdecExContext->_u32PreVdecExIsrEventFlag[u8Idx],
6711 &u32VdecEventFlag,
6712 E_OR_CLEAR,
6713 MSOS_WAIT_FOREVER);
6714
6715 //Sync CL487351
6716 if ((u32VdecEventFlag & ~E_VDEC_EX_EVENT_ISR_EVENT_CHANGE) & pVdecExContext->_u32VdecExIsrEventFlag[u8Idx])
6717 {
6718 for (cb_idx = 0; cb_idx < E_VDEC_EX_CB_MAX_NUM; cb_idx++)
6719 {
6720 VDEC_EX_EventInfo* pstEvInfo = &pAttr->vdecExEventInfo[cb_idx];
6721 MS_U32 u32Event = u32VdecEventFlag & (pstEvInfo->u32EventBitMap);
6722 VDEC_EX_EventCb pvdecNStreamCb = pstEvInfo->pVdecEventCb;
6723
6724 if ((u32Event) && (pvdecNStreamCb))
6725 {
6726 pvdecNStreamCb(u32Event, pstEvInfo->pParam);
6727 }
6728 }
6729 }
6730 }
6731 #endif
6732 }
6733 #else
6734 //------------------------------------------------------------------------------
6735 /// The task for monitoring vdec isr
6736 /// @return -None
6737 //------------------------------------------------------------------------------
_VDEC_EX_MonitorISR_Proc(void)6738 static void _VDEC_EX_MonitorISR_Proc(void)
6739 {
6740 #if 0//!defined(VDEC_UTOPIA_2K)
6741 MS_U32 u32VdecEventFlag = 0;
6742 MS_U32 cb_idx = 0;
6743 VDEC_EX_Attr* pAttr = &(pVdecExContext->_Attr[E_VDEC_EX_MAIN_STREAM]);
6744
6745 while (pAttr->stEventMon.bVdecExIsrMntr == TRUE)
6746 {
6747 if(pVdecExContext->_u32PreVdecExIsrEventFlag[E_VDEC_EX_MAIN_STREAM] != pVdecExContext->_u32VdecExIsrEventFlag[E_VDEC_EX_MAIN_STREAM])
6748 {
6749 MsOS_ClearEvent(s32VdecExEventId[0], VDEC_U32_MAX);
6750 pVdecExContext->_u32PreVdecExIsrEventFlag[E_VDEC_EX_MAIN_STREAM] = pVdecExContext->_u32VdecExIsrEventFlag[E_VDEC_EX_MAIN_STREAM];
6751 }
6752
6753 MsOS_WaitEvent(s32VdecExEventId[0],
6754 pVdecExContext->_u32PreVdecExIsrEventFlag[E_VDEC_EX_MAIN_STREAM],
6755 &u32VdecEventFlag,
6756 E_OR_CLEAR,
6757 MSOS_WAIT_FOREVER);
6758
6759 //VDEC_PRINT("%s:flag=0x%lx\n", __FUNCTION__, u32VdecEventFlag);
6760 //Sync CL487351
6761 if ((u32VdecEventFlag & ~E_VDEC_EX_EVENT_ISR_EVENT_CHANGE) & pVdecExContext->_u32VdecExIsrEventFlag[E_VDEC_EX_MAIN_STREAM])
6762 {
6763 for (cb_idx = 0; cb_idx < E_VDEC_EX_CB_MAX_NUM; cb_idx++)
6764 {
6765 VDEC_EX_EventInfo* pstEvInfo = &pAttr->vdecExEventInfo[cb_idx];
6766 MS_U32 u32Event = u32VdecEventFlag & (pstEvInfo->u32EventBitMap);
6767 VDEC_EX_EventCb pvdecCb = pstEvInfo->pVdecEventCb;
6768
6769 if ((u32Event) && (pvdecCb))
6770 {
6771 pvdecCb(u32Event, pstEvInfo->pParam);
6772 }
6773 }
6774 }
6775 }
6776 #endif
6777 }
6778
_VDEC_EX_MonitorSubISR_Proc(void)6779 static void _VDEC_EX_MonitorSubISR_Proc(void)
6780 {
6781 #if 0//!defined(VDEC_UTOPIA_2K)
6782 MS_U32 u32VdecEventFlag = 0;
6783 MS_U32 cb_idx = 0;
6784 VDEC_EX_Attr* pAttr = &(pVdecExContext->_Attr[E_VDEC_EX_SUB_STREAM]);
6785
6786 while (pAttr->stEventMon.bVdecExIsrMntr == TRUE)
6787 {
6788 if(pVdecExContext->_u32PreVdecExIsrEventFlag[E_VDEC_EX_SUB_STREAM] != pVdecExContext->_u32VdecExIsrEventFlag[E_VDEC_EX_SUB_STREAM])
6789 {
6790 MsOS_ClearEvent(s32VdecExEventId[1], VDEC_U32_MAX);
6791 pVdecExContext->_u32PreVdecExIsrEventFlag[E_VDEC_EX_SUB_STREAM] = pVdecExContext->_u32VdecExIsrEventFlag[E_VDEC_EX_SUB_STREAM];
6792 }
6793
6794 MsOS_WaitEvent(s32VdecExEventId[1],
6795 pVdecExContext->_u32PreVdecExIsrEventFlag[E_VDEC_EX_SUB_STREAM],
6796 &u32VdecEventFlag,
6797 E_OR_CLEAR,
6798 MSOS_WAIT_FOREVER);
6799
6800 //Sync CL487351
6801 if ((u32VdecEventFlag & ~E_VDEC_EX_EVENT_ISR_EVENT_CHANGE) & pVdecExContext->_u32VdecExIsrEventFlag[E_VDEC_EX_SUB_STREAM])
6802 {
6803 for (cb_idx = 0; cb_idx < E_VDEC_EX_CB_MAX_NUM; cb_idx++)
6804 {
6805 VDEC_EX_EventInfo* pstEvInfo = &pAttr->vdecExEventInfo[cb_idx];
6806 MS_U32 u32Event = u32VdecEventFlag & (pstEvInfo->u32EventBitMap);
6807 VDEC_EX_EventCb pvdecSubCb = pstEvInfo->pVdecEventCb;
6808
6809 if ((u32Event) && (pvdecSubCb))
6810 {
6811 pvdecSubCb(u32Event, pstEvInfo->pParam);
6812 }
6813 }
6814 }
6815 }
6816 #endif
6817 }
6818 #endif
6819 #endif
6820
_IsrProc(MS_U8 u8Idx,MS_U32 u32Sid)6821 static void _IsrProc(MS_U8 u8Idx, MS_U32 u32Sid)
6822 {
6823 //_VDEC_EX_MutexLock(u8Idx);
6824
6825 #if (VDEC_EX_ISR_MONITOR)
6826 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & (~E_VDEC_EX_EVENT_ISR_EVENT_CHANGE))
6827 #else
6828 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx])
6829 #endif
6830 {
6831 MS_U32 eEventFlag = E_VDEC_EX_EVENT_OFF;
6832
6833 //Get event info from the specified decoder
6834 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
6835 {
6836 case E_VDEC_EX_DECODER_MVD:
6837 {
6838 MS_U32 u32MVDIsrEvent = MDrv_MVD_GetIsrEvent(u32Sid);
6839 //VDEC_PRINT("%s u32Sid=0x%lx, u32MVDIsrEvent=0x%x\n", __FUNCTION__, u32Sid, u32MVDIsrEvent);
6840 if (u32MVDIsrEvent != E_MVD_EVENT_DISABLE_ALL)
6841 {
6842 if (u32MVDIsrEvent & E_MVD_EVENT_DISP_VSYNC)
6843 {
6844 eEventFlag |= E_VDEC_EX_EVENT_DISP_ONE;
6845 }
6846
6847 if (u32MVDIsrEvent & E_MVD_EVENT_DISP_RDY)
6848 {
6849 eEventFlag |= E_VDEC_EX_EVENT_DISP_INFO_RDY;
6850 }
6851 if (u32MVDIsrEvent & E_MVD_EVENT_SEQ_FOUND)
6852 {
6853 eEventFlag |= E_VDEC_EX_EVENT_SEQ_HDR_FOUND;
6854 if (MDrv_MVD_IsSeqChg(u32Sid))
6855 {
6856 eEventFlag |= E_VDEC_EX_EVENT_DISP_INFO_CHG;
6857 }
6858 }
6859 if (u32MVDIsrEvent & E_MVD_EVENT_USER_DATA)
6860 {
6861 #if !defined(SUPPORT_X_MODEL_FEATURE)
6862 //exclude this for X4_CC for this is UserData in "decoding" order
6863 eEventFlag |= E_VDEC_EX_EVENT_USER_DATA_FOUND;
6864 #endif
6865 MS_U8 u8Afd = MDrv_MVD_GetActiveFormat(u32Sid);
6866
6867 if ((u8Afd != 0) && (u8Afd != 0xff))
6868 {
6869 eEventFlag |= E_VDEC_EX_EVENT_AFD_FOUND;
6870 }
6871 }
6872 if (u32MVDIsrEvent & E_MVD_EVENT_USER_DATA_DISP)
6873 {
6874 //this is UserData in "display" order
6875 eEventFlag |= E_VDEC_EX_EVENT_USER_DATA_FOUND;
6876 }
6877 if (u32MVDIsrEvent & E_MVD_EVENT_UNMUTE)
6878 {
6879 eEventFlag |= E_VDEC_EX_EVENT_VIDEO_UNMUTE;
6880 }
6881 if (u32MVDIsrEvent & E_MVD_EVENT_FIRST_FRAME)
6882 {
6883 eEventFlag |= E_VDEC_EX_EVENT_FIRST_FRAME;
6884 }
6885 if (u32MVDIsrEvent & E_MVD_EVENT_DEC_ONE_FRAME)
6886 {
6887 eEventFlag |= E_VDEC_EX_EVENT_DEC_ONE;
6888 }
6889
6890 if (u32MVDIsrEvent & E_MVD_EVENT_DEC_ERR)
6891 {
6892 eEventFlag |= E_VDEC_EX_EVENT_DEC_ERR;
6893 }
6894
6895 if (u32MVDIsrEvent & E_MVD_EVENT_DEC_DATA_ERR)
6896 {
6897 eEventFlag |= E_VDEC_EX_EVENT_ES_DATA_ERR;
6898 }
6899 if (u32MVDIsrEvent & E_MVD_EVENT_XC_LOW_DEALY)
6900 {
6901 eEventFlag |= E_VDEC_EX_EVENT_XC_LOW_DEALY;
6902 }
6903 if (u32MVDIsrEvent & E_MVD_EVENT_DEC_I)
6904 {
6905 eEventFlag |= E_VDEC_EX_EVENT_DEC_I;
6906 }
6907 }
6908 break;
6909 }
6910 case E_VDEC_EX_DECODER_HVD:
6911 {
6912 MS_U32 eEvent = E_HVD_EX_ISR_NONE;
6913
6914 if (MDrv_HVD_EX_GetISRInfo(u32Sid, &eEvent))
6915 {
6916 if (eEvent & E_HVD_EX_ISR_DISP_ONE)
6917 {
6918 eEventFlag |= E_VDEC_EX_EVENT_DISP_ONE;
6919 }
6920 if (eEvent & E_HVD_EX_ISR_DISP_REPEAT)
6921 {
6922 eEventFlag |= E_VDEC_EX_EVENT_DISP_REPEAT;
6923 }
6924 if (eEvent & E_HVD_EX_ISR_DISP_WITH_CC)
6925 {
6926 eEventFlag |= E_VDEC_EX_EVENT_DISP_WITH_CC;
6927 }
6928 if (eEvent & E_HVD_EX_ISR_DISP_FIRST_FRM)
6929 {
6930 eEventFlag |= E_VDEC_EX_EVENT_VIDEO_UNMUTE;
6931 }
6932 if (eEvent & E_HVD_EX_ISR_DEC_ONE)
6933 {
6934 eEventFlag |= E_VDEC_EX_EVENT_DEC_ONE;
6935 }
6936 if (eEvent & E_HVD_EX_ISR_DEC_I)
6937 {
6938 eEventFlag |= E_VDEC_EX_EVENT_DEC_I;
6939 }
6940 if (eEvent & E_HVD_EX_ISR_DEC_HW_ERR)
6941 {
6942 eEventFlag |= E_VDEC_EX_EVENT_DEC_ERR;
6943 }
6944 if (eEvent & E_HVD_EX_ISR_DEC_CC_FOUND)
6945 {
6946 eEventFlag |= E_VDEC_EX_EVENT_USER_DATA_FOUND;
6947 }
6948 if (eEvent & E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE)
6949 {
6950 MS_U8 u8Afd = MDrv_HVD_EX_GetActiveFormat(u32Sid);
6951
6952 if (u8Afd != 0)
6953 {
6954 eEventFlag |= E_VDEC_EX_EVENT_AFD_FOUND;
6955 }
6956 eEventFlag |= E_VDEC_EX_EVENT_DISP_INFO_CHG;
6957 }
6958 if (eEvent & E_HVD_EX_ISR_DEC_DATA_ERR)
6959 {
6960 eEventFlag |= E_VDEC_EX_EVENT_ES_DATA_ERR;
6961 }
6962
6963 if (eEvent & E_HVD_EX_ISR_DEC_FIRST_FRM)
6964 {
6965 eEventFlag |= E_VDEC_EX_EVENT_FIRST_FRAME;
6966 }
6967 if (eEvent & E_HVD_EX_ISR_DEC_SEQ_HDR_FOUND)
6968 {
6969 eEventFlag |= E_VDEC_EX_EVENT_SEQ_HDR_FOUND;
6970 }
6971 }
6972 break;
6973 }
6974 case E_VDEC_EX_DECODER_MJPEG:
6975 break;
6976 default:
6977 break;
6978 }
6979
6980 // Notify AP by calling callback functions if there are interested events
6981 if (E_VDEC_EX_EVENT_OFF != eEventFlag)
6982 {
6983 #if (VDEC_EX_ISR_MONITOR)
6984 MsOS_SetEvent(s32VdecExEventId[u8Idx], eEventFlag);
6985 #else
6986 MS_U32 cb_idx;
6987 for (cb_idx = 0; cb_idx < E_VDEC_EX_CB_MAX_NUM; cb_idx++)
6988 {
6989 VDEC_EX_EventInfo* pstEvInfo = &(pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_idx]);
6990 MS_U32 u32Event = eEventFlag & (pstEvInfo->u32EventBitMap);
6991
6992 if ((u32Event) && (pstEvInfo->pVdecEventCb))
6993 {
6994 //_VDEC_EX_MutexUnlock(u8Idx);
6995 pstEvInfo->pVdecEventCb(u32Event, pstEvInfo->pParam);
6996 //_VDEC_EX_MutexLock(u8Idx);
6997 }
6998 }
6999 #endif
7000 }
7001
7002 }
7003
7004 //_VDEC_EX_MutexUnlock(u8Idx);
7005 }
7006
7007 #ifdef VDEC3
_VDEC_EX_NStream_IsrProc(MS_U32 u32Sid)7008 static void _VDEC_EX_NStream_IsrProc(MS_U32 u32Sid)
7009 {
7010 _IsrProc(_VDEC_GET_DRV_IDX(u32Sid), u32Sid);
7011 return;
7012 }
7013 #else
_VDEC_EX_IsrProc(MS_U32 u32Sid)7014 static void _VDEC_EX_IsrProc(MS_U32 u32Sid)
7015 {
7016 _IsrProc(E_VDEC_EX_MAIN_STREAM, u32Sid);
7017 return;
7018 }
7019
_VDEC_EX_Sub_IsrProc(MS_U32 u32Sid)7020 void _VDEC_EX_Sub_IsrProc(MS_U32 u32Sid)
7021 {
7022 _IsrProc(E_VDEC_EX_SUB_STREAM, u32Sid);
7023 return;
7024 }
7025 #endif
7026
_VDEC_EX_GetESBuffVacancy(VDEC_StreamId * pStreamId)7027 static MS_VIRT _VDEC_EX_GetESBuffVacancy(VDEC_StreamId *pStreamId)
7028 {
7029 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7030 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7031 MS_VIRT u32ESRdPtr = 0;
7032 MS_VIRT u32ESWtPtr = 0;
7033
7034 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7035 {
7036 case E_VDEC_EX_DECODER_MVD:
7037 {
7038 u32ESRdPtr = MDrv_MVD_GetESReadPtr(u32Id);
7039 u32ESWtPtr = MDrv_MVD_GetESWritePtr(u32Id);
7040 break;
7041 }
7042 case E_VDEC_EX_DECODER_HVD:
7043 {
7044 u32ESRdPtr = MDrv_HVD_EX_GetESReadPtr(u32Id);
7045 u32ESWtPtr = MDrv_HVD_EX_GetESWritePtr(u32Id);
7046 break;
7047 }
7048 case E_VDEC_EX_DECODER_MJPEG:
7049 {
7050 _VDEC_EX_API_MutexLock();
7051 u32ESRdPtr = MApi_MJPEG_GetESReadPtr(u32Id);
7052 u32ESWtPtr = MApi_MJPEG_GetESWritePtr(u32Id);
7053 _VDEC_EX_API_MutexUnlock();
7054 break;
7055 }
7056 default:
7057 break;
7058 }
7059
7060 if (u32ESWtPtr == u32ESRdPtr)
7061 {
7062 return pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufSize;
7063 }
7064 else if (u32ESWtPtr > u32ESRdPtr)
7065 {
7066 return pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufSize - u32ESWtPtr + u32ESRdPtr;
7067 }
7068
7069 return u32ESRdPtr - u32ESWtPtr;
7070 }
7071
_VDEC_EX_GetESQuantity(VDEC_StreamId * pStreamId,MS_U32 * param)7072 static VDEC_EX_Result _VDEC_EX_GetESQuantity(VDEC_StreamId *pStreamId, MS_U32 *param)
7073 {
7074 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7075 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7076 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7077 //MS_U32 u32SubViewId = (u32Id + 0x00011000);
7078
7079 if (param == NULL)
7080 {
7081 return E_VDEC_EX_RET_INVALID_PARAM;
7082 }
7083
7084 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7085 {
7086 case E_VDEC_EX_DECODER_HVD:
7087 *param = MDrv_HVD_EX_GetESQuantity(u32Id);
7088 break;
7089
7090 case E_VDEC_EX_DECODER_MVD:
7091 case E_VDEC_EX_DECODER_MJPEG:
7092 *param = 0;
7093 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
7094 break;
7095
7096 default:
7097 *param = 0;
7098 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
7099 break;
7100 }
7101
7102 return eRet;
7103 }
7104
_VDEC_EX_GetColorMatrixCoef(VDEC_StreamId * pStreamId,MS_U32 * param)7105 static VDEC_EX_Result _VDEC_EX_GetColorMatrixCoef(VDEC_StreamId *pStreamId, MS_U32 *param)
7106 {
7107 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7108 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7109 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7110
7111 if (param == NULL)
7112 {
7113 return E_VDEC_EX_RET_INVALID_PARAM;
7114 }
7115
7116 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7117 {
7118 case E_VDEC_EX_DECODER_MVD:
7119 *param = MDrv_MVD_GetMatrixCoef(u32Id);
7120 eRet = E_VDEC_EX_OK;
7121 break;
7122 case E_VDEC_EX_DECODER_HVD:
7123 case E_VDEC_EX_DECODER_MJPEG:
7124 default:
7125 *param = 0xff;
7126 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7127 break;
7128 }
7129
7130 return eRet;
7131 }
7132
_VDEC_EX_GetIsDynScalingEnabled(VDEC_StreamId * pStreamId,MS_U32 * param)7133 static VDEC_EX_Result _VDEC_EX_GetIsDynScalingEnabled(VDEC_StreamId *pStreamId, MS_U32* param)
7134 {
7135 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7136 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7137 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7138
7139 if (!param)
7140 {
7141 return E_VDEC_EX_RET_INVALID_PARAM;
7142 }
7143 else
7144 {
7145 *param = FALSE;
7146 }
7147
7148 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7149 {
7150 case E_VDEC_EX_DECODER_HVD:
7151 {
7152 if (E_HVD_EX_OK == MDrv_HVD_EX_CheckDispInfoRdy(u32Id))
7153 {
7154 *param = (MS_BOOL)MDrv_HVD_EX_GetDynamicScalingInfo(u32Id, E_HVD_EX_DS_IS_ENABLED);
7155 eRet = E_VDEC_EX_OK;
7156 }
7157 else
7158 {
7159 eRet = E_VDEC_EX_RET_NOT_READY;
7160 }
7161 break;
7162 }
7163 case E_VDEC_EX_DECODER_MVD:
7164 {
7165 if (0 != MDrv_MVD_GetDispRdy(u32Id))
7166 {
7167 *param = MDrv_MVD_GetIsDynScalingEnabled(u32Id);
7168 eRet = E_VDEC_EX_OK;
7169 }
7170 else
7171 {
7172 eRet = E_VDEC_EX_RET_NOT_READY;
7173 }
7174 break;
7175 }
7176 case E_VDEC_EX_DECODER_MJPEG:
7177 default:
7178 {
7179 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7180 break;
7181 }
7182 }
7183
7184 VDEC_INFO(u8Idx, VDEC_PRINT("%s = %x\n", __FUNCTION__, (MS_BOOL)*param));
7185 return eRet;
7186 }
7187
_VDEC_EX_HandleSingleDecodeMode(VDEC_EX_Decoder eDec)7188 static MS_BOOL _VDEC_EX_HandleSingleDecodeMode(VDEC_EX_Decoder eDec)
7189 {
7190 MS_BOOL bRet = FALSE;
7191
7192 switch (eDec)
7193 {
7194 case E_VDEC_EX_DECODER_MVD:
7195 bRet = MDrv_MVD_SetSingleDecodeMode(TRUE);
7196 break;
7197 case E_VDEC_EX_DECODER_HVD:
7198 bRet = MDrv_HVD_SetSingleDecodeMode(TRUE);
7199 break;
7200 case E_VDEC_EX_DECODER_MJPEG:
7201 break;
7202 default:
7203 break;
7204 }
7205
7206 return bRet;
7207 }
7208
7209 #ifndef VDEC3
_VDEC_EX_ReparseVP8Packet(MS_U8 u8Idx,HVD_EX_PacketInfo * pPacketInfo)7210 static VDEC_EX_Result _VDEC_EX_ReparseVP8Packet(MS_U8 u8Idx, HVD_EX_PacketInfo *pPacketInfo)
7211 {
7212 MS_U8 *pData = (MS_U8 *) MsOS_PA2KSEG1(pPacketInfo->u32Staddr + pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufAddr);
7213 MS_U32 u32FrmSize;
7214 MS_U32 u32FirstPartitionSize;
7215 MS_U8 u8FrmType; //u8Version;
7216
7217 if (NULL == pData)
7218 {
7219 return E_VDEC_EX_FAIL;
7220 }
7221
7222 u32FrmSize = pPacketInfo->u32Length;
7223 //u32FrmSize = (pData[3] << 24) | (pData[2] << 16) | (pData[1] << 8) | (pData[0]);
7224 //pData += 12;
7225 u8FrmType = (pData[0] & 1);
7226 //u8Version = (pData[0] >> 1) & 7;
7227 u32FirstPartitionSize = (pData[0] | (pData[1] << 8) | (pData[2] << 16)) >> 5;
7228
7229 //pPacketInfo->u32Staddr += 12;
7230 pPacketInfo->u32Length = u32FirstPartitionSize + (u8FrmType ? 3 : 10);
7231 pPacketInfo->u32Staddr2 = pPacketInfo->u32Staddr + pPacketInfo->u32Length;
7232 pPacketInfo->u32Length2 = u32FrmSize - pPacketInfo->u32Length;
7233
7234 #if 0
7235 VDEC_PRINT("frm_type=%d, ver=%d, first_part_size=%lu\n",
7236 u8FrmType, u8Version, u32FirstPartitionSize);
7237 VDEC_PRINT("u32FrmSize=0x%lx, st1=0x%lx, size=0x%lx, st2=0x%lx, size=0x%lx\n",
7238 u32FrmSize,
7239 pPacketInfo->u32Staddr, pPacketInfo->u32Length,
7240 pPacketInfo->u32Staddr2, pPacketInfo->u32Length2);
7241 #endif
7242
7243 //VDEC_PRINT("FRM: %x %x %x\n", pPacketInfo->u32Length, u32FirstPartitionSize, u8FrmType);
7244 //VDEC_PRINT("[VDEC] %x %x %x %x\n", pPacketInfo->u32Staddr, pPacketInfo->u32Length, pPacketInfo->u32Staddr2, pPacketInfo->u32Length2);
7245
7246 return E_VDEC_EX_OK;
7247 }
7248 #endif
7249
7250 //------------------------------------------------------------------------------
7251 /// Set Support AVC to MVC codec
7252 /// @param bEnable \b IN : turn on / off.
7253 /// @return VDEC_EX_Result
7254 //------------------------------------------------------------------------------
_VDEC_EX_Support_AVC2MVC(VDEC_StreamId * pStreamId,MS_BOOL bEnable)7255 static VDEC_EX_Result _VDEC_EX_Support_AVC2MVC(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
7256 {
7257 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7258 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7259 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7260
7261 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7262 {
7263 case E_VDEC_EX_DECODER_HVD:
7264 _HVD_RET_HANDLE(MDrv_HVD_EX_Support_AVC2MVC(u32Id, bEnable));
7265 eRet = E_VDEC_EX_OK;
7266 break;
7267 case E_VDEC_EX_DECODER_MVD:
7268 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7269 break;
7270 case E_VDEC_EX_DECODER_MJPEG:
7271 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7272 break;
7273 default:
7274 break;
7275 }
7276
7277 return eRet;
7278 }
7279
7280 //------------------------------------------------------------------------------
7281 /// Set View exchange
7282 /// @param bEnable \b IN : turn on / off.
7283 /// @return VDEC_EX_Result
7284 //------------------------------------------------------------------------------
_VDEC_EX_3DLR_View_Excahnge(VDEC_StreamId * pStreamId,MS_BOOL bEnable)7285 static VDEC_EX_Result _VDEC_EX_3DLR_View_Excahnge(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
7286 {
7287 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7288 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7289 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7290
7291 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7292 {
7293 case E_VDEC_EX_DECODER_HVD:
7294 _HVD_RET_HANDLE(MDrv_HVD_EX_3DLR_View_Exchange(u32Id, bEnable));
7295 eRet = E_VDEC_EX_OK;
7296 break;
7297 case E_VDEC_EX_DECODER_MVD:
7298 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7299 break;
7300 case E_VDEC_EX_DECODER_MJPEG:
7301 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7302 break;
7303 default:
7304 break;
7305 }
7306
7307 return eRet;
7308 }
7309
_VDEC_EX_Context_Init(void)7310 static void _VDEC_EX_Context_Init(void)
7311 {
7312 #ifdef VDEC3
7313 MS_U8 i;
7314
7315 for (i = 0; i < VDEC_MAX_SUPPORT_STREAM_NUM; i++)
7316 {
7317 #if (VDEC_EX_ISR_MONITOR)
7318 pVdecExContext->_Attr[i].stEventMon.bVdecExIsrMntr = TRUE;
7319 strncpy(pVdecExContext->_Attr[i].stEventMon.pu8VdecExEvent, "VDEC_EX_Event", sizeof(pVdecExContext->_Attr[i].stEventMon.pu8VdecExEvent));
7320 strncpy(pVdecExContext->_Attr[i].stEventMon.pu8VdecExTask, "VDEC_EX_Task", sizeof(pVdecExContext->_Attr[i].stEventMon.pu8VdecExTask));
7321 pVdecExContext->_u32VdecExIsrEventFlag[i] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
7322 pVdecExContext->_u32PreVdecExIsrEventFlag[i] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
7323 #endif
7324 pVdecExContext->u32PriData[i] = VDEC_U32_MAX;
7325 }
7326 #else
7327 //pVdecExContext->_Attr[0].s32VdecExMutexId = -1;
7328 //strncpy(pVdecExContext->_Attr[0].pu8VdecExMutex,"VDEC_EX_Mutex0",sizeof(pVdecExContext->_Attr[0].pu8VdecExMutex));
7329 #if (VDEC_EX_ISR_MONITOR)
7330 pVdecExContext->_Attr[0].stEventMon.bVdecExIsrMntr = TRUE;
7331 strncpy(pVdecExContext->_Attr[0].stEventMon.pu8VdecExEvent,"VDEC_EX_Event0",sizeof(pVdecExContext->_Attr[0].stEventMon.pu8VdecExEvent));
7332 //pVdecExContext->_Attr[0].stEventMon.s32VdecExTaskId = -1;
7333 strncpy(pVdecExContext->_Attr[0].stEventMon.pu8VdecExTask,"VDEC_EX_Task0",sizeof(pVdecExContext->_Attr[0].stEventMon.pu8VdecExTask));
7334 //pVdecExContext->_Attr[0].stEventMon.pfMonISR_Proc = _VDEC_EX_MonitorISR_Proc;
7335 #endif
7336
7337 //pVdecExContext->_Attr[1].s32VdecExMutexId = -1;
7338 //strncpy(pVdecExContext->_Attr[1].pu8VdecExMutex,"VDEC_EX_Mutex1",sizeof(pVdecExContext->_Attr[1].pu8VdecExMutex));
7339 #if (VDEC_EX_ISR_MONITOR)
7340 pVdecExContext->_Attr[1].stEventMon.bVdecExIsrMntr = TRUE;
7341 strncpy(pVdecExContext->_Attr[1].stEventMon.pu8VdecExEvent,"VDEC_EX_Event1",sizeof(pVdecExContext->_Attr[1].stEventMon.pu8VdecExEvent));
7342 //pVdecExContext->_Attr[1].stEventMon.s32VdecExTaskId = -1;
7343 strncpy(pVdecExContext->_Attr[1].stEventMon.pu8VdecExTask,"VDEC_EX_Task1",sizeof(pVdecExContext->_Attr[1].stEventMon.pu8VdecExTask));
7344 //pVdecExContext->_Attr[1].stEventMon.pfMonISR_Proc = _VDEC_EX_MonitorSubISR_Proc;
7345 #endif
7346
7347 #if (VDEC_EX_ISR_MONITOR)
7348 pVdecExContext->_u32VdecExIsrEventFlag[0] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
7349 pVdecExContext->_u32VdecExIsrEventFlag[1] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
7350 pVdecExContext->_u32PreVdecExIsrEventFlag[0] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
7351 pVdecExContext->_u32PreVdecExIsrEventFlag[1] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
7352 #endif
7353
7354 pVdecExContext->u32PriData[0] = VDEC_U32_MAX;
7355 pVdecExContext->u32PriData[1] = VDEC_U32_MAX;
7356 #endif
7357
7358 //strncpy(pVdecExContext->_u8VDEC_Mutex,"VDEC_API_Mutex",sizeof(pVdecExContext->_u8VDEC_Mutex));
7359 // pVdecExContext->u32VdecMutexCnt[0] = 0;
7360 // pVdecExContext->u32VdecMutexCnt[1] = 0;
7361 for (i = 0; i < VDEC_MAX_SUPPORT_STREAM_NUM; i++)
7362 {
7363 pVdecExContext->_power_state[i] = E_VDEC_EX_POWER_NONE;
7364 }
7365 pVdecExContext->_prev_u16PowerState = E_POWER_MECHANICAL;
7366 }
7367
7368 #ifdef VDEC3
_VDEC_EX_Context_Init_Function_Pointer(MS_U8 u8Idx)7369 static void _VDEC_EX_Context_Init_Function_Pointer(MS_U8 u8Idx)
7370 #else
7371 static void _VDEC_EX_Context_Init_Function_Pointer(VDEC_EX_Stream eStreamType)
7372 #endif
7373 {
7374 #if (VDEC_EX_ISR_MONITOR)
7375 #ifdef VDEC3
7376 pVdecExContext->_Attr[u8Idx].stEventMon.pfMonISR_Proc = _VDEC_EX_MonitorNStreamISR_Proc;
7377 #else
7378 if(eStreamType == E_VDEC_EX_MAIN_STREAM)
7379 {
7380 pVdecExContext->_Attr[0].stEventMon.pfMonISR_Proc = _VDEC_EX_MonitorISR_Proc;
7381 }
7382 else if(eStreamType == E_VDEC_EX_SUB_STREAM)
7383 {
7384 pVdecExContext->_Attr[1].stEventMon.pfMonISR_Proc = _VDEC_EX_MonitorSubISR_Proc;
7385 }
7386 #endif
7387 #endif
7388 }
7389
7390
_MApi_VDEC_EX_GetFrmPackingArrSEI(VDEC_StreamId * pStreamId,void * param)7391 static VDEC_EX_Result _MApi_VDEC_EX_GetFrmPackingArrSEI(VDEC_StreamId *pStreamId,void *param)
7392 {
7393 VDEC_EX_Result eRet = E_VDEC_EX_OK;
7394 VDEC_EX_Frame_packing_SEI *pFPASEIInfo = NULL;
7395
7396 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7397 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7398
7399 if( param == NULL)
7400 {
7401 return E_VDEC_EX_RET_INVALID_PARAM;
7402 }
7403 else
7404 {
7405 pFPASEIInfo = (VDEC_EX_Frame_packing_SEI *)param;
7406 }
7407
7408 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7409 {
7410 case E_VDEC_EX_DECODER_MVD:
7411 {
7412 VDEC_EX_Frame_packing_SEI_EX *pFPASEIInfo = (VDEC_EX_Frame_packing_SEI_EX *)param;
7413 MS_U8 u8StereoType = MDrv_MVD_GetStereoType(u32Id);
7414
7415 if (u8StereoType != 0)
7416 {
7417 pFPASEIInfo->u8Frm_packing_arr_type = u8StereoType;
7418 }
7419 else
7420 {
7421 eRet = E_VDEC_EX_RET_INVALID_PARAM;
7422 }
7423 }
7424 break;
7425 case E_VDEC_EX_DECODER_HVD:
7426 _HVD_RET_HANDLE(MDrv_HVD_EX_GetFrmPackingArrSEI(u32Id,&(pVdecExContext->_stFrmPacking[u8Idx])));
7427
7428 pFPASEIInfo->u8Frm_packing_arr_cnl_flag = pVdecExContext->_stFrmPacking[u8Idx].u8Frm_packing_arr_cnl_flag;
7429 pFPASEIInfo->u8Frm_packing_arr_type = pVdecExContext->_stFrmPacking[u8Idx].u8Frm_packing_arr_type;
7430 pFPASEIInfo->u8content_interpretation_type = pVdecExContext->_stFrmPacking[u8Idx].u8content_interpretation_type;
7431 pFPASEIInfo->u1Quincunx_sampling_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Quincunx_sampling_flag;
7432
7433 pFPASEIInfo->u1Spatial_flipping_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Spatial_flipping_flag;
7434 pFPASEIInfo->u1Frame0_flipping_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Frame0_flipping_flag;
7435 pFPASEIInfo->u1Field_views_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Field_views_flag;
7436 pFPASEIInfo->u1Current_frame_is_frame0_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Current_frame_is_frame0_flag;
7437
7438 pFPASEIInfo->u1Frame0_self_contained_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Frame0_self_contained_flag;
7439 pFPASEIInfo->u1Frame1_self_contained_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Frame1_self_contained_flag;
7440 pFPASEIInfo->u4Frame0_grid_position_x = pVdecExContext->_stFrmPacking[u8Idx].u4Frame0_grid_position_x;
7441 pFPASEIInfo->u4Frame0_grid_position_y = pVdecExContext->_stFrmPacking[u8Idx].u4Frame0_grid_position_y;
7442
7443 pFPASEIInfo->u4Frame1_grid_position_x = pVdecExContext->_stFrmPacking[u8Idx].u4Frame1_grid_position_x;
7444 pFPASEIInfo->u4Frame1_grid_position_y = pVdecExContext->_stFrmPacking[u8Idx].u4Frame1_grid_position_y;
7445
7446 break;
7447 case E_VDEC_EX_DECODER_MJPEG:
7448 default:
7449 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7450 break;
7451 }
7452 return eRet;
7453 }
7454
_MApi_VDEC_EX_GetFrmPackingArrSEI_EX(VDEC_StreamId * pStreamId,void * param)7455 static VDEC_EX_Result _MApi_VDEC_EX_GetFrmPackingArrSEI_EX(VDEC_StreamId *pStreamId, void *param)
7456 {
7457 VDEC_EX_Result eRet = E_VDEC_EX_OK;
7458
7459 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7460 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7461 if( param == NULL)
7462 {
7463 return E_VDEC_EX_RET_INVALID_PARAM;
7464 }
7465
7466 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7467 {
7468 case E_VDEC_EX_DECODER_MVD:
7469 {
7470 VDEC_EX_Frame_packing_SEI_EX *pFPASEIInfo = (VDEC_EX_Frame_packing_SEI_EX *)param;
7471 MS_U8 u8StereoType = MDrv_MVD_GetStereoType(u32Id);
7472
7473 if (u8StereoType != 0)
7474 {
7475 pFPASEIInfo->u8Frm_packing_arr_type = u8StereoType;
7476 }
7477 else
7478 {
7479 eRet = E_VDEC_EX_RET_INVALID_PARAM;
7480 }
7481 }
7482 break;
7483 case E_VDEC_EX_DECODER_HVD:
7484 {
7485 VDEC_EX_VerCtl *pVerCtl = (VDEC_EX_VerCtl *)param;
7486
7487 if((pVerCtl->u32version == 0)
7488 && (pVerCtl->u32size == sizeof(VDEC_EX_Frame_packing_SEI_EX)))
7489 {
7490 VDEC_EX_Frame_packing_SEI_EX *pFPASEIInfo = (VDEC_EX_Frame_packing_SEI_EX *)param;
7491 _HVD_RET_HANDLE(MDrv_HVD_EX_GetFrmPackingArrSEI(u32Id, &(pVdecExContext->_stFrmPacking[u8Idx])));
7492
7493 pFPASEIInfo->bUsed =pVdecExContext->_stFrmPacking[u8Idx].bUsed;
7494 pFPASEIInfo->u8Frm_packing_arr_cnl_flag = pVdecExContext->_stFrmPacking[u8Idx].u8Frm_packing_arr_cnl_flag;
7495 pFPASEIInfo->u8Frm_packing_arr_type = pVdecExContext->_stFrmPacking[u8Idx].u8Frm_packing_arr_type;
7496 pFPASEIInfo->u8content_interpretation_type = pVdecExContext->_stFrmPacking[u8Idx].u8content_interpretation_type;
7497 pFPASEIInfo->u1Quincunx_sampling_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Quincunx_sampling_flag;
7498 pFPASEIInfo->u1Spatial_flipping_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Spatial_flipping_flag;
7499 pFPASEIInfo->u1Frame0_flipping_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Frame0_flipping_flag;
7500 pFPASEIInfo->u1Field_views_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Field_views_flag;
7501 pFPASEIInfo->u1Current_frame_is_frame0_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Current_frame_is_frame0_flag;
7502 pFPASEIInfo->u1Frame0_self_contained_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Frame0_self_contained_flag;
7503 pFPASEIInfo->u1Frame1_self_contained_flag = pVdecExContext->_stFrmPacking[u8Idx].u1Frame1_self_contained_flag;
7504 pFPASEIInfo->u4Frame0_grid_position_x = pVdecExContext->_stFrmPacking[u8Idx].u4Frame0_grid_position_x;
7505 pFPASEIInfo->u4Frame0_grid_position_y = pVdecExContext->_stFrmPacking[u8Idx].u4Frame0_grid_position_y;
7506 pFPASEIInfo->u4Frame1_grid_position_x = pVdecExContext->_stFrmPacking[u8Idx].u4Frame1_grid_position_x;
7507 pFPASEIInfo->u4Frame1_grid_position_y = pVdecExContext->_stFrmPacking[u8Idx].u4Frame1_grid_position_y;
7508 pFPASEIInfo->bottom = (MS_U32)pVdecExContext->_stFrmPacking[u8Idx].u16CropBottom;
7509 pFPASEIInfo->left = (MS_U32)pVdecExContext->_stFrmPacking[u8Idx].u16CropLeft;
7510 pFPASEIInfo->right = (MS_U32)pVdecExContext->_stFrmPacking[u8Idx].u16CropRight;
7511 pFPASEIInfo->top = (MS_U32)pVdecExContext->_stFrmPacking[u8Idx].u16CropTop;
7512 if((pFPASEIInfo->bIsCropInfo == FALSE)
7513 && (pVdecExContext->_stFrmPacking[u8Idx].bvaild == TRUE)
7514 && (pVdecExContext->_stFrmPacking[u8Idx].bUsed == TRUE))
7515 {
7516 #if 1//#ifdef VDEC_UTOPIA_2K
7517 pFPASEIInfo->u32DataBuff = MsOS_VA2PA(pVdecExContext->_stFrmPacking[u8Idx].u32payload);
7518 #else
7519 pFPASEIInfo->u32DataBuff = pVdecExContext->_stFrmPacking[u8Idx].u32payload;
7520 #endif
7521 pFPASEIInfo->u32DataSize = (MS_U32)pVdecExContext->_stFrmPacking[u8Idx].u8payload_len;
7522 pFPASEIInfo->bValid = TRUE;
7523 pVdecExContext->_stFrmPacking[u8Idx].bvaild = FALSE;
7524 }
7525 else
7526 {
7527 pFPASEIInfo->bValid = FALSE;
7528 }
7529 }
7530 else
7531 {
7532 VDEC_PRINT("%s: invalid u32Version(%d) or u32Size(%d)\n", __FUNCTION__, pVerCtl->u32version, (MS_U32)sizeof(VDEC_EX_Frame_packing_SEI_EX));
7533 }
7534 }
7535
7536 break;
7537 case E_VDEC_EX_DECODER_MJPEG:
7538 default:
7539 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7540 break;
7541 }
7542 return eRet;
7543 }
7544
_MApi_VDEC_EX_GetDisplayColourVolumeArrSEI(VDEC_StreamId * pStreamId,void * param)7545 static VDEC_EX_Result _MApi_VDEC_EX_GetDisplayColourVolumeArrSEI(VDEC_StreamId *pStreamId,void *param)
7546 {
7547 VDEC_EX_Result eRet = E_VDEC_EX_OK;
7548 VDEC_EX_DisplayColourVolume_SEI *pDCVSEIInfo = NULL;
7549
7550 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7551 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7552
7553 if( param == NULL)
7554 {
7555 return E_VDEC_EX_RET_INVALID_PARAM;
7556 }
7557 else
7558 {
7559 pDCVSEIInfo = (VDEC_EX_DisplayColourVolume_SEI *)param;
7560 }
7561
7562 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7563 {
7564 case E_VDEC_EX_DECODER_HVD:
7565 _HVD_RET_HANDLE(MDrv_HVD_EX_GetDisplayColourVolumeArrSEI(u32Id,&(pVdecExContext->_stDCV[u8Idx])));
7566
7567 pDCVSEIInfo->bColourVolumeSEIEnabled = pVdecExContext->_stDCV[u8Idx].bColourVolumeSEIEnabled;
7568 pDCVSEIInfo->u32MaxLuminance = pVdecExContext->_stDCV[u8Idx].u32MaxLuminance;
7569 pDCVSEIInfo->u32MinLuminance = pVdecExContext->_stDCV[u8Idx].u32MinLuminance;
7570
7571 pDCVSEIInfo->u16Primaries[0][0] = pVdecExContext->_stDCV[u8Idx].u16Primaries[0][0];
7572 pDCVSEIInfo->u16Primaries[0][1] = pVdecExContext->_stDCV[u8Idx].u16Primaries[0][1];
7573 pDCVSEIInfo->u16Primaries[1][0] = pVdecExContext->_stDCV[u8Idx].u16Primaries[1][0];
7574 pDCVSEIInfo->u16Primaries[1][1] = pVdecExContext->_stDCV[u8Idx].u16Primaries[1][1];
7575 pDCVSEIInfo->u16Primaries[2][0] = pVdecExContext->_stDCV[u8Idx].u16Primaries[2][0];
7576 pDCVSEIInfo->u16Primaries[2][1] = pVdecExContext->_stDCV[u8Idx].u16Primaries[2][1];
7577
7578 pDCVSEIInfo->u16WhitePoint[0] = pVdecExContext->_stDCV[u8Idx].u16WhitePoint[0];
7579 pDCVSEIInfo->u16WhitePoint[1] = pVdecExContext->_stDCV[u8Idx].u16WhitePoint[1];
7580
7581 break;
7582 case E_VDEC_EX_DECODER_MVD:
7583 case E_VDEC_EX_DECODER_MJPEG:
7584 default:
7585 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7586 break;
7587 }
7588 return eRet;
7589 }
7590
_MApi_VDEC_EX_GetContentLightLevelInfoSEI(VDEC_StreamId * pStreamId,void * param)7591 static VDEC_EX_Result _MApi_VDEC_EX_GetContentLightLevelInfoSEI(VDEC_StreamId *pStreamId,void *param)
7592 {
7593 VDEC_EX_Result eRet = E_VDEC_EX_OK;
7594 VDEC_EX_ContentLightLevelInfo_SEI *pCLLI_SEI = NULL;
7595
7596 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7597 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7598 if (param == NULL)
7599 {
7600 return E_VDEC_EX_RET_INVALID_PARAM;
7601 }
7602 else
7603 {
7604 pCLLI_SEI = (VDEC_EX_ContentLightLevelInfo_SEI *)param;
7605 }
7606
7607 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7608 {
7609 case E_VDEC_EX_DECODER_HVD:
7610 _HVD_RET_HANDLE(MDrv_HVD_EX_GetContentLightLevelInfoSEI(u32Id, &(pVdecExContext->_stCLLI[u8Idx])));
7611
7612 pCLLI_SEI->bUsed = pVdecExContext->_stCLLI[u8Idx].bUsed;
7613 pCLLI_SEI->bContentLightLevelEnabled = pVdecExContext->_stCLLI[u8Idx].ContentLightLevelEnabled;
7614 pCLLI_SEI->u16MaxContentLightLevel = pVdecExContext->_stCLLI[u8Idx].maxContentLightLevel;
7615 pCLLI_SEI->u16MaxPicAverageLightLevel = pVdecExContext->_stCLLI[u8Idx].maxPicAverageLightLevel;
7616 break;
7617
7618 case E_VDEC_EX_DECODER_MVD:
7619 case E_VDEC_EX_DECODER_MJPEG:
7620 default:
7621 pCLLI_SEI->bUsed = 0;
7622 pCLLI_SEI->bContentLightLevelEnabled = 0;
7623 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7624 break;
7625 }
7626 return eRet;
7627 }
7628
7629 #ifdef VDEC_CAP_DV_OTT_API
_MApi_VDEC_EX_GetDVSupportProfiles(void * param)7630 static VDEC_EX_Result _MApi_VDEC_EX_GetDVSupportProfiles(void *param)
7631 {
7632 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7633 VDEC_EX_DV_Info *pDV_Info = NULL;
7634 MS_U32 u32DVSupportProfiles;
7635
7636 if (param == NULL)
7637 {
7638 return E_VDEC_EX_RET_INVALID_PARAM;
7639 }
7640 else
7641 {
7642 pDV_Info = (VDEC_EX_DV_Info *)param;
7643 }
7644
7645 if(MDrv_HVD_EX_GetDVSupportProfiles(&u32DVSupportProfiles) == E_HVD_EX_OK)
7646 {
7647 pDV_Info->u32DVSupportProfiles = u32DVSupportProfiles;
7648 eRet = E_VDEC_EX_OK;
7649 }
7650
7651 return eRet;
7652 }
7653
_MApi_VDEC_EX_GetDVSupportHighestLevel(void * param)7654 static VDEC_EX_Result _MApi_VDEC_EX_GetDVSupportHighestLevel(void *param)
7655 {
7656 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7657 VDEC_EX_DV_Info *pDV_Info = NULL;
7658 MS_U32 u32DVLevel;
7659
7660 if (param == NULL)
7661 {
7662 return E_VDEC_EX_RET_INVALID_PARAM;
7663 }
7664 else
7665 {
7666 pDV_Info = (VDEC_EX_DV_Info *)param;
7667 }
7668
7669 if(MDrv_HVD_EX_GetDVSupportHighestLevel(pDV_Info->eDVProfile, &u32DVLevel) == E_HVD_EX_OK)
7670 {
7671 pDV_Info->eDVLevel = (VDEC_EX_DV_Stream_Highest_Level)u32DVLevel;
7672 eRet = E_VDEC_EX_OK;
7673 }
7674
7675 return eRet;
7676 }
7677 #endif
7678
_MApi_VDEC_EX_V2_GetVUI_DISP_INFO(VDEC_StreamId * pStreamId,void * param)7679 VDEC_EX_Result _MApi_VDEC_EX_V2_GetVUI_DISP_INFO(VDEC_StreamId *pStreamId, void *param)
7680 {
7681 VDEC_EX_Result eRet = E_VDEC_EX_OK;
7682 VDEC_EX_AVC_VUI_DISP_INFO *pVUI_DISP_Info = NULL;
7683
7684 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7685 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7686
7687 if( param == NULL)
7688 {
7689 return E_VDEC_EX_RET_INVALID_PARAM;
7690 }
7691 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7692 {
7693 case E_VDEC_EX_DECODER_HVD:
7694 {
7695 VDEC_EX_AVC_VUI_DISP_INFO *pVUIInfo = (VDEC_EX_AVC_VUI_DISP_INFO *)param;
7696 pVUI_DISP_Info = (VDEC_EX_AVC_VUI_DISP_INFO *)MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_AVC_VUI_DISP_INFO);
7697
7698 pVUIInfo->bAspect_ratio_info_present_flag = pVUI_DISP_Info->bAspect_ratio_info_present_flag;
7699 pVUIInfo->u8Aspect_ratio_idc = pVUI_DISP_Info->u8Aspect_ratio_idc;
7700 pVUIInfo->u16Sar_width = pVUI_DISP_Info->u16Sar_width;
7701 pVUIInfo->u16Sar_height = pVUI_DISP_Info->u16Sar_height;
7702 pVUIInfo->bOverscan_info_present_flag = pVUI_DISP_Info->bOverscan_info_present_flag;
7703 pVUIInfo->bOverscan_appropriate_flag = pVUI_DISP_Info->bOverscan_appropriate_flag;
7704 pVUIInfo->bVideo_signal_type_present_flag = pVUI_DISP_Info->bVideo_signal_type_present_flag;
7705 pVUIInfo->u8Video_format = pVUI_DISP_Info->u8Video_format;
7706 pVUIInfo->bVideo_full_range_flag = pVUI_DISP_Info->bVideo_full_range_flag;
7707 pVUIInfo->bColour_description_present_flag = pVUI_DISP_Info->bColour_description_present_flag;
7708 pVUIInfo->u8Colour_primaries = pVUI_DISP_Info->u8Colour_primaries;
7709 pVUIInfo->u8Transfer_characteristics = pVUI_DISP_Info->u8Transfer_characteristics;
7710 pVUIInfo->u8Matrix_coefficients = pVUI_DISP_Info->u8Matrix_coefficients;
7711 pVUIInfo->bChroma_location_info_present_flag = pVUI_DISP_Info->bChroma_location_info_present_flag;
7712 pVUIInfo->u8Chroma_sample_loc_type_top_field = pVUI_DISP_Info->u8Chroma_sample_loc_type_top_field;
7713 pVUIInfo->u8Chroma_sample_loc_type_bottom_field = pVUI_DISP_Info->u8Chroma_sample_loc_type_bottom_field;
7714 pVUIInfo->bTiming_info_present_flag = pVUI_DISP_Info->bTiming_info_present_flag;
7715 pVUIInfo->bFixed_frame_rate_flag = pVUI_DISP_Info->bFixed_frame_rate_flag;
7716 pVUIInfo->u32Num_units_in_tick = pVUI_DISP_Info->u32Num_units_in_tick;
7717 pVUIInfo->u32Time_scale = pVUI_DISP_Info->u32Time_scale;
7718
7719 break;
7720 }
7721 case E_VDEC_EX_DECODER_MJPEG:
7722 case E_VDEC_EX_DECODER_MVD:
7723 default:
7724 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7725 break;
7726 }
7727 return eRet;
7728 }
7729
7730 //------------------------------------------------------------------------------
7731 /// Set _VDEC_EX_AVC_Enable_New_Slow_Motion
7732 /// @param bEnable \b IN : turn on / off.
7733 /// @return VDEC_EX_Result
7734 //------------------------------------------------------------------------------
_VDEC_EX_AVC_Enable_New_Slow_Motion(VDEC_StreamId * pStreamId,MS_BOOL bEnable)7735 static VDEC_EX_Result _VDEC_EX_AVC_Enable_New_Slow_Motion(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
7736 {
7737 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7738 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7739 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7740
7741 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7742 {
7743 case E_VDEC_EX_DECODER_HVD:
7744 _HVD_RET_HANDLE(MDrv_HVD_EX_Enable_New_Slow_Motion(u32Id, bEnable));
7745 eRet = E_VDEC_EX_OK;
7746 break;
7747 case E_VDEC_EX_DECODER_MVD:
7748 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7749 break;
7750 case E_VDEC_EX_DECODER_MJPEG:
7751 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7752 break;
7753 default:
7754 break;
7755 }
7756
7757 return eRet;
7758 }
7759
7760 //------------------------------------------------------------------------------
7761 /// Set _VDEC_EX_DynamicScalingResvNBuffer
7762 /// @param bEnable \b IN : turn on / off.
7763 /// @return VDEC_EX_Result
7764 //------------------------------------------------------------------------------
_VDEC_EX_DynamicScalingResvNBuffer(VDEC_StreamId * pStreamId,MS_BOOL bEnable)7765 static VDEC_EX_Result _VDEC_EX_DynamicScalingResvNBuffer(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
7766 {
7767 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7768 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7769 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7770
7771 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7772 {
7773 case E_VDEC_EX_DECODER_HVD:
7774 _HVD_RET_HANDLE(MDrv_HVD_EX_DynamicScalingResvNBuffer(u32Id, bEnable));
7775 eRet = E_VDEC_EX_OK;
7776 break;
7777 case E_VDEC_EX_DECODER_MVD:
7778 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7779 break;
7780 case E_VDEC_EX_DECODER_MJPEG:
7781 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7782 break;
7783 default:
7784 break;
7785 }
7786
7787 return eRet;
7788 }
7789
_VDEC_EX_IgnorePicStructDisplay(VDEC_StreamId * pStreamId,MS_U32 param)7790 static VDEC_EX_Result _VDEC_EX_IgnorePicStructDisplay(VDEC_StreamId *pStreamId, MS_U32 param)
7791 {
7792 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7793 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7794 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7795
7796 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7797 {
7798 case E_VDEC_EX_DECODER_MVD:
7799 eRet = E_VDEC_EX_OK;
7800 break;
7801 case E_VDEC_EX_DECODER_HVD:
7802 _HVD_RET_HANDLE(MDrv_HVD_EX_IgnorePicStructDisplay(u32Id, param));
7803 eRet = E_VDEC_EX_OK;
7804 break;
7805 case E_VDEC_EX_DECODER_MJPEG:
7806 eRet = E_VDEC_EX_OK;
7807 break;
7808 default:
7809 break;
7810 }
7811
7812 return eRet;
7813 }
7814
_VDEC_EX_Field_Polarity_Display_One_Field(VDEC_StreamId * pStreamId,VDEC_EX_Field_Polarity * pFieldPority)7815 static VDEC_EX_Result _VDEC_EX_Field_Polarity_Display_One_Field(VDEC_StreamId *pStreamId, VDEC_EX_Field_Polarity* pFieldPority)
7816 {
7817 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7818 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7819 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7820
7821 if(pFieldPority == NULL)
7822 {
7823 return E_VDEC_EX_FAIL;
7824 }
7825
7826 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7827 {
7828 case E_VDEC_EX_DECODER_MVD:
7829 if(MDrv_MVD_Field_Polarity_Display_One_field(u32Id,pFieldPority->bEnable,pFieldPority->u8DisplayTop) == TRUE)
7830 {
7831 eRet = E_VDEC_EX_OK;
7832 }
7833 else
7834 {
7835 eRet = E_VDEC_EX_FAIL;
7836 }
7837 break;
7838 case E_VDEC_EX_DECODER_HVD:
7839 eRet = E_VDEC_EX_OK;
7840 break;
7841 case E_VDEC_EX_DECODER_MJPEG:
7842 eRet = E_VDEC_EX_OK;
7843 break;
7844 default:
7845 break;
7846 }
7847
7848 return eRet;
7849 }
7850
_VDEC_EX_InputPtsFreerunMode(VDEC_StreamId * pStreamId,MS_U32 param)7851 static VDEC_EX_Result _VDEC_EX_InputPtsFreerunMode(VDEC_StreamId *pStreamId, MS_U32 param)
7852 {
7853 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7854 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7855 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7856
7857 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7858 {
7859 case E_VDEC_EX_DECODER_MVD:
7860 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7861 break;
7862 case E_VDEC_EX_DECODER_HVD:
7863 _HVD_RET_HANDLE(MDrv_HVD_EX_InputPtsFreerunMode(u32Id, param));
7864 eRet = E_VDEC_EX_OK;
7865 break;
7866 case E_VDEC_EX_DECODER_MJPEG:
7867 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7868 break;
7869 default:
7870 break;
7871 }
7872
7873 return eRet;
7874 }
7875
_VDEC_EX_ErrConcealStartSlice1stMB(VDEC_StreamId * pStreamId,MS_U32 param)7876 static VDEC_EX_Result _VDEC_EX_ErrConcealStartSlice1stMB(VDEC_StreamId *pStreamId, MS_U32 param)
7877 {
7878 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7879 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7880 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7881
7882 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7883 {
7884 case E_VDEC_EX_DECODER_MVD:
7885 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7886 break;
7887 case E_VDEC_EX_DECODER_HVD:
7888 _HVD_RET_HANDLE(MDrv_HVD_EX_ErrConcealStartSlice1stMB(u32Id, param));
7889 eRet = E_VDEC_EX_OK;
7890 break;
7891 case E_VDEC_EX_DECODER_MJPEG:
7892 eRet = E_VDEC_EX_RET_UNSUPPORTED;
7893 break;
7894 default:
7895 break;
7896 }
7897
7898 return eRet;
7899 }
7900
7901
7902 #if VDEC_ENABLE_MVC
_MApi_VDEC_EX_MVC_SubFrameDispInfo(VDEC_StreamId * pStreamId,MS_U32 * param)7903 static VDEC_EX_Result _MApi_VDEC_EX_MVC_SubFrameDispInfo(VDEC_StreamId *pStreamId, MS_U32* param)
7904 {
7905 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
7906 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7907 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7908 MS_U32 u32SubViewId = (u32Id + 0x00011000);
7909 VDEC_EX_FrameInfo *pExFrmInfo = NULL;
7910
7911 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_MVC)
7912 {
7913 return E_VDEC_EX_RET_UNSUPPORTED;
7914 }
7915
7916 if( param == NULL)
7917 {
7918 return E_VDEC_EX_RET_INVALID_PARAM;
7919 }
7920 else
7921 {
7922 pExFrmInfo = (VDEC_EX_FrameInfo *)param;
7923 }
7924
7925 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
7926 {
7927
7928 case E_VDEC_EX_DECODER_HVD:
7929 {
7930 HVD_EX_FrameInfo info;
7931
7932 _VDEC_Memset(&info, 0, sizeof(HVD_EX_FrameInfo));
7933
7934 _HVD_RET_HANDLE(MDrv_HVD_EX_GetFrmInfo(u32SubViewId, E_HVD_EX_GFRMINFO_DISPLAY_SUB, &info));
7935
7936 pExFrmInfo->eFrameType = _VDEC_EX_MapFrmType2HVD(info.eFrmType);
7937 pExFrmInfo->u16Height = info.u16Height;
7938 pExFrmInfo->u16Width = info.u16Width;
7939 pExFrmInfo->u16Pitch = info.u16Pitch;
7940 pExFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
7941 pExFrmInfo->u32ID_H = info.u32ID_H;
7942 pExFrmInfo->u32ID_L = info.u32ID_L;
7943 pExFrmInfo->u32LumaAddr = info.u32LumaAddr;
7944 pExFrmInfo->u32TimeStamp = info.u32TimeStamp;
7945 pExFrmInfo->eFieldType = _VDEC_EX_MapFieldType2HVD(info.eFieldType);
7946
7947 eRet = E_VDEC_EX_OK;
7948 break;
7949 }
7950
7951 default:
7952 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
7953 break;
7954 }
7955
7956 return eRet;
7957 }
7958
_MApi_VDEC_EX_MVC_SetControl(VDEC_StreamId * pStreamId,VDEC_MVC_Control_type eType,void ** param)7959 static VDEC_EX_Result _MApi_VDEC_EX_MVC_SetControl(VDEC_StreamId *pStreamId, VDEC_MVC_Control_type eType, void** param)
7960 {
7961 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
7962 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
7963 MS_U32 u32SubViewId = (u32Id + 0x00011000);
7964
7965 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_MVC)
7966 {
7967 return E_VDEC_EX_RET_UNSUPPORTED;
7968 }
7969
7970 switch(eType)
7971 {
7972 case E_VDEC_EX_MVC_SET_BBU2_PUSH_PACKET:
7973 {
7974 HVD_EX_PacketInfo packetInfo;
7975 VDEC_EX_DecCmd *pInput;
7976 _VDEC_Memset(&packetInfo, 0, sizeof(HVD_EX_PacketInfo));
7977 pInput = (VDEC_EX_DecCmd *)(*((MS_VIRT*)(param[0])));
7978
7979 packetInfo.u32Staddr = pInput->u32StAddr;
7980 packetInfo.u32Length = pInput->u32Size;
7981 packetInfo.u32TimeStamp = pInput->u32Timestamp;
7982 packetInfo.u32ID_H = pInput->u32ID_H;
7983 packetInfo.u32ID_L = pInput->u32ID_L;
7984
7985 _HVD_RET_HANDLE(MDrv_HVD_EX_PushQueue(u32SubViewId, &packetInfo));
7986 break;
7987 }
7988 case E_VDEC_EX_MVC_SET_BBU2_FIRE_DECCMD:
7989 MDrv_HVD_EX_PushQueue_Fire(u32SubViewId);
7990 break;
7991
7992 default:
7993 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
7994 break;
7995 }
7996 return E_VDEC_EX_OK;
7997 }
7998
_MApi_VDEC_EX_MVC_GetControl(VDEC_StreamId * pStreamId,VDEC_MVC_Control_type eType,MS_U32 * param)7999 static VDEC_EX_Result _MApi_VDEC_EX_MVC_GetControl(VDEC_StreamId *pStreamId, VDEC_MVC_Control_type eType, MS_U32* param)
8000 {
8001 //VDEC_EX_Result ret = E_VDEC_EX_FAIL;
8002 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8003 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8004 MS_U32 u32SubViewId = (u32Id + 0x00011000);
8005
8006 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_MVC)
8007 {
8008 return E_VDEC_EX_RET_UNSUPPORTED;
8009 }
8010
8011 if( param == NULL)
8012 {
8013 return E_VDEC_EX_RET_INVALID_PARAM;
8014 }
8015
8016 switch(eType)
8017 {
8018 case E_VDEC_EX_MVC_GET_BBU2_DECQ_VACANCY:
8019 *param = MDrv_HVD_EX_GetBBUVacancy(u32SubViewId);
8020 break;
8021 case E_VDEC_EX_MVC_GET_ES2_READ_PTR:
8022 *param = MDrv_HVD_EX_GetESReadPtr(u32SubViewId);
8023 break;
8024 case E_VDEC_EX_MVC_GET_ES2_WRITE_PTR:
8025 *param = MDrv_HVD_EX_GetESWritePtr(u32SubViewId);
8026 break;
8027
8028 default:
8029 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
8030 break;
8031 }
8032
8033 return E_VDEC_EX_OK;
8034 }
8035
8036 #endif /// VDEC_ENABLE_MVC
8037
8038
_MApi_VDEC_EX_Get_U64PTS(VDEC_StreamId * pStreamId,void * param)8039 static VDEC_EX_Result _MApi_VDEC_EX_Get_U64PTS(VDEC_StreamId *pStreamId,void* param)
8040 {
8041 MS_U64* ptr_tmp = NULL;
8042 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8043 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8044
8045 if( param == NULL)
8046 {
8047 return E_VDEC_EX_RET_INVALID_PARAM;
8048 }
8049 else
8050 {
8051 ptr_tmp = (MS_U64*)param;
8052 }
8053
8054 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8055 {
8056 case E_VDEC_EX_DECODER_MVD:
8057 {
8058 if (MDrv_MVD_GetU64PTS(u32Id,E_MVD_PTS_DISP) == VDEC_U64_MAX)
8059 {
8060 *ptr_tmp = VDEC_U64_MAX;
8061 }
8062 else
8063 {
8064 *ptr_tmp = MDrv_MVD_GetU64PTS(u32Id,E_MVD_PTS_DISP) + MDrv_MVD_GetAVSyncDelay(u32Id);
8065 }
8066 break;
8067 }
8068 case E_VDEC_EX_DECODER_HVD:
8069 {
8070 *ptr_tmp = MDrv_HVD_EX_GetU64PTS(u32Id);
8071 break;
8072 }
8073 case E_VDEC_EX_DECODER_MJPEG:
8074 {
8075 _VDEC_EX_API_MutexLock();
8076 *ptr_tmp = MApi_MJPEG_GetPTS(u32Id);
8077 _VDEC_EX_API_MutexUnlock();
8078 break;
8079 }
8080 default:
8081 *ptr_tmp = 0;
8082 break;
8083 }
8084 return E_VDEC_EX_OK;
8085 }
8086
_MApi_VDEC_EX_Get_PRE_PAS_U64PTS(VDEC_StreamId * pStreamId,void * param)8087 static VDEC_EX_Result _MApi_VDEC_EX_Get_PRE_PAS_U64PTS(VDEC_StreamId *pStreamId,void* param)
8088 {
8089 MS_U64* ptr_tmp = NULL;
8090 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8091 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8092
8093 _VDEC_INVALID_DRVID_RET(u8Idx, u32Id);
8094
8095 if( param == NULL)
8096 {
8097 return E_VDEC_EX_RET_INVALID_PARAM;
8098 }
8099 else
8100 {
8101 ptr_tmp = (MS_U64*)param;
8102 }
8103
8104 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8105 {
8106 case E_VDEC_EX_DECODER_MVD:
8107 {
8108 *ptr_tmp = MDrv_MVD_GetU64PTS(u32Id,E_MVD_PTS_PRE_PAS);
8109 break;
8110 }
8111 case E_VDEC_EX_DECODER_HVD:
8112 {
8113 *ptr_tmp = MDrv_HVD_EX_GetU64PTS_PreParse(u32Id);
8114 break;
8115 }
8116 case E_VDEC_EX_DECODER_MJPEG:
8117 default:
8118 *ptr_tmp = 0;
8119 break;
8120 }
8121 return E_VDEC_EX_OK;
8122 }
8123
8124
_VDEC_EX_GetIsOriInterlaceMode(VDEC_StreamId * pStreamId,MS_U32 * param)8125 static VDEC_EX_Result _VDEC_EX_GetIsOriInterlaceMode(VDEC_StreamId *pStreamId, MS_U32 *param)
8126 {
8127 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8128 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8129 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8130
8131 if (param == NULL)
8132 {
8133 return E_VDEC_EX_RET_INVALID_PARAM;
8134 }
8135
8136 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8137 {
8138 case E_VDEC_EX_DECODER_MVD:
8139 {
8140 MVD_FrameInfo info;
8141 _VDEC_Memset(&info, 0, sizeof(MVD_FrameInfo));
8142 MDrv_MVD_GetFrameInfo(u32Id, &info);
8143 *param = (MS_U32)info.u8Interlace;
8144 eRet = E_VDEC_EX_OK;
8145 break;
8146 }
8147 case E_VDEC_EX_DECODER_HVD:
8148 {
8149 if ( MDrv_HVD_EX_CheckDispInfoRdy(u32Id) == E_HVD_EX_OK)
8150 {
8151 *param = MDrv_HVD_EX_GetData(u32Id,E_HVD_EX_GDATA_TYPE_IS_ORI_INTERLACE_MODE);
8152 eRet = E_VDEC_EX_OK;
8153 }
8154 break;
8155 }
8156 case E_VDEC_EX_DECODER_MJPEG:
8157 {
8158 *param = 0;
8159 eRet = E_VDEC_EX_OK;
8160 break;
8161 }
8162 default:
8163 *param = 0;
8164 break;
8165 }
8166
8167 return eRet;
8168 }
8169
_VDEC_GetMbsOnlyFlag(VDEC_StreamId * pStreamId,MS_U32 * param)8170 static VDEC_EX_Result _VDEC_GetMbsOnlyFlag(VDEC_StreamId *pStreamId, MS_U32 *param)
8171 {
8172 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8173 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8174 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8175
8176 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8177 {
8178 case E_VDEC_EX_DECODER_HVD:
8179 {
8180 if ( E_HVD_EX_OK == MDrv_HVD_EX_CheckDispInfoRdy(u32Id))
8181 {
8182 *param = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_FRAME_MBS_ONLY_FLAG);
8183 eRet = E_VDEC_EX_OK;
8184 }
8185 else
8186 {
8187 eRet = E_VDEC_EX_RET_NOT_READY;
8188 }
8189 break;
8190 }
8191 case E_VDEC_EX_DECODER_MVD:
8192 case E_VDEC_EX_DECODER_MJPEG:
8193 default:
8194 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8195 break;
8196 }
8197
8198 return eRet;
8199 }
8200
_VDEC_IsLeastDispQSize(VDEC_StreamId * pStreamId,MS_U32 * param)8201 static VDEC_EX_Result _VDEC_IsLeastDispQSize(VDEC_StreamId *pStreamId, MS_U32 *param)
8202 {
8203 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8204 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8205 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8206
8207 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8208 {
8209 case E_VDEC_EX_DECODER_HVD:
8210 *param = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_IS_LEAST_DISPQ_SIZE);
8211 eRet = E_VDEC_EX_OK;
8212 break;
8213 case E_VDEC_EX_DECODER_MVD:
8214 case E_VDEC_EX_DECODER_MJPEG:
8215 default:
8216 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8217 break;
8218 }
8219
8220 return eRet;
8221 }
8222
_VDEC_EX_GetFieldPicFlag(VDEC_StreamId * pStreamId,MS_U32 * param)8223 static VDEC_EX_Result _VDEC_EX_GetFieldPicFlag(VDEC_StreamId *pStreamId, MS_U32 *param)
8224 {
8225 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8226 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8227 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8228
8229 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8230 {
8231 case E_VDEC_EX_DECODER_HVD:
8232 *param = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_FIELD_PIC_FLAG);
8233 eRet = E_VDEC_EX_OK;
8234 break;
8235 case E_VDEC_EX_DECODER_MVD:
8236 case E_VDEC_EX_DECODER_MJPEG:
8237 default:
8238 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8239 break;
8240 }
8241
8242 return eRet;
8243 }
8244
_VDEC_EX_GetFlushPatternEntryNum(VDEC_StreamId * pStreamId,MS_U32 * param)8245 static VDEC_EX_Result _VDEC_EX_GetFlushPatternEntryNum(VDEC_StreamId *pStreamId, MS_U32 *param)
8246 {
8247 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8248 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8249 //MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8250
8251 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8252 {
8253 case E_VDEC_EX_DECODER_HVD:
8254 *param = (MS_U32)2;
8255 eRet = E_VDEC_EX_OK;
8256 break;
8257 case E_VDEC_EX_DECODER_MVD:
8258 *param = (MS_U32)1;
8259 eRet = E_VDEC_EX_OK;
8260 break;
8261 case E_VDEC_EX_DECODER_MJPEG:
8262 default:
8263 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8264 break;
8265 }
8266
8267 return eRet;
8268 }
8269
_VDEC_EX_GetHWMaxPixel(VDEC_StreamId * pStreamId,MS_U32 * param)8270 static VDEC_EX_Result _VDEC_EX_GetHWMaxPixel(VDEC_StreamId *pStreamId, MS_U32 *param)
8271 {
8272 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8273 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8274 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8275
8276 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8277 {
8278 case E_VDEC_EX_DECODER_HVD:
8279 *param = MDrv_HVD_EX_GetData(u32Id,E_HVD_EX_GDATA_TYPE_HVD_HW_MAX_PIXEL);
8280 eRet = E_VDEC_EX_OK;
8281 break;
8282 case E_VDEC_EX_DECODER_MVD:
8283 *param = MDrv_MVD_GetMaxPixel(u32Id);
8284 eRet = E_VDEC_EX_OK;
8285 break;
8286 case E_VDEC_EX_DECODER_MJPEG:
8287 default:
8288 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8289 break;
8290 }
8291
8292 return eRet;
8293 }
8294
_VDEC_EX_GetDSBufMiuSel(VDEC_StreamId * pStreamId,MS_U32 * param)8295 static VDEC_EX_Result _VDEC_EX_GetDSBufMiuSel(VDEC_StreamId *pStreamId, MS_U32 *param)
8296 {
8297 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8298 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8299 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8300
8301 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8302 {
8303 case E_VDEC_EX_DECODER_HVD:
8304 *param = (MS_U32)MDrv_HVD_EX_GetDSBufMiuSelect(u32Id);
8305 eRet = E_VDEC_EX_OK;
8306 break;
8307 case E_VDEC_EX_DECODER_MVD:
8308 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8309 break;
8310 case E_VDEC_EX_DECODER_MJPEG:
8311 default:
8312 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8313 break;
8314 }
8315
8316 return eRet;
8317 }
8318
8319
8320
_VDEC_EX_GetSupport2ndMVOPInterface(VDEC_StreamId * pStreamId,MS_BOOL * param)8321 static VDEC_EX_Result _VDEC_EX_GetSupport2ndMVOPInterface(VDEC_StreamId *pStreamId, MS_BOOL* param)
8322 {
8323 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8324 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8325
8326 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8327 {
8328 case E_VDEC_EX_DECODER_HVD:
8329 *param = MDrv_HVD_EX_GetSupport2ndMVOPInterface();
8330 eRet = E_VDEC_EX_OK;
8331 break;
8332 case E_VDEC_EX_DECODER_MVD:
8333 *param = MDrv_MVD_GetSupport2ndMVOPInterface();
8334 eRet = E_VDEC_EX_OK;
8335 break;
8336 case E_VDEC_EX_DECODER_MJPEG:
8337 *param = TRUE;
8338 eRet = E_VDEC_EX_OK;
8339 break;
8340 default:
8341 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8342 break;
8343 }
8344
8345 return eRet;
8346 }
8347
_VDEC_EX_GetVsyncBridgeAddr(VDEC_StreamId * pStreamId,MS_VIRT * param)8348 static VDEC_EX_Result _VDEC_EX_GetVsyncBridgeAddr(VDEC_StreamId *pStreamId, MS_VIRT *param)
8349 {
8350 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8351 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8352 MS_VIRT u32SHMaddr = 0;
8353 MS_VIRT u32VsyncSHMOffset = 0;
8354
8355 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8356 {
8357 case E_VDEC_EX_DECODER_HVD:
8358 case E_VDEC_EX_DECODER_MVD:
8359 case E_VDEC_EX_DECODER_MJPEG:
8360 MDrv_MVD_REE_GetSHMInformation(&u32SHMaddr,&u32VsyncSHMOffset);
8361 if(u32SHMaddr != 0) // TEE project
8362 {
8363 *param = u32SHMaddr+u32VsyncSHMOffset;
8364 }
8365 else // normal project
8366 {
8367 *param = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32CodeBufAddr + u32VsyncSHMOffset;
8368 }
8369 eRet = E_VDEC_EX_OK;
8370 break;
8371 default:
8372 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8373 break;
8374 }
8375
8376 return eRet;
8377 }
8378
_VDEC_EX_GetVsyncBridgeExtAddr(VDEC_StreamId * pStreamId,MS_VIRT * param)8379 static VDEC_EX_Result _VDEC_EX_GetVsyncBridgeExtAddr(VDEC_StreamId *pStreamId, MS_VIRT *param)
8380 {
8381 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8382 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8383 MS_VIRT u32SHMaddr = 0;
8384 MS_VIRT u32VsyncExtSHMOffset = 0;
8385
8386 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8387 {
8388 case E_VDEC_EX_DECODER_HVD:
8389 case E_VDEC_EX_DECODER_MVD:
8390 case E_VDEC_EX_DECODER_MJPEG:
8391 if(E_MVD_RET_OK == MDrv_MVD_REE_GetVsyncExtShm(&u32SHMaddr,&u32VsyncExtSHMOffset))
8392 {
8393
8394 if(u32SHMaddr != 0) // TEE project
8395 {
8396 *param = u32SHMaddr + u32VsyncExtSHMOffset;
8397 }
8398 else // normal project
8399 {
8400 *param = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32CodeBufAddr + u32VsyncExtSHMOffset;
8401 }
8402 eRet = E_VDEC_EX_OK;
8403 }
8404 break;
8405 default:
8406 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8407 break;
8408 }
8409
8410 return eRet;
8411 }
8412
8413 //------------------------------------------------------------------------------
8414 /// Set ignore error reference
8415 /// @param VDEC_EX_CODEC_CAP_INFO, get chip codec param from hal
8416 /// @return VDEC_EX_Result
8417 //------------------------------------------------------------------------------
_VDEC_EX_GetCodecCapInfo(VDEC_EX_CODEC_CAP_INFO * param)8418 static VDEC_EX_Result _VDEC_EX_GetCodecCapInfo( VDEC_EX_CODEC_CAP_INFO *param)
8419 {
8420 VDEC_EX_Result eRet = E_VDEC_EX_OK;
8421
8422 MDrv_HVD_EX_GetCodecCapInfo( param->u32CodecType, param);
8423 return eRet;
8424 }
8425
_VDEC_EX_GetNotSupportInfo(VDEC_StreamId * pStreamId,MS_U32 * param)8426 static VDEC_EX_Result _VDEC_EX_GetNotSupportInfo(VDEC_StreamId *pStreamId, MS_U32 *param)
8427 {
8428 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8429 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8430 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8431
8432 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8433 {
8434 case E_VDEC_EX_DECODER_HVD:
8435 *param = MDrv_HVD_EX_GetData(u32Id,E_HVD_EX_GDATA_TYPE_GET_NOT_SUPPORT_INFO);
8436 eRet = E_VDEC_EX_OK;
8437 break;
8438 case E_VDEC_EX_DECODER_MVD:
8439 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8440 break;
8441 case E_VDEC_EX_DECODER_MJPEG:
8442 default:
8443 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8444 break;
8445 }
8446
8447 return eRet;
8448 }
8449
_VDEC_EX_GetMinTspDataSize(VDEC_StreamId * pStreamId,MS_U32 * param)8450 static VDEC_EX_Result _VDEC_EX_GetMinTspDataSize(VDEC_StreamId *pStreamId, MS_U32 *param)
8451 {
8452 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8453 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8454 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8455
8456 VDEC_EX_DispInfo DisplayInfo ;
8457 _VDEC_Memset(&DisplayInfo, 0, sizeof(VDEC_EX_DispInfo));
8458
8459 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8460 {
8461 case E_VDEC_EX_DECODER_HVD:
8462 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_H264 &&
8463 pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_AVS &&
8464 pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_HEVC)
8465 {
8466 return E_VDEC_EX_RET_UNSUPPORTED;
8467 }
8468 *param = MDrv_HVD_EX_GetData(u32Id,E_HVD_EX_GDATA_TYPE_GET_MIN_TSP_DATA_SIZE);
8469 eRet = E_VDEC_EX_OK;
8470 break;
8471 case E_VDEC_EX_DECODER_MVD:
8472 if(pVdecExContext->_Attr[u8Idx].eCodecType != E_VDEC_EX_CODEC_TYPE_MPEG2)
8473 {
8474 return E_VDEC_EX_RET_UNSUPPORTED;
8475 }
8476 *param = MDrv_MVD_EX_GetMinTspDataSize(u32Id);
8477 eRet = E_VDEC_EX_OK;
8478 break;
8479 case E_VDEC_EX_DECODER_MJPEG:
8480 default:
8481 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8482 break;
8483 }
8484
8485 return eRet;
8486 }
8487
8488 // Allocate share memory from OS
8489 // This function can't be called at the same time in dual decode
8490 // Because there is share memory used in this function
_VDEC_Init_Share_Mem(VDEC_EX_Stream eStreamType)8491 static VDEC_EX_Result _VDEC_Init_Share_Mem(VDEC_EX_Stream eStreamType)
8492 {
8493 #if defined(MSOS_TYPE_LINUX) || defined(MSOS_TYPE_LINUX_KERNEL) || defined(MSOS_TYPE_ECOS)
8494 #if !defined(SUPPORT_X_MODEL_FEATURE)
8495 MS_U32 u32ShmId;
8496 MS_VIRT u32Addr;
8497 MS_U32 u32BufSize;
8498
8499 if (FALSE == MsOS_SHM_GetId( (MS_U8*)"Linux VDEC driver",
8500 sizeof(VDEC_EX_CTX),
8501 &u32ShmId,
8502 &u32Addr,
8503 &u32BufSize,
8504 MSOS_SHM_QUERY))
8505 {
8506 if (FALSE == MsOS_SHM_GetId((MS_U8*)"Linux VDEC driver",
8507 sizeof(VDEC_EX_CTX),
8508 &u32ShmId,
8509 &u32Addr,
8510 &u32BufSize,
8511 MSOS_SHM_CREATE))
8512 {
8513 VDEC_PRINT("[%s]SHM allocation failed!!!use global structure instead !!!\n",__FUNCTION__);
8514 if(pVdecExContext == NULL)
8515 {
8516 pVdecExContext = &gVdecExContext;
8517 memset(pVdecExContext,0,sizeof(VDEC_EX_CTX));
8518 _VDEC_EX_Context_Init();
8519 VDEC_PRINT("[%s]Global structure init Success!!!\n",__FUNCTION__);
8520 }
8521 else
8522 {
8523 VDEC_PRINT("[%s]Global structure exists!!!\n",__FUNCTION__);
8524 }
8525 //return E_VDEC_EX_FAIL;
8526 }
8527 else
8528 {
8529 memset((MS_U8*)u32Addr, 0, sizeof(VDEC_EX_CTX));
8530 pVdecExContext = (VDEC_EX_CTX*)u32Addr; // for one process
8531 _VDEC_EX_Context_Init();
8532 #if defined(CHIP_MONACO) || defined(CHIP_CLIPPERS) || defined(CHIP_MUJI) || defined(CHIP_MONET) || defined(CHIP_MANHATTAN) || defined(CHIP_KANO) || defined(CHIP_CURRY)
8533
8534 #ifdef DONT_USE_CMA //new cma , work for muji only.
8535 pVdecExContext->bCMAUsed = FALSE; // Disable in the future
8536 #else
8537 pVdecExContext->bCMAUsed = TRUE; // enable in the future
8538 #endif
8539
8540 #endif
8541 }
8542 }
8543 else
8544 {
8545 pVdecExContext = (VDEC_EX_CTX*)u32Addr; // for another process
8546 MS_PHY u32NonPMBankSize = 0;
8547 MS_VIRT u32RiuBaseAddr = 0;
8548
8549 if (!MDrv_MMIO_GetBASE(&u32RiuBaseAddr, &u32NonPMBankSize, MS_MODULE_HW))
8550 {
8551 VDEC_PRINT("VDEC HVD Init Err: MMIO_GetBASE failure\n");
8552 return E_VDEC_EX_FAIL;
8553 }
8554 else
8555 {
8556 MDrv_HVD_EX_SetOSRegBase(u32RiuBaseAddr);
8557 MDrv_MVD_RegSetBase(u32RiuBaseAddr);
8558 }
8559 }
8560 #else
8561 if(pVdecExContext == NULL)
8562 {
8563 pVdecExContext = &gVdecExContext;
8564 memset(pVdecExContext,0,sizeof(VDEC_EX_CTX));
8565 _VDEC_EX_Context_Init();
8566 }
8567 #endif
8568
8569 if(_VDEC_EX_API_MutexCreate() != TRUE)
8570 {
8571 VDEC_PRINT("[%s] API Mutex create failed!\n",__FUNCTION__);
8572 return E_VDEC_EX_FAIL;
8573 }
8574 #else
8575 if(pVdecExContext == NULL)
8576 {
8577 pVdecExContext = &gVdecExContext;
8578 memset(pVdecExContext,0,sizeof(VDEC_EX_CTX));
8579 _VDEC_EX_Context_Init();
8580 }
8581 #endif
8582
8583 #ifndef VDEC3
8584 _VDEC_EX_Context_Init_Function_Pointer(eStreamType);
8585 #endif
8586
8587 #ifdef CMA_FW_INIT
8588 if (pVdecExContext->bCMAUsed)
8589 {
8590 pVdecExContext->cmaInitParam[0].heap_id = ION_VDEC_HEAP_ID; // 19
8591 pVdecExContext->cmaInitParam[0].flags = CMA_FLAG_MAP_VMA| CMA_FLAG_CACHED;
8592
8593 if (MApi_CMA_Pool_Init(&pVdecExContext->cmaInitParam[0]) == FALSE)
8594 {
8595 return E_VDEC_EX_FAIL;
8596 }
8597 else
8598 {
8599 bCMAInitPool[0] = TRUE;
8600
8601 VPRINTF("[VDEC][%d]MApi_CMA_Pool_Init[0]: pool_handle_id=%x, miu=%d, offset=%llx, length=%x\n",
8602 (unsigned int)eStreamType,
8603 (unsigned int)pVdecExContext->cmaInitParam[0].pool_handle_id,
8604 (unsigned int)pVdecExContext->cmaInitParam[0].miu,
8605 (unsigned long long int)pVdecExContext->cmaInitParam[0].heap_miu_start_offset,
8606 (unsigned int)pVdecExContext->cmaInitParam[0].heap_length);
8607 }
8608
8609 pVdecExContext->cmaInitParam[1].heap_id = ION_VDEC_HEAP_ID + 1; // 20
8610 pVdecExContext->cmaInitParam[1].flags = CMA_FLAG_MAP_VMA;
8611
8612 if (MApi_CMA_Pool_Init(&pVdecExContext->cmaInitParam[1]) == FALSE)
8613 {
8614 VDEC_ERR("[Error]:%s, the 2nd heap of CMA doesn't exist\n", __FUNCTION__);
8615 }
8616 else
8617 {
8618 bCMAInitPool[1] = TRUE;
8619 }
8620
8621 VPRINTF("MApi_CMA_Pool_Init[1]: pool_handle_id=0x%lx, miu=%ld, offset=0x%llx, length=0x%llx\n",
8622 pVdecExContext->cmaInitParam[1].pool_handle_id,
8623 pVdecExContext->cmaInitParam[1].miu,
8624 pVdecExContext->cmaInitParam[1].heap_miu_start_offset,
8625 pVdecExContext->cmaInitParam[1].heap_length);
8626 }
8627 #endif
8628
8629 if(MDrv_MVD_Init_Share_Mem() != E_MVD_RET_OK)
8630 {
8631 VDEC_PRINT("[%s]MVD SHM allocation failed!\n",__FUNCTION__);
8632 return E_VDEC_EX_FAIL;
8633 }
8634
8635 if(MDrv_HVD_Init_Share_Mem() != E_HVD_EX_OK)
8636 {
8637 VDEC_PRINT("[%s]HVD SHM allocation failed!\n",__FUNCTION__);
8638 return E_VDEC_EX_FAIL;
8639 }
8640
8641 #ifdef CMA_FW_INIT
8642 if(pVdecExContext->bCMAUsed == TRUE && pVdecExContext->bCMAInit == FALSE)
8643 {
8644 // mvd add in here
8645 MDrv_MVD_SetCMAInformation(&(pVdecExContext->cmaInitParam[0]));
8646
8647 // hvd add in here
8648 MDrv_HVD_EX_SetCMAInformation(pVdecExContext->cmaInitParam);
8649 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
8650 // mjpeg add in here
8651 MApi_MJPEG_SetCMAInformation(&(pVdecExContext->cmaInitParam[0]));
8652 #endif
8653
8654 pVdecExContext->bCMAInit = TRUE;
8655 }
8656 #endif
8657
8658 return E_VDEC_EX_OK;
8659
8660 }
8661
8662 //------------------------------------------------------------------------------
8663 /// Get CRC value
8664 /// @param pCrcIn \b IN : the structure of generate CRC
8665 /// @param pCrcOut \b OUT : CRC value
8666 /// @return VDEC_EX_Result
8667 //------------------------------------------------------------------------------
_VDEC_EX_GetCrcValue(VDEC_StreamId * pStreamId,VDEC_EX_CrcValue * pCrcValue)8668 static VDEC_EX_Result _VDEC_EX_GetCrcValue(VDEC_StreamId *pStreamId, VDEC_EX_CrcValue *pCrcValue)
8669 {
8670 VDEC_EX_Result eRet = E_VDEC_EX_OK;
8671 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8672 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8673
8674 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8675 {
8676 case E_VDEC_EX_DECODER_MVD:
8677 {
8678 MVD_CrcIn stMvdCrcIn;
8679 MVD_CrcOut stMvdCrcOut;
8680
8681 _VDEC_Memset(&stMvdCrcIn, 0, sizeof(MVD_CrcIn));
8682 _VDEC_Memset(&stMvdCrcOut, 0, sizeof(MVD_CrcOut));
8683
8684 stMvdCrcIn.u32HSize = pCrcValue->stCrcIn.u32HorSize;
8685 stMvdCrcIn.u32VSize = pCrcValue->stCrcIn.u32VerSize;
8686 stMvdCrcIn.u32Strip = pCrcValue->stCrcIn.u32Strip;
8687 stMvdCrcIn.u32YStartAddr = pCrcValue->stCrcIn.u32LumaStartAddr;
8688 stMvdCrcIn.u32UVStartAddr = pCrcValue->stCrcIn.u32ChromaStartAddr;
8689
8690 _MVD_RET_HANDLE(MDrv_MVD_GetCrcValue(u32Id, &stMvdCrcIn, &stMvdCrcOut));
8691
8692 pCrcValue->stCrcOut.u32LumaCRC = stMvdCrcOut.u32YCrc;
8693 pCrcValue->stCrcOut.u32ChromaCRC = stMvdCrcOut.u32UVCrc;
8694
8695 break;
8696 }
8697 case E_VDEC_EX_DECODER_HVD:
8698 case E_VDEC_EX_DECODER_MJPEG:
8699 {
8700 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8701 break;
8702 }
8703 default:
8704 {
8705 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
8706 break;
8707 }
8708 }
8709
8710 return eRet;
8711 }
8712
_VDEC_GetBBUQNum(VDEC_StreamId * pStreamId,MS_U32 * param)8713 static VDEC_EX_Result _VDEC_GetBBUQNum(VDEC_StreamId *pStreamId, MS_U32 *param)
8714 {
8715 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8716 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8717 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8718
8719 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8720 {
8721 case E_VDEC_EX_DECODER_MVD:
8722 *param = MDrv_MVD_GetSLQNum(u32Id);
8723 eRet = E_VDEC_EX_OK;
8724 break;
8725 case E_VDEC_EX_DECODER_HVD:
8726 *param = MDrv_HVD_EX_GetBBUQNum(u32Id);
8727 eRet = E_VDEC_EX_OK;
8728 break;
8729 case E_VDEC_EX_DECODER_MJPEG:
8730 default:
8731 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8732 break;
8733 }
8734
8735 return eRet;
8736 }
8737
_VDEC_EX_GetDispFrmNum(VDEC_StreamId * pStreamId,MS_U32 * param)8738 static VDEC_EX_Result _VDEC_EX_GetDispFrmNum(VDEC_StreamId *pStreamId, MS_U32 *param)
8739 {
8740 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8741 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8742 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8743
8744 if (param == NULL)
8745 {
8746 return E_VDEC_EX_RET_INVALID_PARAM;
8747 }
8748
8749 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8750 {
8751 case E_VDEC_EX_DECODER_HVD:
8752 *param = MDrv_HVD_EX_GetDispFrmNum(u32Id);
8753 break;
8754 case E_VDEC_EX_DECODER_MVD:
8755 *param = MDrv_MVD_GetDispQNum(u32Id);
8756 break;
8757 case E_VDEC_EX_DECODER_MJPEG:
8758 _VDEC_EX_API_MutexLock();
8759 *param = MApi_MJPEG_GetDispFrmNum(u32Id);;
8760 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
8761 _VDEC_EX_API_MutexUnlock();
8762 break;
8763 default:
8764 *param = 0;
8765 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
8766 break;
8767 }
8768 return eRet;
8769 }
8770
_VDEC_EX_Set_External_DS_Buffer(VDEC_StreamId * pStreamId,VDEC_EX_EXTERNAL_DS_BUFFER * pExternalDSBuf)8771 static VDEC_EX_Result _VDEC_EX_Set_External_DS_Buffer(VDEC_StreamId *pStreamId, VDEC_EX_EXTERNAL_DS_BUFFER* pExternalDSBuf)
8772 {
8773
8774 #define SIZE_4K 0x1000
8775 #define SIZE_3K 0xC00
8776
8777 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8778 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8779 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8780
8781 if(pExternalDSBuf == NULL)
8782 {
8783 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
8784 }
8785
8786 /// DS buffer need more than 4K buffer.
8787 if(pExternalDSBuf->u32DSBufSize < SIZE_4K)
8788 {
8789 return E_VDEC_EX_RET_UNSUPPORTED;
8790 }
8791
8792 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8793 {
8794 case E_VDEC_EX_DECODER_MVD:
8795 {
8796 MVD_EX_ExternalDSBuf stMVDExternalDSBuf;
8797 stMVDExternalDSBuf.u32DSBufAddr = pExternalDSBuf->u32DSBufAddr;
8798 stMVDExternalDSBuf.u32DSBufSize = SIZE_3K; //pExternalDSBuf->u32DSBufSize; /// MVD only use 3K for IP/OP buffer.
8799 ///VDEC_PRINT("[EDS] API HVD 0x%x, 0x%lx, 0x%lx.\n",stMVDExternalDSBuf.bEnable,stMVDExternalDSBuf.u32DSBufAddr,stMVDExternalDSBuf.u32DSBufSize);
8800 _MVD_RET_HANDLE(MDrv_MVD_SetExternalDSBuffer(u32Id,&stMVDExternalDSBuf));
8801 eRet = E_VDEC_EX_OK;
8802 break;
8803 }
8804 case E_VDEC_EX_DECODER_HVD:
8805 {
8806 HVD_EX_ExternalDSBuf stExternalDSBuf;
8807 stExternalDSBuf.u32DSBufAddr = pExternalDSBuf->u32DSBufAddr;
8808 stExternalDSBuf.u32DSBufSize = SIZE_3K;// pExternalDSBuf->u32DSBufSize;
8809 ///VDEC_PRINT("[EDS] API HVD 0x%x, 0x%lx, 0x%lx.\n",stExternalDSBuf.bEnable,stExternalDSBuf.u32DSBufAddr,stExternalDSBuf.u32DSBufSize);
8810 _HVD_RET_HANDLE(MDrv_HVD_EX_SetExternalDSBuffer(u32Id,&stExternalDSBuf));
8811 eRet = E_VDEC_EX_OK;
8812 break;
8813 }
8814 case E_VDEC_EX_DECODER_MJPEG:
8815 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8816 break;
8817 default:
8818 break;
8819 }
8820
8821 return eRet;
8822 }
8823
_VDEC_EX_GetESBufferStatus(VDEC_StreamId * pStreamId,MS_U32 * param)8824 static VDEC_EX_Result _VDEC_EX_GetESBufferStatus(VDEC_StreamId *pStreamId, MS_U32 *param)
8825 {
8826 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
8827 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8828 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8829
8830 if (param == NULL)
8831 {
8832 return E_VDEC_EX_RET_INVALID_PARAM;
8833 }
8834
8835 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8836 {
8837 case E_VDEC_EX_DECODER_HVD:
8838 {
8839 MS_U32 u32ESBufStatus;
8840
8841 u32ESBufStatus = MDrv_HVD_EX_GetESBufferStatus(u32Id);
8842 *param = _VDEC_Map2ESBufStatus(u32ESBufStatus);
8843 if(*param != ES_BUFFER_STATUS_UNKNOWN)
8844 {
8845 eRet = E_VDEC_EX_OK;
8846 }
8847 break;
8848 }
8849 case E_VDEC_EX_DECODER_MVD:
8850 *param = MDrv_MVD_GetESBufferStatus(u32Id);
8851 if(*param != ES_BUFFER_STATUS_UNKNOWN)
8852 {
8853 eRet = E_VDEC_EX_OK;
8854 }
8855 break;
8856 case E_VDEC_EX_DECODER_MJPEG:
8857 *param = 0;
8858 eRet = E_VDEC_EX_RET_UNSUPPORTED;
8859 break;
8860 default:
8861 *param = 0;
8862 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
8863 break;
8864 }
8865 return eRet;
8866 }
8867
_VDEC_EX_SetDbgLevel(VDEC_StreamId * pStreamId,VDEC_EX_DbgLevel eDbgLevel)8868 static VDEC_EX_Result _VDEC_EX_SetDbgLevel(VDEC_StreamId *pStreamId, VDEC_EX_DbgLevel eDbgLevel)
8869 {
8870 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8871 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8872
8873 if (E_VDEC_EX_DBG_LEVEL_FW == eDbgLevel)
8874 {
8875 MS_PHY u32NonPMBankSize=0;
8876 MS_VIRT u32RiuBaseAdd=0;
8877 _RET_VDEC_HVD_LINT_CHECK();
8878
8879 if (!MDrv_MMIO_GetBASE(&u32RiuBaseAdd, &u32NonPMBankSize, MS_MODULE_HW))
8880 {
8881 VDEC_PRINT("VDEC HVD MApi_VDEC_EX_SetDbgLevel Err: MMIO_GetBASE failure\n");
8882 return E_VDEC_EX_FAIL;
8883 }
8884 else
8885 {
8886 //VDEC_PRINT("HVD:1 u32RiuBaseAdd = %lx\n", u32RiuBaseAdd);
8887 MDrv_HVD_EX_SetOSRegBase(u32RiuBaseAdd);
8888 }
8889
8890 MDrv_HVD_EX_SetDbgLevel(u32Id, E_HVD_EX_UART_LEVEL_FW);
8891
8892 return E_VDEC_EX_OK;
8893 }
8894
8895 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8896 {
8897 case E_VDEC_EX_DECODER_MVD:
8898 {
8899 _RET_VDEC_MVD_LINT_CHECK();
8900 MDrv_MVD_SetDbgLevel(eDbgLevel);
8901
8902 break;
8903 }
8904 case E_VDEC_EX_DECODER_HVD:
8905 {
8906 _RET_VDEC_HVD_LINT_CHECK();
8907 if (E_VDEC_EX_DBG_LEVEL_NONE == eDbgLevel)
8908 {
8909 MDrv_HVD_EX_SetDbgLevel(u32Id, E_HVD_EX_UART_LEVEL_NONE);
8910 }
8911 if (E_VDEC_EX_DBG_LEVEL_ERR == eDbgLevel)
8912 {
8913 MDrv_HVD_EX_SetDbgLevel(u32Id, E_HVD_EX_UART_LEVEL_ERR);
8914 }
8915 else if (E_VDEC_EX_DBG_LEVEL_INFO == eDbgLevel)
8916 {
8917 MDrv_HVD_EX_SetDbgLevel(u32Id, E_HVD_EX_UART_LEVEL_INFO);
8918 }
8919 else if (E_VDEC_EX_DBG_LEVEL_DBG == eDbgLevel)
8920 {
8921 MDrv_HVD_EX_SetDbgLevel(u32Id, E_HVD_EX_UART_LEVEL_DBG);
8922 }
8923 else if (E_VDEC_EX_DBG_LEVEL_TRACE == eDbgLevel)
8924 {
8925 MDrv_HVD_EX_SetDbgLevel(u32Id, E_HVD_EX_UART_LEVEL_TRACE);
8926 }
8927
8928 break;
8929 }
8930 case E_VDEC_EX_DECODER_MJPEG:
8931 {
8932 _VDEC_EX_API_MutexLock();
8933 MApi_MJPEG_DbgSetMsgLevel((MJPEG_DbgLevel)eDbgLevel);
8934 _VDEC_EX_API_MutexUnlock();
8935
8936 break;
8937 }
8938 default:
8939 break;
8940 }
8941
8942 return E_VDEC_EX_OK;
8943 }
8944
8945 extern void HAL_HVD_EX_ExchangeCidx(MS_U32);
8946 extern void HAL_VPU_EX_ExchangeCidx(MS_U32);
8947 #ifdef VDEC3
8948 extern void HAL_HVD_EX_SetCidx(MS_U32, MS_BOOL, MS_BOOL);
8949 extern void HAL_VPU_EX_SetCidx(MS_U32, MS_BOOL, MS_BOOL);
8950 #else
8951 extern void HAL_HVD_EX_SetCidx(MS_U32, MS_BOOL);
8952 extern void HAL_VPU_EX_SetCidx(MS_U32, MS_BOOL);
8953 #endif
8954 extern MS_U8 HAL_HVD_EX_GetCidx(MS_U32);
8955
8956 #if VDEC_EXCHANGE_CIDX_PATCH
_VDEC_EX_ExchangeCidx(VDEC_StreamId * pStreamId)8957 static VDEC_EX_Result _VDEC_EX_ExchangeCidx(VDEC_StreamId *pStreamId)
8958 {
8959 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8960
8961 HAL_HVD_EX_ExchangeCidx(u32Id);
8962 HAL_VPU_EX_ExchangeCidx(u32Id);
8963
8964 return E_VDEC_EX_OK;
8965 }
8966 #endif
8967
8968 #ifdef VDEC3
_VDEC_EX_SetCidx(VDEC_StreamId * pStreamId,MS_BOOL bIsEVD,MS_BOOL bIsNStreamMode)8969 static VDEC_EX_Result _VDEC_EX_SetCidx(VDEC_StreamId *pStreamId, MS_BOOL bIsEVD, MS_BOOL bIsNStreamMode)
8970 #else
8971 static VDEC_EX_Result _VDEC_EX_SetCidx(VDEC_StreamId *pStreamId, MS_BOOL bIsEVD)
8972 #endif
8973 {
8974 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
8975 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
8976
8977 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
8978 {
8979 case E_VDEC_EX_DECODER_MVD:
8980 {
8981 #ifdef VDEC3
8982 HAL_HVD_EX_SetCidx(u32Id, FALSE, bIsNStreamMode);
8983 HAL_VPU_EX_SetCidx(u32Id, FALSE, bIsNStreamMode);
8984 #else
8985 HAL_HVD_EX_SetCidx(u32Id, FALSE);
8986 HAL_VPU_EX_SetCidx(u32Id, FALSE);
8987 #endif
8988 break;
8989 }
8990 case E_VDEC_EX_DECODER_HVD:
8991 {
8992 #ifdef VDEC3
8993 HAL_HVD_EX_SetCidx(u32Id, bIsEVD, bIsNStreamMode);
8994 HAL_VPU_EX_SetCidx(u32Id, bIsEVD, bIsNStreamMode);
8995 #else
8996 HAL_HVD_EX_SetCidx(u32Id, bIsEVD);
8997 HAL_VPU_EX_SetCidx(u32Id, bIsEVD);
8998 #endif
8999 break;
9000 }
9001 case E_VDEC_EX_DECODER_MJPEG:
9002 {
9003 #ifdef VDEC3
9004 HAL_HVD_EX_SetCidx(u32Id, FALSE, FALSE);
9005 HAL_VPU_EX_SetCidx(u32Id, FALSE, FALSE);
9006 #else
9007 HAL_HVD_EX_SetCidx(u32Id, FALSE);
9008 HAL_VPU_EX_SetCidx(u32Id, FALSE);
9009 #endif
9010 break;
9011 }
9012 default:
9013 break;
9014 }
9015
9016 return E_VDEC_EX_OK;
9017 }
9018
_VDEC_EX_GetCidx(VDEC_StreamId * pStreamId,MS_U8 * u8Cidx)9019 static VDEC_EX_Result _VDEC_EX_GetCidx(VDEC_StreamId *pStreamId, MS_U8* u8Cidx)
9020 {
9021 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9022 *u8Cidx = HAL_HVD_EX_GetCidx(u32Id);
9023 return E_VDEC_EX_OK;
9024 }
9025
9026 extern MS_BOOL HAL_VPU_EX_NotSupportDS(void);
_VDEC_EX_GetCaps(VDEC_EX_CapCmd cmd_id,MS_U32 * param)9027 static VDEC_EX_Result _VDEC_EX_GetCaps(VDEC_EX_CapCmd cmd_id, MS_U32* param)
9028 {
9029 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
9030
9031 #if 0
9032 switch (cmd_id)
9033 {
9034 case E_VDEC_EX_CAP_XC_NOT_SUPPORT_DS:
9035 *param = HAL_VPU_EX_NotSupportDS();
9036 eRet = E_VDEC_EX_OK;
9037 break;
9038 default:
9039 eRet = E_VDEC_EX_RET_INVALID_PARAM
9040 break;
9041 }
9042
9043 #else
9044 if(cmd_id == E_VDEC_EX_CAP_XC_NOT_SUPPORT_DS)
9045 {
9046 *param = HAL_VPU_EX_NotSupportDS();
9047 eRet = E_VDEC_EX_OK;
9048 }
9049 #endif
9050 return eRet;
9051 }
9052
9053 //------------------------------------------------------------------------------
9054 /// Enable to let decoder force to drop error frame
9055 /// @param bEnable \b IN : TRUE - enable; FALSE - disable
9056 /// @return VDEC_EX_Result
9057 //------------------------------------------------------------------------------
_VDEC_EX_DropErrFrame(VDEC_StreamId * pStreamId,MS_BOOL bEnable)9058 static VDEC_EX_Result _VDEC_EX_DropErrFrame(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
9059 {
9060 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9061 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9062 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9063
9064 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9065 {
9066 case E_VDEC_EX_DECODER_MVD:
9067 {
9068 if (FALSE == MDrv_MVD_DropErrorFrame(u32Id, bEnable))
9069 {
9070 eRet = E_VDEC_EX_FAIL;
9071 }
9072 pVdecExContext->bDropErrFrm[u8Idx] = bEnable;
9073 break;
9074 }
9075 case E_VDEC_EX_DECODER_HVD:
9076 {
9077 if(MDrv_HVD_EX_SetDispErrFrm(u32Id, !bEnable) != E_HVD_EX_OK)
9078 {
9079 eRet = E_VDEC_EX_FAIL;
9080 }
9081 break;
9082 }
9083 case E_VDEC_EX_DECODER_MJPEG:
9084 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9085 break;
9086 default:
9087 break;
9088 }
9089
9090 return eRet;
9091 }
9092
_VDEC_EX_GetFWCodecType(VDEC_StreamId * pStreamId,MS_U32 * param)9093 static VDEC_EX_Result _VDEC_EX_GetFWCodecType(VDEC_StreamId *pStreamId, MS_U32 *param)
9094 {
9095 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
9096 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9097 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9098
9099 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9100 {
9101 case E_VDEC_EX_DECODER_HVD:
9102 {
9103 if ( MDrv_HVD_EX_CheckDispInfoRdy(u32Id) == E_HVD_EX_OK)
9104 {
9105 *param = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_FW_CODEC_TYPE);
9106 switch (*param)
9107 {
9108 case E_HVD_EX_AVC:
9109 {
9110 *param = E_VDEC_EX_CODEC_TYPE_H264;
9111 break;
9112 }
9113 case E_HVD_EX_AVS:
9114 {
9115 *param = E_VDEC_EX_CODEC_TYPE_AVS;
9116 break;
9117 }
9118 case E_HVD_EX_RM:
9119 {
9120 *param = E_VDEC_EX_CODEC_TYPE_RV9;
9121 break;
9122 }
9123 case E_HVD_EX_MVC:
9124 {
9125 *param = E_VDEC_EX_CODEC_TYPE_MVC;
9126 break;
9127 }
9128 case E_HVD_EX_VP8:
9129 {
9130 *param = E_VDEC_EX_CODEC_TYPE_VP8;
9131 break;
9132 }
9133 case E_HVD_EX_HEVC:
9134 {
9135 *param = E_VDEC_EX_CODEC_TYPE_HEVC;
9136 break;
9137 }
9138 case E_HVD_EX_NONE:
9139 default:
9140 {
9141 *param = E_VDEC_EX_CODEC_TYPE_NONE;
9142 break;
9143 }
9144 }
9145
9146 eRet = E_VDEC_EX_OK;
9147 }
9148 else
9149 {
9150 eRet = E_VDEC_EX_RET_NOT_READY;
9151 }
9152 break;
9153 }
9154 case E_VDEC_EX_DECODER_MVD:
9155 case E_VDEC_EX_DECODER_MJPEG:
9156 default:
9157 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9158 break;
9159 }
9160
9161 return eRet;
9162 }
9163
_VDEC_EX_Enable_External_CC_608_Buffer(VDEC_StreamId * pStreamId,MS_VIRT u32_ccinfo)9164 static VDEC_EX_Result _VDEC_EX_Enable_External_CC_608_Buffer(VDEC_StreamId *pStreamId, MS_VIRT u32_ccinfo)
9165 {
9166 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
9167 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9168 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9169 MS_VIRT u32Buffer_Addr = (u32_ccinfo >> 8);//unit is kb
9170 MS_U8 u8Buffer_Size= u32_ccinfo & 0xFF;
9171
9172 if(u32_ccinfo==0)
9173 VDEC_PRINT("\nIt will turn off this feature.......\n");
9174
9175 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9176 {
9177
9178 case E_VDEC_EX_DECODER_MVD:
9179 _MVD_RET_HANDLE(MDrv_MVD_SetExternal_CC608_Buffer(u32Id,u32Buffer_Addr,u8Buffer_Size));
9180 eRet = E_VDEC_EX_OK;
9181 break;
9182 case E_VDEC_EX_DECODER_HVD:
9183 _HVD_RET_HANDLE(MDrv_HVD_EX_SetExternal_CC608_Buffer(u32Id,u32Buffer_Addr,u8Buffer_Size));
9184 eRet = E_VDEC_EX_OK;
9185 break;
9186
9187 case E_VDEC_EX_DECODER_MJPEG:
9188 default:
9189 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9190 break;
9191 }
9192 return eRet;
9193 }
9194
_VDEC_EX_Enable_External_CC_708_Buffer(VDEC_StreamId * pStreamId,MS_VIRT u32_ccinfo)9195 static VDEC_EX_Result _VDEC_EX_Enable_External_CC_708_Buffer(VDEC_StreamId *pStreamId, MS_VIRT u32_ccinfo)
9196 {
9197 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
9198 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9199 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9200 MS_VIRT u32Buffer_Addr = (u32_ccinfo >> 8);//unit is kb
9201 MS_U8 u8Buffer_Size= u32_ccinfo & 0xFF;
9202
9203 if(u32_ccinfo==0)
9204 VDEC_PRINT("\nIt will turn off this feature.......\n");
9205
9206 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9207 {
9208
9209 case E_VDEC_EX_DECODER_MVD:
9210 _MVD_RET_HANDLE(MDrv_MVD_SetExternal_CC708_Buffer(u32Id,u32Buffer_Addr,u8Buffer_Size));
9211 eRet = E_VDEC_EX_OK;
9212 break;
9213 case E_VDEC_EX_DECODER_HVD:
9214 _HVD_RET_HANDLE(MDrv_HVD_EX_SetExternal_CC708_Buffer(u32Id,u32Buffer_Addr,u8Buffer_Size));
9215 eRet = E_VDEC_EX_OK;
9216 break;
9217
9218 case E_VDEC_EX_DECODER_MJPEG:
9219 default:
9220 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9221 break;
9222 }
9223 return eRet;
9224
9225 }
9226
9227 #if VDEC_DTV_DIRECT_STC_PATCH
9228 #include "apiDMX.h"
_Feed_Direct_STC(MS_U32 u32streamIdx)9229 static void _Feed_Direct_STC(MS_U32 u32streamIdx)
9230 {
9231 MS_U8 u8Idx = _VDEC_GET_IDX(u32streamIdx);
9232 MS_U32 u32Id = _VDEC_GET_DRV_ID(u32streamIdx);
9233 MS_U32 u32High = 0;
9234 MS_U32 u32Low = 0;
9235 MS_U64 u64STC = 0;
9236 MS_U8 u8STCSource = u8Idx; //main use tsp0, sub use tsp1
9237 pVdecExContext->bDirectStcThreadRunning[u8Idx] = TRUE;
9238 VDEC_PRINT("[%d] start of _Feed_Direct_STC \n", MsOS_GetSystemTime());
9239
9240 while(pVdecExContext->bDirectStcThreadRunning[u8Idx])
9241 {
9242 MApi_DMX_Stc_Eng_Get(u8STCSource, &u32High, &u32Low);
9243 u64STC = ((((MS_U64) u32High) << 32) | u32Low) / 90;
9244 #if 0
9245 MS_U64 u64PCR = 0;
9246 MApi_DMX_Pcr_Eng_Get(u8STCSource, &u32High, &u32Low);
9247 u64PCR = ((((MS_U64) u32High) << 32) | u32Low) / 90;
9248 #endif
9249
9250 MDrv_HVD_EX_DirectSTCMode(u32Id, u64STC);
9251 //VDEC_PRINT("[%d] id=%d, STC=%lld \n", MsOS_GetSystemTime(), u8Idx, u64STC);
9252 MsOS_DelayTask(12);
9253 }
9254
9255 VDEC_PRINT("[%d] end of _Feed_Direct_STC \n", MsOS_GetSystemTime());
9256 }
9257
_VDEC_EX_Create_DirectSTC_Task(MS_U32 u32streamIdx)9258 static MS_BOOL _VDEC_EX_Create_DirectSTC_Task(MS_U32 u32streamIdx) //0x00004040, 0x01014141
9259 {
9260 MS_U8 u8Idx = _VDEC_GET_IDX(u32streamIdx);
9261
9262 VDEC_PRINT("%s \n", __FUNCTION__);
9263
9264 if (s32VdecDirectStcId[u8Idx] == -1)
9265 {
9266 s32VdecDirectStcId[u8Idx] = MsOS_CreateTask((TaskEntry)_Feed_Direct_STC,
9267 u32streamIdx,
9268 E_TASK_PRI_MEDIUM,
9269 TRUE,
9270 (void *)u8VdecDirectSTCStack,
9271 VDEC_EX_STACK_SIZE,
9272 "VdecFeedDirectSTC");
9273 if (s32VdecDirectStcId[u8Idx] < 0)
9274 {
9275 VDEC_PRINT("[%s][%d] MsOS_CreateTask failed!!\n", __FUNCTION__, __LINE__);
9276 return FALSE;
9277 }
9278 }
9279
9280 VDEC_PRINT("create thread VdecFeedDirectSTC, id=%d, pid=%d \033[0m\n", u8Idx, s32VdecDirectStcId[u8Idx]);
9281
9282 return TRUE;
9283 }
9284
_VDEC_EX_Delete_DirectSTC_Task(MS_U32 u32streamIdx)9285 static void _VDEC_EX_Delete_DirectSTC_Task(MS_U32 u32streamIdx)
9286 {
9287 MS_U8 u8Idx = _VDEC_GET_IDX(u32streamIdx);
9288
9289 VDEC_PRINT("%s \n", __FUNCTION__);
9290
9291 pVdecExContext->bDirectStcThreadRunning[u8Idx] = FALSE;
9292 MsOS_DelayTask(24);
9293
9294 if (s32VdecDirectStcId[u8Idx] != -1)
9295 {
9296 //MsOS_DeleteTask(s32VdecDirectStcId[u8Idx]);
9297 VDEC_PRINT("delete thread VdecFeedDirectSTC, id=%d, pid=%d \n", u8Idx, s32VdecDirectStcId[u8Idx]);
9298 s32VdecDirectStcId[u8Idx] = -1;
9299 }
9300
9301 return;
9302 }
9303 #endif
9304
9305
9306
9307 #if 1//#ifdef VDEC_UTOPIA_2K
9308
9309 typedef struct
9310 {
9311 MS_BOOL bRunning;
9312 MS_U8 u8Dbglevl;
9313 VDEC_StreamId StreamId;
9314 MS_U32 u32EventMap[E_VDEC_EX_CB_MAX_NUM];
9315 VDEC_EX_EventCb pfn[E_VDEC_EX_CB_MAX_NUM];
9316 void *param[E_VDEC_EX_CB_MAX_NUM];
9317 }VDEC_EX_2k_CbData;
9318
9319 VDEC_EX_2k_CbData gVDEC_EX_2k_CbData[VDEC_MAX_SUPPORT_STREAM_NUM];
9320
9321
9322
_VDEC_Callback_Proc(MS_U32 u32streamIdx)9323 void _VDEC_Callback_Proc(MS_U32 u32streamIdx)
9324 {
9325 MS_U32 u32VdecEventFlag = 0;
9326 MS_U32 u8Idx = 0;
9327 VDEC_StreamId* pStreamId;
9328 MS_U32 cb_type = 0;
9329 VDEC_EX_V2_IO_Param IO_arg;
9330 memset((void*)(&IO_arg),0,sizeof(VDEC_EX_V2_IO_Param));
9331 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
9332 MS_U32 u32Event = 0;
9333 for(u8Idx=0;u8Idx<VDEC_MAX_SUPPORT_STREAM_NUM;u8Idx++)
9334 {
9335 pStreamId = &(gVDEC_EX_2k_CbData[u8Idx].StreamId);
9336
9337 if(pStreamId->u32Id == u32streamIdx)
9338 break;
9339 }
9340
9341 if(u8Idx >= VDEC_MAX_SUPPORT_STREAM_NUM) //CID 47265
9342 {
9343 VPRINTF("[Fail][%s,%d]Out of bound error\n",__FUNCTION__,__LINE__);
9344 return ;
9345 }
9346
9347 while(gVDEC_EX_2k_CbData[u8Idx].bRunning)
9348 {
9349 MsOS_DelayTaskUs(1000);
9350 if (pu32VDEC_EX_Inst == NULL)
9351 {
9352 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9353 return ;
9354 }
9355 if(gVDEC_EX_2k_CbData[u8Idx].u8Dbglevl == 2)
9356 {
9357 VDEC_PRINT("EventMap:0x%x\n",gVDEC_EX_2k_CbData[u8Idx].u32EventMap[0]);
9358 }
9359 if(gVDEC_EX_2k_CbData[u8Idx].u32EventMap[0]||gVDEC_EX_2k_CbData[u8Idx].u32EventMap[1])
9360 {
9361 u32VdecEventFlag = 0;
9362 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
9363 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_EVENT_FLAG;
9364 IO_arg.param[0] = (void*)(&u32VdecEventFlag);
9365 IO_arg.param[1] = (void*)(&cb_type);
9366 IO_arg.pRet = (void*)(&ret);
9367
9368 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
9369 {
9370 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
9371 }
9372 for(cb_type=0;cb_type<E_VDEC_EX_CB_MAX_NUM;cb_type++)
9373 {
9374 u32Event = u32VdecEventFlag & gVDEC_EX_2k_CbData[u8Idx].u32EventMap[cb_type];
9375 if(gVDEC_EX_2k_CbData[u8Idx].u8Dbglevl == 2)
9376 {
9377 VDEC_PRINT("Find event:0x%x\n",u32Event);
9378 }
9379 if (gVDEC_EX_2k_CbData[u8Idx].pfn[cb_type] && u32Event)
9380 {
9381 gVDEC_EX_2k_CbData[u8Idx].pfn[cb_type](u32Event, gVDEC_EX_2k_CbData[u8Idx].param[cb_type]);
9382 }
9383 }
9384 }
9385 }
9386 }
9387
_VDEC_EX_Create_Callback_task(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,VDEC_EX_EventCb pfn,void * param,MS_U32 u32EventFlag)9388 MS_BOOL _VDEC_EX_Create_Callback_task(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, VDEC_EX_EventCb pfn, void *param, MS_U32 u32EventFlag)
9389 {
9390 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9391
9392 memcpy(&gVDEC_EX_2k_CbData[u8Idx].StreamId,pStreamId,sizeof(VDEC_StreamId));
9393 gVDEC_EX_2k_CbData[u8Idx].param[cb_type] = param;
9394 gVDEC_EX_2k_CbData[u8Idx].pfn[cb_type] = pfn;
9395 gVDEC_EX_2k_CbData[u8Idx].u32EventMap[cb_type] = u32EventFlag;
9396 gVDEC_EX_2k_CbData[u8Idx].bRunning = TRUE;
9397
9398 //char task_name[100] = {0,};
9399 //snVDEC_PRINT(task_name,sizeof(task_name),"VDEC_Callback_Task_%d",u8Idx);
9400
9401 if(_s32VDEC_Callback_TaskId[u8Idx] == -1 )
9402 {
9403 _s32VDEC_Callback_TaskId[u8Idx] = MsOS_CreateTask((TaskEntry)_VDEC_Callback_Proc,
9404 (MS_U32)(pStreamId->u32Id),
9405 E_TASK_PRI_MEDIUM,
9406 TRUE,
9407 (void*)u8VdecExCallbackStack[u8Idx],
9408 VDEC_EX_STACK_SIZE,
9409 cbTaskName[u8Idx]);
9410
9411 if (_s32VDEC_Callback_TaskId[u8Idx] < 0)
9412 {
9413 return FALSE;
9414 }
9415 }
9416 else
9417 {
9418 return FALSE;
9419 }
9420 return TRUE;
9421 }
9422
_VDEC_EX_UnSetEvent(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,MS_U32 u32EventFlag)9423 void _VDEC_EX_UnSetEvent(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, MS_U32 u32EventFlag)
9424 {
9425 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9426 if (E_VDEC_EX_EVENT_OFF != u32EventFlag)
9427 {
9428 gVDEC_EX_2k_CbData[u8Idx].u32EventMap[cb_type] &= ~u32EventFlag ;
9429 }
9430 }
9431
_VDEC_EX_Delete_Callback_Task(VDEC_StreamId * pStreamId)9432 void _VDEC_EX_Delete_Callback_Task(VDEC_StreamId *pStreamId)
9433 {
9434 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9435 int i;
9436 MS_BOOL eRet = FALSE;
9437
9438 for(i=0;i<E_VDEC_EX_CB_MAX_NUM;i++)
9439 {
9440
9441 gVDEC_EX_2k_CbData[u8Idx].u32EventMap[i] = 0;
9442 }
9443
9444 if(_s32VDEC_Callback_TaskId[u8Idx]!=-1)
9445 {
9446 gVDEC_EX_2k_CbData[u8Idx].bRunning = FALSE;
9447 eRet = MsOS_DeleteTask(_s32VDEC_Callback_TaskId[u8Idx]);
9448 if(TRUE == eRet)
9449 {
9450 _s32VDEC_Callback_TaskId[u8Idx] = -1;
9451 }
9452 }
9453 }
9454 #endif
9455
9456
9457
_MApi_VDEC_EX_ReturnCMABuffer(VDEC_StreamId * pStreamId)9458 VDEC_EX_Result _MApi_VDEC_EX_ReturnCMABuffer(VDEC_StreamId *pStreamId)
9459 {
9460 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9461 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9462
9463 #ifdef CMA_DRV_DIRECT_INIT
9464 MS_BOOL bNDecAllocator = _VDEC_EX_NdecAllocator_IsNDecode();//VDEC_EX_ALLOCATOR_ENABLE;
9465
9466 if(bNDecAllocator == FALSE)
9467 {
9468 #if VDEC_DUAL_FRAME_BUFFER_MANAGEMENT
9469 MS_BOOL bReturnCMABuffer = TRUE;
9470 MS_U8 i;
9471 MS_U8 u8StreamCnt = 0;
9472 for (i=0; i<VDEC_MAX_SUPPORT_STREAM_NUM; i++)
9473 {
9474 if (TRUE == pVdecExContext->_Attr[i].bUsed)
9475 {
9476 u8StreamCnt++;
9477 }
9478 }
9479 if (u8StreamCnt > 1)
9480 {
9481 bReturnCMABuffer = FALSE;
9482 }
9483 #endif
9484
9485 #if VDEC_DUAL_FRAME_BUFFER_MANAGEMENT
9486 if (pVdecExContext->bCMAUsed && bReturnCMABuffer)
9487 #else
9488 if (pVdecExContext->bCMAUsed && u8Idx == 0)
9489 #endif
9490 {
9491 if (pVdecExContext->bCMAGetMem[0][u8Idx])
9492 {
9493 if (MApi_CMA_Pool_PutMem(&pVdecExContext->cmaFreeParam[0][u8Idx]) == FALSE)
9494 {
9495 VPRINTF("[VDEC][%d]MApi_CMA_Pool_PutMem0 fail in vdec: cmaFreeParam.pool_handle_id=%x, cmaFreeParam.offset_in_pool=%llx, cmaFreeParam.length=%x\n",
9496 (unsigned int)u8Idx,
9497 (unsigned int)pVdecExContext->cmaFreeParam[0][u8Idx].pool_handle_id,
9498 (unsigned long long int)pVdecExContext->cmaFreeParam[0][u8Idx].offset_in_pool,
9499 (unsigned int)pVdecExContext->cmaFreeParam[0][u8Idx].length);
9500 return E_VDEC_EX_FAIL;
9501 }
9502 else
9503 {
9504 pVdecExContext->bCMAGetMem[0][u8Idx] = FALSE;
9505 VPRINTF("[VDEC][%d]MApi_CMA_Pool_PutMem0 in vdec: cmaFreeParam.pool_handle_id=%x, cmaFreeParam.offset_in_pool=%llx, cmaFreeParam.length=%x\n",
9506 (unsigned int)u8Idx,
9507 (unsigned int)pVdecExContext->cmaFreeParam[0][u8Idx].pool_handle_id,
9508 (unsigned long long int)pVdecExContext->cmaFreeParam[0][u8Idx].offset_in_pool,
9509 (unsigned int)pVdecExContext->cmaFreeParam[0][u8Idx].length);
9510 }
9511 }
9512
9513 if (pVdecExContext->bCMAGetMem[1][u8Idx])
9514 {
9515 if (MApi_CMA_Pool_PutMem(&pVdecExContext->cmaFreeParam[1][u8Idx]) == FALSE)
9516 {
9517 VPRINTF("[VDEC][%d]MApi_CMA_Pool_PutMem1 fail in vdec: cmaFreeParam.pool_handle_id=%x, cmaFreeParam.offset_in_pool=%llx, cmaFreeParam.length=%x\n",
9518 (unsigned int)u8Idx,
9519 (unsigned int)pVdecExContext->cmaFreeParam[0][u8Idx].pool_handle_id,
9520 (unsigned long long int)pVdecExContext->cmaFreeParam[0][u8Idx].offset_in_pool,
9521 (unsigned int)pVdecExContext->cmaFreeParam[0][u8Idx].length);
9522 return E_VDEC_EX_FAIL;
9523 }
9524 else
9525 {
9526 pVdecExContext->bCMAGetMem[1][u8Idx] = FALSE;
9527 VPRINTF("[VDEC][%d]MApi_CMA_Pool_PutMem1 in vdec: cmaFreeParam.pool_handle_id=%x, cmaFreeParam.offset_in_pool=%llx, cmaFreeParam.length=%x\n",
9528 (unsigned int)u8Idx,
9529 (unsigned int)pVdecExContext->cmaFreeParam[1][u8Idx].pool_handle_id,
9530 (unsigned long long int)pVdecExContext->cmaFreeParam[1][u8Idx].offset_in_pool,
9531 (unsigned int)pVdecExContext->cmaFreeParam[1][u8Idx].length);
9532 }
9533 }
9534 }
9535 }
9536 else
9537 #endif
9538 {
9539 _VDEC_EX_NdecAllocator_FreeBuffer(u8Idx, E_VDEC_EX_ALLOCATOR_BUFFER_FB1);
9540 _VDEC_EX_NdecAllocator_FreeBuffer(u8Idx, E_VDEC_EX_ALLOCATOR_BUFFER_FB2);
9541 _VDEC_EX_NdecAllocator_FreeBuffer(u8Idx, E_VDEC_EX_ALLOCATOR_BUFFER_BS);
9542 }
9543
9544 return eRet;
9545 }
9546
_VDEC_EX_GetFbMemUsageSize(VDEC_EX_FbMemUsage_Param * pParam)9547 static VDEC_EX_Result _VDEC_EX_GetFbMemUsageSize(VDEC_EX_FbMemUsage_Param *pParam)
9548 {
9549 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
9550
9551 switch (_VDEC_EX_GetDecoderByCodecType(pParam->eCodecType))
9552 {
9553 case E_VDEC_EX_DECODER_HVD:
9554 {
9555 HVD_EX_FbMemUsage_Param info;
9556
9557 _VDEC_Memset(&info, 0, sizeof(HVD_EX_FbMemUsage_Param));
9558
9559 info.eCodecType = _VDEC_EX_Map2HVDCodecType(pParam->eCodecType);
9560 info.u32DataVAddr = MS_PA2KSEG1(pParam->u32DataAddr);
9561 info.u16DataSize = pParam->u16DataSize;
9562
9563 if(MDrv_HVD_EX_GetFbMemUsageSize(&info) == E_HVD_EX_OK)
9564 {
9565 pParam->u32MemUsageSize = info.u32MemUsageSize;
9566 eRet = E_VDEC_EX_OK;
9567 }
9568 }
9569 break;
9570
9571 default:
9572 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9573 break;
9574 }
9575 return eRet;
9576 }
9577
_MApi_VDEC_EX_V2_Exit(VDEC_StreamId * pStreamId)9578 VDEC_EX_Result _MApi_VDEC_EX_V2_Exit(VDEC_StreamId *pStreamId)
9579 {
9580 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9581 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9582 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9583
9584 #if (VDEC_EX_ISR_MONITOR)
9585 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
9586 MsOS_SetEvent(s32VdecExEventId[u8Idx], E_VDEC_EX_EVENT_ISR_EVENT_CHANGE);
9587 #else
9588 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = 0;
9589 #endif
9590
9591 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9592 {
9593 case E_VDEC_EX_DECODER_MVD:
9594 {
9595 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_Exit(u32Id));
9596 if(eRet == E_VDEC_EX_OK)
9597 {
9598 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
9599 }
9600 break;
9601 }
9602 case E_VDEC_EX_DECODER_HVD:
9603 {
9604 _VDEC_EX_Delete_BBU_Task(pStreamId->u32Id);
9605 #if VDEC_DTV_DIRECT_STC_PATCH
9606 _VDEC_EX_Delete_DirectSTC_Task(pStreamId->u32Id);
9607 #endif
9608 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_Exit(u32Id));
9609 break;
9610 }
9611 case E_VDEC_EX_DECODER_MJPEG:
9612 {
9613 _VDEC_EX_API_MutexLock();
9614 MDrv_HVD_EX_SetBurstMode(u32Id, FALSE);
9615 MDrv_HVD_EX_MJPEG_Exit(u32Id);
9616 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_Stop(u32Id));
9617 if(eRet == E_VDEC_EX_OK)
9618 {
9619 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
9620 }
9621 _VDEC_EX_API_MutexUnlock();
9622 break;
9623 }
9624 default:
9625 break;
9626 }
9627
9628 _VDEC_EX_API_MutexLock();
9629
9630 if(pVdecExContext->_power_state[u8Idx] != E_VDEC_EX_POWER_SUSPEND_ING)
9631 {
9632 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
9633 }
9634
9635 //When Exit, we need to re-init attributes of stream info
9636 _VDEC_EX_InitLocalVar(u8Idx);
9637
9638 _VDEC_Memset((void*) &pVdecExContext->_Pre_Ctrl[u8Idx], 0, sizeof(VDEC_Pre_Ctrl));
9639
9640 pVdecExContext->_Attr[u8Idx].bUsed = FALSE;
9641 pVdecExContext->bTrickMode[u8Idx] = FALSE;
9642
9643 MS_U8 i;
9644 for (i=0; i<VDEC_MAX_SUPPORT_STREAM_NUM; i++)
9645 {
9646 if (TRUE == pVdecExContext->_Attr[i].bUsed) break;
9647 }
9648 if (i == VDEC_MAX_SUPPORT_STREAM_NUM)
9649 {
9650 _VDEC_Memset((void*) &pVdecExContext->_Pre_DecModeCfg, 0, sizeof(VDEC_EX_DecModCfg));
9651
9652 pVdecExContext->bFWdecideFB = FALSE;
9653 pVdecExContext->bDRVdecideBS = FALSE;
9654 }
9655
9656 pVdecExContext->_Attr[u8Idx].u32DrvId = 0;
9657 pVdecExContext->bEnableAutoInsertDummyPattern[u8Idx] = FALSE;
9658 #ifdef VDEC3
9659 pVdecExContext->u32FrameBaseMode[u8Idx] = FALSE;
9660 #endif
9661 pVdecExContext->bDirectStcThreadRunning[u8Idx] = FALSE;
9662
9663 pVdecExContext->_bSingleDecodeMode = FALSE;
9664 _VDEC_EX_API_MutexUnlock();
9665
9666 return eRet;
9667 }
9668
_MApi_VDEC_EX_V2_Rst(VDEC_StreamId * pStreamId)9669 VDEC_EX_Result _MApi_VDEC_EX_V2_Rst(VDEC_StreamId *pStreamId)
9670 {
9671 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9672 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9673
9674 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9675 {
9676 case E_VDEC_EX_DECODER_MVD:
9677 {
9678 if(MDrv_MVD_Rst(u32Id,_VDEC_EX_Map2MVDCodecType(pVdecExContext->_Attr[u8Idx].eCodecType)) != E_MVD_RET_OK)
9679 {
9680 return E_VDEC_EX_FAIL;
9681 }
9682
9683 break;
9684 }
9685 case E_VDEC_EX_DECODER_HVD:
9686 {
9687 if(MDrv_HVD_EX_Rst(u32Id, FALSE) != E_HVD_EX_OK)
9688 {
9689 return E_VDEC_EX_FAIL;
9690 }
9691
9692 break;
9693 }
9694 case E_VDEC_EX_DECODER_MJPEG:
9695 {
9696 _VDEC_EX_API_MutexLock();
9697
9698 if(MApi_MJPEG_Rst(u32Id) != E_MJPEG_RET_SUCCESS)
9699 {
9700 _VDEC_EX_API_MutexUnlock();
9701 return E_VDEC_EX_FAIL;
9702 }
9703 _VDEC_EX_API_MutexUnlock();
9704 break;
9705 }
9706 default:
9707 break;
9708 }
9709
9710 return E_VDEC_EX_OK;
9711 }
9712
9713
_MApi_VDEC_EX_V2_CheckDispInfoRdy(VDEC_StreamId * pStreamId)9714 VDEC_EX_Result _MApi_VDEC_EX_V2_CheckDispInfoRdy(VDEC_StreamId *pStreamId)
9715 {
9716 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9717 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9718 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9719
9720 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9721 {
9722 case E_VDEC_EX_DECODER_MVD:
9723 if (0 == MDrv_MVD_GetDispRdy(u32Id))
9724 {
9725 eRet = E_VDEC_EX_RET_NOT_READY;
9726 }
9727 break;
9728
9729 case E_VDEC_EX_DECODER_HVD:
9730 {
9731 HVD_EX_Result ret = MDrv_HVD_EX_CheckDispInfoRdy(u32Id);
9732
9733 if (E_HVD_EX_OK != ret)
9734 {
9735 if (E_HVD_EX_RET_NOTREADY == ret)
9736 {
9737 eRet = E_VDEC_EX_RET_NOT_READY;
9738 }
9739 else if( ret == E_HVD_EX_RET_UNSUPPORTED)
9740 {
9741 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9742 }
9743 else
9744 {
9745 eRet = E_VDEC_EX_FAIL;
9746 }
9747 }
9748
9749 break;
9750 }
9751 case E_VDEC_EX_DECODER_MJPEG:
9752 {
9753 _VDEC_EX_API_MutexLock();
9754 if (E_MJPEG_RET_SUCCESS != MApi_MJPEG_CheckDispInfoRdy(u32Id))
9755 {
9756 eRet = E_VDEC_EX_FAIL;
9757 }
9758 _VDEC_EX_API_MutexUnlock();
9759
9760 break;
9761 }
9762 default:
9763 break;
9764 }
9765
9766 return eRet;
9767 }
9768
_MApi_VDEC_EX_V2_SetFrcMode(VDEC_StreamId * pStreamId,VDEC_EX_FrcMode eFrcMode)9769 VDEC_EX_Result _MApi_VDEC_EX_V2_SetFrcMode(VDEC_StreamId *pStreamId, VDEC_EX_FrcMode eFrcMode)
9770 {
9771 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9772 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9773 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9774
9775 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9776 {
9777 case E_VDEC_EX_DECODER_MVD:
9778 {
9779 MVD_FrcMode eMvdFrcMode = E_MVD_FRC_NORMAL;
9780
9781 switch(eFrcMode)
9782 {
9783 case E_VDEC_EX_FRC_NORMAL:
9784 eMvdFrcMode = E_MVD_FRC_NORMAL;
9785 break;
9786 case E_VDEC_EX_FRC_DISP_TWICE:
9787 eMvdFrcMode = E_MVD_FRC_DISP_TWICE;
9788 break;
9789 case E_VDEC_EX_FRC_3_2_PULLDOWN:
9790 eMvdFrcMode = E_MVD_FRC_3_2_PULLDOWN;
9791 break;
9792 case E_VDEC_EX_FRC_PAL_TO_NTSC:
9793 eMvdFrcMode = E_MVD_FRC_PAL_TO_NTSC;
9794 break;
9795 case E_VDEC_EX_FRC_NTSC_TO_PAL:
9796 eMvdFrcMode = E_MVD_FRC_NTSC_TO_PAL;
9797 break;
9798 default:
9799 eRet = E_VDEC_EX_RET_INVALID_PARAM;
9800 break;
9801 }
9802
9803 if(E_VDEC_EX_RET_INVALID_PARAM != eRet)
9804 {
9805 eRet = MDrv_MVD_DispCtrl(u32Id, FALSE, pVdecExContext->bDropErrFrm[u8Idx], FALSE, eMvdFrcMode);
9806 }
9807 break;
9808 }
9809 case E_VDEC_EX_DECODER_HVD:
9810 {
9811 HVD_EX_FrmRateConvMode eHvdFrcMode = E_HVD_EX_FRC_MODE_NORMAL;
9812
9813 switch(eFrcMode)
9814 {
9815 case E_VDEC_EX_FRC_NORMAL:
9816 eHvdFrcMode = E_HVD_EX_FRC_MODE_NORMAL;
9817 break;
9818 case E_VDEC_EX_FRC_DISP_TWICE:
9819 eHvdFrcMode = E_HVD_EX_FRC_MODE_DISP_2X;
9820 break;
9821 case E_VDEC_EX_FRC_3_2_PULLDOWN:
9822 eHvdFrcMode = E_HVD_EX_FRC_MODE_32PULLDOWN;
9823 break;
9824 case E_VDEC_EX_FRC_PAL_TO_NTSC:
9825 eHvdFrcMode = E_HVD_EX_FRC_MODE_PAL2NTSC;
9826 break;
9827 case E_VDEC_EX_FRC_NTSC_TO_PAL:
9828 eHvdFrcMode = E_HVD_EX_FRC_MODE_NTSC2PAL;
9829 break;
9830 case E_VDEC_EX_FRC_MODE_50P_60P:
9831 eHvdFrcMode = E_HVD_EX_FRC_MODE_50P_60P;
9832 break;
9833 case E_VDEC_EX_FRC_MODE_60P_50P:
9834 eHvdFrcMode = E_HVD_EX_FRC_MODE_60P_50P;
9835 break;
9836 default:
9837 eRet = E_VDEC_EX_RET_INVALID_PARAM;
9838 break;
9839 }
9840
9841 if(E_VDEC_EX_RET_INVALID_PARAM != eRet)
9842 {
9843 eRet = MDrv_HVD_EX_SetFrcMode(u32Id, eHvdFrcMode);
9844 }
9845 break;
9846 }
9847 case E_VDEC_EX_DECODER_MJPEG:
9848 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9849 break;
9850 default:
9851 eRet = E_VDEC_EX_RET_INVALID_PARAM;
9852 break;
9853 }
9854
9855 return eRet;
9856 }
9857
_MApi_VDEC_EX_V2_SetDynScalingParams(VDEC_StreamId * pStreamId,MS_PHY u32Addr,MS_U32 u32Size)9858 VDEC_EX_Result _MApi_VDEC_EX_V2_SetDynScalingParams(VDEC_StreamId *pStreamId, MS_PHY u32Addr, MS_U32 u32Size)
9859 {
9860 VDEC_EX_Result eRet = E_VDEC_EX_RET_NOT_INIT;
9861 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9862 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9863
9864 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9865 {
9866 case E_VDEC_EX_DECODER_MVD:
9867 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_SetDynScalingParam(u32Id, u32Addr, u32Size));
9868 break;
9869
9870 case E_VDEC_EX_DECODER_HVD:
9871 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetDynScalingParam(u32Id, (void*)MS_PA2KSEG1(u32Addr),u32Size));
9872 break;
9873
9874 case E_VDEC_EX_DECODER_MJPEG:
9875 eRet = E_VDEC_EX_OK;
9876 break;
9877
9878 default:
9879 eRet = E_VDEC_EX_RET_UNSUPPORTED;
9880 break;
9881 }
9882 return eRet;
9883 }
9884
_MApi_VDEC_EX_V2_Play(VDEC_StreamId * pStreamId)9885 VDEC_EX_Result _MApi_VDEC_EX_V2_Play(VDEC_StreamId *pStreamId)
9886 {
9887 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9888 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9889 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9890
9891 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9892 {
9893 case E_VDEC_EX_DECODER_MVD:
9894 {
9895 MDrv_MVD_Play(u32Id);
9896 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_PLAY;
9897 eRet = E_VDEC_EX_OK;
9898 break;
9899 }
9900 case E_VDEC_EX_DECODER_HVD:
9901 {
9902 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_Play(u32Id));
9903 break;
9904 }
9905 case E_VDEC_EX_DECODER_MJPEG:
9906 {
9907 _VDEC_EX_API_MutexLock();
9908 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_Play(u32Id));
9909 if(eRet == E_VDEC_EX_OK)
9910 {
9911 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_PLAY;
9912 }
9913 else
9914 {
9915 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
9916 }
9917 _VDEC_EX_API_MutexUnlock();
9918 break;
9919 }
9920 default:
9921 break;
9922 }
9923
9924 pVdecExContext->u8enable_store_set_cmd[u8Idx] = FALSE;
9925
9926 return eRet;
9927 }
9928
_MApi_VDEC_EX_V2_Pause(VDEC_StreamId * pStreamId)9929 VDEC_EX_Result _MApi_VDEC_EX_V2_Pause(VDEC_StreamId *pStreamId)
9930 {
9931 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9932 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9933 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9934
9935 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9936 {
9937 case E_VDEC_EX_DECODER_MVD:
9938 {
9939 MDrv_MVD_Pause(u32Id);
9940 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_PAUSE;
9941 eRet = E_VDEC_EX_OK;
9942 break;
9943 }
9944 case E_VDEC_EX_DECODER_HVD:
9945 {
9946 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_Pause(u32Id));
9947 break;
9948 }
9949 case E_VDEC_EX_DECODER_MJPEG:
9950 {
9951 _VDEC_EX_API_MutexLock();
9952 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_Pause(u32Id));
9953 if(eRet == E_VDEC_EX_OK)
9954 {
9955 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_PAUSE;
9956 }
9957 _VDEC_EX_API_MutexUnlock();
9958 break;
9959 }
9960 default:
9961 break;
9962 }
9963
9964 return eRet;
9965 }
9966
_MApi_VDEC_EX_V2_Resume(VDEC_StreamId * pStreamId)9967 VDEC_EX_Result _MApi_VDEC_EX_V2_Resume(VDEC_StreamId *pStreamId)
9968 {
9969 VDEC_EX_Result eRet = E_VDEC_EX_OK;
9970 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
9971 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
9972
9973 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
9974 {
9975 case E_VDEC_EX_DECODER_MVD:
9976 {
9977 MDrv_MVD_Resume(u32Id);
9978 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_PLAY;
9979 eRet = E_VDEC_EX_OK;
9980 break;
9981 }
9982 case E_VDEC_EX_DECODER_HVD:
9983 {
9984 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_Play(u32Id));
9985 break;
9986 }
9987 case E_VDEC_EX_DECODER_MJPEG:
9988 {
9989 _VDEC_EX_API_MutexLock();
9990 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_Resume(u32Id));
9991 if(eRet == E_VDEC_EX_OK)
9992 {
9993 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_PLAY;
9994 }
9995 _VDEC_EX_API_MutexUnlock();
9996 break;
9997 }
9998 default:
9999 break;
10000 }
10001
10002 return eRet;
10003 }
10004
_MApi_VDEC_EX_V2_StepDisp(VDEC_StreamId * pStreamId)10005 VDEC_EX_Result _MApi_VDEC_EX_V2_StepDisp(VDEC_StreamId *pStreamId)
10006 {
10007 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10008 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10009 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10010
10011 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10012 {
10013 case E_VDEC_EX_DECODER_MVD:
10014 {
10015 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_StepDisp(u32Id));
10016 break;
10017 }
10018 case E_VDEC_EX_DECODER_HVD:
10019 {
10020 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_StepDisp(u32Id));
10021 break;
10022 }
10023 case E_VDEC_EX_DECODER_MJPEG:
10024 {
10025 _VDEC_EX_API_MutexLock();
10026 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_StepPlay(u32Id));
10027 _VDEC_EX_API_MutexUnlock();
10028 break;
10029 }
10030 default:
10031 break;
10032 }
10033
10034 return eRet;
10035 }
10036
_MApi_VDEC_EX_V2_StepDecode(VDEC_StreamId * pStreamId)10037 VDEC_EX_Result _MApi_VDEC_EX_V2_StepDecode(VDEC_StreamId *pStreamId)
10038 {
10039 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10040 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10041 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10042
10043 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10044 {
10045 case E_VDEC_EX_DECODER_MVD:
10046 {
10047 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_StepDecode(u32Id));
10048 break;
10049 }
10050 case E_VDEC_EX_DECODER_HVD:
10051 {
10052 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_StepDecode(u32Id));
10053 break;
10054 }
10055 case E_VDEC_EX_DECODER_MJPEG:
10056 {
10057 _VDEC_EX_API_MutexLock();
10058 // Now we always return success
10059 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_StepDecode(u32Id));
10060 _VDEC_EX_API_MutexUnlock();
10061 break;
10062 }
10063 default:
10064 eRet = E_VDEC_EX_RET_UNSUPPORTED;
10065 break;
10066 }
10067
10068 pVdecExContext->u8enable_store_set_cmd[u8Idx] = FALSE;
10069
10070 return eRet;
10071 }
10072
_MApi_VDEC_EX_V2_SetTrickMode(VDEC_StreamId * pStreamId,VDEC_EX_TrickDec eTrickDec)10073 VDEC_EX_Result _MApi_VDEC_EX_V2_SetTrickMode(VDEC_StreamId *pStreamId, VDEC_EX_TrickDec eTrickDec)
10074 {
10075 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10076 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10077 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10078
10079 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10080 {
10081 case E_VDEC_EX_DECODER_MVD:
10082 {
10083 if (E_VDEC_EX_TRICK_DEC_ALL == eTrickDec)
10084 {
10085 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_TrickPlay(u32Id, E_MVD_TRICK_DEC_ALL, 1));
10086 }
10087 else if (E_VDEC_EX_TRICK_DEC_IP == eTrickDec)
10088 {
10089 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_TrickPlay(u32Id, E_MVD_TRICK_DEC_IP, 1));
10090 }
10091 else if (E_VDEC_EX_TRICK_DEC_I == eTrickDec)
10092 {
10093 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_TrickPlay(u32Id, E_MVD_TRICK_DEC_I, 1));
10094 }
10095 else
10096 {
10097 eRet = E_VDEC_EX_RET_INVALID_PARAM;
10098 }
10099
10100 break;
10101 }
10102 case E_VDEC_EX_DECODER_HVD:
10103 {
10104 if (E_VDEC_EX_TRICK_DEC_ALL == eTrickDec)
10105 {
10106 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSkipDecMode(u32Id, E_HVD_EX_SKIP_DECODE_ALL));
10107 }
10108 else if (E_VDEC_EX_TRICK_DEC_IP == eTrickDec)
10109 {
10110 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSkipDecMode(u32Id, E_HVD_EX_SKIP_DECODE_IP));
10111 }
10112 else if (E_VDEC_EX_TRICK_DEC_I == eTrickDec)
10113 {
10114 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSkipDecMode(u32Id, E_HVD_EX_SKIP_DECODE_I));
10115 }
10116 else
10117 {
10118 eRet = E_VDEC_EX_RET_INVALID_PARAM;
10119 }
10120
10121 break;
10122 }
10123 case E_VDEC_EX_DECODER_MJPEG:
10124 default:
10125 eRet = E_VDEC_EX_RET_UNSUPPORTED;
10126 break;
10127 }
10128
10129 return eRet;
10130 }
10131
_MApi_VDEC_EX_V2_PushDecQ(VDEC_StreamId * pStreamId,VDEC_EX_DecCmd * pCmd)10132 VDEC_EX_Result _MApi_VDEC_EX_V2_PushDecQ(VDEC_StreamId *pStreamId, VDEC_EX_DecCmd *pCmd)
10133 {
10134 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10135 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10136 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10137
10138 if (pVdecExContext->_bEsBufMgmt[u8Idx])
10139 {
10140 //minus bsStartAdd automatically since GetESBuff returns PA but PushDecQ use offset
10141 pCmd->u32StAddr = pCmd->u32StAddr - pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufAddr;
10142 }
10143
10144 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10145 {
10146 case E_VDEC_EX_DECODER_MVD:
10147 {
10148 MVD_PacketInfo stMvdPktInfo;
10149
10150 _VDEC_Memset(&stMvdPktInfo, 0, sizeof(MVD_PacketInfo));
10151
10152 stMvdPktInfo.u32StAddr = pCmd->u32StAddr;
10153 stMvdPktInfo.u32Length = pCmd->u32Size;
10154 stMvdPktInfo.u32TimeStamp = pCmd->u32Timestamp;
10155 stMvdPktInfo.u32ID_H = pCmd->u32ID_H;
10156 stMvdPktInfo.u32ID_L = pCmd->u32ID_L;
10157
10158 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_PushQueue(u32Id, &stMvdPktInfo));
10159
10160 break;
10161 }
10162 case E_VDEC_EX_DECODER_HVD:
10163 { // File mode
10164 HVD_EX_PacketInfo packetInfo;
10165
10166 _VDEC_Memset(&packetInfo, 0, sizeof(HVD_EX_PacketInfo));
10167
10168 packetInfo.u32Staddr = pCmd->u32StAddr;
10169 packetInfo.u32Length = pCmd->u32Size;
10170 packetInfo.u32TimeStamp = pCmd->u32Timestamp;
10171 packetInfo.u32ID_H = pCmd->u32ID_H;
10172 packetInfo.u32ID_L = pCmd->u32ID_L;
10173
10174 #ifndef VDEC3
10175 if (pVdecExContext->_bEsBufMgmt[u8Idx])
10176 {
10177 packetInfo.u32AllocLength = packetInfo.u32Length;// + ES_SAFE_SIZE;
10178 }
10179 else
10180 {
10181 packetInfo.u32AllocLength = packetInfo.u32Length;
10182 }
10183
10184 if (E_VDEC_EX_CODEC_TYPE_VP8 == pVdecExContext->_Attr[u8Idx].eCodecType)
10185 {
10186 _VDEC_EX_ReparseVP8Packet(u8Idx, &packetInfo);
10187 }
10188 #endif
10189 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_PushQueue(u32Id, &packetInfo));
10190
10191 break;
10192 }
10193 case E_VDEC_EX_DECODER_MJPEG:
10194 {
10195 _VDEC_EX_API_MutexLock();
10196 MJPEG_Packet_Info packetInfo;
10197
10198 _VDEC_Memset(&packetInfo, 0, sizeof(MJPEG_Packet_Info));
10199
10200 packetInfo.u32StAddr = pCmd->u32StAddr;
10201 packetInfo.u32Size = pCmd->u32Size;
10202 packetInfo.u32TimeStamp = pCmd->u32Timestamp;
10203 packetInfo.u32ID_H = pCmd->u32ID_H;
10204 packetInfo.u32ID_L = pCmd->u32ID_L;
10205
10206 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_PushQueue(u32Id, &packetInfo));
10207 _VDEC_EX_API_MutexUnlock();
10208
10209 break;
10210 }
10211 default:
10212 break;
10213 }
10214
10215 return eRet;
10216 }
10217
_MApi_VDEC_EX_V2_Flush(VDEC_StreamId * pStreamId,VDEC_EX_FreezePicSelect eFreezePic)10218 VDEC_EX_Result _MApi_VDEC_EX_V2_Flush(VDEC_StreamId *pStreamId, VDEC_EX_FreezePicSelect eFreezePic)
10219 {
10220 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10221 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10222 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10223
10224 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10225 {
10226 case E_VDEC_EX_DECODER_MVD:
10227 {
10228 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_FlushQueue(u32Id));
10229 break;
10230 }
10231 case E_VDEC_EX_DECODER_HVD:
10232 {
10233 if (eFreezePic == E_VDEC_EX_FREEZE_AT_LAST_PIC)
10234 {
10235 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_Flush(u32Id, TRUE));
10236 }
10237 else
10238 {
10239 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_Flush(u32Id, FALSE));
10240 }
10241 break;
10242 }
10243 case E_VDEC_EX_DECODER_MJPEG:
10244 {
10245 _VDEC_EX_API_MutexLock();
10246 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_FlushQueue(u32Id));
10247 _VDEC_EX_API_MutexUnlock();
10248 break;
10249 }
10250 default:
10251 break;
10252 }
10253
10254 pVdecExContext->bFlush[u8Idx] = TRUE;
10255
10256 return eRet;
10257 }
10258
10259
_MApi_VDEC_EX_V2_EnableLastFrameShow(VDEC_StreamId * pStreamId,MS_BOOL bEnable)10260 VDEC_EX_Result _MApi_VDEC_EX_V2_EnableLastFrameShow(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
10261 {
10262 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10263 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10264 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10265
10266 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10267 {
10268 case E_VDEC_EX_DECODER_MVD:
10269 {
10270 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_EnableLastFrameShow(u32Id, bEnable));
10271 break;
10272 }
10273 case E_VDEC_EX_DECODER_HVD:
10274 {
10275 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetDataEnd(u32Id, bEnable));
10276 break;
10277 }
10278 case E_VDEC_EX_DECODER_MJPEG:
10279 {
10280 _VDEC_EX_API_MutexLock();
10281 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_EnableLastFrameShow(u32Id, bEnable));
10282 _VDEC_EX_API_MutexUnlock();
10283 break;
10284 }
10285 default:
10286 break;
10287 }
10288
10289 return eRet;
10290 }
10291
10292
_MApi_VDEC_EX_V2_SetSpeed(VDEC_StreamId * pStreamId,VDEC_EX_SpeedType eSpeedType,VDEC_EX_DispSpeed eSpeed)10293 VDEC_EX_Result _MApi_VDEC_EX_V2_SetSpeed(VDEC_StreamId *pStreamId, VDEC_EX_SpeedType eSpeedType, VDEC_EX_DispSpeed eSpeed)
10294 {
10295 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10296 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10297 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10298
10299 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10300 {
10301 case E_VDEC_EX_DECODER_MVD:
10302 {
10303 MS_U8 u8MvdSpeed = _VDEC_EX_Map2MVDSpeed(eSpeed);
10304
10305 if (u8MvdSpeed == 0)
10306 {
10307 return E_VDEC_EX_RET_INVALID_PARAM;
10308 }
10309
10310 if (E_VDEC_EX_SPEED_FAST == eSpeedType)
10311 {
10312 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_SetSpeed(u32Id, E_MVD_SPEED_FAST, u8MvdSpeed));
10313 if(eRet == E_VDEC_EX_OK)
10314 {
10315 pVdecExContext->bTrickMode[u8Idx] = TRUE;
10316 }
10317 }
10318 else if (E_VDEC_EX_SPEED_SLOW == eSpeedType)
10319 {
10320 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_SetSpeed(u32Id, E_MVD_SPEED_SLOW, u8MvdSpeed));
10321 if(eRet == E_VDEC_EX_OK)
10322 {
10323 pVdecExContext->bTrickMode[u8Idx] = TRUE;
10324 }
10325 }
10326 else
10327 {
10328 //MS_ASSERT(u8MvdSpeed == 1);
10329 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_SetSpeed(u32Id, E_MVD_SPEED_DEFAULT, 1));
10330 if(eRet == E_VDEC_EX_OK)
10331 {
10332 pVdecExContext->bTrickMode[u8Idx] = FALSE;
10333 }
10334 }
10335
10336 break;
10337 }
10338 case E_VDEC_EX_DECODER_HVD:
10339 {
10340 HVD_EX_DispSpeed eHvdDispSpeed = E_HVD_EX_DISP_SPEED_NORMAL_1X;
10341 if (E_VDEC_EX_SPEED_FAST == eSpeedType)
10342 {
10343 switch (eSpeed)
10344 {
10345 case E_VDEC_EX_DISP_SPEED_32X:
10346 {
10347 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_FF_32X;
10348 break;
10349 }
10350 case E_VDEC_EX_DISP_SPEED_16X:
10351 {
10352 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_FF_16X;
10353 break;
10354 }
10355 case E_VDEC_EX_DISP_SPEED_8X:
10356 {
10357 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_FF_8X;
10358 break;
10359 }
10360 case E_VDEC_EX_DISP_SPEED_4X:
10361 {
10362 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_FF_4X;
10363 break;
10364 }
10365 case E_VDEC_EX_DISP_SPEED_2X:
10366 {
10367 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_FF_2X;
10368 break;
10369 }
10370 case E_VDEC_EX_DISP_SPEED_1X:
10371 {
10372 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_NORMAL_1X;
10373 break;
10374 }
10375 default:
10376 return E_VDEC_EX_FAIL;
10377
10378 break;
10379 }
10380
10381 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetDispSpeed(u32Id, eHvdDispSpeed));
10382 }
10383 else if (E_VDEC_EX_SPEED_SLOW == eSpeedType)
10384 {
10385 switch (eSpeed)
10386 {
10387 case E_VDEC_EX_DISP_SPEED_32X:
10388 {
10389 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_SF_32X;
10390 break;
10391 }
10392 case E_VDEC_EX_DISP_SPEED_16X:
10393 {
10394 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_SF_16X;
10395 break;
10396 }
10397 case E_VDEC_EX_DISP_SPEED_8X:
10398 {
10399 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_SF_8X;
10400 break;
10401 }
10402 case E_VDEC_EX_DISP_SPEED_4X:
10403 {
10404 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_SF_4X;
10405 break;
10406 }
10407 case E_VDEC_EX_DISP_SPEED_2X:
10408 {
10409 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_SF_2X;
10410 break;
10411 }
10412 case E_VDEC_EX_DISP_SPEED_1X:
10413 {
10414 eHvdDispSpeed = E_HVD_EX_DISP_SPEED_NORMAL_1X;
10415 break;
10416 }
10417 default:
10418 return E_VDEC_EX_FAIL;
10419
10420 break;
10421
10422 }
10423
10424 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetDispSpeed(u32Id, eHvdDispSpeed));
10425 }
10426 else
10427 {
10428 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetDispSpeed(u32Id, E_HVD_EX_DISP_SPEED_NORMAL_1X));
10429 }
10430
10431 break;
10432 }
10433 case E_VDEC_EX_DECODER_MJPEG:
10434 {
10435 _VDEC_EX_API_MutexLock();
10436 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_SetSpeed(u32Id, (MJPEG_SpeedType) eSpeedType, (MJPEG_DispSpeed) eSpeed));
10437 _VDEC_EX_API_MutexUnlock();
10438 break;
10439 }
10440 default:
10441 break;
10442 }
10443
10444 return eRet;
10445 }
10446
_MApi_VDEC_EX_V2_SetFrmBuffAddr(VDEC_StreamId * pStreamId,MS_PHY u32FrmBuffAddr)10447 VDEC_EX_Result _MApi_VDEC_EX_V2_SetFrmBuffAddr(VDEC_StreamId *pStreamId, MS_PHY u32FrmBuffAddr)
10448 {
10449 #ifdef VDEC3_FB
10450 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10451 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10452 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10453
10454 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10455 {
10456 case E_VDEC_EX_DECODER_MVD:
10457 {
10458 // TO DO
10459 break;
10460 }
10461 case E_VDEC_EX_DECODER_HVD:
10462 {
10463 //if( (u32Id >> 24) == E_VDEC_EX_MAIN_STREAM)
10464 {
10465 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetFrmBuffAddr(u32Id, u32FrmBuffAddr));
10466 }
10467 //else
10468 //{
10469 // eRet = E_VDEC_EX_FAIL;
10470 //}
10471 break;
10472 }
10473 case E_VDEC_EX_DECODER_MJPEG:
10474 {
10475 // TO DO
10476 break;
10477 }
10478 default:
10479 break;
10480 }
10481 return eRet;
10482 #else
10483 return E_VDEC_EX_FAIL;
10484 #endif
10485 }
10486
_MApi_VDEC_EX_V2_SetFrmBuffSize(VDEC_StreamId * pStreamId,MS_U32 u32FrmBuffSize)10487 VDEC_EX_Result _MApi_VDEC_EX_V2_SetFrmBuffSize(VDEC_StreamId *pStreamId, MS_U32 u32FrmBuffSize)
10488 {
10489 #ifdef VDEC3_FB
10490 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10491 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10492 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10493
10494 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10495 {
10496 case E_VDEC_EX_DECODER_MVD:
10497 {
10498 // TO DO
10499 break;
10500 }
10501 case E_VDEC_EX_DECODER_HVD:
10502 {
10503 //if((u32Id >> 24) == E_VDEC_EX_MAIN_STREAM)
10504 {
10505 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetFrmBuffSize(u32Id, u32FrmBuffSize));
10506
10507 }
10508 //else{
10509 // eRet = E_VDEC_EX_FAIL;
10510 //}
10511 break;
10512 }
10513 case E_VDEC_EX_DECODER_MJPEG:
10514 {
10515 // TO DO
10516 break;
10517 }
10518 default:
10519 break;
10520 }
10521 return eRet;
10522 #else
10523 return E_VDEC_EX_FAIL;
10524 #endif
10525 }
10526
_MApi_VDEC_EX_V2_SetFreezeDisp(VDEC_StreamId * pStreamId,MS_BOOL bEnable)10527 VDEC_EX_Result _MApi_VDEC_EX_V2_SetFreezeDisp(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
10528 {
10529 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10530 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10531 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10532
10533 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10534 {
10535 case E_VDEC_EX_DECODER_MVD:
10536 {
10537 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_SetFreezeDisp(u32Id, bEnable));
10538 break;
10539 }
10540 case E_VDEC_EX_DECODER_HVD:
10541 {
10542 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetFreezeImg(u32Id, bEnable));
10543 break;
10544 }
10545 case E_VDEC_EX_DECODER_MJPEG:
10546 {
10547 _VDEC_EX_API_MutexLock();
10548 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_SetFreezeDisp(u32Id, bEnable));
10549 _VDEC_EX_API_MutexUnlock();
10550 break;
10551 }
10552 default:
10553 break;
10554 }
10555
10556 return eRet;
10557 }
10558
_MApi_VDEC_EX_V2_SetBlueScreen(VDEC_StreamId * pStreamId,MS_BOOL bOn)10559 VDEC_EX_Result _MApi_VDEC_EX_V2_SetBlueScreen(VDEC_StreamId *pStreamId, MS_BOOL bOn)
10560 {
10561 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10562 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10563 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10564
10565 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10566 {
10567 case E_VDEC_EX_DECODER_MVD:
10568 {
10569 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_SetBlueScreen(u32Id, bOn));
10570
10571 break;
10572 }
10573 case E_VDEC_EX_DECODER_HVD:
10574 {
10575 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetBlueScreen(u32Id, bOn));
10576 break;
10577 }
10578 case E_VDEC_EX_DECODER_MJPEG:
10579 {
10580 _VDEC_EX_API_MutexLock();
10581 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_SetBlueScreen(u32Id, bOn));
10582 _VDEC_EX_API_MutexUnlock();
10583 break;
10584 }
10585 default:
10586 break;
10587 }
10588
10589 return eRet;
10590 }
10591
_MApi_VDEC_EX_V2_ResetPTS(VDEC_StreamId * pStreamId,MS_U32 u32PtsBase)10592 VDEC_EX_Result _MApi_VDEC_EX_V2_ResetPTS(VDEC_StreamId *pStreamId, MS_U32 u32PtsBase)
10593 {
10594 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10595 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10596 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10597
10598 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10599 {
10600 case E_VDEC_EX_DECODER_MVD:
10601 {
10602 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_ResetPTS(u32Id, u32PtsBase));
10603 break;
10604 }
10605 case E_VDEC_EX_DECODER_HVD:
10606 {
10607 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_RstPTS(u32Id, u32PtsBase));
10608 break;
10609 }
10610 case E_VDEC_EX_DECODER_MJPEG:
10611 {
10612 _VDEC_EX_API_MutexLock();
10613 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_ResetPTS(u32Id, u32PtsBase));
10614 _VDEC_EX_API_MutexUnlock();
10615 break;
10616 }
10617 default:
10618 eRet = E_VDEC_EX_RET_UNSUPPORTED;
10619 break;
10620 }
10621
10622 return eRet;
10623 }
10624
_MApi_VDEC_EX_V2_AVSyncOn(VDEC_StreamId * pStreamId,MS_BOOL bOn,MS_U32 u32SyncDelay,MS_U16 u16SyncTolerance)10625 VDEC_EX_Result _MApi_VDEC_EX_V2_AVSyncOn(VDEC_StreamId *pStreamId, MS_BOOL bOn, MS_U32 u32SyncDelay, MS_U16 u16SyncTolerance)
10626 {
10627 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10628 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10629 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10630
10631 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10632 {
10633 case E_VDEC_EX_DECODER_MVD:
10634 {
10635 if(pVdecExContext->bTrickMode[u8Idx] == TRUE)
10636 {
10637 return E_VDEC_EX_OK;
10638 }
10639 MDrv_MVD_SetAVSync(u32Id, bOn, u32SyncDelay);
10640
10641 if ((u16SyncTolerance!=0) && (FALSE == MDrv_MVD_ChangeAVsync(u32Id, bOn, u16SyncTolerance)))
10642 {
10643 eRet = E_VDEC_EX_FAIL;
10644 }
10645 else
10646 {
10647 eRet = E_VDEC_EX_OK;
10648 }
10649
10650 break;
10651 }
10652 case E_VDEC_EX_DECODER_HVD:
10653 {
10654 if (bOn)
10655 {
10656 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSyncActive(u32Id, TRUE));
10657
10658 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSyncVideoDelay(u32Id, u32SyncDelay));
10659
10660 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSyncTolerance(u32Id, u16SyncTolerance));
10661 }
10662 else
10663 {
10664 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSyncActive(u32Id, FALSE));
10665 }
10666
10667 break;
10668 }
10669 case E_VDEC_EX_DECODER_MJPEG:
10670 {
10671 _VDEC_EX_API_MutexLock();
10672 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_AVSyncOn(u32Id, bOn, u32SyncDelay, u16SyncTolerance));
10673 _VDEC_EX_API_MutexUnlock();
10674 break;
10675 }
10676 default:
10677 break;
10678 }
10679
10680 return eRet;
10681 }
10682
10683
_MApi_VDEC_EX_V2_SetAVSyncFreerunThreshold(VDEC_StreamId * pStreamId,MS_U32 u32Threshold)10684 VDEC_EX_Result _MApi_VDEC_EX_V2_SetAVSyncFreerunThreshold(VDEC_StreamId *pStreamId, MS_U32 u32Threshold)
10685 {
10686 VDEC_EX_Result eRet = E_VDEC_EX_OK;
10687 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10688 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10689
10690 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10691 {
10692 case E_VDEC_EX_DECODER_MVD:
10693 {
10694 MDrv_MVD_SetAVSyncFreerunThreshold(u32Id, u32Threshold);
10695 eRet = E_VDEC_EX_OK;
10696 break;
10697 }
10698 case E_VDEC_EX_DECODER_HVD:
10699 {
10700 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSyncFreeRunTH(u32Id, u32Threshold));
10701 break;
10702 }
10703 case E_VDEC_EX_DECODER_MJPEG:
10704 break;
10705 default:
10706 eRet = E_VDEC_EX_RET_UNSUPPORTED;
10707 break;
10708 }
10709
10710 return eRet;
10711 }
10712
_MApi_VDEC_EX_V2_SetEvent_MultiCallback(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,MS_U32 u32EventFlag,VDEC_EX_EventCb pfn,void * param)10713 VDEC_EX_Result _MApi_VDEC_EX_V2_SetEvent_MultiCallback(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, MS_U32 u32EventFlag, VDEC_EX_EventCb pfn, void *param)
10714 {
10715 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
10716 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10717 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10718 MS_U32 i = 0;
10719
10720 if ((u32EventFlag != E_VDEC_EX_EVENT_OFF) && (pfn == NULL))
10721 {
10722 return E_VDEC_EX_RET_INVALID_PARAM;
10723 }
10724
10725 //_VDEC_EX_MutexLock(u8Idx);
10726 pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_type].u32EventBitMap = u32EventFlag;
10727 pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_type].pVdecEventCb = pfn;
10728 pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_type].pParam = param;
10729
10730 #if (VDEC_EX_ISR_MONITOR)
10731 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
10732 #else
10733 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = 0; //reset event flag;
10734 #endif
10735 for(i = 0; i < E_VDEC_EX_CB_MAX_NUM; i++)
10736 {
10737 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] |= pVdecExContext->_Attr[u8Idx].vdecExEventInfo[i].u32EventBitMap;
10738 }
10739
10740 VDEC_INFO(u8Idx, VDEC_PRINT("%s: flag=0x%x\n", __FUNCTION__, u32EventFlag));
10741
10742 #if (VDEC_EX_ISR_MONITOR)
10743 MsOS_SetEvent(s32VdecExEventId[u8Idx], E_VDEC_EX_EVENT_ISR_EVENT_CHANGE);
10744 #endif
10745
10746 #ifdef VDEC3
10747 pVdecExContext->_pVdec_IsrProc[u8Idx] = (VDEC_EX_IsrHandle) _VDEC_EX_NStream_IsrProc;
10748 #else
10749 switch (u8Idx) // here need to review.....
10750 {
10751 case E_VDEC_EX_MAIN_STREAM:
10752 pVdecExContext->_pVdec_IsrProc[u8Idx] = (VDEC_EX_IsrHandle) _VDEC_EX_IsrProc;
10753 break;
10754 case E_VDEC_EX_SUB_STREAM:
10755 pVdecExContext->_pVdec_IsrProc[u8Idx] = (VDEC_EX_IsrHandle) _VDEC_EX_Sub_IsrProc;
10756 break;
10757 default:
10758 break;
10759 }
10760 #endif
10761
10762 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10763 {
10764 case E_VDEC_EX_DECODER_MVD:
10765 {
10766 MS_U32 u32Event = E_MVD_EVENT_DISABLE_ALL;
10767
10768 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_ONE)
10769 {
10770 u32Event |= E_MVD_EVENT_DISP_VSYNC;
10771 }
10772 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_RDY)
10773 {
10774 u32Event |= E_MVD_EVENT_DISP_RDY;
10775 }
10776
10777 if ((pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_CHG) ||
10778 (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_SEQ_HDR_FOUND))
10779
10780 {
10781 u32Event |= E_MVD_EVENT_SEQ_FOUND;
10782 }
10783 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_USER_DATA_FOUND)
10784 {
10785 #if defined(SUPPORT_X_MODEL_FEATURE)
10786 //subscribe event "CC data found in display order"
10787 u32Event |= E_MVD_EVENT_USER_DATA_DISP;
10788 #else
10789 u32Event |= E_MVD_EVENT_USER_DATA;
10790 #endif
10791 }
10792
10793 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_AFD_FOUND)
10794 {
10795 u32Event |= E_MVD_EVENT_USER_DATA;
10796 }
10797
10798 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_FIRST_FRAME)
10799 {
10800 u32Event |= E_MVD_EVENT_FIRST_FRAME;
10801 }
10802
10803 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_PIC_FOUND)
10804 {
10805 u32Event |= E_MVD_EVENT_PIC_FOUND;
10806 }
10807
10808 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_VIDEO_UNMUTE)
10809 {
10810 u32Event |= E_MVD_EVENT_UNMUTE;
10811 }
10812
10813 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ONE)
10814 {
10815 u32Event |= E_MVD_EVENT_DEC_ONE_FRAME;
10816 }
10817
10818 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ERR)
10819 {
10820 u32Event |= E_MVD_EVENT_DEC_ERR;
10821 }
10822
10823 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_ES_DATA_ERR)
10824 {
10825 u32Event |= E_MVD_EVENT_DEC_DATA_ERR;
10826 }
10827
10828 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_XC_LOW_DEALY)
10829 {
10830 u32Event |= E_MVD_EVENT_XC_LOW_DEALY;
10831 }
10832
10833 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_I)
10834 {
10835 u32Event |= E_MVD_EVENT_DEC_I;
10836 }
10837
10838 #if 0
10839 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
10840 {
10841 _VDEC_EX_MutexUnlock(u8Idx);
10842 }
10843 #endif
10844 if (E_MVD_RET_OK != MDrv_MVD_SetIsrEvent(u32Id, u32Event, (MVD_InterruptCb) pVdecExContext->_pVdec_IsrProc[u8Idx]))
10845 {
10846 eRet = E_VDEC_EX_FAIL;
10847 }
10848 else
10849 {
10850 eRet = E_VDEC_EX_OK;
10851 }
10852 #if 0
10853 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
10854 {
10855 _VDEC_EX_MutexLock(u8Idx);
10856 }
10857 #endif
10858 break;
10859 }
10860 case E_VDEC_EX_DECODER_HVD:
10861 {
10862 MS_U32 eEvent = E_HVD_EX_ISR_NONE;
10863
10864 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_ONE)
10865 {
10866 eEvent |= E_HVD_EX_ISR_DISP_ONE;
10867 }
10868 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_REPEAT)
10869 {
10870 eEvent |= E_HVD_EX_ISR_DISP_REPEAT;
10871 }
10872 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_WITH_CC)
10873 {
10874 eEvent |= E_HVD_EX_ISR_DISP_WITH_CC;
10875 }
10876 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ONE)
10877 {
10878 eEvent |= E_HVD_EX_ISR_DEC_ONE;
10879 }
10880 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_I)
10881 {
10882 eEvent |= E_HVD_EX_ISR_DEC_I;
10883 }
10884 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ERR)
10885 {
10886 eEvent |= E_HVD_EX_ISR_DEC_HW_ERR;
10887 }
10888 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_CHG)
10889 {
10890 eEvent |= E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE;
10891 }
10892 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_USER_DATA_FOUND)
10893 {
10894 eEvent |= E_HVD_EX_ISR_DEC_CC_FOUND;
10895 }
10896 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_RDY)
10897 {
10898 eEvent |= E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE;
10899 }
10900 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_FIRST_FRAME)
10901 {
10902 eEvent |= E_HVD_EX_ISR_DEC_FIRST_FRM;
10903 }
10904 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_VIDEO_UNMUTE)
10905 {
10906 eEvent |= E_HVD_EX_ISR_DISP_FIRST_FRM;
10907 }
10908 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_SEQ_HDR_FOUND)
10909 {
10910 eEvent |= E_HVD_EX_ISR_DEC_SEQ_HDR_FOUND;
10911 }
10912 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_AFD_FOUND)
10913 {
10914 eEvent |= E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE;
10915 }
10916 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_ES_DATA_ERR)
10917 {
10918 eEvent |= E_HVD_EX_ISR_DEC_DATA_ERR;
10919 }
10920 if (E_HVD_EX_OK != MDrv_HVD_EX_SetISREvent(u32Id, eEvent, (HVD_InterruptCb) pVdecExContext->_pVdec_IsrProc[u8Idx]))
10921 {
10922 eRet = E_VDEC_EX_FAIL;
10923 goto _END;
10924 }
10925
10926 eRet = E_VDEC_EX_OK;
10927 break;
10928 }
10929 case E_VDEC_EX_DECODER_MJPEG:
10930 {
10931 eRet = E_VDEC_EX_RET_UNSUPPORTED;
10932 break;
10933 }
10934 default:
10935 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
10936 break;
10937 }
10938
10939 _END:
10940 //_VDEC_EX_MutexUnlock(u8Idx);
10941 return eRet;
10942 }
10943
_MApi_VDEC_EX_V2_UnsetEvent_MultiCallback(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,MS_U32 u32EventFlag)10944 VDEC_EX_Result _MApi_VDEC_EX_V2_UnsetEvent_MultiCallback(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, MS_U32 u32EventFlag)
10945 {
10946 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
10947 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
10948 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
10949 MS_U32 i = 0;
10950
10951 //_VDEC_EX_MutexLock(u8Idx);
10952
10953 if (E_VDEC_EX_EVENT_OFF == u32EventFlag)
10954 {
10955 //_VDEC_EX_MutexUnlock(u8Idx);
10956 return E_VDEC_EX_RET_INVALID_PARAM;
10957 }
10958
10959 pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_type].u32EventBitMap &= ~u32EventFlag;
10960
10961 if (E_VDEC_EX_EVENT_OFF == pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_type].u32EventBitMap)
10962 {
10963 pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_type].pVdecEventCb = NULL;
10964 pVdecExContext->_Attr[u8Idx].vdecExEventInfo[cb_type].pParam = NULL;
10965 }
10966
10967 #if (VDEC_EX_ISR_MONITOR)
10968 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = E_VDEC_EX_EVENT_ISR_EVENT_CHANGE;
10969 #else
10970 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] = 0; //reset event flag;
10971 #endif
10972 for(i = 0; i < E_VDEC_EX_CB_MAX_NUM; i++)
10973 {
10974 pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] |= pVdecExContext->_Attr[u8Idx].vdecExEventInfo[i].u32EventBitMap;
10975 }
10976
10977 #if (VDEC_EX_ISR_MONITOR)
10978 MsOS_SetEvent(s32VdecExEventId[u8Idx], E_VDEC_EX_EVENT_ISR_EVENT_CHANGE);
10979 #endif
10980
10981 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
10982 {
10983 case E_VDEC_EX_DECODER_MVD:
10984 {
10985 MS_U32 u32Event = 0;
10986
10987 //Set Event
10988 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_RDY)
10989 {
10990 u32Event |= E_MVD_EVENT_DISP_RDY;
10991 }
10992
10993 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_CHG)
10994 {
10995 u32Event |= E_MVD_EVENT_SEQ_FOUND;
10996 }
10997
10998 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_SEQ_HDR_FOUND)
10999 {
11000 u32Event |= E_MVD_EVENT_SEQ_FOUND;
11001 }
11002
11003 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_USER_DATA_FOUND)
11004 {
11005 #if defined(SUPPORT_X_MODEL_FEATURE)
11006 u32Event |= E_MVD_EVENT_USER_DATA_DISP;
11007 #else
11008 u32Event |= E_MVD_EVENT_USER_DATA;
11009 #endif
11010 }
11011
11012 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_AFD_FOUND)
11013 {
11014 u32Event |= E_MVD_EVENT_USER_DATA;
11015 }
11016
11017 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_FIRST_FRAME)
11018 {
11019 u32Event |= E_MVD_EVENT_FIRST_FRAME;
11020 }
11021
11022 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_PIC_FOUND)
11023 {
11024 u32Event |= E_MVD_EVENT_PIC_FOUND;
11025 }
11026
11027 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_VIDEO_UNMUTE)
11028 {
11029 u32Event |= E_MVD_EVENT_UNMUTE;
11030 }
11031
11032 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ONE)
11033 {
11034 u32Event |= E_MVD_EVENT_DEC_ONE_FRAME;
11035 }
11036
11037 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ERR)
11038 {
11039 u32Event |= E_MVD_EVENT_DEC_ERR;
11040 }
11041
11042 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_ES_DATA_ERR)
11043 {
11044 u32Event |= E_MVD_EVENT_DEC_DATA_ERR;
11045 }
11046 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_XC_LOW_DEALY)
11047 {
11048 u32Event |= E_MVD_EVENT_XC_LOW_DEALY;
11049 }
11050 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_I)
11051 {
11052 u32Event |= E_MVD_EVENT_DEC_I;
11053 }
11054 #if 0
11055 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11056 {
11057 //to avoid deadlock: unlock mutex so that _VDEC_EX_IsrProc() can lock mutex
11058 _VDEC_EX_MutexUnlock(u8Idx);
11059 }
11060 #endif
11061 if (E_MVD_RET_OK != MDrv_MVD_SetIsrEvent(u32Id, u32Event, (MVD_InterruptCb) pVdecExContext->_pVdec_IsrProc[u8Idx]))
11062 {
11063 eRet = E_VDEC_EX_FAIL;
11064 }
11065 else
11066 {
11067 eRet = E_VDEC_EX_OK;
11068 }
11069 #if 0
11070 if (u32Event == E_MVD_EVENT_DISABLE_ALL)
11071 {
11072 _VDEC_EX_MutexLock(u8Idx);
11073 }
11074 #endif
11075 break;
11076 }
11077 case E_VDEC_EX_DECODER_HVD:
11078 {
11079 HVD_EX_IsrEvent eEvent = E_HVD_EX_ISR_NONE;
11080
11081 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_ONE)
11082 {
11083 eEvent |= E_HVD_EX_ISR_DISP_ONE;
11084 }
11085 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_REPEAT)
11086 {
11087 eEvent |= E_HVD_EX_ISR_DISP_REPEAT;
11088 }
11089 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_WITH_CC)
11090 {
11091 eEvent |= E_HVD_EX_ISR_DISP_WITH_CC;
11092 }
11093 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ONE)
11094 {
11095 eEvent |= E_HVD_EX_ISR_DEC_ONE;
11096 }
11097 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_I)
11098 {
11099 eEvent |= E_HVD_EX_ISR_DEC_I;
11100 }
11101 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DEC_ERR)
11102 {
11103 eEvent |= E_HVD_EX_ISR_DEC_HW_ERR;
11104 }
11105 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_CHG)
11106 {
11107 eEvent |= E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE;
11108 }
11109 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_USER_DATA_FOUND)
11110 {
11111 eEvent |= E_HVD_EX_ISR_DISP_WITH_CC;
11112 }
11113 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_DISP_INFO_RDY)
11114 {
11115 eEvent |= E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE;
11116 }
11117 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_FIRST_FRAME)
11118 {
11119 eEvent |= E_HVD_EX_ISR_DEC_FIRST_FRM;
11120 }
11121 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_VIDEO_UNMUTE)
11122 {
11123 eEvent |= E_HVD_EX_ISR_DISP_FIRST_FRM;
11124 }
11125 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_AFD_FOUND)
11126 {
11127 eEvent |= E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE;
11128 }
11129
11130 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_SEQ_HDR_FOUND)
11131 {
11132 eEvent |= E_HVD_EX_ISR_DEC_SEQ_HDR_FOUND;
11133 }
11134 if (pVdecExContext->_u32VdecExIsrEventFlag[u8Idx] & E_VDEC_EX_EVENT_ES_DATA_ERR)
11135 {
11136 eEvent |= E_HVD_EX_ISR_DEC_DATA_ERR;
11137 }
11138 if (eEvent != E_HVD_EX_ISR_NONE)
11139 {
11140 if (E_HVD_EX_OK != MDrv_HVD_EX_SetISREvent(u32Id, eEvent, (HVD_InterruptCb) pVdecExContext->_pVdec_IsrProc[u8Idx]))
11141 {
11142 //_VDEC_EX_MutexUnlock(u8Idx);
11143 return E_VDEC_EX_FAIL;
11144 }
11145 }
11146 eRet = E_VDEC_EX_OK;
11147 break;
11148 }
11149 case E_VDEC_EX_DECODER_MJPEG:
11150 {
11151 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11152 break;
11153 }
11154 default:
11155 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
11156 break;
11157 }
11158
11159 //_VDEC_EX_MutexUnlock(u8Idx);
11160 return eRet;
11161 }
11162
_MApi_VDEC_EX_V2_FireDecCmd(VDEC_StreamId * pStreamId)11163 VDEC_EX_Result _MApi_VDEC_EX_V2_FireDecCmd(VDEC_StreamId *pStreamId)
11164 {
11165 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
11166 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11167 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11168
11169 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11170 {
11171 case E_VDEC_EX_DECODER_MVD:
11172 {
11173 #ifdef VDEC3
11174 if(pVdecExContext->u32FrameBaseMode[u8Idx] == FALSE)
11175 #endif
11176 {
11177 MDrv_MVD_SetSLQWritePtr(u32Id, TRUE);
11178 }
11179 eRet = E_VDEC_EX_OK;
11180 break;
11181 }
11182 case E_VDEC_EX_DECODER_HVD:
11183 {
11184 #ifndef VDEC3
11185 MDrv_HVD_EX_PushQueue_Fire(u32Id);
11186 #endif
11187 eRet = E_VDEC_EX_OK;
11188 break;
11189 }
11190 case E_VDEC_EX_DECODER_MJPEG:
11191 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11192 break;
11193
11194 default:
11195 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11196 break;
11197 }
11198
11199 return eRet;
11200 }
11201
_MApi_VDEC_EX_V2_SeekToPTS(VDEC_StreamId * pStreamId,MS_U32 u32PTS)11202 VDEC_EX_Result _MApi_VDEC_EX_V2_SeekToPTS(VDEC_StreamId *pStreamId, MS_U32 u32PTS)
11203 {
11204 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
11205 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11206 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11207
11208 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11209 {
11210 case E_VDEC_EX_DECODER_MVD:
11211 {
11212 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_SeekToPTS(u32Id, u32PTS));
11213 break;
11214 }
11215 case E_VDEC_EX_DECODER_HVD:
11216 {
11217 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SeekToPTS(u32Id, u32PTS));
11218 break;
11219 }
11220 case E_VDEC_EX_DECODER_MJPEG:
11221 {
11222 _VDEC_EX_API_MutexLock();
11223 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_SeekToPTS(u32Id, u32PTS));
11224 _VDEC_EX_API_MutexUnlock();
11225 break;
11226 }
11227 default:
11228 break;
11229 }
11230
11231 return eRet;
11232 }
11233
_MApi_VDEC_EX_V2_SkipToPTS(VDEC_StreamId * pStreamId,MS_U32 u32PTS)11234 VDEC_EX_Result _MApi_VDEC_EX_V2_SkipToPTS(VDEC_StreamId *pStreamId, MS_U32 u32PTS)
11235 {
11236 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
11237 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11238 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11239
11240 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11241 {
11242 case E_VDEC_EX_DECODER_MVD:
11243 {
11244 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_SkipToPTS(u32Id, u32PTS));
11245 break;
11246 }
11247 case E_VDEC_EX_DECODER_HVD:
11248 {
11249 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SkipToPTS(u32Id, u32PTS));
11250 break;
11251 }
11252 case E_VDEC_EX_DECODER_MJPEG:
11253 {
11254 _VDEC_EX_API_MutexLock();
11255 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_SkipToPTS(u32Id, u32PTS));
11256 _VDEC_EX_API_MutexUnlock();
11257 break;
11258 }
11259 default:
11260 break;
11261 }
11262
11263 return eRet;
11264 }
11265
_MApi_VDEC_EX_V2_DisableDeblocking(VDEC_StreamId * pStreamId,MS_BOOL bDisable)11266 VDEC_EX_Result _MApi_VDEC_EX_V2_DisableDeblocking(VDEC_StreamId *pStreamId, MS_BOOL bDisable)
11267 {
11268 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11269 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11270 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11271
11272 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11273 {
11274 case E_VDEC_EX_DECODER_MVD:
11275 break;
11276
11277 case E_VDEC_EX_DECODER_HVD:
11278 {
11279 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSettings_Pro(u32Id,E_HVD_EX_SSET_DISABLE_DEBLOCKING,bDisable));
11280 break;
11281 }
11282 case E_VDEC_EX_DECODER_MJPEG:
11283 {
11284 break;
11285 }
11286 default:
11287 break;
11288 }
11289
11290 return eRet;
11291 }
11292
_MApi_VDEC_EX_V2_DisableQuarterPixel(VDEC_StreamId * pStreamId,MS_BOOL bDisable)11293 VDEC_EX_Result _MApi_VDEC_EX_V2_DisableQuarterPixel(VDEC_StreamId *pStreamId, MS_BOOL bDisable)
11294 {
11295 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11296 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11297 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11298
11299 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11300 {
11301 case E_VDEC_EX_DECODER_MVD:
11302 break;
11303
11304 case E_VDEC_EX_DECODER_HVD:
11305 {
11306 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetSettings_Pro(u32Id, E_HVD_EX_SSET_DISABLE_QUARTER_PIXEL ,bDisable));
11307 break;
11308 }
11309 case E_VDEC_EX_DECODER_MJPEG:
11310 {
11311 break;
11312 }
11313 default:
11314 break;
11315 }
11316
11317 return eRet;
11318 }
11319
_MApi_VDEC_EX_V2_SetAutoRmLstZeroByte(VDEC_StreamId * pStreamId,MS_BOOL bOn)11320 VDEC_EX_Result _MApi_VDEC_EX_V2_SetAutoRmLstZeroByte(VDEC_StreamId *pStreamId, MS_BOOL bOn)
11321 {
11322 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11323 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11324 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11325
11326 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11327 {
11328 case E_VDEC_EX_DECODER_MVD:
11329 break;
11330
11331 case E_VDEC_EX_DECODER_HVD:
11332 {
11333 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetAutoRmLstZeroByte(u32Id, bOn));
11334 break;
11335 }
11336 case E_VDEC_EX_DECODER_MJPEG:
11337 {
11338 break;
11339 }
11340 default:
11341 break;
11342 }
11343
11344 return eRet;
11345 }
11346
_MApi_VDEC_EX_V2_SetBalanceBW(VDEC_StreamId * pStreamId,MS_U8 u8QuarPixelTH,MS_U8 u8DeBlockingTH,MS_U8 u8UpperBound,MS_U8 u8SafeCoef)11347 VDEC_EX_Result _MApi_VDEC_EX_V2_SetBalanceBW(VDEC_StreamId *pStreamId, MS_U8 u8QuarPixelTH, MS_U8 u8DeBlockingTH, MS_U8 u8UpperBound, MS_U8 u8SafeCoef)
11348 {
11349 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11350 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11351 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11352
11353 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11354 {
11355 case E_VDEC_EX_DECODER_MVD:
11356 break;
11357
11358 case E_VDEC_EX_DECODER_HVD:
11359 {
11360 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_SetBalanceBW(u32Id, u8QuarPixelTH, u8DeBlockingTH, u8UpperBound));
11361 break;
11362 }
11363 case E_VDEC_EX_DECODER_MJPEG:
11364 {
11365 break;
11366 }
11367 default:
11368 break;
11369 }
11370
11371 return eRet;
11372 }
11373
_MApi_VDEC_EX_V2_GenPattern(VDEC_StreamId * pStreamId,VDEC_EX_PatternType ePatternType,MS_PHY u32Addr,MS_U32 * u32Size)11374 VDEC_EX_Result _MApi_VDEC_EX_V2_GenPattern(VDEC_StreamId *pStreamId, VDEC_EX_PatternType ePatternType, MS_PHY u32Addr, MS_U32* u32Size)
11375 {
11376 VDEC_EX_Result eRet=E_VDEC_EX_RET_UNSUPPORTED;
11377 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11378 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11379
11380 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11381 {
11382 case E_VDEC_EX_DECODER_MVD:
11383 {
11384 if (ePatternType == E_VDEC_EX_PATTERN_FLUSH)
11385 {
11386 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_GenPattern(u32Id, E_MVD_PATTERN_FLUSH, u32Addr, u32Size));
11387 }
11388 else if (ePatternType == E_VDEC_EX_PATTERN_FILEEND)
11389 {
11390 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_GenPattern(u32Id, E_MVD_PATTERN_FILEEND, u32Addr, u32Size));
11391 }
11392 break;
11393 }
11394 case E_VDEC_EX_DECODER_HVD:
11395 {
11396 if (ePatternType == E_VDEC_EX_PATTERN_FLUSH)
11397 {
11398 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_GenPattern(u32Id, E_HVD_EX_PATTERN_FLUSH, MS_PA2KSEG1(u32Addr), u32Size));
11399 }
11400 else if (ePatternType == E_VDEC_EX_PATTERN_FILEEND)
11401 {
11402 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_GenPattern(u32Id, E_HVD_EX_PATTERN_FILEEND, MS_PA2KSEG1(u32Addr), u32Size));
11403 }
11404 break;
11405 }
11406 case E_VDEC_EX_DECODER_MJPEG:
11407 break;
11408
11409 default:
11410 break;
11411 }
11412
11413 return eRet;
11414 }
11415
11416
_MApi_VDEC_EX_V2_MHEG_DecodeIFrame(VDEC_StreamId * pStreamId,MS_PHY u32FrameBufAddr,MS_PHY u32SrcSt,MS_PHY u32SrcEnd)11417 VDEC_EX_Result _MApi_VDEC_EX_V2_MHEG_DecodeIFrame(VDEC_StreamId *pStreamId,
11418 MS_PHY u32FrameBufAddr,
11419 MS_PHY u32SrcSt,
11420 MS_PHY u32SrcEnd)
11421 {
11422 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
11423 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11424 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11425
11426 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11427 {
11428 case E_VDEC_EX_DECODER_MVD:
11429 {
11430 if ((u32FrameBufAddr == 0) && pVdecExContext->bCMAUsed && bCMAInitPool[0] && (u8Idx == 0))
11431 {
11432 u32FrameBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr;
11433 }
11434 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_DecodeIFrame(u32Id, u32FrameBufAddr, u32SrcSt, u32SrcEnd));
11435 break;
11436 }
11437 case E_VDEC_EX_DECODER_HVD:
11438 {
11439 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_DecodeIFrame(u32Id, u32SrcSt, (u32SrcEnd - u32SrcSt)));
11440 break;
11441 }
11442 case E_VDEC_EX_DECODER_MJPEG:
11443 default:
11444 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11445
11446 break;
11447 }
11448
11449 pVdecExContext->u8enable_store_set_cmd[u8Idx] = FALSE;
11450
11451 return eRet;
11452 }
11453
_MApi_VDEC_EX_V2_MHEG_RstIFrameDec(VDEC_StreamId * pStreamId)11454 VDEC_EX_Result _MApi_VDEC_EX_V2_MHEG_RstIFrameDec(VDEC_StreamId *pStreamId)
11455 {
11456 VDEC_PRINT("VDEC_EX err: %s is obsolete!\n", __FUNCTION__);
11457
11458 return E_VDEC_EX_RET_UNSUPPORTED;
11459 }
11460
_MApi_VDEC_EX_V2_CC_StartParsing(VDEC_StreamId * pStreamId,VDEC_EX_CCCfg * pCCParam)11461 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_StartParsing(VDEC_StreamId *pStreamId, VDEC_EX_CCCfg *pCCParam)
11462 {
11463 VDEC_PRINT("%s is obsolete\n", __FUNCTION__);
11464 UNUSED(pStreamId);
11465 UNUSED(pCCParam);
11466 return E_VDEC_EX_RET_UNSUPPORTED;
11467 }
11468
_MApi_VDEC_EX_V2_CC_StopParsing(VDEC_StreamId * pStreamId)11469 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_StopParsing(VDEC_StreamId *pStreamId)
11470 {
11471 VDEC_PRINT("%s is obsolete\n", __FUNCTION__);
11472 UNUSED(pStreamId);
11473 return E_VDEC_EX_RET_UNSUPPORTED;
11474 }
11475
11476
_MApi_VDEC_EX_V2_CC_UpdateReadPtr(VDEC_StreamId * pStreamId,MS_U32 u32EachPacketSize)11477 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_UpdateReadPtr(VDEC_StreamId *pStreamId, MS_U32 u32EachPacketSize)
11478 {
11479 VDEC_PRINT("%s is obsolete\n", __FUNCTION__);
11480 UNUSED(pStreamId);
11481 UNUSED(u32EachPacketSize);
11482 return E_VDEC_EX_RET_UNSUPPORTED;
11483 }
11484
11485
_MApi_VDEC_EX_V2_SetBlockDisplay(VDEC_StreamId * pStreamId,MS_BOOL bEnable)11486 VDEC_EX_Result _MApi_VDEC_EX_V2_SetBlockDisplay(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
11487 {
11488 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11489 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11490 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11491
11492 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11493 {
11494 case E_VDEC_EX_DECODER_MVD:
11495 {
11496 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_SetMStreamerMode(u32Id, bEnable));
11497 break;
11498 }
11499 case E_VDEC_EX_DECODER_HVD:
11500 {
11501 _HVD_RET_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_EnableDispQue(u32Id, bEnable));
11502 break;
11503 }
11504 case E_VDEC_EX_DECODER_MJPEG:
11505 {
11506 _VDEC_EX_API_MutexLock();
11507 _MJPEG_RET_TO_VDEC_RESULT(eRet, MApi_MJPEG_EnableDispCmdQ(u32Id, bEnable));
11508 _VDEC_EX_API_MutexUnlock();
11509 break;
11510 }
11511 default:
11512 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11513 break;
11514 }
11515
11516 return eRet;
11517 }
11518
_MApi_VDEC_EX_V2_EnableESBuffMalloc(VDEC_StreamId * pStreamId,MS_BOOL bEnable)11519 VDEC_EX_Result _MApi_VDEC_EX_V2_EnableESBuffMalloc(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
11520 {
11521 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11522
11523 if ((E_VDEC_EX_DECODER_MVD != pVdecExContext->_Attr[u8Idx].eDecoder) &&
11524 (E_VDEC_EX_DECODER_HVD != pVdecExContext->_Attr[u8Idx].eDecoder) &&
11525 (E_VDEC_EX_DECODER_MJPEG != pVdecExContext->_Attr[u8Idx].eDecoder))
11526 {
11527 return E_VDEC_EX_RET_UNSUPPORTED;
11528 }
11529
11530 pVdecExContext->_bEsBufMgmt[u8Idx] = bEnable;
11531 return E_VDEC_EX_OK;
11532 }
11533
_MApi_VDEC_EX_V2_DisplayFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame * pDispFrm)11534 VDEC_EX_Result _MApi_VDEC_EX_V2_DisplayFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame *pDispFrm)
11535 {
11536 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11537 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11538 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11539
11540 if (!pDispFrm)
11541 {
11542 return E_VDEC_EX_RET_INVALID_PARAM;
11543 }
11544
11545 if (_VDEC_EX_IsDqValid(pDispFrm))
11546 {
11547 VDEC_INFO(u8Idx, VDEC_PRINT("%s invalid pDispFrm 0x%x\n", __FUNCTION__, pDispFrm->u32PriData));
11548 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
11549 }
11550
11551 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11552 {
11553 case E_VDEC_EX_DECODER_MVD:
11554 {
11555 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_FrameFlip(u32Id, pDispFrm->u32PriData));
11556 _VDEC_EX_FreeDq(u8Idx, pDispFrm);
11557 break;
11558 }
11559 case E_VDEC_EX_DECODER_HVD:
11560 {
11561 if(MDrv_HVD_EX_DispFrame(u32Id, pDispFrm->u32PriData) != E_HVD_EX_OK)
11562 {
11563 return E_VDEC_EX_FAIL;
11564 }
11565 _VDEC_EX_FreeDq(u8Idx, pDispFrm);
11566 break;
11567 }
11568 case E_VDEC_EX_DECODER_MJPEG:
11569 {
11570 _VDEC_EX_API_MutexLock();
11571
11572 if(MApi_MJPEG_DispFrame(u32Id, pDispFrm->u32PriData) != E_MJPEG_RET_SUCCESS)
11573 {
11574 _VDEC_EX_API_MutexUnlock();
11575 return E_VDEC_EX_FAIL;
11576 }
11577 _VDEC_EX_FreeDq(u8Idx, pDispFrm);
11578 _VDEC_EX_API_MutexUnlock();
11579 break;
11580 }
11581 default:
11582 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11583 break;
11584 }
11585
11586 return eRet;
11587 }
11588
11589
_MApi_VDEC_EX_V2_ReleaseFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame * pDispFrm)11590 VDEC_EX_Result _MApi_VDEC_EX_V2_ReleaseFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame *pDispFrm)
11591 {
11592 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11593 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11594 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11595
11596 if (!pDispFrm)
11597 {
11598 return E_VDEC_EX_RET_INVALID_PARAM;
11599 }
11600
11601 if (_VDEC_EX_IsDqValid(pDispFrm))
11602 {
11603 VDEC_INFO(u8Idx, VDEC_PRINT("%s invalid pDispFrm 0x%x\n", __FUNCTION__, pDispFrm->u32PriData));
11604 return E_VDEC_EX_RET_INVALID_PARAM;
11605 }
11606
11607 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11608 {
11609 case E_VDEC_EX_DECODER_MVD:
11610 {
11611 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_FrameRelease(u32Id, pDispFrm->u32PriData));
11612 _VDEC_EX_FreeDq(u8Idx, pDispFrm);
11613 break;
11614 }
11615 case E_VDEC_EX_DECODER_HVD:
11616 {
11617 if(MDrv_HVD_EX_FreeFrame(u32Id, pDispFrm->u32PriData) != E_HVD_EX_OK)
11618 {
11619 return E_VDEC_EX_FAIL;
11620 }
11621 _VDEC_EX_FreeDq(u8Idx, pDispFrm);
11622 break;
11623 }
11624 case E_VDEC_EX_DECODER_MJPEG:
11625 {
11626 _VDEC_EX_API_MutexLock();
11627
11628 if(MApi_MJPEG_FreeFrame(u32Id, pDispFrm->u32PriData) != E_MJPEG_RET_SUCCESS)
11629 {
11630 _VDEC_EX_API_MutexUnlock();
11631 return E_VDEC_EX_FAIL;
11632 }
11633 _VDEC_EX_FreeDq(u8Idx, pDispFrm);
11634 _VDEC_EX_API_MutexUnlock();
11635 break;
11636 }
11637 default:
11638 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11639 break;
11640 }
11641
11642 return eRet;
11643 }
11644
_MApi_VDEC_EX_V2_CaptureFrame(VDEC_StreamId * pStreamId,MS_U32 u32FrmPriData,MS_BOOL bEnable)11645 VDEC_EX_Result _MApi_VDEC_EX_V2_CaptureFrame(VDEC_StreamId *pStreamId, MS_U32 u32FrmPriData, MS_BOOL bEnable)
11646 {
11647 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11648 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11649 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11650
11651 if (u32FrmPriData == VDEC_U32_MAX)
11652 {
11653 return E_VDEC_EX_RET_INVALID_PARAM;
11654 }
11655
11656 //check the disable frame is valid
11657 if ((FALSE == bEnable) && (pVdecExContext->u32PriData[u8Idx] != u32FrmPriData))
11658 {
11659 VDEC_PRINT("%s: Release an uncaptured frame(0x%x != 0x%x)!\n",
11660 __FUNCTION__, u32FrmPriData, pVdecExContext->u32PriData[u8Idx]);
11661 return E_VDEC_EX_RET_INVALID_PARAM;
11662 }
11663
11664 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11665 {
11666 case E_VDEC_EX_DECODER_MVD:
11667 {
11668 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_FrameCapture(u32Id, u32FrmPriData, bEnable));
11669 break;
11670 }
11671 case E_VDEC_EX_DECODER_HVD:
11672 break;
11673
11674 case E_VDEC_EX_DECODER_MJPEG:
11675 break;
11676
11677 default:
11678 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11679 break;
11680 }
11681
11682 if (E_VDEC_EX_OK == eRet)
11683 {
11684 if (FALSE == bEnable)
11685 {
11686 pVdecExContext->u32PriData[u8Idx] = VDEC_U32_MAX;
11687 }
11688 else
11689 { //record the captured frame idx
11690 pVdecExContext->u32PriData[u8Idx] = u32FrmPriData;
11691 }
11692 }
11693
11694 return eRet;
11695 }
11696
_MApi_VDEC_EX_V2_CC_Init(VDEC_StreamId * pStreamId,MS_U32 * pIn)11697 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_Init(VDEC_StreamId *pStreamId, MS_U32 *pIn)
11698 {
11699 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11700 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11701 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11702
11703 if(MDrv_SYS_Query(E_SYS_QUERY_DTVCC_SUPPORTED ) == TRUE)
11704 {
11705 pVdecExContext->support_cc[u8Idx] = TRUE;
11706 }
11707 else
11708 {
11709 pVdecExContext->support_cc[u8Idx] = FALSE;
11710 return E_VDEC_EX_RET_UNSUPPORTED;
11711 }
11712
11713 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11714 {
11715 case E_VDEC_EX_DECODER_MVD:
11716 {
11717 MDrv_CC_Init(u32Id);
11718 eRet = E_VDEC_EX_OK;
11719 }
11720 break;
11721
11722 case E_VDEC_EX_DECODER_HVD:
11723 {
11724 eRet = MDrv_HVD_EX_CC_Init(u32Id);
11725 }
11726 break;
11727
11728 case E_VDEC_EX_DECODER_MJPEG:
11729 default:
11730 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
11731 break;
11732 }
11733
11734 return eRet;
11735 }
11736
_MApi_VDEC_EX_V2_CC_SetCfg(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,VDEC_EX_CCType eType,MS_U32 * pIn)11737 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_SetCfg(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, VDEC_EX_CCType eType, MS_U32 *pIn)
11738 {
11739 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11740 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11741 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11742
11743 if(pVdecExContext->support_cc[u8Idx] == FALSE)
11744 {
11745 return E_VDEC_EX_RET_UNSUPPORTED;
11746 }
11747
11748 if (!pIn)
11749 {
11750 return E_VDEC_EX_RET_INVALID_PARAM;
11751 }
11752
11753 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11754 {
11755 case E_VDEC_EX_DECODER_MVD:
11756 {
11757 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
11758 MS_U8 u8Opt = _VDEC_Map2MVDCCOpt((VDEC_EX_CCType)eType);
11759 MS_U16 u16BufferSize = 0;
11760 VDEC_EX_CC_InputPara* pInput = (VDEC_EX_CC_InputPara*)pIn;
11761 if (pInput->u32Ver != 0)
11762 {
11763 VDEC_PRINT("%s not supported ver %d\n", __FUNCTION__, pInput->u32Ver);
11764 return E_VDEC_EX_FAIL;
11765 }
11766 u16BufferSize = (MS_U16)pInput->u32Val;
11767 MDrv_CC_CM_SetParsingType(u32Id, u8Opt, u16BufferSize, u8Type);
11768 eRet = E_VDEC_EX_OK;
11769 }
11770 break;
11771 case E_VDEC_EX_DECODER_HVD:
11772 {
11773 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
11774 MS_U8 u8Opt = _VDEC_Map2HVDCCOpt((VDEC_EX_CCType)eType);
11775 MS_U16 u16BufferSize = 0;
11776 VDEC_EX_CC_InputPara* pInput = (VDEC_EX_CC_InputPara*)pIn;
11777 if (pInput->u32Ver != 0)
11778 {
11779 VDEC_PRINT("%s not supported ver %d\n", __FUNCTION__, pInput->u32Ver);
11780 return E_VDEC_EX_FAIL;
11781 }
11782 u16BufferSize = (MS_U16)pInput->u32Val;
11783 eRet = MDrv_HVD_EX_CC_SetCfg(u32Id, u8Opt, u16BufferSize, u8Type);
11784
11785 }
11786 break;
11787
11788 default:
11789 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11790 break;
11791 }
11792
11793 return eRet;
11794 }
11795
_MApi_VDEC_EX_V2_CC_SetBuffStartAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)11796 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_SetBuffStartAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
11797 {
11798 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11799 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11800 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11801
11802 if(pVdecExContext->support_cc[u8Idx] == FALSE)
11803 {
11804 return E_VDEC_EX_RET_UNSUPPORTED;
11805 }
11806
11807 if (!pIn)
11808 {
11809 return E_VDEC_EX_RET_INVALID_PARAM;
11810 }
11811
11812 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11813 {
11814 case E_VDEC_EX_DECODER_MVD:
11815 {
11816 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
11817 MS_VIRT u32StartAdd = 0;
11818 VDEC_EX_CC_InputPara* pInput = (VDEC_EX_CC_InputPara*)pIn;
11819 if (pInput->u32Ver != 0)
11820 {
11821 VDEC_PRINT("%s not supported ver %d\n", __FUNCTION__, pInput->u32Ver);
11822 return E_VDEC_EX_FAIL;
11823 }
11824 u32StartAdd = pInput->u32Val;
11825 MDrv_CC_CM_SetMVDRB_HWAddr(u32Id, u32StartAdd, u8Type);
11826 eRet = E_VDEC_EX_OK;
11827 }
11828 break;
11829 case E_VDEC_EX_DECODER_HVD:
11830 {
11831 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
11832 MS_VIRT u32StartAdd = 0;
11833 VDEC_EX_CC_InputPara* pInput = (VDEC_EX_CC_InputPara*)pIn;
11834 if (pInput->u32Ver != 0)
11835 {
11836 VDEC_PRINT("%s not supported ver %d\n", __FUNCTION__, pInput->u32Ver);
11837 return E_VDEC_EX_FAIL;
11838 }
11839 u32StartAdd = pInput->u32Val;
11840 eRet = MDrv_HVD_EX_CC_Set_RB_StartAddr(u32Id, u32StartAdd, u8Type);
11841
11842 }
11843 break;
11844 default:
11845 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11846 break;
11847 }
11848
11849 return eRet;
11850 }
11851
_MApi_VDEC_EX_V2_CC_UpdateWriteAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)11852 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_UpdateWriteAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
11853 {
11854 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11855 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11856 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11857
11858 if(pVdecExContext->support_cc[u8Idx] == FALSE)
11859 {
11860 return E_VDEC_EX_RET_UNSUPPORTED;
11861 }
11862
11863 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11864 {
11865 case E_VDEC_EX_DECODER_MVD:
11866 {
11867 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
11868 MDrv_CC_CM_SyncMVDRB_SWAddr2HWAddr(u32Id, u8Type);
11869 eRet = E_VDEC_EX_OK;
11870 }
11871 break;
11872 case E_VDEC_EX_DECODER_HVD:
11873 {
11874 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
11875 eRet = MDrv_HVD_EX_CC_SyncRB_RdAddr2WrAddr(u32Id, u8Type);
11876
11877 }
11878 break;
11879 default:
11880 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11881 break;
11882 }
11883
11884 return eRet;
11885 }
11886
_MApi_VDEC_EX_V2_CC_UpdateReadAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)11887 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_UpdateReadAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
11888 {
11889 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11890 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11891 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11892
11893 if(pVdecExContext->support_cc[u8Idx] == FALSE)
11894 {
11895 return E_VDEC_EX_RET_UNSUPPORTED;
11896 }
11897
11898 if (!pIn)
11899 {
11900 return E_VDEC_EX_RET_INVALID_PARAM;
11901 }
11902
11903 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11904 {
11905 case E_VDEC_EX_DECODER_MVD:
11906 {
11907 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
11908 MS_U32 u32EachPktSize = 0;
11909 VDEC_EX_CC_InputPara* pInput = (VDEC_EX_CC_InputPara*)pIn;
11910 if (pInput->u32Ver != 0)
11911 {
11912 VDEC_PRINT("%s not supported ver %d\n", __FUNCTION__, pInput->u32Ver);
11913 return E_VDEC_EX_FAIL;
11914 }
11915 u32EachPktSize = pInput->u32Val;
11916 MDrv_CC_PM_SetMVDRB_ReadAddr(u32Id, u32EachPktSize, u8Type);
11917 eRet = E_VDEC_EX_OK;
11918 }
11919 break;
11920
11921 case E_VDEC_EX_DECODER_HVD:
11922 {
11923 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
11924 MS_U32 u32EachPktSize = 0;
11925 VDEC_EX_CC_InputPara* pInput = (VDEC_EX_CC_InputPara*)pIn;
11926 if (pInput->u32Ver != 0)
11927 {
11928 VDEC_PRINT("%s not supported ver %d\n", __FUNCTION__, pInput->u32Ver);
11929 return E_VDEC_EX_FAIL;
11930 }
11931 u32EachPktSize = pInput->u32Val;
11932 eRet = MDrv_HVD_EX_CC_Adv_RB_ReadAddr(u32Id, u32EachPktSize, u8Type);
11933
11934 }
11935 break;
11936
11937 default:
11938 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11939 break;
11940 }
11941
11942 return eRet;
11943 }
11944
_MApi_VDEC_EX_V2_CC_DisableParsing(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)11945 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_DisableParsing(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
11946 {
11947 VDEC_EX_Result eRet = E_VDEC_EX_OK;
11948 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11949 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11950
11951 if(pVdecExContext->support_cc[u8Idx] == FALSE)
11952 {
11953 return E_VDEC_EX_RET_UNSUPPORTED;
11954 }
11955
11956 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11957 {
11958 case E_VDEC_EX_DECODER_MVD:
11959 {
11960 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
11961 MDrv_CC_CM_DisableParsing(u32Id, u8Type);
11962 eRet = E_VDEC_EX_OK;
11963 }
11964 break;
11965 case E_VDEC_EX_DECODER_HVD:
11966 {
11967 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
11968 eRet = MDrv_HVD_EX_CC_DisableParsing(u32Id, u8Type);
11969
11970 }
11971 break;
11972 default:
11973 eRet = E_VDEC_EX_RET_UNSUPPORTED;
11974 break;
11975 }
11976
11977 return eRet;
11978 }
11979
_MApi_VDEC_EX_V2_IsStepDispDone(VDEC_StreamId * pStreamId)11980 VDEC_EX_Result _MApi_VDEC_EX_V2_IsStepDispDone(VDEC_StreamId *pStreamId)
11981 {
11982 VDEC_EX_Result eRet;
11983 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
11984 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
11985
11986 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
11987 {
11988 case E_VDEC_EX_DECODER_MVD:
11989 {
11990 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_IsStepDispDone(u32Id));
11991 break;
11992 }
11993 case E_VDEC_EX_DECODER_HVD:
11994 {
11995 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsFrameShowed(u32Id));
11996 break;
11997 }
11998 case E_VDEC_EX_DECODER_MJPEG:
11999 {
12000 _VDEC_EX_API_MutexLock();
12001 _BOOL_TO_VDEC_RESULT(eRet, MApi_MJPEG_IsStepPlayDone(u32Id));
12002 _VDEC_EX_API_MutexUnlock();
12003 break;
12004 }
12005 default:
12006 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12007 break;
12008 }
12009
12010 return eRet;
12011 }
12012
_MApi_VDEC_EX_V2_IsStepDecodeDone(VDEC_StreamId * pStreamId)12013 VDEC_EX_Result _MApi_VDEC_EX_V2_IsStepDecodeDone(VDEC_StreamId *pStreamId)
12014 {
12015 VDEC_EX_Result eRet = E_VDEC_EX_OK;
12016 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12017 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12018
12019 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12020 {
12021 case E_VDEC_EX_DECODER_MVD:
12022 {
12023 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_IsStepDecodeDone(u32Id));
12024 break;
12025 }
12026 case E_VDEC_EX_DECODER_HVD:
12027 {
12028 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsStepDecodeDone(u32Id));
12029 break;
12030 }
12031 case E_VDEC_EX_DECODER_MJPEG:
12032 {
12033 _VDEC_EX_API_MutexLock();
12034 _BOOL_TO_VDEC_RESULT(eRet, MApi_MJPEG_IsStepDecodeDone(u32Id));
12035 _VDEC_EX_API_MutexUnlock();
12036 break;
12037 }
12038 default:
12039 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12040 break;
12041 }
12042
12043 return eRet;
12044 }
12045
_MApi_VDEC_EX_V2_GetDispInfo(VDEC_StreamId * pStreamId,VDEC_EX_DispInfo * pDispinfo)12046 VDEC_EX_Result _MApi_VDEC_EX_V2_GetDispInfo(VDEC_StreamId *pStreamId, VDEC_EX_DispInfo *pDispinfo)
12047 {
12048 VDEC_EX_Result eRet = E_VDEC_EX_OK;
12049 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12050 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12051
12052 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12053 {
12054 case E_VDEC_EX_DECODER_MVD:
12055 {
12056 MVD_FrameInfo info;
12057
12058 _VDEC_Memset(&info, 0, sizeof(MVD_FrameInfo));
12059
12060 MDrv_MVD_GetFrameInfo(u32Id, &info);
12061
12062 pDispinfo->u16HorSize = info.u16HorSize;
12063 pDispinfo->u16VerSize = info.u16VerSize;
12064 pDispinfo->u32FrameRate = info.u32FrameRate;
12065 pDispinfo->u8AspectRate = info.u8AspectRate;
12066 pDispinfo->u8Interlace = info.u8Interlace;
12067 pDispinfo->u8AFD = info.u8AFD;
12068 ///VDEC SAR actually means PAR(Pixel Aspect Ratio)
12069 pDispinfo->u16SarWidth = (MS_U16)info.u16par_width;
12070 pDispinfo->u16SarHeight = (MS_U16)info.u16par_height;
12071 if((pDispinfo->u16SarWidth >= 1) && (pDispinfo->u16SarHeight >= 1) &&
12072 (pDispinfo->u16HorSize > 1 ) && (pDispinfo->u16VerSize > 1) &&
12073 (( info.u16CropRight + info.u16CropLeft) < pDispinfo->u16HorSize) &&
12074 ((info.u16CropTop + info.u16CropBottom) <pDispinfo->u16VerSize))
12075 {
12076 pDispinfo->u32AspectWidth = (MS_U32)pDispinfo->u16SarWidth * (MS_U32)(pDispinfo->u16HorSize- ( info.u16CropRight + info.u16CropLeft));
12077 pDispinfo->u32AspectHeight = (MS_U32)pDispinfo->u16SarHeight * (MS_U32)(pDispinfo->u16VerSize - ( info.u16CropTop + info.u16CropBottom));
12078 }
12079 else
12080 {
12081 pDispinfo->u32AspectWidth = pDispinfo->u16HorSize;
12082 pDispinfo->u32AspectHeight = pDispinfo->u16VerSize;
12083 }
12084
12085 pDispinfo->u16CropRight = info.u16CropRight;
12086 pDispinfo->u16CropLeft = info.u16CropLeft;
12087 pDispinfo->u16CropBottom = info.u16CropBottom;
12088 pDispinfo->u16CropTop = info.u16CropTop;
12089 pDispinfo->u16Pitch = info.u16Pitch;
12090 pDispinfo->u16PTSInterval = info.u16PTSInterval;
12091 pDispinfo->u8MPEG1 = info.u8MPEG1;
12092 pDispinfo->u8PlayMode = info.u8PlayMode;
12093 pDispinfo->u8FrcMode = info.u8FrcMode;
12094 pDispinfo->bWithChroma = TRUE;
12095 pDispinfo->bEnableMIUSel = info.bEnableMIUSel;
12096 pDispinfo->u32DynScalingAddr= info.u32DynScalingAddr;
12097 pDispinfo->u8DynScalingDepth= info.u8DynScalingDepth;
12098 pDispinfo->u32DynScalingSize = info.u32DynScalingBufSize;
12099
12100
12101 if (MDrv_MVD_GetVideoRange(u32Id) == 1)
12102 {
12103 pDispinfo->bColorInXVYCC = TRUE;
12104 }
12105 else
12106 {
12107 pDispinfo->bColorInXVYCC = FALSE;
12108 }
12109
12110 eRet = E_VDEC_EX_OK;
12111 break;
12112 }
12113 case E_VDEC_EX_DECODER_HVD:
12114 {
12115 HVD_EX_DispInfo info;
12116
12117 _VDEC_Memset(&info, 0, sizeof(HVD_EX_DispInfo));
12118
12119 if(MDrv_HVD_EX_GetDispInfo(u32Id, &info) == E_HVD_EX_OK)
12120 {
12121 pDispinfo->u16HorSize = info.u16HorSize;
12122 pDispinfo->u16VerSize = info.u16VerSize;
12123 pDispinfo->u32FrameRate = info.u32FrameRate;
12124 pDispinfo->u8AspectRate = info.u8AspectRate;
12125 pDispinfo->u8Interlace = info.u8Interlace;
12126 pDispinfo->u8AFD = info.u8AFD;
12127 pDispinfo->u16SarWidth = info.u16SarWidth;
12128 pDispinfo->u16SarHeight = info.u16SarHeight;
12129
12130 if( (pDispinfo->u16SarWidth >= 1) && (pDispinfo->u16SarHeight >= 1) &&
12131 (pDispinfo->u16HorSize > 1 ) && (pDispinfo->u16VerSize > 1) &&
12132 (( info.u16CropRight + info.u16CropLeft) < pDispinfo->u16HorSize) &&
12133 ((info.u16CropTop + info.u16CropBottom) <pDispinfo->u16VerSize))
12134 {
12135 pDispinfo->u32AspectWidth = (MS_U32)pDispinfo->u16SarWidth * (MS_U32)(pDispinfo->u16HorSize- ( info.u16CropRight + info.u16CropLeft));
12136 pDispinfo->u32AspectHeight = (MS_U32)pDispinfo->u16SarHeight * (MS_U32)(pDispinfo->u16VerSize - ( info.u16CropTop + info.u16CropBottom));
12137 }
12138 else
12139 {
12140 pDispinfo->u32AspectWidth = pDispinfo->u16HorSize;
12141 pDispinfo->u32AspectHeight = pDispinfo->u16VerSize;
12142 }
12143
12144 pDispinfo->u16CropRight = info.u16CropRight;
12145 pDispinfo->u16CropLeft = info.u16CropLeft;
12146 pDispinfo->u16CropBottom = info.u16CropBottom;
12147 pDispinfo->u16CropTop = info.u16CropTop;
12148 pDispinfo->u16Pitch = info.u16Pitch;
12149 pDispinfo->bWithChroma = !(info.bChroma_idc_Mono);
12150 pDispinfo->bColorInXVYCC = TRUE;
12151 pDispinfo->bEnableMIUSel = MDrv_HVD_EX_GetDynamicScalingInfo(u32Id, E_HVD_EX_DS_BUF_MIUSEL);
12152 pDispinfo->u32DynScalingAddr= MDrv_HVD_EX_GetDynamicScalingInfo(u32Id, E_HVD_EX_DS_BUF_ADDR);
12153 pDispinfo->u8DynScalingDepth= MDrv_HVD_EX_GetDynamicScalingInfo(u32Id, E_HVD_EX_DS_VECTOR_DEPTH);
12154 pDispinfo->u32DynScalingSize= MDrv_HVD_EX_GetDynamicScalingInfo(u32Id, E_HVD_EX_DS_BUF_SIZE);
12155
12156 eRet = E_VDEC_EX_OK;
12157 }
12158 else
12159 {
12160 eRet = E_VDEC_EX_FAIL;
12161 }
12162 break;
12163 }
12164 case E_VDEC_EX_DECODER_MJPEG:
12165 {
12166 _VDEC_EX_API_MutexLock();
12167 MJPEG_DISP_INFO info;
12168
12169 _VDEC_Memset(&info, 0, sizeof(MJPEG_DISP_INFO));
12170
12171 if (E_MJPEG_RET_SUCCESS == MApi_MJPEG_GetDispInfo(u32Id, &info))
12172 {
12173 pDispinfo->u16HorSize = info.u16Width;
12174 pDispinfo->u16VerSize = info.u16Height;
12175 pDispinfo->u32FrameRate = info.u32FrameRate;
12176 pDispinfo->u8Interlace = 0; // no interlace
12177 pDispinfo->u8AFD = 0; // not used
12178 pDispinfo->u16SarWidth = 1;
12179 pDispinfo->u16SarHeight = 1;
12180 pDispinfo->u32AspectWidth = pDispinfo->u16HorSize;
12181 pDispinfo->u32AspectHeight = pDispinfo->u16VerSize;
12182 pDispinfo->u16CropRight = info.u16CropRight;
12183 pDispinfo->u16CropLeft = info.u16CropLeft;
12184 pDispinfo->u16CropBottom = info.u16CropBottom;
12185 pDispinfo->u16CropTop = info.u16CropTop;
12186 pDispinfo->u16Pitch = info.u16Pitch;
12187 pDispinfo->u16PTSInterval = 0; //not used
12188 pDispinfo->u8MPEG1 = 0; // not used
12189 pDispinfo->u8PlayMode = 0; // not used
12190 pDispinfo->u8FrcMode = 0; // not used
12191 pDispinfo->u8AspectRate = 0; // not used
12192 pDispinfo->bWithChroma = TRUE;
12193 pDispinfo->bColorInXVYCC = TRUE;
12194 pDispinfo->u32DynScalingAddr = 0; // not used
12195 pDispinfo->u8DynScalingDepth = 0; // not used
12196 pDispinfo->u32DynScalingSize = 0; // not used
12197 pDispinfo->bEnableMIUSel = FALSE; // not used
12198
12199 eRet = E_VDEC_EX_OK;
12200 }
12201 else
12202 {
12203 eRet = E_VDEC_EX_FAIL;
12204 }
12205 _VDEC_EX_API_MutexUnlock();
12206 break;
12207 }
12208 default:
12209 break;
12210 }
12211
12212 return eRet;
12213 }
12214
_MApi_VDEC_EX_V2_IsAVSyncOn(VDEC_StreamId * pStreamId)12215 VDEC_EX_Result _MApi_VDEC_EX_V2_IsAVSyncOn(VDEC_StreamId *pStreamId)
12216 {
12217 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12218 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12219 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12220
12221 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12222 {
12223 case E_VDEC_EX_DECODER_MVD:
12224 {
12225 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_GetIsAVSyncOn(u32Id));
12226 break;
12227 }
12228 case E_VDEC_EX_DECODER_HVD:
12229 {
12230 _BOOL_TO_VDEC_RESULT(eRet, (MS_BOOL) MDrv_HVD_EX_GetPlayMode(u32Id, E_HVD_EX_GMODE_IS_SYNC_ON));
12231 break;
12232 }
12233 case E_VDEC_EX_DECODER_MJPEG:
12234 {
12235 _VDEC_EX_API_MutexLock();
12236 _BOOL_TO_VDEC_RESULT(eRet, MApi_MJPEG_IsAVSyncOn(u32Id));
12237 _VDEC_EX_API_MutexUnlock();
12238 break;
12239 }
12240 default:
12241 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12242 break;
12243 }
12244
12245 return eRet;
12246 }
12247
_MApi_VDEC_EX_V2_IsWithValidStream(VDEC_StreamId * pStreamId)12248 VDEC_EX_Result _MApi_VDEC_EX_V2_IsWithValidStream(VDEC_StreamId *pStreamId)
12249 {
12250 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12251 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12252 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12253
12254 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12255 {
12256 case E_VDEC_EX_DECODER_MVD:
12257 {
12258 if (MDrv_MVD_GetValidStreamFlag(u32Id))
12259 {
12260 eRet = E_VDEC_EX_OK;
12261 }
12262 else
12263 {
12264 eRet = E_VDEC_EX_FAIL;
12265 }
12266
12267 break;
12268 }
12269 case E_VDEC_EX_DECODER_HVD:
12270 case E_VDEC_EX_DECODER_MJPEG:
12271 default:
12272 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12273 break;
12274 }
12275
12276 return eRet;
12277 }
12278
_MApi_VDEC_EX_V2_IsDispFinish(VDEC_StreamId * pStreamId)12279 VDEC_EX_Result _MApi_VDEC_EX_V2_IsDispFinish(VDEC_StreamId *pStreamId)
12280 {
12281 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12282 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12283 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12284
12285 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12286 {
12287 case E_VDEC_EX_DECODER_MVD:
12288 {
12289 _MVD_RET_TO_VDEC_RESULT(eRet, MDrv_MVD_IsDispFinish(u32Id));
12290 break;
12291 }
12292 case E_VDEC_EX_DECODER_HVD:
12293 {
12294 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsDispFinish(u32Id));
12295 break;
12296 }
12297 case E_VDEC_EX_DECODER_MJPEG:
12298 {
12299 _VDEC_EX_API_MutexLock();
12300 _BOOL_TO_VDEC_RESULT(eRet, MApi_MJPEG_IsDispFinish(u32Id));
12301 _VDEC_EX_API_MutexUnlock();
12302 break;
12303 }
12304 default:
12305 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12306 break;
12307 }
12308
12309 return eRet;
12310 }
12311
12312
_MApi_VDEC_EX_V2_IsIFrameFound(VDEC_StreamId * pStreamId)12313 VDEC_EX_Result _MApi_VDEC_EX_V2_IsIFrameFound(VDEC_StreamId *pStreamId)
12314 {
12315 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12316 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12317 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12318
12319 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12320 {
12321 case E_VDEC_EX_DECODER_MVD:
12322 {
12323 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_GetIsIPicFound(u32Id));
12324 break;
12325 }
12326 case E_VDEC_EX_DECODER_HVD:
12327 {
12328 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsIFrmFound(u32Id));
12329 break;
12330 }
12331 case E_VDEC_EX_DECODER_MJPEG:
12332 {
12333 _VDEC_EX_API_MutexLock();
12334 _BOOL_TO_VDEC_RESULT(eRet, MApi_MJPEG_IsIFrameFound(u32Id));
12335 _VDEC_EX_API_MutexUnlock();
12336 break;
12337 }
12338 default:
12339 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12340 break;
12341 }
12342
12343 return eRet;
12344 }
12345
_VDEC_EX_GetSeqChangeInfo(VDEC_StreamId * pStreamId,MS_U32 * param)12346 static VDEC_EX_Result _VDEC_EX_GetSeqChangeInfo(VDEC_StreamId *pStreamId, MS_U32 *param)
12347 {
12348 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12349 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12350 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12351 MS_U32 changeInfo = 0;
12352
12353 if (param == NULL)
12354 {
12355 return E_VDEC_EX_RET_INVALID_PARAM;
12356 }
12357
12358 *param = 0;
12359 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12360 {
12361 case E_VDEC_EX_DECODER_HVD:
12362 changeInfo = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_SEQ_CHANGE_INFO);
12363 if (changeInfo != E_HVD_SEQ_CHANGE_NONE)
12364 {
12365 if (changeInfo & E_HVD_SEQ_CHANGE_FIRST_TIME)
12366 *param |= VDEC_EX_SEQ_CHANGE_FIRST_TIME;
12367 if (changeInfo & E_HVD_SEQ_CHANGE_RESOLUTION)
12368 *param |= VDEC_EX_SEQ_CHANGE_RESOLUTION;
12369 if (changeInfo & E_HVD_SEQ_CHANGE_PICTURE_TYPE)
12370 *param |= VDEC_EX_SEQ_CHANGE_PICTURE_TYPE;
12371 if (changeInfo & E_HVD_SEQ_CHANGE_FRAME_RATE)
12372 *param |= VDEC_EX_SEQ_CHANGE_FRAME_RATE;
12373 if (changeInfo & E_HVD_SEQ_CHANGE_HDR_INFO)
12374 *param |= VDEC_EX_SEQ_CHANGE_HDR_INFO;
12375 eRet = E_VDEC_EX_OK;
12376 }
12377 break;
12378 case E_VDEC_EX_DECODER_MVD:
12379 case E_VDEC_EX_DECODER_MJPEG:
12380 default:
12381 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12382 break;
12383 }
12384
12385 return eRet;
12386 }
12387
_MApi_VDEC_EX_V2_IsSeqChg(VDEC_StreamId * pStreamId)12388 VDEC_EX_Result _MApi_VDEC_EX_V2_IsSeqChg(VDEC_StreamId *pStreamId)
12389 {
12390 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12391 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12392 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12393
12394 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12395 {
12396 case E_VDEC_EX_DECODER_MVD:
12397 {
12398 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_IsSeqChg(u32Id));
12399 break;
12400 }
12401 case E_VDEC_EX_DECODER_HVD:
12402 {
12403 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsDispInfoChg(u32Id));
12404 break;
12405 }
12406 case E_VDEC_EX_DECODER_MJPEG:
12407 eRet = E_VDEC_EX_FAIL;
12408 break;
12409 default:
12410 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12411 break;
12412 }
12413
12414 return eRet;
12415 }
12416
_MApi_VDEC_EX_V2_IsReachSync(VDEC_StreamId * pStreamId)12417 VDEC_EX_Result _MApi_VDEC_EX_V2_IsReachSync(VDEC_StreamId *pStreamId)
12418 {
12419 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12420 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12421 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12422
12423 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12424 {
12425 case E_VDEC_EX_DECODER_MVD:
12426 {
12427 _BOOL_TO_VDEC_RESULT(eRet, (MS_BOOL) (MDrv_MVD_GetSyncStatus(u32Id)==1));
12428 break;
12429 }
12430 case E_VDEC_EX_DECODER_HVD:
12431 {
12432 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsSyncReach(u32Id));
12433 break;
12434 }
12435 case E_VDEC_EX_DECODER_MJPEG:
12436 {
12437 _VDEC_EX_API_MutexLock();
12438 _BOOL_TO_VDEC_RESULT(eRet, MApi_MJPEG_IsReachSync(u32Id));
12439 _VDEC_EX_API_MutexUnlock();
12440 break;
12441 }
12442 default:
12443 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12444 break;
12445 }
12446
12447 return eRet;
12448 }
12449
_MApi_VDEC_EX_V2_IsStartSync(VDEC_StreamId * pStreamId)12450 VDEC_EX_Result _MApi_VDEC_EX_V2_IsStartSync(VDEC_StreamId *pStreamId)
12451 {
12452 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12453 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12454 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12455
12456 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12457 {
12458 case E_VDEC_EX_DECODER_MVD:
12459 {
12460 if (MDrv_MVD_GetIsSyncSkip(u32Id) || MDrv_MVD_GetIsSyncRep(u32Id))
12461 {
12462 eRet = E_VDEC_EX_OK;
12463 }
12464 else
12465 {
12466 eRet = E_VDEC_EX_FAIL;
12467 }
12468 break;
12469 }
12470 case E_VDEC_EX_DECODER_HVD:
12471 {
12472 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsSyncStart(u32Id));
12473 break;
12474 }
12475 case E_VDEC_EX_DECODER_MJPEG:
12476 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12477 break;
12478 default:
12479 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12480 break;
12481 }
12482
12483 return eRet;
12484 }
12485
_MApi_VDEC_EX_V2_IsFreerun(VDEC_StreamId * pStreamId)12486 VDEC_EX_Result _MApi_VDEC_EX_V2_IsFreerun(VDEC_StreamId *pStreamId)
12487 {
12488 VDEC_EX_Result eRet = E_VDEC_EX_OK;
12489 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12490 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12491
12492 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12493 {
12494 case E_VDEC_EX_DECODER_MVD:
12495 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_GetIsFreerun(u32Id));
12496 break;
12497
12498 case E_VDEC_EX_DECODER_HVD:
12499 break;
12500
12501 case E_VDEC_EX_DECODER_MJPEG:
12502 default:
12503 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12504 break;
12505 }
12506
12507 return eRet;
12508 }
12509
_MApi_VDEC_EX_V2_IsWithLowDelay(VDEC_StreamId * pStreamId)12510 VDEC_EX_Result _MApi_VDEC_EX_V2_IsWithLowDelay(VDEC_StreamId *pStreamId)
12511 {
12512 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12513 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12514 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12515
12516 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12517 {
12518 case E_VDEC_EX_DECODER_MVD:
12519 {
12520 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_GetLowDelayFlag(u32Id));
12521 break;
12522 }
12523 case E_VDEC_EX_DECODER_HVD:
12524 {
12525 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsLowDelay(u32Id));
12526 break;
12527 }
12528 case E_VDEC_EX_DECODER_MJPEG:
12529 {
12530 _VDEC_EX_API_MutexLock();
12531 _BOOL_TO_VDEC_RESULT(eRet, MApi_MJPEG_IsWithLowDelay(u32Id));
12532 _VDEC_EX_API_MutexUnlock();
12533 break;
12534 }
12535 default:
12536 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12537 break;
12538 }
12539
12540 return eRet;
12541 }
12542
_MApi_VDEC_EX_V2_IsAllBufferEmpty(VDEC_StreamId * pStreamId)12543 VDEC_EX_Result _MApi_VDEC_EX_V2_IsAllBufferEmpty(VDEC_StreamId *pStreamId)
12544 {
12545 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12546 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12547 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12548
12549 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12550 {
12551 case E_VDEC_EX_DECODER_MVD:
12552 {
12553 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_IsAllBufferEmpty(u32Id));
12554 break;
12555 }
12556 case E_VDEC_EX_DECODER_HVD:
12557 {
12558 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_IsAllBufferEmpty(u32Id));
12559 break;
12560 }
12561 case E_VDEC_EX_DECODER_MJPEG:
12562 eRet = E_VDEC_EX_FAIL;
12563 break;
12564
12565 default:
12566 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12567 break;
12568 }
12569
12570 return eRet;
12571 }
12572
_MApi_VDEC_EX_V2_GetExtDispInfo(VDEC_StreamId * pStreamId,VDEC_EX_ExtDispInfo * pExtDispinfo)12573 VDEC_EX_Result _MApi_VDEC_EX_V2_GetExtDispInfo(VDEC_StreamId *pStreamId, VDEC_EX_ExtDispInfo *pExtDispinfo)
12574 {
12575 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12576 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12577 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12578
12579 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12580 {
12581 case E_VDEC_EX_DECODER_MVD:
12582 {
12583 MVD_ExtDispInfo stExtDispInfo;
12584 _VDEC_Memset(&stExtDispInfo, 0, sizeof(MVD_ExtDispInfo));
12585 if (E_MVD_RET_OK == MDrv_MVD_GetExtDispInfo(u32Id, &stExtDispInfo))
12586 {
12587 pExtDispinfo->u16VSize = stExtDispInfo.u16VSize;
12588 pExtDispinfo->u16HSize = stExtDispInfo.u16HSize;
12589 pExtDispinfo->s16VOffset = (MS_S16)stExtDispInfo.u16VOffset;
12590 pExtDispinfo->s16HOffset = (MS_S16)stExtDispInfo.u16HOffset;
12591 eRet = E_VDEC_EX_OK;
12592 }
12593 else
12594 {
12595 eRet = E_VDEC_EX_FAIL;
12596 }
12597 break;
12598 }
12599 case E_VDEC_EX_DECODER_HVD:
12600 case E_VDEC_EX_DECODER_MJPEG:
12601 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12602 break;
12603
12604 default:
12605 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
12606 break;
12607 }
12608
12609 return eRet;
12610 }
12611
_MApi_VDEC_EX_V2_IsDispQueueEmpty(VDEC_StreamId * pStreamId,MS_BOOL * bEmpty)12612 VDEC_EX_Result _MApi_VDEC_EX_V2_IsDispQueueEmpty(VDEC_StreamId *pStreamId,MS_BOOL* bEmpty)
12613 {
12614 VDEC_EX_Result eRet = E_VDEC_EX_OK;
12615 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12616 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12617
12618 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12619 {
12620 case E_VDEC_EX_DECODER_MVD:
12621 {
12622 *bEmpty = MDrv_MVD_EX_IsDispQueueEmpty(u32Id);
12623 break;
12624 }
12625 case E_VDEC_EX_DECODER_HVD:
12626 {
12627 *bEmpty = MDrv_HVD_EX_IsDispQueueEmpty(u32Id);
12628 break;
12629 }
12630 case E_VDEC_EX_DECODER_MJPEG:
12631 {
12632 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12633 break;
12634 }
12635 default:
12636 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12637 break;
12638 }
12639
12640 return eRet;
12641 }
12642
_MApi_VDEC_EX_V2_GetDecFrameInfo(VDEC_StreamId * pStreamId,VDEC_EX_FrameInfo * pFrmInfo)12643 VDEC_EX_Result _MApi_VDEC_EX_V2_GetDecFrameInfo(VDEC_StreamId *pStreamId, VDEC_EX_FrameInfo *pFrmInfo)
12644 {
12645 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12646 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12647 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12648
12649 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12650 {
12651 case E_VDEC_EX_DECODER_MVD:
12652 {
12653 MVD_FrmInfo stFrm;
12654 _VDEC_Memset(&stFrm, 0, sizeof(MVD_FrmInfo));
12655 if (E_MVD_RET_OK == MDrv_MVD_GetFrmInfo(u32Id, E_MVD_FRMINFO_DECODE, &stFrm))
12656 {
12657 pFrmInfo->eFrameType = _VDEC_EX_MapFrmType2MVD(stFrm.eFrmType);
12658 pFrmInfo->u16Height = stFrm.u16Height;
12659 pFrmInfo->u16Width = stFrm.u16Width;
12660 pFrmInfo->u16Pitch = stFrm.u16Pitch;
12661 pFrmInfo->u32ChromaAddr = stFrm.u32ChromaAddr;
12662 pFrmInfo->u32ID_H = stFrm.u32ID_H;
12663 pFrmInfo->u32ID_L = stFrm.u32ID_L;
12664 pFrmInfo->u32LumaAddr = stFrm.u32LumaAddr;
12665 pFrmInfo->u32TimeStamp = stFrm.u32TimeStamp;
12666 pFrmInfo->eFieldType= E_VDEC_EX_FIELDTYPE_BOTH;
12667
12668 eRet = E_VDEC_EX_OK;
12669 }
12670 else
12671 {
12672 eRet = E_VDEC_EX_FAIL;
12673 }
12674 break;
12675 }
12676 case E_VDEC_EX_DECODER_HVD:
12677 {
12678 HVD_EX_FrameInfo info;
12679 _VDEC_Memset(&info, 0, sizeof(HVD_EX_FrameInfo));
12680 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFrmInfo(u32Id, E_HVD_EX_GFRMINFO_DECODE, &info))
12681 {
12682 pFrmInfo->eFrameType = _VDEC_EX_MapFrmType2HVD(info.eFrmType);
12683 pFrmInfo->u16Height = info.u16Height;
12684 pFrmInfo->u16Width = info.u16Width;
12685 pFrmInfo->u16Pitch = info.u16Pitch;
12686 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
12687 pFrmInfo->u32ID_H = info.u32ID_H;
12688 pFrmInfo->u32ID_L = info.u32ID_L;
12689 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
12690 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
12691 pFrmInfo->eFieldType= _VDEC_EX_MapFieldType2HVD(info.eFieldType);
12692
12693 eRet = E_VDEC_EX_OK;
12694 }
12695 else
12696 {
12697 eRet = E_VDEC_EX_FAIL;
12698 }
12699 break;
12700 }
12701 case E_VDEC_EX_DECODER_MJPEG:
12702 {
12703 _VDEC_EX_API_MutexLock();
12704
12705 MJPEG_FrameInfo info;
12706 _VDEC_Memset(&info, 0, sizeof(MJPEG_FrameInfo));
12707 if (E_MJPEG_RET_SUCCESS == MApi_MJPEG_GetDecFrameInfo(u32Id, &info))
12708 {
12709 pFrmInfo->eFrameType = _VDEC_EX_MapFrmType2MJPEG(info.u8FrmType);
12710 pFrmInfo->u16Height = info.u16Height;
12711 pFrmInfo->u16Width = info.u16Width;
12712 pFrmInfo->u16Pitch = info.u16Pitch;
12713 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
12714 pFrmInfo->u32ID_H = info.u32ID_H;
12715 pFrmInfo->u32ID_L = info.u32ID_L;
12716 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
12717 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
12718 pFrmInfo->eFieldType= E_VDEC_EX_FIELDTYPE_BOTH;
12719
12720 eRet = E_VDEC_EX_OK;
12721 }
12722 else
12723 {
12724 eRet = E_VDEC_EX_FAIL;
12725 }
12726 _VDEC_EX_API_MutexUnlock();
12727 break;
12728 }
12729 default:
12730 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
12731 break;
12732 }
12733
12734 return eRet;
12735 }
12736
_MApi_VDEC_EX_V2_GetDispFrameInfo(VDEC_StreamId * pStreamId,VDEC_EX_FrameInfo * pFrmInfo)12737 VDEC_EX_Result _MApi_VDEC_EX_V2_GetDispFrameInfo(VDEC_StreamId *pStreamId, VDEC_EX_FrameInfo *pFrmInfo)
12738 {
12739 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12740 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12741 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12742
12743 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12744 {
12745 case E_VDEC_EX_DECODER_MVD:
12746 {
12747 MVD_FrmInfo stFrm;
12748 _VDEC_Memset(&stFrm, 0, sizeof(MVD_FrmInfo));
12749 if (E_MVD_RET_OK == MDrv_MVD_GetFrmInfo(u32Id, E_MVD_FRMINFO_DISPLAY, &stFrm))
12750 {
12751 pFrmInfo->eFrameType = _VDEC_EX_MapFrmType2MVD(stFrm.eFrmType);
12752 pFrmInfo->u16Height = stFrm.u16Height;
12753 pFrmInfo->u16Width = stFrm.u16Width;
12754 pFrmInfo->u16Pitch = stFrm.u16Pitch;
12755 pFrmInfo->u32ChromaAddr = stFrm.u32ChromaAddr;
12756 pFrmInfo->u32ID_H = stFrm.u32ID_H;
12757 pFrmInfo->u32ID_L = stFrm.u32ID_L;
12758 pFrmInfo->u32LumaAddr = stFrm.u32LumaAddr;
12759 pFrmInfo->u32TimeStamp = stFrm.u32TimeStamp;
12760 pFrmInfo->eFieldType= E_VDEC_EX_FIELDTYPE_BOTH;
12761 eRet = E_VDEC_EX_OK;
12762 }
12763 else
12764 {
12765 eRet = E_VDEC_EX_FAIL;
12766 }
12767 break;
12768 }
12769
12770 case E_VDEC_EX_DECODER_HVD:
12771 {
12772 HVD_EX_FrameInfo info;
12773
12774 _VDEC_Memset(&info, 0, sizeof(HVD_EX_FrameInfo));
12775
12776 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFrmInfo(u32Id, E_HVD_EX_GFRMINFO_DISPLAY, &info))
12777 {
12778 pFrmInfo->eFrameType = _VDEC_EX_MapFrmType2HVD(info.eFrmType);
12779 pFrmInfo->u16Height = info.u16Height;
12780 pFrmInfo->u16Width = info.u16Width;
12781 pFrmInfo->u16Pitch = info.u16Pitch;
12782 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
12783 pFrmInfo->u32ID_H = info.u32ID_H;
12784 pFrmInfo->u32ID_L = info.u32ID_L;
12785 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
12786 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
12787 pFrmInfo->eFieldType = _VDEC_EX_MapFieldType2HVD(info.eFieldType);
12788 eRet = E_VDEC_EX_OK;
12789 }
12790 else
12791 {
12792 eRet = E_VDEC_EX_FAIL;
12793 }
12794 break;
12795 }
12796 case E_VDEC_EX_DECODER_MJPEG:
12797 {
12798 _VDEC_EX_API_MutexLock();
12799 MJPEG_FrameInfo info;
12800
12801 _VDEC_Memset(&info, 0, sizeof(MJPEG_FrameInfo));
12802
12803 if (E_MJPEG_RET_SUCCESS == MApi_MJPEG_GetDispFrameInfo(u32Id, &info))
12804 {
12805 pFrmInfo->eFrameType = _VDEC_EX_MapFrmType2MJPEG(info.u8FrmType);
12806 pFrmInfo->u16Height = info.u16Height;
12807 pFrmInfo->u16Width = info.u16Width;
12808 pFrmInfo->u16Pitch = info.u16Pitch;
12809 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
12810 pFrmInfo->u32ID_H = info.u32ID_H;
12811 pFrmInfo->u32ID_L = info.u32ID_L;
12812 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
12813 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
12814 pFrmInfo->eFieldType= E_VDEC_EX_FIELDTYPE_BOTH;
12815 eRet = E_VDEC_EX_OK;
12816 }
12817 else
12818 {
12819 eRet = E_VDEC_EX_FAIL;
12820 }
12821 _VDEC_EX_API_MutexUnlock();
12822 break;
12823 }
12824 default:
12825 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
12826 break;
12827 }
12828
12829 return eRet;
12830 }
12831
_MApi_VDEC_EX_V2_GetDecTimeCode(VDEC_StreamId * pStreamId,VDEC_EX_TimeCode * pTimeCode)12832 VDEC_EX_Result _MApi_VDEC_EX_V2_GetDecTimeCode(VDEC_StreamId *pStreamId, VDEC_EX_TimeCode* pTimeCode)
12833 {
12834 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12835 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12836 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12837
12838
12839 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12840 {
12841 case E_VDEC_EX_DECODER_MVD:
12842 {
12843 MVD_TimeCode stTimeCode;
12844 _VDEC_Memset(&stTimeCode, 0, sizeof(MVD_TimeCode));
12845 if (E_MVD_RET_OK == MDrv_MVD_GetTimeCode(u32Id, E_MVD_FRMINFO_DECODE, &stTimeCode))
12846 {
12847 pTimeCode->u8TimeCodeHr = stTimeCode.u8TimeCodeHr ;
12848 pTimeCode->u8TimeCodeMin = stTimeCode.u8TimeCodeMin;
12849 pTimeCode->u8TimeCodeSec = stTimeCode.u8TimeCodeSec;
12850 pTimeCode->u8TimeCodePic = stTimeCode.u8TimeCodePic;
12851 pTimeCode->u8DropFrmFlag = stTimeCode.u8DropFrmFlag;
12852
12853 eRet = E_VDEC_EX_OK;
12854 }
12855 else
12856 {
12857 eRet = E_VDEC_EX_FAIL;
12858 }
12859 break;
12860 }
12861
12862 case E_VDEC_EX_DECODER_HVD:
12863 case E_VDEC_EX_DECODER_MJPEG:
12864 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12865 break;
12866
12867 default:
12868 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
12869 break;
12870 }
12871
12872 return eRet;
12873 }
12874
_MApi_VDEC_EX_V2_GetDispTimeCode(VDEC_StreamId * pStreamId,VDEC_EX_TimeCode * pTimeCode)12875 VDEC_EX_Result _MApi_VDEC_EX_V2_GetDispTimeCode(VDEC_StreamId *pStreamId, VDEC_EX_TimeCode* pTimeCode)
12876 {
12877 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
12878 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12879 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12880
12881 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12882 {
12883 case E_VDEC_EX_DECODER_MVD:
12884 {
12885 MVD_TimeCode stTimeCode;
12886 _VDEC_Memset(&stTimeCode, 0, sizeof(MVD_TimeCode));
12887 if (E_MVD_RET_OK == MDrv_MVD_GetTimeCode(u32Id, E_MVD_FRMINFO_DISPLAY, &stTimeCode))
12888 {
12889 pTimeCode->u8TimeCodeHr = stTimeCode.u8TimeCodeHr ;
12890 pTimeCode->u8TimeCodeMin = stTimeCode.u8TimeCodeMin;
12891 pTimeCode->u8TimeCodeSec = stTimeCode.u8TimeCodeSec;
12892 pTimeCode->u8TimeCodePic = stTimeCode.u8TimeCodePic;
12893 pTimeCode->u8DropFrmFlag = stTimeCode.u8DropFrmFlag;
12894
12895 eRet = E_VDEC_EX_OK;
12896 }
12897 else
12898 {
12899 eRet = E_VDEC_EX_FAIL;
12900 }
12901 break;
12902 }
12903
12904 case E_VDEC_EX_DECODER_HVD:
12905 case E_VDEC_EX_DECODER_MJPEG:
12906 eRet = E_VDEC_EX_RET_UNSUPPORTED;
12907 break;
12908
12909 default:
12910 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
12911 break;
12912 }
12913
12914 return eRet;
12915 }
12916
12917
_MApi_VDEC_EX_V2_GetEventInfo(VDEC_StreamId * pStreamId,MS_U32 * u32EventFlag)12918 VDEC_EX_Result _MApi_VDEC_EX_V2_GetEventInfo(VDEC_StreamId *pStreamId, MS_U32* u32EventFlag)
12919 {
12920 VDEC_EX_Result eRet = E_VDEC_EX_OK;
12921 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
12922 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
12923
12924 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
12925 {
12926 case E_VDEC_EX_DECODER_MVD:
12927 {
12928 eRet = E_VDEC_EX_OK;
12929 break;
12930 }
12931 case E_VDEC_EX_DECODER_HVD:
12932 {
12933 MS_U32 eEvent = E_HVD_EX_ISR_NONE;
12934 if( MDrv_HVD_EX_GetISRInfo(u32Id, &eEvent ) )
12935 {
12936 *u32EventFlag = E_VDEC_EX_EVENT_OFF;
12937 if ( eEvent & E_HVD_EX_ISR_DISP_ONE )
12938 {
12939 *u32EventFlag|=E_VDEC_EX_EVENT_DISP_ONE;
12940 }
12941 if (eEvent &E_HVD_EX_ISR_DISP_REPEAT )
12942 {
12943 *u32EventFlag|=E_VDEC_EX_EVENT_DISP_REPEAT;
12944 }
12945 if (eEvent &E_HVD_EX_ISR_DISP_WITH_CC )
12946 {
12947 *u32EventFlag|=E_VDEC_EX_EVENT_DISP_WITH_CC;
12948 }
12949 if (eEvent &E_HVD_EX_ISR_DISP_FIRST_FRM)
12950 {
12951 *u32EventFlag|=E_VDEC_EX_EVENT_VIDEO_UNMUTE;
12952 }
12953 if (eEvent &E_HVD_EX_ISR_DEC_ONE )
12954 {
12955 *u32EventFlag|=E_VDEC_EX_EVENT_DEC_ONE;
12956 }
12957 if (eEvent &E_HVD_EX_ISR_DEC_I )
12958 {
12959 *u32EventFlag|=E_VDEC_EX_EVENT_DEC_I;
12960 }
12961 if (eEvent &E_HVD_EX_ISR_DEC_HW_ERR )
12962 {
12963 *u32EventFlag|=E_VDEC_EX_EVENT_DEC_ERR;
12964 }
12965 if (eEvent &E_HVD_EX_ISR_DEC_CC_FOUND )
12966 {
12967 *u32EventFlag|=E_VDEC_EX_EVENT_USER_DATA_FOUND;
12968 }
12969 if (eEvent &E_HVD_EX_ISR_DEC_DISP_INFO_CHANGE )
12970 {
12971 MS_U8 u8Afd = MDrv_HVD_EX_GetActiveFormat(u32Id);
12972 if (u8Afd != 0)
12973 {
12974 *u32EventFlag|=E_VDEC_EX_EVENT_AFD_FOUND;
12975 }
12976 *u32EventFlag|=E_VDEC_EX_EVENT_DISP_INFO_CHG;
12977 }
12978 if (eEvent &E_HVD_EX_ISR_DEC_DATA_ERR )
12979 {
12980 *u32EventFlag|=E_VDEC_EX_EVENT_ES_DATA_ERR;
12981 }
12982 if (eEvent &E_HVD_EX_ISR_DEC_FIRST_FRM )
12983 {
12984 *u32EventFlag|=E_VDEC_EX_EVENT_FIRST_FRAME;
12985 }
12986
12987 if (eEvent &E_HVD_EX_ISR_DEC_SEQ_HDR_FOUND )
12988 {
12989 *u32EventFlag|=E_VDEC_EX_EVENT_SEQ_HDR_FOUND;
12990 }
12991 eRet = E_VDEC_EX_OK;
12992 }
12993 else
12994 {
12995 eRet = E_VDEC_EX_FAIL;
12996 }
12997 break;
12998 }
12999 case E_VDEC_EX_DECODER_MJPEG:
13000 eRet = E_VDEC_EX_RET_UNSUPPORTED;
13001 break;
13002 default:
13003 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
13004 break;
13005 }
13006
13007 return eRet;
13008 }
13009
_MApi_VDEC_EX_V2_GetActiveFormat(VDEC_StreamId * pStreamId,MS_U8 * u8ActFmt)13010 VDEC_EX_Result _MApi_VDEC_EX_V2_GetActiveFormat(VDEC_StreamId *pStreamId,MS_U8* u8ActFmt)
13011 {
13012 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13013 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13014 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13015 *u8ActFmt = 0xFF;
13016
13017 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13018 {
13019 case E_VDEC_EX_DECODER_MVD:
13020 {
13021 *u8ActFmt = MDrv_MVD_GetActiveFormat(u32Id);
13022
13023 break;
13024 }
13025 case E_VDEC_EX_DECODER_HVD:
13026 {
13027 *u8ActFmt = MDrv_HVD_EX_GetActiveFormat(u32Id);
13028
13029 break;
13030 }
13031 case E_VDEC_EX_DECODER_MJPEG:
13032 default:
13033 *u8ActFmt = 0xFF;
13034 break;
13035 }
13036
13037 return eRet;
13038 }
13039
13040 //------------------------------------------------------------------------------
13041 /// Get stream colour primaries
13042 /// @param eStream \b IN : stream type
13043 /// @return stream colour primaries
13044 //------------------------------------------------------------------------------
13045
_MApi_VDEC_EX_V2_GetColourPrimaries(VDEC_StreamId * pStreamId,MS_U8 * u8ColourPrimaries)13046 VDEC_EX_Result _MApi_VDEC_EX_V2_GetColourPrimaries(VDEC_StreamId *pStreamId,MS_U8* u8ColourPrimaries)
13047 {
13048 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13049 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13050 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13051 *u8ColourPrimaries = 0xFF;
13052
13053 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13054 {
13055 case E_VDEC_EX_DECODER_MVD:
13056 {
13057 *u8ColourPrimaries = MDrv_MVD_GetColorFormat(u32Id);
13058
13059 break;
13060 }
13061 case E_VDEC_EX_DECODER_HVD:
13062 {
13063 HVD_EX_DispInfo info;
13064
13065 _VDEC_Memset(&info, 0, sizeof(HVD_EX_DispInfo));
13066
13067 if (E_HVD_EX_OK != MDrv_HVD_EX_GetDispInfo(u32Id, &info))
13068 {
13069 *u8ColourPrimaries = 0xFF;
13070 }
13071 else
13072 {
13073 *u8ColourPrimaries = info.u8ColourPrimaries;
13074 }
13075
13076 break;
13077 }
13078 case E_VDEC_EX_DECODER_MJPEG:
13079 default:
13080 *u8ColourPrimaries = 0xFF;
13081 break;
13082 }
13083
13084 return eRet;
13085 }
13086
_MApi_VDEC_EX_V2_GetFwVersion(VDEC_StreamId * pStreamId,VDEC_EX_FwType eFwType,MS_U32 * u32FWVer)13087 VDEC_EX_Result _MApi_VDEC_EX_V2_GetFwVersion(VDEC_StreamId *pStreamId, VDEC_EX_FwType eFwType,MS_U32* u32FWVer)
13088 {
13089 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13090 const MVD_DrvInfo* pMvdDrvInfo = NULL;
13091 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13092 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13093
13094 *u32FWVer = 0;
13095
13096 switch (eFwType)
13097 {
13098 case E_VDEC_EX_FW_TYPE_MVD:
13099 pMvdDrvInfo = MDrv_MVD_GetInfo();
13100 *u32FWVer = pMvdDrvInfo->u32FWVersion;
13101 if ((TRUE == pVdecExContext->_Attr[u8Idx].bInit) && (E_VDEC_EX_DECODER_MVD == pVdecExContext->_Attr[u8Idx].eDecoder))
13102 {
13103 if (MDrv_MVD_GetFWVer(u32Id) != 0)
13104 {
13105 *u32FWVer = MDrv_MVD_GetFWVer(u32Id);
13106 }
13107 }
13108 break;
13109
13110 case E_VDEC_EX_FW_TYPE_HVD:
13111 *u32FWVer = MDrv_HVD_EX_GetDrvFwVer();
13112 if ((TRUE == pVdecExContext->_Attr[u8Idx].bInit) && (E_VDEC_EX_DECODER_HVD == pVdecExContext->_Attr[u8Idx].eDecoder))
13113 {
13114 *u32FWVer = MDrv_HVD_EX_GetFwVer(u32Id);
13115 }
13116 break;
13117
13118 default:
13119 break;
13120 }
13121
13122 return eRet;
13123 }
13124
13125 //------------------------------------------------------------------------------
13126 /// Get picture counter of current GOP
13127 /// @param eStream \b IN : stream type
13128 /// @return picture counter
13129 //------------------------------------------------------------------------------
13130
_MApi_VDEC_EX_V2_GetGOPCnt(VDEC_StreamId * pStreamId,MS_U8 * u8Cnt)13131 VDEC_EX_Result _MApi_VDEC_EX_V2_GetGOPCnt(VDEC_StreamId *pStreamId,MS_U8* u8Cnt)
13132 {
13133 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13134 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13135 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13136
13137 *u8Cnt = 0;
13138
13139 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13140 {
13141 case E_VDEC_EX_DECODER_MVD:
13142 *u8Cnt = MDrv_MVD_GetGOPCount(u32Id);
13143 break;
13144
13145 case E_VDEC_EX_DECODER_HVD:
13146 // not supported in HVD
13147 break;
13148
13149 case E_VDEC_EX_DECODER_MJPEG:
13150 // not supported in MJPEG
13151 break;
13152
13153 default:
13154 break;
13155 }
13156
13157 return eRet;
13158 }
13159
13160 //------------------------------------------------------------------------------
13161 /// Get decoder ES buffer read pointer
13162 /// @param eStream \b IN : stream type
13163 /// @return read pointer
13164 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetESReadPtr(VDEC_StreamId * pStreamId,MS_VIRT * u32Ptr)13165 VDEC_EX_Result _MApi_VDEC_EX_V2_GetESReadPtr(VDEC_StreamId *pStreamId,MS_VIRT* u32Ptr)
13166 {
13167 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13168 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13169 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13170
13171 *u32Ptr = 0;
13172
13173 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13174 {
13175 case E_VDEC_EX_DECODER_MVD:
13176 {
13177 *u32Ptr = (MS_VIRT) MDrv_MVD_GetESReadPtr(u32Id);
13178
13179 break;
13180 }
13181 case E_VDEC_EX_DECODER_HVD:
13182 {
13183 *u32Ptr = MDrv_HVD_EX_GetESReadPtr(u32Id);
13184
13185 break;
13186 }
13187 case E_VDEC_EX_DECODER_MJPEG:
13188 {
13189 _VDEC_EX_API_MutexLock();
13190 *u32Ptr = MApi_MJPEG_GetESReadPtr(u32Id);
13191 _VDEC_EX_API_MutexUnlock();
13192
13193 break;
13194 }
13195 default:
13196 *u32Ptr = 0;
13197 break;
13198 }
13199
13200 return eRet;
13201 }
13202
13203 //------------------------------------------------------------------------------
13204 /// Get ES buffer write pointer
13205 /// @param eStream \b IN : stream type
13206 /// @return write pointer
13207 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetESWritePtr(VDEC_StreamId * pStreamId,MS_VIRT * u32Ptr)13208 VDEC_EX_Result _MApi_VDEC_EX_V2_GetESWritePtr(VDEC_StreamId *pStreamId,MS_VIRT* u32Ptr)
13209 {
13210 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13211 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13212 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13213
13214 *u32Ptr = 0;
13215
13216 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13217 {
13218 case E_VDEC_EX_DECODER_MVD:
13219 {
13220 *u32Ptr = MDrv_MVD_GetESWritePtr(u32Id);
13221
13222 break;
13223 }
13224 case E_VDEC_EX_DECODER_HVD:
13225 {
13226 *u32Ptr = MDrv_HVD_EX_GetESWritePtr(u32Id);
13227
13228 break;
13229 }
13230 case E_VDEC_EX_DECODER_MJPEG:
13231 {
13232 _VDEC_EX_API_MutexLock();
13233 *u32Ptr = MApi_MJPEG_GetESWritePtr(u32Id);
13234 _VDEC_EX_API_MutexUnlock();
13235
13236 break;
13237 }
13238 default:
13239 *u32Ptr = 0;
13240 break;
13241 }
13242
13243 return eRet;
13244 }
13245
13246 //------------------------------------------------------------------------------
13247 /// Get the PTS of current displayed frame
13248 /// @param eStream \b IN : stream type
13249 /// @return PTS
13250 //------------------------------------------------------------------------------
13251
_MApi_VDEC_EX_V2_GetPTS(VDEC_StreamId * pStreamId,MS_U32 * u32Pts)13252 VDEC_EX_Result _MApi_VDEC_EX_V2_GetPTS(VDEC_StreamId *pStreamId,MS_U32* u32Pts)
13253 {
13254 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13255 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13256 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13257
13258 *u32Pts = 0;
13259
13260 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13261 {
13262 case E_VDEC_EX_DECODER_MVD:
13263 {
13264 if(MDrv_MVD_GetPTS(u32Id) != VDEC_U32_MAX)
13265 {
13266 *u32Pts = MDrv_MVD_GetPTS(u32Id) + MDrv_MVD_GetAVSyncDelay(u32Id);
13267 }
13268 else
13269 {
13270 *u32Pts = VDEC_U32_MAX;
13271 }
13272 break;
13273 }
13274 case E_VDEC_EX_DECODER_HVD:
13275 {
13276 *u32Pts = MDrv_HVD_EX_GetPTS(u32Id);
13277
13278 break;
13279 }
13280 case E_VDEC_EX_DECODER_MJPEG:
13281 {
13282 _VDEC_EX_API_MutexLock();
13283 *u32Pts = MApi_MJPEG_GetPTS(u32Id);
13284 _VDEC_EX_API_MutexUnlock();
13285
13286 break;
13287 }
13288 default:
13289 *u32Pts = 0;
13290 break;
13291 }
13292
13293 return eRet;
13294 }
13295
13296 //------------------------------------------------------------------------------
13297 /// Get the PTS of next displayed frame
13298 /// @return next PTS (unit:ms)
13299 //------------------------------------------------------------------------------
13300
_MApi_VDEC_EX_V2_GetNextPTS(VDEC_StreamId * pStreamId,MS_U32 * u32Pts)13301 VDEC_EX_Result _MApi_VDEC_EX_V2_GetNextPTS(VDEC_StreamId *pStreamId,MS_U32* u32Pts)
13302 {
13303 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13304 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13305 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13306
13307 *u32Pts = 0;
13308
13309 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13310 {
13311 case E_VDEC_EX_DECODER_MVD:
13312 *u32Pts = MDrv_MVD_GetNextPTS(u32Id);
13313 break;
13314
13315 case E_VDEC_EX_DECODER_HVD:
13316 *u32Pts = MDrv_HVD_EX_GetNextPTS(u32Id);
13317 break;
13318
13319 case E_VDEC_EX_DECODER_MJPEG:
13320 *u32Pts = 0;
13321 break;
13322
13323 default:
13324 *u32Pts = 0;
13325 break;
13326 }
13327
13328 return eRet;
13329 }
13330
13331 //------------------------------------------------------------------------------
13332 /// Get the value of PTS - STC for video
13333 /// @return the value of PTS - STC for video
13334 //------------------------------------------------------------------------------
13335
_MApi_VDEC_EX_V2_GetVideoPtsStcDelta(VDEC_StreamId * pStreamId,MS_S64 * s64Pts)13336 VDEC_EX_Result _MApi_VDEC_EX_V2_GetVideoPtsStcDelta(VDEC_StreamId *pStreamId,MS_S64* s64Pts)
13337 {
13338 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13339 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13340 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13341
13342 *s64Pts = 0;
13343
13344 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13345 {
13346 case E_VDEC_EX_DECODER_MVD:
13347 *s64Pts = MDrv_MVD_GetPtsStcDiff(u32Id);
13348 //VDEC_PRINT("s64Pts=%lld, s32=%ld\n", s64Pts, MDrv_MVD_GetPtsStcDiff(u32Id));
13349 break;
13350
13351 case E_VDEC_EX_DECODER_HVD:
13352 *s64Pts = MDrv_HVD_EX_GetPtsStcDiff(u32Id);
13353 break;
13354
13355 default:
13356 *s64Pts = 0;
13357 break;
13358 }
13359
13360 return eRet;
13361 }
13362
13363 //------------------------------------------------------------------------------
13364 /// Get error code
13365 /// @param eStream \b IN : stream type
13366 /// @return error code
13367 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetErrCode(VDEC_StreamId * pStreamId,VDEC_EX_ErrCode * eErrCode)13368 VDEC_EX_Result _MApi_VDEC_EX_V2_GetErrCode(VDEC_StreamId *pStreamId,VDEC_EX_ErrCode* eErrCode)
13369 {
13370 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13371 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13372 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13373
13374 if(u8CodecCompare[u8Idx] == 1)
13375 {
13376 pVdecExContext->_Attr[u8Idx].eErrCode = E_VDEC_EX_ERR_CODE_CODEC_COMPARE_CASE1;
13377 }
13378 else if(u8CodecCompare[u8Idx] == 2)
13379 {
13380 pVdecExContext->_Attr[u8Idx].eErrCode = E_VDEC_EX_ERR_CODE_CODEC_COMPARE_CASE2;
13381 }
13382 else
13383 {
13384 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13385 {
13386 case E_VDEC_EX_DECODER_MVD:
13387 {
13388 MVD_ErrCode errCode = E_MVD_ERR_UNKNOWN;
13389 MVD_ErrStatus errStatus = E_MVD_ERR_STATUS_UNKOWN;
13390
13391 MDrv_MVD_GetErrInfo(u32Id, &errCode, &errStatus);
13392
13393 pVdecExContext->_Attr[u8Idx].eErrCode = (VDEC_EX_ErrCode) (errCode + (MS_U32) E_VDEC_EX_MVD_ERR_CODE_BASE);
13394 //Check if framerate is out of HW spec
13395 if (E_MVD_ERR_UNKNOWN == errCode)
13396 {
13397 //VDEC_PRINT("%s(%d) check MVD FrmRate eErrCode=0x%x\n", __FUNCTION__, __LINE__, _Attr[u8Idx].eErrCode);
13398 if (FALSE == MDrv_MVD_GetFrmRateIsSupported(u32Id))
13399 {
13400 pVdecExContext->_Attr[u8Idx].eErrCode = E_VDEC_EX_ERR_CODE_FRMRATE_NOT_SUPPORT;
13401 //VDEC_PRINT("%s(%d) NS!!! eErrCode=0x%x\n", __FUNCTION__, __LINE__, pVdecExContext->_Attr[u8Idx].eErrCode);
13402 }
13403
13404 if ( (bIsSupportDivxPlus == FALSE) && (MDrv_MVD_GetDivxVer(u32Id) != 0) )
13405 {
13406 pVdecExContext->_Attr[u8Idx].eErrCode = E_VDEC_EX_ERR_CODE_DIVX_PLUS_UNSUPPORTED;
13407 }
13408 }
13409
13410 break;
13411 }
13412 case E_VDEC_EX_DECODER_HVD:
13413 {
13414 MS_U32 HVDerrCode = 0;
13415 HVDerrCode = MDrv_HVD_EX_GetErrCode(u32Id);
13416 pVdecExContext->_Attr[u8Idx].eErrCode =(VDEC_EX_ErrCode)_VDEC_Map2HVDErrCode(HVDerrCode);
13417 //Check if framerate is out of HW spec
13418 if (HVDerrCode == 0)
13419 {
13420 //VDEC_PRINT("%s(%d) check HVD FrmRate eErrCode=0x%x\n", __FUNCTION__, __LINE__, _Attr[u8Idx].eErrCode);
13421 if (FALSE == MDrv_HVD_EX_GetFrmRateIsSupported(u32Id))
13422 {
13423 pVdecExContext->_Attr[u8Idx].eErrCode = E_VDEC_EX_ERR_CODE_FRMRATE_NOT_SUPPORT;
13424 //VDEC_PRINT("%s(%d) NS!!! eErrCode=0x%x\n", __FUNCTION__, __LINE__, pVdecExContext->_Attr[u8Idx].eErrCode);
13425 }
13426 }
13427
13428 break;
13429 }
13430 case E_VDEC_EX_DECODER_MJPEG:
13431 {
13432 _VDEC_EX_API_MutexLock();
13433 pVdecExContext->_Attr[u8Idx].eErrCode = (VDEC_EX_ErrCode) (MApi_MJPEG_GetErrCode(u32Id) + (MS_U32) E_VDEC_EX_MJPEG_ERR_CODE_BASE);
13434 _VDEC_EX_API_MutexUnlock();
13435
13436 break;
13437 }
13438 default:
13439 pVdecExContext->_Attr[u8Idx].eErrCode=(VDEC_EX_ErrCode)(0);
13440 break;
13441 }
13442 }
13443
13444 if (((MS_U32)(pVdecExContext->_Attr[u8Idx].eErrCode) & 0x00ffffff) == 0)
13445 {
13446 pVdecExContext->_Attr[u8Idx].eErrCode = (VDEC_EX_ErrCode)(0);
13447 }
13448
13449 *eErrCode = pVdecExContext->_Attr[u8Idx].eErrCode;
13450
13451 return eRet;
13452 }
13453
13454 //------------------------------------------------------------------------------
13455 /// Get accumulated error counter
13456 /// @param eStream \b IN : stream type
13457 /// @return error counter
13458 //------------------------------------------------------------------------------
13459
_MApi_VDEC_EX_V2_GetErrCnt(VDEC_StreamId * pStreamId,MS_U32 * u32Cnt)13460 VDEC_EX_Result _MApi_VDEC_EX_V2_GetErrCnt(VDEC_StreamId *pStreamId,MS_U32* u32Cnt)
13461 {
13462 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13463 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13464 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13465
13466 *u32Cnt = 0;
13467
13468 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13469 {
13470 case E_VDEC_EX_DECODER_MVD:
13471 {
13472 *u32Cnt = MDrv_MVD_GetVldErrCount(u32Id);
13473 break;
13474 }
13475 case E_VDEC_EX_DECODER_HVD:
13476 {
13477 *u32Cnt = MDrv_HVD_EX_GetDecErrCnt(u32Id) + MDrv_HVD_EX_GetDataErrCnt(u32Id);
13478
13479 break;
13480 }
13481 case E_VDEC_EX_DECODER_MJPEG:
13482 {
13483 _VDEC_EX_API_MutexLock();
13484 *u32Cnt = MApi_MJPEG_GetErrCnt(u32Id);
13485 _VDEC_EX_API_MutexUnlock();
13486
13487 break;
13488 }
13489 default:
13490 *u32Cnt = 0;
13491 break;
13492 }
13493
13494 return eRet;
13495 }
13496
13497
13498 //------------------------------------------------------------------------------
13499 /// Get bitrate which decoder retrieved from stream
13500 /// @param eStream \b IN : stream type
13501 /// @return bitrate
13502 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetBitsRate(VDEC_StreamId * pStreamId,MS_U32 * u32Bitrate)13503 VDEC_EX_Result _MApi_VDEC_EX_V2_GetBitsRate(VDEC_StreamId *pStreamId,MS_U32* u32Bitrate)
13504 {
13505 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13506 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13507 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13508
13509 *u32Bitrate = 0;
13510
13511 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13512 {
13513 case E_VDEC_EX_DECODER_MVD:
13514 *u32Bitrate = MDrv_MVD_GetBitsRate(u32Id);
13515 break;
13516 case E_VDEC_EX_DECODER_HVD:
13517 case E_VDEC_EX_DECODER_MJPEG: // unnecessary
13518 default:
13519 *u32Bitrate = 0;
13520 break;
13521 }
13522
13523 return eRet;
13524 }
13525
13526 //-----------------------------------------------------------------------------
13527 /// Get accumulated decoded frame Count
13528 /// @param eStream \b IN : stream type
13529 /// @return - decoded frame Count
13530 //-----------------------------------------------------------------------------
13531
_MApi_VDEC_EX_V2_GetFrameCnt(VDEC_StreamId * pStreamId,MS_U32 * u32Cnt)13532 VDEC_EX_Result _MApi_VDEC_EX_V2_GetFrameCnt(VDEC_StreamId *pStreamId,MS_U32* u32Cnt)
13533 {
13534 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13535 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13536 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13537
13538 *u32Cnt = 0;
13539
13540 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13541 {
13542 case E_VDEC_EX_DECODER_MVD:
13543 {
13544 *u32Cnt = MDrv_MVD_GetPicCounter(u32Id) + MDrv_MVD_GetSkipPicCounter(u32Id);
13545
13546 break;
13547 }
13548 case E_VDEC_EX_DECODER_HVD:
13549 {
13550 *u32Cnt = MDrv_HVD_EX_GetDecodeCnt(u32Id) + MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_SKIP_CNT);
13551
13552 break;
13553 }
13554 case E_VDEC_EX_DECODER_MJPEG:
13555 {
13556 _VDEC_EX_API_MutexLock();
13557 *u32Cnt = MApi_MJPEG_GetFrameCnt(u32Id);
13558 _VDEC_EX_API_MutexUnlock();
13559
13560 break;
13561 }
13562 default:
13563 *u32Cnt = 0;
13564 break;
13565 }
13566
13567 if(pVdecExContext->_power_state[u8Idx] == E_VDEC_EX_POWER_RESUME_DONE && *u32Cnt > 0)
13568 {
13569 if (E_VDEC_EX_CODEC_TYPE_H264 == pVdecExContext->_Attr[u8Idx].eCodecType)
13570 _MApi_VDEC_EX_V2_SetBlueScreen(pStreamId, FALSE);
13571 pVdecExContext->_power_state[u8Idx] = E_VDEC_EX_POWER_NONE;
13572 }
13573
13574 return eRet;
13575 }
13576
13577 //------------------------------------------------------------------------------
13578 /// Get skipped counter
13579 /// @param eStream \b IN : stream type
13580 /// @return counter
13581 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetSkipCnt(VDEC_StreamId * pStreamId,MS_U32 * u32Cnt)13582 VDEC_EX_Result _MApi_VDEC_EX_V2_GetSkipCnt(VDEC_StreamId *pStreamId,MS_U32* u32Cnt)
13583 {
13584 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13585 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13586 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13587
13588 *u32Cnt = 0;
13589
13590 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13591 {
13592 case E_VDEC_EX_DECODER_MVD:
13593 {
13594 *u32Cnt = MDrv_MVD_GetSkipPicCounter(u32Id);
13595 break;
13596 }
13597 case E_VDEC_EX_DECODER_HVD:
13598 {
13599 *u32Cnt = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_SKIP_CNT);
13600 break;
13601 }
13602 case E_VDEC_EX_DECODER_MJPEG:
13603 _VDEC_EX_API_MutexLock();
13604 *u32Cnt = MApi_MJPEG_GetSkipCnt(u32Id);
13605 _VDEC_EX_API_MutexUnlock();
13606 break;
13607
13608 default:
13609 break;
13610 }
13611
13612 return eRet;
13613 }
13614
13615 //------------------------------------------------------------------------------
13616 /// Get dropped frame counter
13617 /// @param eStream \b IN : stream type
13618 /// @return counter
13619 //------------------------------------------------------------------------------
13620
_MApi_VDEC_EX_V2_GetDropCnt(VDEC_StreamId * pStreamId,MS_U32 * u32Cnt)13621 VDEC_EX_Result _MApi_VDEC_EX_V2_GetDropCnt(VDEC_StreamId *pStreamId,MS_U32* u32Cnt)
13622 {
13623 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13624 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13625 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13626
13627 *u32Cnt = 0;
13628
13629 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13630 {
13631 case E_VDEC_EX_DECODER_MVD:
13632 {
13633 *u32Cnt = 0;
13634 break;
13635 }
13636 case E_VDEC_EX_DECODER_HVD:
13637 {
13638 *u32Cnt = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_DROP_CNT);
13639 break;
13640 }
13641 case E_VDEC_EX_DECODER_MJPEG:
13642 break;
13643
13644 default:
13645 break;
13646 }
13647
13648 return eRet;
13649 }
13650
13651 //------------------------------------------------------------------------------
13652 /// Get displayed frame counter
13653 /// @param pStreamId \b IN : pointer to stream ID
13654 /// @return counter
13655 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetDispCnt(VDEC_StreamId * pStreamId,MS_U32 * u32Cnt)13656 VDEC_EX_Result _MApi_VDEC_EX_V2_GetDispCnt(VDEC_StreamId *pStreamId,MS_U32* u32Cnt)
13657 {
13658 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13659 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13660 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13661
13662 *u32Cnt = 0;
13663
13664 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13665 {
13666 case E_VDEC_EX_DECODER_MVD:
13667 *u32Cnt = MDrv_MVD_GetDispCount(u32Id);
13668 break;
13669
13670 case E_VDEC_EX_DECODER_HVD:
13671 *u32Cnt = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_DISP_CNT);
13672 break;
13673
13674 case E_VDEC_EX_DECODER_MJPEG:
13675 break;
13676
13677 default:
13678 *u32Cnt = 0;
13679 break;
13680 }
13681
13682 return eRet;
13683 }
13684
13685 //------------------------------------------------------------------------------
13686 /// Get current queue vacancy
13687 /// @param eStream \b IN : stream type
13688 /// @return vacancy number
13689 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetDecQVacancy(VDEC_StreamId * pStreamId,MS_U32 * u32Vacancy)13690 MS_U32 _MApi_VDEC_EX_V2_GetDecQVacancy(VDEC_StreamId *pStreamId,MS_U32* u32Vacancy)
13691 {
13692 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13693 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13694 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13695
13696 *u32Vacancy = 0;
13697
13698 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13699 {
13700 case E_VDEC_EX_DECODER_MVD:
13701 {
13702 *u32Vacancy = MDrv_MVD_GetQueueVacancy(u32Id, !pVdecExContext->_bVdecDispOutSide[u8Idx]);
13703
13704 break;
13705 }
13706 case E_VDEC_EX_DECODER_HVD:
13707 {
13708 *u32Vacancy = MDrv_HVD_EX_GetBBUVacancy(u32Id);
13709
13710 break;
13711 }
13712 case E_VDEC_EX_DECODER_MJPEG:
13713 {
13714 _VDEC_EX_API_MutexLock();
13715 *u32Vacancy = MApi_MJPEG_GetQueueVacancy(u32Id);
13716 _VDEC_EX_API_MutexUnlock();
13717
13718 break;
13719 }
13720 default:
13721 *u32Vacancy = 0;
13722 break;
13723 }
13724
13725 return eRet;
13726 }
13727
13728 //------------------------------------------------------------------------------
13729 /// Get 3:2 pull down flag which decoder retrieved from stream
13730 /// @param eStream \b IN : stream type
13731 /// @return TRUE/FALSE
13732 //------------------------------------------------------------------------------
13733
_MApi_VDEC_EX_V2_Is32PullDown(VDEC_StreamId * pStreamId,MS_BOOL * bIs32PullDown)13734 VDEC_EX_Result _MApi_VDEC_EX_V2_Is32PullDown(VDEC_StreamId *pStreamId,MS_BOOL* bIs32PullDown)
13735 {
13736 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13737 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13738 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13739
13740 *bIs32PullDown = 0;
13741
13742 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13743 {
13744 case E_VDEC_EX_DECODER_MVD:
13745 *bIs32PullDown = MDrv_MVD_GetIs32PullDown(u32Id);
13746 break;
13747 case E_VDEC_EX_DECODER_HVD:
13748 *bIs32PullDown = (MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_FRC_MODE) == E_HVD_EX_FRC_MODE_32PULLDOWN) ? TRUE : FALSE;
13749 break;
13750 case E_VDEC_EX_DECODER_MJPEG:
13751 default:
13752 *bIs32PullDown = FALSE;
13753 break;
13754 }
13755
13756 return eRet;
13757 }
13758
13759 //------------------------------------------------------------------------------
13760 /// Check whether the status of decoder is running or not.
13761 /// @param eStream \b IN : stream type
13762 /// @return VDEC_EX_Result: E_VDEC_EX_OK/E_VDEC_EX_RET_NOT_RUNNING/E_VDEC_EX_RET_NOT_INIT
13763 //------------------------------------------------------------------------------
13764
_MApi_VDEC_EX_V2_IsAlive(VDEC_StreamId * pStreamId)13765 VDEC_EX_Result _MApi_VDEC_EX_V2_IsAlive(VDEC_StreamId *pStreamId)
13766 {
13767 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13768 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13769 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13770
13771 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13772 {
13773 case E_VDEC_EX_DECODER_MVD:
13774 eRet = MDrv_MVD_IsAlive(u32Id);
13775 break;
13776 case E_VDEC_EX_DECODER_HVD:
13777 {
13778 if (E_HVD_EX_RET_NOT_RUNNING == MDrv_HVD_EX_IsAlive(u32Id))
13779 {
13780 eRet = E_VDEC_EX_RET_NOT_RUNNING;
13781 }
13782 break;
13783 }
13784 case E_VDEC_EX_DECODER_MJPEG:
13785 default:
13786 break;
13787 }
13788
13789 return eRet;
13790 }
13791
13792 //------------------------------------------------------------------------------
13793 /// Check cc is available.
13794 /// @param eStream \b IN : stream type
13795 /// @return VDEC_EX_Result: TRUE or NOT
13796 //------------------------------------------------------------------------------
13797
_MApi_VDEC_EX_V2_IsCCAvailable(VDEC_StreamId * pStreamId,MS_BOOL * is_available)13798 VDEC_EX_Result _MApi_VDEC_EX_V2_IsCCAvailable(VDEC_StreamId *pStreamId,MS_BOOL* is_available)
13799 {
13800 VDEC_EX_Result ret = E_VDEC_EX_OK;
13801 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13802 MS_U32 u32Id = pVdecExContext->_Attr[u8Idx].u32DrvId;
13803
13804 *is_available = FALSE;
13805 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13806 {
13807 case E_VDEC_EX_DECODER_MVD:
13808 {
13809 *is_available = MDrv_MVD_GetUsrDataIsAvailable(u32Id);
13810 break;
13811 }
13812 case E_VDEC_EX_DECODER_HVD:
13813 {
13814 *is_available = MDrv_HVD_EX_GetUsrDataIsAvailable(u32Id);
13815 break;
13816 }
13817 default:
13818 break;
13819 }
13820
13821 return ret;
13822 }
13823
_MApi_VDEC_EX_V2_GetCCInfo(VDEC_StreamId * pStreamId,void * pInfo,MS_U32 u32Size)13824 VDEC_EX_Result _MApi_VDEC_EX_V2_GetCCInfo(VDEC_StreamId *pStreamId, void *pInfo, MS_U32 u32Size)
13825 {
13826 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
13827 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13828 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13829
13830 if(pVdecExContext->support_cc[u8Idx] == FALSE)
13831 {
13832 return E_VDEC_EX_RET_UNSUPPORTED;
13833 }
13834
13835 MS_U32 u32Version = *((MS_U32 *) pInfo);
13836
13837 if (u32Version == 0 && u32Size == sizeof(VDEC_EX_CC_Info))
13838 {
13839 VDEC_EX_CC_Info *pCCInfo = (VDEC_EX_CC_Info *) pInfo;
13840
13841 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13842 {
13843 case E_VDEC_EX_DECODER_MVD:
13844 {
13845 MVD_UsrDataInfo stUsrInfo;
13846 _VDEC_Memset(&stUsrInfo, 0, sizeof(MVD_UsrDataInfo));
13847
13848 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_GetUsrDataInfo(u32Id, &stUsrInfo));
13849 if (E_VDEC_EX_OK == eRet)
13850 {
13851 pCCInfo->u8PicStructure = (VDEC_EX_PicStructure)stUsrInfo.u8PicStruct;
13852 pCCInfo->u8TopFieldFirst = stUsrInfo.u8TopFieldFirst;
13853 pCCInfo->u16TempRef = stUsrInfo.u16TmpRef;
13854 pCCInfo->u32Pts = stUsrInfo.u32Pts;
13855 #if 1//#ifdef VDEC_UTOPIA_2K
13856 pCCInfo->u32UserDataBuf = MsOS_VA2PA(stUsrInfo.u32DataBuf);
13857 #else
13858 pCCInfo->u32UserDataBuf = stUsrInfo.u32DataBuf;
13859 #endif
13860
13861 pCCInfo->u32UserDataSize = stUsrInfo.u8ByteCnt;
13862
13863 if(1 == stUsrInfo.u8PicType) //according Mvd4_interface.h
13864 pCCInfo->eFrameType = E_VDEC_EX_FRM_TYPE_I;
13865 else if(2 == stUsrInfo.u8PicType)
13866 pCCInfo->eFrameType = E_VDEC_EX_FRM_TYPE_P;
13867 else if(3 == stUsrInfo.u8PicType)
13868 pCCInfo->eFrameType = E_VDEC_EX_FRM_TYPE_B;
13869 else
13870 pCCInfo->eFrameType = E_VDEC_EX_FRM_TYPE_OTHER;
13871 }
13872 break;
13873 }
13874 case E_VDEC_EX_DECODER_HVD:
13875 {
13876 HVD_EX_UserData_Info stUsrInfo;
13877 _VDEC_Memset(&stUsrInfo, 0, sizeof(HVD_EX_UserData_Info));
13878
13879
13880 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_GetUserDataInfo(u32Id, &stUsrInfo));
13881 if (E_VDEC_EX_OK == eRet)
13882 {
13883 pCCInfo->u8PicStructure = (VDEC_EX_PicStructure)stUsrInfo.u8PicStruct;
13884 pCCInfo->u8TopFieldFirst = stUsrInfo.u8TopFieldFirst;
13885 pCCInfo->u16TempRef = stUsrInfo.u16TmpRef;
13886 pCCInfo->u32Pts = stUsrInfo.u32Pts;
13887 #if 1//#ifdef VDEC_UTOPIA_2K
13888 pCCInfo->u32UserDataBuf = MsOS_VA2PA(stUsrInfo.u32DataBuf);
13889 #else
13890 pCCInfo->u32UserDataBuf = stUsrInfo.u32DataBuf;
13891 #endif
13892 pCCInfo->u32UserDataSize = stUsrInfo.u8ByteCnt;
13893 }
13894 break;
13895 }
13896 case E_VDEC_EX_DECODER_MJPEG:
13897 {
13898 break;
13899 }
13900 default:
13901 break;
13902 }
13903 }
13904
13905 return eRet;
13906 }
13907
13908 //------------------------------------------------------------------------------
13909 /// Get current trick decode mode of decoder
13910 /// @param eStream \b IN : stream type
13911 /// @return VDEC_EX_TrickDec
13912 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetTrickMode(VDEC_StreamId * pStreamId,VDEC_EX_TrickDec * eTrick)13913 VDEC_EX_Result _MApi_VDEC_EX_V2_GetTrickMode(VDEC_StreamId *pStreamId,VDEC_EX_TrickDec* eTrick)
13914 {
13915 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13916 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13917 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
13918
13919 *eTrick = E_VDEC_EX_TRICK_DEC_ALL;
13920
13921 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
13922 {
13923 case E_VDEC_EX_DECODER_MVD:
13924 {
13925 MVD_TrickDec dec = MDrv_MVD_GetTrickMode(u32Id);
13926
13927 if (E_MVD_TRICK_DEC_ALL == dec)
13928 {
13929 *eTrick = E_VDEC_EX_TRICK_DEC_ALL;
13930 }
13931 else if (E_MVD_TRICK_DEC_IP == dec)
13932 {
13933 *eTrick = E_VDEC_EX_TRICK_DEC_IP;
13934 }
13935 else if (E_MVD_TRICK_DEC_I == dec)
13936 {
13937 *eTrick = E_VDEC_EX_TRICK_DEC_I;
13938 }
13939 else
13940 {
13941 *eTrick = E_VDEC_EX_TRICK_DEC_NUM;
13942 }
13943
13944 break;
13945 }
13946 case E_VDEC_EX_DECODER_HVD:
13947 {
13948 HVD_EX_SkipDecode dec = (HVD_EX_SkipDecode) MDrv_HVD_EX_GetPlayMode(u32Id, E_HVD_EX_GMODE_SKIP_MODE);
13949
13950 if (E_HVD_EX_SKIP_DECODE_ALL == dec)
13951 {
13952 *eTrick = E_VDEC_EX_TRICK_DEC_ALL;
13953 }
13954 else if (E_HVD_EX_SKIP_DECODE_I == dec)
13955 {
13956 *eTrick = E_VDEC_EX_TRICK_DEC_I;
13957 }
13958 else if (E_HVD_EX_SKIP_DECODE_IP == dec)
13959 {
13960 *eTrick = E_VDEC_EX_TRICK_DEC_IP;
13961 }
13962 else
13963 {
13964 *eTrick = E_VDEC_EX_TRICK_DEC_NUM;
13965 }
13966
13967 break;
13968 }
13969 case E_VDEC_EX_DECODER_MJPEG:
13970 break;
13971 default:
13972 break;
13973 }
13974
13975 return eRet;
13976 }
13977
13978 //------------------------------------------------------------------------------
13979 /// Get codec type which be initialed
13980 /// @param eStream \b IN : stream type
13981 /// @return VDEC_EX_CodecType
13982 //------------------------------------------------------------------------------
13983
_MApi_VDEC_EX_V2_GetActiveCodecType(VDEC_StreamId * pStreamId,VDEC_EX_CodecType * CodecType)13984 VDEC_EX_Result _MApi_VDEC_EX_V2_GetActiveCodecType(VDEC_StreamId *pStreamId,VDEC_EX_CodecType* CodecType)
13985 {
13986 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
13987 VDEC_EX_Result eRet = E_VDEC_EX_OK;
13988
13989 *CodecType = pVdecExContext->_Attr[u8Idx].eCodecType;
13990
13991 return eRet;
13992 }
13993
13994 //------------------------------------------------------------------------------
13995 /// Get the information of the least length of pattern used for specific function
13996 /// @param eStream \b IN : stream type
13997 /// @param pFrmInfo \b IN : the information of the least length of pattern used for specific function
13998 /// @return -the length (Bytes)
13999 //------------------------------------------------------------------------------
14000
_MApi_VDEC_EX_V2_GetPatternLeastLength(VDEC_StreamId * pStreamId,VDEC_EX_PatternType ePatternType,MS_U32 * length)14001 VDEC_EX_Result _MApi_VDEC_EX_V2_GetPatternLeastLength(VDEC_StreamId *pStreamId, VDEC_EX_PatternType ePatternType,MS_U32* length)
14002 {
14003 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14004 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14005 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14006
14007 *length = 0;
14008
14009 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14010 {
14011 case E_VDEC_EX_DECODER_MVD:
14012 {
14013 *length = MDrv_MVD_GetPatternInfo();
14014
14015 break;
14016 }
14017 case E_VDEC_EX_DECODER_HVD:
14018 {
14019 if (ePatternType == E_VDEC_EX_PATTERN_FLUSH)
14020 {
14021 *length = MDrv_HVD_EX_GetPatternInfo(u32Id, E_HVD_EX_FLUSH_PATTERN_SIZE);
14022 }
14023 else if (ePatternType == E_VDEC_EX_PATTERN_FILEEND)
14024 {
14025 *length = MDrv_HVD_EX_GetPatternInfo(u32Id, E_HVD_EX_DUMMY_HW_FIFO);
14026 }
14027 break;
14028 }
14029 case E_VDEC_EX_DECODER_MJPEG:
14030 break;
14031
14032 default:
14033 break;
14034 }
14035
14036 return eRet;
14037 }
14038
14039 //------------------------------------------------------------------------------
14040 /// For MHEG5 MW, check if I frame decode done
14041 /// @param eStream \b IN : stream type
14042 /// @return VDEC_EX_Result
14043 /// - E_VDEC_EX_OK: decode done
14044 /// - E_VDEC_EX_FAIL: not yet
14045 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
14046 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
14047 //------------------------------------------------------------------------------
14048
_MApi_VDEC_EX_V2_MHEG_IsIFrameDecoding(VDEC_StreamId * pStreamId)14049 VDEC_EX_Result _MApi_VDEC_EX_V2_MHEG_IsIFrameDecoding(VDEC_StreamId *pStreamId)
14050 {
14051 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
14052 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14053 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14054
14055 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14056 {
14057 case E_VDEC_EX_DECODER_MVD:
14058 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_GetIsIFrameDecoding(u32Id));
14059 break;
14060
14061 case E_VDEC_EX_DECODER_HVD:
14062 case E_VDEC_EX_DECODER_MJPEG:
14063 default:
14064 eRet = E_VDEC_EX_RET_UNSUPPORTED;
14065 break;
14066 }
14067
14068 return eRet;
14069 }
14070
14071 //------------------------------------------------------------------------------
14072 /// [Obsolete] Get write pointer of CC data buffer.
14073 /// @param eStream \b IN : stream type
14074 /// @param pu32Write \b OUT : current write pointer
14075 /// @return -VDEC_EX_Result
14076 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_CC_GetWritePtr(VDEC_StreamId * pStreamId,MS_U32 * pu32Write)14077 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetWritePtr(VDEC_StreamId *pStreamId, MS_U32 *pu32Write)
14078 {
14079 VDEC_PRINT("%s is obsolete\n", __FUNCTION__);
14080 UNUSED(pStreamId);
14081 UNUSED(pu32Write);
14082 return E_VDEC_EX_RET_UNSUPPORTED;
14083 }
14084
14085 //------------------------------------------------------------------------------
14086 /// [Obsolete] Get the read pointer of CC data buffer.
14087 /// @param eStream \b IN : stream type
14088 /// @param pu32Read \b OUT : current read pointer
14089 /// @return -VDEC_EX_Result
14090 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_CC_GetReadPtr(VDEC_StreamId * pStreamId,MS_U32 * pu32Read)14091 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetReadPtr(VDEC_StreamId *pStreamId, MS_U32 *pu32Read)
14092 {
14093 VDEC_PRINT("%s is obsolete\n", __FUNCTION__);
14094 UNUSED(pStreamId);
14095 UNUSED(pu32Read);
14096 return E_VDEC_EX_RET_UNSUPPORTED;
14097 }
14098
14099 //------------------------------------------------------------------------------
14100 /// [Obsolete] Get if CC data buffer is overflow.
14101 /// @param eStream \b IN : stream type
14102 /// @param pbOverflow \b OUT : overflow flag
14103 /// @return -VDEC_EX_Result
14104 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_CC_GetIsOverflow(VDEC_StreamId * pStreamId,MS_BOOL * pbOverflow)14105 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetIsOverflow(VDEC_StreamId *pStreamId, MS_BOOL *pbOverflow)
14106 {
14107 VDEC_PRINT("%s is obsolete\n", __FUNCTION__);
14108 UNUSED(pStreamId);
14109 UNUSED(pbOverflow);
14110 return E_VDEC_EX_RET_UNSUPPORTED;
14111 }
14112
14113 //------------------------------------------------------------------------------
14114 /// [Obsolete] Get HW key
14115 /// @param eStream \b IN : stream type
14116 /// @return -VDEC_EX_Result
14117 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetHWKey(VDEC_StreamId * pStreamId,MS_U8 * pu8Key)14118 VDEC_EX_Result _MApi_VDEC_EX_V2_GetHWKey(VDEC_StreamId *pStreamId, MS_U8 *pu8Key)
14119 {
14120 VDEC_EX_Result eRet = E_VDEC_EX_RET_UNSUPPORTED;
14121 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14122 UNUSED(pu8Key);
14123
14124 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14125 {
14126 case E_VDEC_EX_DECODER_MVD:
14127 break;
14128
14129 case E_VDEC_EX_DECODER_HVD:
14130 case E_VDEC_EX_DECODER_MJPEG:
14131 eRet = E_VDEC_EX_RET_UNSUPPORTED;
14132 break;
14133
14134 default:
14135 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
14136 break;
14137 }
14138
14139 return eRet;
14140 }
14141
14142 //------------------------------------------------------------------------------
14143 /// [Obsolete] Get ES buffer vancacy
14144 /// @param eStream \b IN : stream type
14145 /// @return -VDEC_EX_Result
14146 //------------------------------------------------------------------------------
14147
_MApi_VDEC_EX_V2_GetESBuffVacancy(VDEC_StreamId * pStreamId,MS_U32 * u32ESBuffVacancy)14148 VDEC_EX_Result _MApi_VDEC_EX_V2_GetESBuffVacancy(VDEC_StreamId *pStreamId, MS_U32* u32ESBuffVacancy)
14149 {
14150 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14151
14152 *u32ESBuffVacancy = _VDEC_EX_GetESBuffVacancy(pStreamId);
14153
14154 return eRet;
14155 }
14156
14157 //------------------------------------------------------------------------------
14158 /// [Obsolete] Get ES buffer
14159 /// @param eStream \b IN : stream type
14160 /// @return -VDEC_EX_Result
14161 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetESBuff(VDEC_StreamId * pStreamId,MS_U32 u32ReqSize,MS_U32 * u32AvailSize,MS_PHY * u32Addr)14162 VDEC_EX_Result _MApi_VDEC_EX_V2_GetESBuff(VDEC_StreamId *pStreamId, MS_U32 u32ReqSize, MS_U32 *u32AvailSize, MS_PHY *u32Addr)
14163 {
14164 MS_VIRT u32ReadPtr = 0;
14165 MS_VIRT u32WritePtr = 0;
14166 MS_VIRT u32WritePtrNew = 0;
14167 MS_VIRT u32BuffSt = 0;
14168 MS_VIRT u32BuffEnd = 0;
14169 MS_VIRT u32Vacancy = 0;
14170 VDEC_EX_SysCfg *pCfg = NULL;
14171 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14172 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14173 MS_U32 u32paddingsize = 0;
14174
14175 #ifndef VDEC3
14176 if(pVdecExContext->bEnableAutoInsertDummyPattern[u8Idx] == TRUE && pVdecExContext->_Attr[u8Idx].eDecoder == E_VDEC_EX_DECODER_MVD)
14177 #endif
14178 {
14179 u32paddingsize = 256; // mvd fifo size 256 bytes
14180 }
14181
14182 u32ReqSize += u32paddingsize;
14183
14184 pCfg = &(pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig);
14185
14186 if (!(pVdecExContext->_bEsBufMgmt[u8Idx]))
14187 {
14188 //VDEC_PRINT("Please EnableESBuffMalloc before use GetESBuff\n");
14189 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
14190 }
14191
14192 //check input parameters
14193 if ((NULL == u32AvailSize) || (NULL == u32Addr))
14194 {
14195 //VDEC_PRINT("NULL pointer for output\n");
14196 return E_VDEC_EX_RET_INVALID_PARAM;
14197 }
14198
14199 if(pVdecExContext->bFlush[u8Idx] == TRUE)
14200 {
14201 if((pCfg->u32BitstreamBufSize-pCfg->u32DrvProcBufSize) < (u32ReqSize+ES_SAFE_SIZE))
14202 {
14203 VDEC_INFO(u8Idx, VDEC_PRINT("ESVaca(%x) < ReqSize(%x)\n", (unsigned int)(pCfg->u32BitstreamBufSize-pCfg->u32DrvProcBufSize), (unsigned int)u32ReqSize));
14204 return E_VDEC_EX_FAIL;
14205 }
14206
14207 u32WritePtr = pCfg->u32DrvProcBufSize;
14208 u32ReadPtr = pCfg->u32DrvProcBufSize;
14209
14210 *u32Addr = u32WritePtr + pCfg->u32BitstreamBufAddr;
14211 *u32AvailSize = u32ReqSize+ES_SAFE_SIZE-u32paddingsize;
14212
14213 VDEC_INFO(u8Idx, VDEC_PRINT("Rd=0x%lx, Wr=0x%lx, WrNew=0x%lx, BsBuff=0x%lx, ReqSize=0x%x\n", (unsigned long)u32ReadPtr, (unsigned long)u32WritePtr,
14214 (unsigned long)(u32WritePtr+(*u32AvailSize)), (unsigned long)pCfg->u32BitstreamBufAddr, u32ReqSize));
14215
14216 pVdecExContext->bFlush[u8Idx] = FALSE;
14217
14218 return E_VDEC_EX_OK;
14219
14220 }
14221
14222 if (_VDEC_EX_GetESBuffVacancy(pStreamId) < u32ReqSize)
14223 {
14224 VDEC_INFO(u8Idx, VDEC_PRINT("ESVaca(0x%lx) < ReqSize(0x%x)\n", (unsigned long)_VDEC_EX_GetESBuffVacancy(pStreamId), u32ReqSize));
14225 return E_VDEC_EX_FAIL;
14226 }
14227
14228 //check DecCmdQ/BBU vacancy
14229 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14230 {
14231 case E_VDEC_EX_DECODER_MVD:
14232 {
14233 u32Vacancy = MDrv_MVD_GetQueueVacancy(u32Id, TRUE);
14234 break;
14235 }
14236 case E_VDEC_EX_DECODER_HVD:
14237 {
14238 u32Vacancy = MDrv_HVD_EX_GetBBUVacancy(u32Id);
14239 break;
14240 }
14241 case E_VDEC_EX_DECODER_MJPEG:
14242 {
14243 _VDEC_EX_API_MutexLock();
14244 u32Vacancy = MApi_MJPEG_GetQueueVacancy(u32Id);
14245 _VDEC_EX_API_MutexUnlock();
14246 break;
14247 }
14248 default:
14249 {
14250 u32Vacancy = 0;
14251 break;
14252 }
14253 }
14254
14255 if(u32Vacancy == 0)
14256 {
14257 VDEC_INFO(u8Idx, VDEC_PRINT("DecQ full\n"));
14258 goto _NO_ES_BUFF;
14259 }
14260
14261 #if 0//_VDEC_PTS_TABLE
14262 if (_VDEC_PtsTableIsFull())
14263 {
14264 VDEC_INFO(u8Idx, VDEC_INFO("PtsTable full\n"));
14265 goto _NO_ES_BUFF;
14266 }
14267 #endif
14268
14269 //check ES read/write pointer
14270
14271 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14272 {
14273 case E_VDEC_EX_DECODER_MVD:
14274 {
14275 u32ReadPtr = MDrv_MVD_GetESReadPtr(u32Id);
14276 u32WritePtr = MDrv_MVD_GetESWritePtr(u32Id);
14277 break;
14278 }
14279 case E_VDEC_EX_DECODER_HVD:
14280 {
14281 u32ReadPtr = MDrv_HVD_EX_GetESReadPtr(u32Id);
14282 u32WritePtr = MDrv_HVD_EX_GetESWritePtr(u32Id);
14283 break;
14284 }
14285 case E_VDEC_EX_DECODER_MJPEG:
14286 {
14287 _VDEC_EX_API_MutexLock();
14288 u32ReadPtr = MApi_MJPEG_GetESReadPtr(u32Id);
14289 u32WritePtr = MApi_MJPEG_GetESWritePtr(u32Id);
14290 _VDEC_EX_API_MutexUnlock();
14291 break;
14292 }
14293 default:
14294 u32ReadPtr = u32WritePtr = 0;
14295 break;
14296 }
14297
14298 u32BuffSt = pCfg->u32DrvProcBufSize;
14299 u32BuffEnd = pCfg->u32BitstreamBufSize;
14300
14301 if (u32WritePtr == 0)
14302 {
14303 u32WritePtr = u32BuffSt;
14304 }
14305
14306 u32WritePtr = ((u32WritePtr+3)>>2)<<2; //4 byte alignment
14307
14308 u32ReqSize += ES_SAFE_SIZE; //for safety
14309 u32WritePtrNew = u32WritePtr + u32ReqSize;
14310
14311 if (u32ReadPtr <= u32WritePtr)
14312 {
14313 if (u32WritePtrNew >= u32BuffEnd)
14314 {
14315 u32WritePtrNew = u32BuffSt + u32ReqSize;
14316
14317 if (u32WritePtrNew > u32ReadPtr)
14318 {
14319 VDEC_INFO(u8Idx, VDEC_PRINT("xRd=0x%lx, Wr=0x%lx, WrNew=0x%lx, BsBuff=0x%lx, ReqSize=0x%x\n", (unsigned long)u32ReadPtr, (unsigned long)u32WritePtr,
14320 (unsigned long)u32WritePtrNew, (unsigned long)(pCfg->u32BitstreamBufAddr), u32ReqSize));
14321 goto _NO_ES_BUFF;
14322 }
14323
14324 u32WritePtr = u32BuffSt;
14325 }
14326 }
14327 else
14328 {
14329 if (u32WritePtrNew > u32ReadPtr)
14330 {
14331 VDEC_INFO(u8Idx, VDEC_PRINT("xRd=0x%lx, Wr=0x%lx, WrNew=0x%lx, BsBuff=0x%lx, ReqSize=0x%x\n", (unsigned long)u32ReadPtr, (unsigned long)u32WritePtr,
14332 (unsigned long)u32WritePtrNew, (unsigned long)pCfg->u32BitstreamBufAddr, u32ReqSize));
14333 goto _NO_ES_BUFF;
14334 }
14335 }
14336
14337 *u32Addr = u32WritePtr + pCfg->u32BitstreamBufAddr;
14338 *u32AvailSize = u32ReqSize-u32paddingsize;
14339 VDEC_INFO(u8Idx, VDEC_PRINT("Rd=0x%lx, Wr=0x%lx, WrNew=0x%lx, BsBuff=0x%lx, ReqSize=0x%x\n", (unsigned long)u32ReadPtr, (unsigned long)u32WritePtr,
14340 (unsigned long)u32WritePtrNew, (unsigned long)pCfg->u32BitstreamBufAddr, u32ReqSize));
14341
14342 return E_VDEC_EX_OK;
14343
14344 _NO_ES_BUFF:
14345 *u32AvailSize = 0;
14346 *u32Addr = NULL;
14347 return E_VDEC_EX_FAIL;
14348 }
14349
_MApi_VDEC_EX_V2_GetNextDispFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame * pDispFrm)14350 VDEC_EX_Result _MApi_VDEC_EX_V2_GetNextDispFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame *pDispFrm)
14351 {
14352 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14353 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14354 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14355
14356 if (!pDispFrm)
14357 {
14358 return E_VDEC_EX_RET_INVALID_PARAM;
14359 }
14360
14361 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14362 {
14363 case E_VDEC_EX_DECODER_MVD:
14364 {
14365 MVD_FrmInfo stFrm;
14366 _VDEC_Memset(&stFrm, 0, sizeof(MVD_FrmInfo));
14367 if (E_MVD_RET_OK != MDrv_MVD_GetFrmInfo(u32Id, E_MVD_FRMINFO_NEXT_DISPLAY, &stFrm))
14368 {
14369 return E_VDEC_EX_FAIL;
14370 }
14371
14372 VDEC_EX_DispFrame *pDispFrm_tmp = _VDEC_EX_MallocDq(u8Idx);
14373 if (!pDispFrm_tmp)
14374 {
14375 //VDEC_PRINT("No available DispQ!!!\n");
14376 eRet = E_VDEC_EX_FAIL;
14377 break;
14378 }
14379
14380 pDispFrm->u32Idx = pDispFrm_tmp->u32Idx;
14381 pDispFrm->stFrmInfo.eFrameType = _VDEC_EX_MapFrmType2MVD(stFrm.eFrmType);
14382 pDispFrm->stFrmInfo.u16Height = stFrm.u16Height;
14383 pDispFrm->stFrmInfo.u16Width = stFrm.u16Width;
14384 pDispFrm->stFrmInfo.u16Pitch = stFrm.u16Pitch;
14385 pDispFrm->stFrmInfo.u32ChromaAddr = stFrm.u32ChromaAddr;
14386 pDispFrm->stFrmInfo.u32ID_H = stFrm.u32ID_H;
14387 pDispFrm->stFrmInfo.u32ID_L = stFrm.u32ID_L;
14388 pDispFrm->stFrmInfo.u32LumaAddr = stFrm.u32LumaAddr;
14389 pDispFrm->stFrmInfo.u32TimeStamp = stFrm.u32TimeStamp;
14390 pDispFrm->stFrmInfo.eFieldType = E_VDEC_EX_FIELDTYPE_BOTH;
14391 pDispFrm->u32PriData = stFrm.u16FrmIdx;
14392 //VDEC_PRINT("apiVDEC_MVD pts=%ld, frmIdx=%d\n", pDispFrm->stFrmInfo.u32TimeStamp, stFrm.u16FrmIdx);
14393
14394 eRet = E_VDEC_EX_OK;
14395 break;
14396 }
14397 case E_VDEC_EX_DECODER_HVD:
14398 {
14399 HVD_EX_FrameInfo info;
14400 _VDEC_Memset(&info, 0, sizeof(HVD_EX_FrameInfo));
14401 if (E_HVD_EX_OK != MDrv_HVD_EX_GetFrmInfo(u32Id, E_HVD_EX_GFRMINFO_NEXT_DISPLAY, &info))
14402 {
14403 return E_VDEC_EX_FAIL;
14404 }
14405 VDEC_EX_DispFrame *pDispFrm_tmp = _VDEC_EX_MallocDq(u8Idx);
14406
14407 if (!pDispFrm_tmp)
14408 {
14409 //VDEC_PRINT("No available DispQ!!!\n");
14410 eRet = E_VDEC_EX_FAIL;
14411 break;
14412 }
14413
14414 pDispFrm->u32Idx = pDispFrm_tmp->u32Idx;
14415 pDispFrm->stFrmInfo.eFrameType = _VDEC_EX_MapFrmType2HVD(info.eFrmType);
14416 pDispFrm->stFrmInfo.u16Height = info.u16Height;
14417 pDispFrm->stFrmInfo.u16Width = info.u16Width;
14418 pDispFrm->stFrmInfo.u16Pitch = info.u16Pitch;
14419 pDispFrm->stFrmInfo.u32ChromaAddr = info.u32ChromaAddr;
14420 pDispFrm->stFrmInfo.u32ID_H = info.u32ID_H;
14421 pDispFrm->stFrmInfo.u32ID_L = info.u32ID_L;
14422 pDispFrm->stFrmInfo.u32LumaAddr = info.u32LumaAddr;
14423 pDispFrm->stFrmInfo.u32TimeStamp = info.u32TimeStamp;
14424 pDispFrm->stFrmInfo.eFieldType = _VDEC_EX_MapFieldType2HVD(info.eFieldType);
14425
14426 if(pVdecExContext->_bVdecDispOutSide[u8Idx]== TRUE)
14427 {
14428 pDispFrm->u32PriData = info.u32PrivateData;//info.u32ID_L; [STB]only for AVC
14429 }
14430 else
14431 {
14432 pDispFrm->u32PriData = MDrv_HVD_EX_GetNextDispQPtr(u32Id);
14433 }
14434 //VDEC_PRINT("apiVDEC pts=%ld pri=0x%lx\n", pDispFrm->stFrmInfo.u32TimeStamp, pDispFrm->u32PriData);
14435
14436 eRet = E_VDEC_EX_OK;
14437
14438 break;
14439 }
14440 case E_VDEC_EX_DECODER_MJPEG:
14441 {
14442 _VDEC_EX_API_MutexLock();
14443
14444 MJPEG_FrameInfo info;
14445 _VDEC_Memset(&info, 0, sizeof(MJPEG_FrameInfo));
14446 if (E_MJPEG_RET_SUCCESS != MApi_MJPEG_GetNextDispFrame(u32Id, &info))
14447 {
14448 _VDEC_EX_API_MutexUnlock();
14449 return E_VDEC_EX_FAIL;
14450 }
14451 VDEC_EX_DispFrame* pDispFrm_tmp = _VDEC_EX_MallocDq(u8Idx);
14452
14453 if (!pDispFrm_tmp)
14454 {
14455 //VDEC_PRINT("No available DispQ!!!\n");
14456 eRet = E_VDEC_EX_FAIL;
14457 break;
14458 }
14459
14460 pDispFrm->u32Idx = pDispFrm_tmp->u32Idx;
14461 pDispFrm->stFrmInfo.eFrameType = E_VDEC_EX_FRM_TYPE_I;
14462 pDispFrm->stFrmInfo.u16Height = info.u16Height;
14463 pDispFrm->stFrmInfo.u16Width = info.u16Width;
14464 pDispFrm->stFrmInfo.u16Pitch = info.u16Pitch;
14465 pDispFrm->stFrmInfo.u32ChromaAddr = info.u32ChromaAddr;
14466 pDispFrm->stFrmInfo.u32ID_H = info.u32ID_H;
14467 pDispFrm->stFrmInfo.u32ID_L = info.u32ID_L;
14468 pDispFrm->stFrmInfo.u32LumaAddr = info.u32LumaAddr;
14469 pDispFrm->stFrmInfo.u32TimeStamp = info.u32TimeStamp;
14470 pDispFrm->stFrmInfo.eFieldType = E_VDEC_EX_FIELDTYPE_BOTH;
14471
14472
14473 pDispFrm->u32PriData = MApi_MJPEG_GetNextDispQPtr(u32Id);
14474 //VDEC_PRINT("apiVDEC pts=%ld\n", pDispFrm->stFrmInfo.u32TimeStamp);
14475
14476 eRet = E_VDEC_EX_OK;
14477 _VDEC_EX_API_MutexUnlock();
14478
14479 break;
14480 }
14481 default:
14482 eRet = E_VDEC_EX_RET_UNSUPPORTED;
14483 break;
14484 }
14485
14486 return eRet;
14487 }
14488
_MApi_VDEC_EX_V2_GetFrameInfoEx(VDEC_StreamId * pStreamId,VDEC_EX_FrameInfoEX * pFrmInfoEx)14489 VDEC_EX_Result _MApi_VDEC_EX_V2_GetFrameInfoEx(VDEC_StreamId *pStreamId, VDEC_EX_FrameInfoEX *pFrmInfoEx)
14490 {
14491 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14492 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14493 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14494
14495 if (!pFrmInfoEx)
14496 {
14497 return E_VDEC_EX_RET_INVALID_PARAM;
14498 }
14499
14500 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14501 {
14502 case E_VDEC_EX_DECODER_HVD:
14503 {
14504 HVD_EX_FrameInfo info;
14505 _VDEC_Memset(&info, 0, sizeof(HVD_EX_FrameInfo));
14506
14507 if (E_HVD_EX_OK != MDrv_HVD_EX_GetFrmInfo(u32Id, E_HVD_EX_GFRMINFO_LAST_DISPLAY, &info))
14508 {
14509 return E_VDEC_EX_FAIL;
14510 }
14511
14512 pFrmInfoEx->sFrameInfo.u32LumaAddr = info.u32LumaAddr;
14513 pFrmInfoEx->sFrameInfo.u32ChromaAddr = info.u32ChromaAddr;
14514 pFrmInfoEx->sFrameInfo.u32TimeStamp = info.u32TimeStamp;
14515 pFrmInfoEx->sFrameInfo.u32ID_L = info.u32ID_L;
14516 pFrmInfoEx->sFrameInfo.u32ID_H = info.u32ID_H;
14517 pFrmInfoEx->sFrameInfo.u16Pitch = info.u16Pitch;
14518 pFrmInfoEx->sFrameInfo.u16Width = info.u16Width;
14519 pFrmInfoEx->sFrameInfo.u16Height = info.u16Height;
14520 pFrmInfoEx->sFrameInfo.eFrameType = info.eFrmType;
14521 pFrmInfoEx->sFrameInfo.eFieldType = info.eFieldType;
14522
14523 pFrmInfoEx->u32LumaAddr_2bit = info.u32LumaAddr_2bit;
14524 pFrmInfoEx->u32ChromaAddr_2bit = info.u32ChromaAddr_2bit;
14525 pFrmInfoEx->u8LumaBitdepth = info.u8LumaBitdepth;
14526 pFrmInfoEx->u8ChromaBitdepth = info.u8ChromaBitdepth;
14527 pFrmInfoEx->u16Pitch_2bit = info.u16Pitch_2bit;
14528
14529 eRet = E_VDEC_EX_OK;
14530 break;
14531 }
14532 default:
14533 eRet = E_VDEC_EX_RET_UNSUPPORTED;
14534 break;
14535 }
14536
14537 return eRet;
14538 }
14539
_MApi_VDEC_EX_V2_GetNextDispFrameInfoExt(VDEC_StreamId * pStreamId,void * param)14540 VDEC_EX_Result _MApi_VDEC_EX_V2_GetNextDispFrameInfoExt(VDEC_StreamId *pStreamId, void *param)
14541 {
14542 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14543 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14544 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14545
14546 if( param == NULL)
14547 {
14548 return E_VDEC_EX_RET_INVALID_PARAM;
14549 }
14550
14551 VDEC_EX_VerCtl *pVerCtl = (VDEC_EX_VerCtl *)param;
14552 int version = pVerCtl->u32version;
14553 int size = pVerCtl->u32size;
14554
14555 if ((version == 0 && size == sizeof(VDEC_EX_FrameInfoExt_version0))
14556 #if defined(VDEC_CAP_HEVC_HDR_V2)
14557 || (version == 2 && size == sizeof(VDEC_EX_FrameInfoExt_v2))
14558 #endif
14559 #if defined(VDEC_CAP_HEVC_HDR_V3)
14560 || (version == 3 && size == sizeof(VDEC_EX_FrameInfoExt_v3))
14561 #endif
14562 #if defined(VDEC_CAP_FRAME_INFO_EXT_V4)
14563 || (version == 4 && size == sizeof(VDEC_EX_FrameInfoExt_v4))
14564 #endif
14565 #if defined(VDEC_CAP_FRAME_INFO_EXT_V5)
14566 || (version == 5 && size == sizeof(VDEC_EX_FrameInfoExt_v5))
14567 #endif
14568 #if defined(VDEC_CAP_FRAME_INFO_EXT_V6)
14569 || (version == 6 && size == sizeof(VDEC_EX_FrameInfoExt_v6))
14570 #endif
14571 )
14572 {
14573 // version and size match
14574 }
14575 else
14576 {
14577 VDEC_ERR("ERROR, ver %d, size %d\n", version, size);
14578 return E_VDEC_EX_RET_UNSUPPORTED;
14579 }
14580
14581 memset(param, 0, size);
14582 // restore version and size
14583 pVerCtl->u32version = version;
14584 pVerCtl->u32size = size;
14585
14586 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14587 {
14588 case E_VDEC_EX_DECODER_MVD:
14589 {
14590 MVD_Color_Info stColorInfo;
14591 _VDEC_Memset(&stColorInfo, 0, sizeof(MVD_Color_Info));
14592 if(MDrv_MVD_GetColorInfo(u32Id, &stColorInfo) == FALSE)
14593 {
14594 eRet = E_VDEC_EX_FAIL;
14595 }
14596 if(version == 0)
14597 {
14598 eRet = E_VDEC_EX_FAIL;
14599 }
14600 #if defined(VDEC_CAP_HEVC_HDR_V2)
14601 if(version >= 2)
14602 {
14603 VDEC_EX_FrameInfoExt_v2 *pFrmInfoEx2 = (VDEC_EX_FrameInfoExt_v2 *)param;
14604
14605 if(version == 2)
14606 memset(param, 0, sizeof(VDEC_EX_FrameInfoExt_v2));
14607 #if defined(VDEC_CAP_HEVC_HDR_V3)
14608 else if(version == 3)
14609 memset(param, 0, sizeof(VDEC_EX_FrameInfoExt_v3));
14610 #endif
14611 #if defined(VDEC_CAP_FRAME_INFO_EXT_V4)
14612 else if(version == 4)
14613 memset(param, 0, sizeof(VDEC_EX_FrameInfoExt_v4));
14614 #endif
14615 #if defined(VDEC_CAP_FRAME_INFO_EXT_V5)
14616 else if(version == 5)
14617 memset(param, 0, sizeof(VDEC_EX_FrameInfoExt_v5));
14618 #endif
14619 #if defined(VDEC_CAP_FRAME_INFO_EXT_V6)
14620 else if(version == 6)
14621 memset(param, 0, sizeof(VDEC_EX_FrameInfoExt_v6));
14622 #endif
14623
14624 if(stColorInfo.bColor_Descript)
14625 {
14626 pFrmInfoEx2->u8Frm_Info_Ext_avail = 0x1; //bit1: SEI_Enabled, bit0=colur_description_present_flag
14627 pFrmInfoEx2->u8Colour_primaries = stColorInfo.u8Color_Primaries;
14628 pFrmInfoEx2->u8Transfer_characteristics = stColorInfo.u8Transfer_Char;
14629 pFrmInfoEx2->u8Matrix_coefficients = stColorInfo.u8Matrix_Coef;
14630 }
14631 }
14632 #endif
14633 break;
14634 }
14635 case E_VDEC_EX_DECODER_HVD:
14636 {
14637
14638 eRet = E_VDEC_EX_OK;
14639
14640 HVD_EX_FrameInfo info;
14641 _VDEC_Memset(&info, 0, sizeof(HVD_EX_FrameInfo));
14642
14643 if (E_HVD_EX_OK != MDrv_HVD_EX_GetFrmInfo(u32Id, E_HVD_EX_GFRMINFO_LAST_DISPLAY_EX, &info))
14644 {
14645 return E_VDEC_EX_FAIL;
14646 }
14647
14648 if (version >= 0)
14649 {
14650 VDEC_EX_FrameInfoExt_version0 *pFrmInfoEx = (VDEC_EX_FrameInfoExt_version0 *)param;
14651
14652 pFrmInfoEx->sFrameInfo.u32LumaAddr = info.u32LumaAddr;
14653 pFrmInfoEx->sFrameInfo.u32ChromaAddr = info.u32ChromaAddr;
14654 pFrmInfoEx->sFrameInfo.u32TimeStamp = info.u32TimeStamp;
14655 pFrmInfoEx->sFrameInfo.u32ID_L = info.u32ID_L;
14656 pFrmInfoEx->sFrameInfo.u32ID_H = info.u32ID_H;
14657 pFrmInfoEx->sFrameInfo.u16Pitch = info.u16Pitch;
14658 pFrmInfoEx->sFrameInfo.u16Width = info.u16Width;
14659 pFrmInfoEx->sFrameInfo.u16Height = info.u16Height;
14660 pFrmInfoEx->sFrameInfo.eFrameType = info.eFrmType;
14661 pFrmInfoEx->sFrameInfo.eFieldType = info.eFieldType;
14662
14663 pFrmInfoEx->u32LumaAddr_2bit = info.u32LumaAddr_2bit;
14664 pFrmInfoEx->u32ChromaAddr_2bit = info.u32ChromaAddr_2bit;
14665 pFrmInfoEx->u32LumaAddrI = info.u32LumaAddrI;
14666 pFrmInfoEx->u32LumaAddrI_2bit = info.u32LumaAddrI_2bit;
14667 pFrmInfoEx->u32ChromaAddrI = info.u32ChromaAddrI;
14668 pFrmInfoEx->u32ChromaAddrI_2bit = info.u32ChromaAddrI_2bit;
14669 pFrmInfoEx->u32MFCodecInfo = info.u32MFCodecInfo;
14670 pFrmInfoEx->u32LumaMFCbitlen = info.u32LumaMFCbitlen;
14671 pFrmInfoEx->u32ChromaMFCbitlen = info.u32ChromaMFCbitlen;
14672 pFrmInfoEx->u16Pitch_2bit = info.u16Pitch_2bit;
14673 pFrmInfoEx->u8LumaBitdepth = info.u8LumaBitdepth;
14674 pFrmInfoEx->u8ChromaBitdepth = info.u8ChromaBitdepth;
14675 }
14676 #if defined(VDEC_CAP_HEVC_HDR_V2)
14677 if (version >= 2)
14678 {
14679 VDEC_EX_FrameInfoExt_v2 *pFrmInfoEx2 = (VDEC_EX_FrameInfoExt_v2 *)param;
14680
14681 pFrmInfoEx2->sDisplay_colour_volume.u32MaxLuminance = info.u32MaxLuminance;
14682 pFrmInfoEx2->sDisplay_colour_volume.u32MinLuminance = info.u32MinLuminance;
14683 pFrmInfoEx2->sDisplay_colour_volume.u16Primaries[0][0] = info.u16Primaries[0][0];
14684 pFrmInfoEx2->sDisplay_colour_volume.u16Primaries[0][1] = info.u16Primaries[0][1];
14685 pFrmInfoEx2->sDisplay_colour_volume.u16Primaries[1][0] = info.u16Primaries[1][0];
14686 pFrmInfoEx2->sDisplay_colour_volume.u16Primaries[1][1] = info.u16Primaries[1][1];
14687 pFrmInfoEx2->sDisplay_colour_volume.u16Primaries[2][0] = info.u16Primaries[2][0];
14688 pFrmInfoEx2->sDisplay_colour_volume.u16Primaries[2][1] = info.u16Primaries[2][1];
14689 pFrmInfoEx2->sDisplay_colour_volume.u16WhitePoint[0] = info.u16WhitePoint[0];
14690 pFrmInfoEx2->sDisplay_colour_volume.u16WhitePoint[1] = info.u16WhitePoint[1];
14691 pFrmInfoEx2->u8Frm_Info_Ext_avail = info.u8Frm_Info_Ext_avail; //bit1: SEI_Enabled, bit0=colur_description_present_flag
14692 pFrmInfoEx2->u8Colour_primaries = info.u8Colour_primaries;
14693 pFrmInfoEx2->u8Transfer_characteristics = info.u8Transfer_characteristics;
14694 pFrmInfoEx2->u8Matrix_coefficients = info.u8Matrix_coefficients;
14695 }
14696 #endif
14697 #if defined(VDEC_CAP_HEVC_HDR_V3)
14698 if (version >= 3)
14699 {
14700 VDEC_EX_FrameInfoExt_v3 *pFrmInfoEx3 = (VDEC_EX_FrameInfoExt_v3 *)param;
14701
14702 pFrmInfoEx3->u8DVMode = info.u8DVMode;
14703 pFrmInfoEx3->u32DVMetaDataAddr = info.u32DVMetadataAddr;
14704 pFrmInfoEx3->u32DVMetaDataSize = ((info.u32DVDMSize & 0xFFFF) << 16) | (info.u32DVCompSize & 0xFFFF);
14705 }
14706 #endif
14707 #if defined(VDEC_CAP_FRAME_INFO_EXT_V4)
14708 if (version >= 4)
14709 {
14710 VDEC_EX_FrameInfoExt_v4 *pFrmInfoEx4 = (VDEC_EX_FrameInfoExt_v4 *)param;
14711
14712 pFrmInfoEx4->u8CurrentIndex = info.u8CurrentIndex;
14713 pFrmInfoEx4->u32HDRRegAddr = info.u32HDRRegAddr;
14714 pFrmInfoEx4->u32HDRRegSize = info.u32HDRRegSize;
14715 pFrmInfoEx4->u32HDRLutAddr = info.u32HDRLutAddr;
14716 pFrmInfoEx4->u32HDRLutSize = info.u32HDRLutSize;
14717 pFrmInfoEx4->bDMEnable = info.bDMEnable;
14718 pFrmInfoEx4->bCompEnable = info.bCompEnable;
14719
14720 pFrmInfoEx4->u8ComplexityLevel = info.u8ComplexityLevel;
14721 }
14722 #endif
14723 #if defined(VDEC_CAP_FRAME_INFO_EXT_V5)
14724 if (version >= 5)
14725 {
14726 VDEC_EX_FrameInfoExt_v5 *pFrmInfoEx5 = (VDEC_EX_FrameInfoExt_v5 *)param;
14727
14728 pFrmInfoEx5->u32ParWidth = info.u32ParWidth;
14729 pFrmInfoEx5->u32ParHeight = info.u32ParHeight;
14730 pFrmInfoEx5->u16CropRight = info.u16CropRight;
14731 pFrmInfoEx5->u16CropLeft = info.u16CropLeft;
14732 pFrmInfoEx5->u16CropBottom = info.u16CropBottom;
14733 pFrmInfoEx5->u16CropTop = info.u16CropTop;
14734
14735 }
14736 #endif
14737 #if defined(VDEC_CAP_FRAME_INFO_EXT_V6)
14738 if (version >= 6)
14739 {
14740 VDEC_EX_FrameInfoExt_v6 *pFrmInfoEx6 = (VDEC_EX_FrameInfoExt_v6 *)param;
14741 pFrmInfoEx6->eTileMode = (VDEC_EX_TileMode)info.u8TileMode;
14742 pFrmInfoEx6->u16MIUBandwidth = info.u16MIUBandwidth;
14743 pFrmInfoEx6->u16Bitrate = info.u16Bitrate;
14744 pFrmInfoEx6->u8HTLBTableId = info.u8HTLBTableId;
14745 pFrmInfoEx6->u8HTLBEntriesSize = info.u8HTLBEntriesSize;
14746 pFrmInfoEx6->u32HTLBEntriesAddr = info.u32HTLBEntriesAddr;
14747 }
14748 #endif
14749 break;
14750 }
14751 default:
14752 eRet = E_VDEC_EX_RET_UNSUPPORTED;
14753 break;
14754 }
14755
14756 return eRet;
14757
14758 }
14759
_MApi_VDEC_EX_V2_CC_GetInfo(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,VDEC_EX_CCInfoCmd eCmd,MS_U32 * pOut)14760 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetInfo(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, VDEC_EX_CCInfoCmd eCmd, MS_U32 *pOut)
14761 {
14762 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14763 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14764 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14765
14766 if(pVdecExContext->support_cc[u8Idx] == FALSE)
14767 {
14768 return E_VDEC_EX_RET_UNSUPPORTED;
14769 }
14770
14771 if (!pOut)
14772 {
14773 return E_VDEC_EX_RET_INVALID_PARAM;
14774 }
14775
14776 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14777 {
14778 case E_VDEC_EX_DECODER_MVD:
14779 {
14780 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14781 EN_CC_MVD_INFO eCCInfo = CC_SELECTOR_CCMVD_RINGBUFFER;
14782 MS_U32 u32Val1=0, u32Val2=0;
14783 if (E_VDEC_EX_CC_GET_708_ENABLE == eCmd)
14784 {
14785 eCCInfo = CC_SELECTOR_708_SW;
14786 }
14787 MDrv_CC_CM_GetInfo(u32Id, eCCInfo, u8Type, &u32Val1, &u32Val2);
14788 *pOut = u32Val1;
14789 if (E_VDEC_EX_CC_GET_BUFF_SIZE == eCmd)
14790 {
14791 *pOut = u32Val2;
14792 }
14793 eRet = E_VDEC_EX_OK;
14794 }
14795 break;
14796
14797 case E_VDEC_EX_DECODER_HVD:
14798 {
14799 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14800 EN_CC_HVD_EX_INFO eCCInfo = HVD_EX_CC_SELECTOR_RINGBUFFER;
14801 MS_U32 u32Val1=0, u32Val2=0;
14802 if (E_VDEC_EX_CC_GET_708_ENABLE == eCmd)
14803 {
14804 eCCInfo = CC_SELECTOR_708_SW;
14805 }
14806 eRet = MDrv_HVD_EX_CC_GetInfo(u32Id, eCCInfo, u8Type, &u32Val1, &u32Val2);
14807 *pOut = u32Val1;
14808 if (E_VDEC_EX_CC_GET_BUFF_SIZE == eCmd)
14809 {
14810 *pOut = u32Val2;
14811 }
14812 //eRet = E_VDEC_EX_OK;
14813 }
14814 break;
14815
14816 default:
14817 eRet = E_VDEC_EX_RET_UNSUPPORTED;
14818 break;
14819 }
14820
14821 return eRet;
14822 }
14823
14824 //------------------------------------------------------------------------------
14825 /// [Obsolete] Check CC is RST done
14826 /// @param eStream \b IN : stream type
14827 /// @return -VDEC_EX_Result
14828 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_CC_GetIsRstDone(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)14829 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetIsRstDone(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
14830 {
14831 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14832 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14833 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14834
14835 if(pVdecExContext->support_cc[u8Idx] == FALSE)
14836 {
14837 return E_VDEC_EX_RET_UNSUPPORTED;
14838 }
14839
14840 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14841 {
14842 case E_VDEC_EX_DECODER_MVD:
14843 {
14844 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14845 _BOOL_TO_VDEC_RESULT(eRet, MDrv_CC_CM_IsMvdRstDone(u32Id, u8Type));
14846 }
14847 break;
14848
14849 case E_VDEC_EX_DECODER_HVD:
14850 {
14851 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14852 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_CC_IsHvdRstDone(u32Id, u8Type));
14853 }
14854 break;
14855
14856 case E_VDEC_EX_DECODER_MJPEG:
14857 default:
14858 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
14859 break;
14860 }
14861
14862 return eRet;
14863 }
14864
14865 //------------------------------------------------------------------------------
14866 /// [Obsolete] Check CC buffer is overflow
14867 /// @param eStream \b IN : stream type
14868 /// @return -VDEC_EX_Result
14869 //------------------------------------------------------------------------------
14870
_MApi_VDEC_EX_V2_CC_GetIsBuffOverflow(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)14871 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetIsBuffOverflow(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
14872 {
14873 VDEC_EX_Result eRet = E_VDEC_EX_OK;
14874 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14875 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14876
14877 if(pVdecExContext->support_cc[u8Idx] == FALSE)
14878 {
14879 return E_VDEC_EX_RET_UNSUPPORTED;
14880 }
14881
14882 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14883 {
14884 case E_VDEC_EX_DECODER_MVD:
14885 {
14886 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14887 _BOOL_TO_VDEC_RESULT(eRet, MDrv_CC_CM_GetOverflowStatus(u32Id, u8Type));
14888 }
14889 break;
14890
14891 case E_VDEC_EX_DECODER_HVD:
14892 {
14893 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14894 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_CC_GetOverflowStatus(u32Id, u8Type));
14895 }
14896 break;
14897
14898 case E_VDEC_EX_DECODER_MJPEG:
14899 default:
14900 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
14901 break;
14902 }
14903
14904 return eRet;
14905 }
14906
14907 //------------------------------------------------------------------------------
14908 /// Report the physical address of write pointer
14909 /// @param eFmt \b IN : the format of closed caption
14910 /// @return MS_PHY
14911 //------------------------------------------------------------------------------
14912
_MApi_VDEC_EX_V2_CC_GetWriteAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_PHY * u32CCWrPtr)14913 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetWriteAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt,MS_PHY* u32CCWrPtr)
14914 {
14915 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14916 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14917
14918 *u32CCWrPtr = VDEC_U32_MAX;
14919 if(pVdecExContext->support_cc[u8Idx] == FALSE)
14920 {
14921 return E_VDEC_EX_RET_UNSUPPORTED;
14922 }
14923
14924 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14925 {
14926 case E_VDEC_EX_DECODER_MVD:
14927 {
14928 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14929 *u32CCWrPtr = MDrv_CC_PM_GetMVDRB_WriteAddr(u32Id, u8Type);
14930 }
14931 break;
14932 case E_VDEC_EX_DECODER_HVD:
14933 {
14934 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14935 *u32CCWrPtr = MDrv_HVD_EX_CC_Get_RB_WriteAddr(u32Id, u8Type);
14936 }
14937 break;
14938 default:
14939 break;
14940 }
14941
14942 return E_VDEC_EX_OK;
14943 }
14944
14945 //------------------------------------------------------------------------------
14946 /// Report the physical address of read pointer
14947 /// @param eFmt \b IN : the format of closed caption
14948 /// @return MS_PHY
14949 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_CC_GetReadAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_PHY * u32CCRdPtr)14950 VDEC_EX_Result _MApi_VDEC_EX_V2_CC_GetReadAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt,MS_PHY* u32CCRdPtr)
14951 {
14952 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
14953 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
14954
14955 *u32CCRdPtr = VDEC_U32_MAX;
14956
14957 if(pVdecExContext->support_cc[u8Idx] == FALSE)
14958 {
14959 return E_VDEC_EX_RET_UNSUPPORTED;
14960 }
14961
14962 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
14963 {
14964 case E_VDEC_EX_DECODER_MVD:
14965 {
14966 MS_U8 u8Type = _VDEC_Map2MVDCCFmt(eFmt);
14967 *u32CCRdPtr = MDrv_CC_PM_GetMVDRB_ReadAddr(u32Id, u8Type);
14968 }
14969 break;
14970 case E_VDEC_EX_DECODER_HVD:
14971 {
14972 MS_U8 u8Type = _VDEC_Map2HVDCCFmt(eFmt);
14973 *u32CCRdPtr = MDrv_HVD_EX_CC_Get_RB_ReadAddr(u32Id, u8Type);
14974 }
14975 break;
14976 default:
14977 break;
14978 }
14979
14980 return E_VDEC_EX_OK;
14981 }
14982
14983 //------------------------------------------------------------------------------
14984 /// Get VDEC version
14985 /// @return -the pointer to the VDEC version
14986 //------------------------------------------------------------------------------
14987
_MApi_VDEC_EX_V2_GetLibVer(MSIF_Version * pVersion)14988 VDEC_EX_Result _MApi_VDEC_EX_V2_GetLibVer(MSIF_Version* pVersion)
14989 {
14990 if (pVersion == NULL)
14991 {
14992 return E_VDEC_EX_FAIL;
14993 }
14994
14995 _VDEC_Memcpy(pVersion,&_api_vdec_version,sizeof(MSIF_Version));
14996
14997 return E_VDEC_EX_OK;
14998 }
14999
15000 //-----------------------------------------------------------------------------
15001 /// Get VDEC info
15002 /// @brief \b Function \b Description: Get information of VDEC API
15003 /// @return - the pointer to the VDEC information
15004 //-----------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetInfo(VDEC_EX_Info * pInfo)15005 VDEC_EX_Result _MApi_VDEC_EX_V2_GetInfo(VDEC_EX_Info* pInfo)
15006 {
15007 if (pInfo == NULL)
15008 {
15009 return E_VDEC_EX_FAIL;
15010 }
15011
15012 _VDEC_Memcpy(pInfo,&_api_vdec_info,sizeof(VDEC_EX_Info));
15013
15014 return E_VDEC_EX_OK;
15015 }
15016
15017 //------------------------------------------------------------------------------
15018 /// Check if codec type is supported or not.
15019 /// @param eCodecType \b IN : codec type
15020 /// @return TRUE or FALSE
15021 /// - TRUE: Success
15022 /// - FALSE: Failed
15023 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_CheckCaps(VDEC_StreamId * pStreamId,VDEC_EX_CodecType eCodecType,MS_BOOL * bCaps)15024 VDEC_EX_Result _MApi_VDEC_EX_V2_CheckCaps(VDEC_StreamId *pStreamId, VDEC_EX_CodecType eCodecType,MS_BOOL* bCaps)
15025 {
15026 VDEC_EX_Decoder eDecoder;
15027 VDEC_EX_Result ret = E_VDEC_EX_OK;
15028
15029 *bCaps = FALSE;
15030
15031 eDecoder = _VDEC_EX_GetDecoderByCodecType(eCodecType);
15032
15033 switch (eDecoder)
15034 {
15035 case E_VDEC_EX_DECODER_MVD:
15036 _BOOL_VDEC_MVD_LINT_CHECK();
15037 {
15038 MVD_Caps caps;
15039
15040 _VDEC_Memset(&caps, 0, sizeof(MVD_Caps));
15041
15042 if (MDrv_MVD_GetCaps(&caps))
15043 {
15044 if (E_VDEC_EX_CODEC_TYPE_MPEG2 == eCodecType)
15045 {
15046 *bCaps = caps.bMPEG2;
15047 }
15048 else if (E_VDEC_EX_CODEC_TYPE_MPEG4 == eCodecType)
15049 {
15050 *bCaps = caps.bMPEG4;
15051 }
15052 else if (E_VDEC_EX_CODEC_TYPE_VC1_ADV == eCodecType || E_VDEC_EX_CODEC_TYPE_VC1_MAIN == eCodecType)
15053 {
15054 *bCaps = caps.bVC1;
15055 }
15056 }
15057 else
15058 {
15059 *bCaps = FALSE;
15060 }
15061
15062 break;
15063 }
15064 case E_VDEC_EX_DECODER_HVD:
15065 _BOOL_VDEC_HVD_LINT_CHECK();
15066 {
15067 if (E_VDEC_EX_CODEC_TYPE_H264 == eCodecType)
15068 {
15069 *bCaps = MDrv_HVD_EX_GetCaps(E_HVD_EX_AVC);
15070 }
15071 if (E_VDEC_EX_CODEC_TYPE_MVC == eCodecType)
15072 {
15073 *bCaps = MDrv_HVD_EX_GetCaps(E_HVD_EX_MVC);
15074 }
15075 else if (E_VDEC_EX_CODEC_TYPE_AVS == eCodecType)
15076 {
15077 *bCaps = MDrv_HVD_EX_GetCaps(E_HVD_EX_AVS);
15078 }
15079 else if (E_VDEC_EX_CODEC_TYPE_RV8 == eCodecType || E_VDEC_EX_CODEC_TYPE_RV9 == eCodecType)
15080 {
15081 *bCaps = MDrv_HVD_EX_GetCaps(E_HVD_EX_RM);
15082 }
15083 else if (E_VDEC_EX_CODEC_TYPE_VP8 == eCodecType)
15084 {
15085 *bCaps = MDrv_HVD_EX_GetCaps(E_HVD_EX_VP8);
15086 }
15087 else
15088 {
15089 *bCaps = FALSE;
15090 }
15091
15092 break;
15093 }
15094 case E_VDEC_EX_DECODER_MJPEG:
15095 ret = E_VDEC_EX_RET_UNSUPPORTED;
15096 break;
15097
15098 default:
15099 ret = E_VDEC_EX_FAIL;
15100 break;
15101 }
15102
15103 return ret;
15104 }
15105
15106 //------------------------------------------------------------------------------
15107 /// Enable turbo mode for VDEC.
15108 /// @param bTurbo \b IN : TRUE for enable or FALSE for disable
15109 /// @return VDEC_EX_Result
15110 /// - E_VDEC_EX_OK: success
15111 /// - E_VDEC_EX_FAIL: failed
15112 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_EnableTurboMode(MS_BOOL bEnable)15113 VDEC_EX_Result _MApi_VDEC_EX_V2_EnableTurboMode(MS_BOOL bEnable)
15114 {
15115 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
15116 _VDEC_EX_API_MutexLock();
15117 pVdecExContext->bTurboMode = bEnable;
15118 _VDEC_EX_API_MutexUnlock();
15119 return E_VDEC_EX_OK;
15120 }
15121
_MApi_VDEC_EX_V2_SetSingleDecode(MS_BOOL bEnable)15122 VDEC_EX_Result _MApi_VDEC_EX_V2_SetSingleDecode(MS_BOOL bEnable)
15123 {
15124 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15125 MS_U8 i = 0;
15126
15127 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
15128
15129 for (i=0; i<VDEC_MAX_SUPPORT_STREAM_NUM; i++)
15130 {
15131 if ((TRUE == pVdecExContext->_Attr[i].bInit) && (TRUE == bEnable))
15132 {
15133 VDEC_PRINT("%s must be set before init all tasks (%d)\n", __FUNCTION__, i);
15134 eRet = E_VDEC_EX_FAIL;
15135 }
15136 }
15137
15138 _VDEC_EX_API_MutexLock();
15139 pVdecExContext->_bSingleDecodeMode = bEnable;
15140 _VDEC_EX_API_MutexUnlock();
15141 return eRet;
15142 }
15143
15144 //------------------------------------------------------------------------------
15145 /// Get decoder status
15146 /// @param eStream \b IN : stream type
15147 /// @param pStatus \b OUT : VDEC_EX_Status
15148 /// @return TRUE or FALSE
15149 /// - TRUE: Useful status got
15150 /// - FALSE: No status because of not init yet
15151 //------------------------------------------------------------------------------
_MApi_VDEC_EX_V2_GetStatus(VDEC_StreamId * pStreamId,VDEC_EX_Status * pStatus)15152 VDEC_EX_Result _MApi_VDEC_EX_V2_GetStatus(VDEC_StreamId *pStreamId, VDEC_EX_Status *pStatus)
15153 {
15154 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15155 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15156 MS_BOOL bRet = E_VDEC_EX_FAIL;
15157
15158 if(u8Idx >= VDEC_MAX_SUPPORT_STREAM_NUM)
15159 {
15160 return E_VDEC_EX_FAIL;
15161 }
15162 _VDEC_SHM_POINTER_CHECK(FALSE);
15163
15164 pStatus->bInit = pVdecExContext->_Attr[u8Idx].bInit;
15165
15166 if (!(pVdecExContext->_Attr[u8Idx].bInit))
15167 {
15168 pStatus->bIdle = TRUE;
15169 pStatus->eStage = E_VDEC_EX_STAGE_STOP;
15170 bRet = E_VDEC_EX_OK;
15171 }
15172 else
15173 {
15174 pStatus->bIdle = _VDEC_EX_IsIdle(pStreamId);
15175 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15176 {
15177 case E_VDEC_EX_DECODER_MJPEG:
15178 case E_VDEC_EX_DECODER_MVD:
15179 {
15180 pStatus->eStage = pVdecExContext->_Attr[u8Idx].eStage;
15181 break;
15182 }
15183 case E_VDEC_EX_DECODER_HVD:
15184 {
15185 pStatus->eStage = _VDEC_Map2HVDStatus(MDrv_HVD_EX_GetPlayState(u32Id));
15186 break;
15187 }
15188 default:
15189 break;
15190 }
15191 bRet = E_VDEC_EX_OK;
15192 }
15193
15194 return bRet;
15195 }
15196
_MApi_VDEC_EX_V2_SetPowerState(EN_POWER_MODE u16PowerState)15197 VDEC_EX_Result _MApi_VDEC_EX_V2_SetPowerState(EN_POWER_MODE u16PowerState)
15198 {
15199 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
15200 VDEC_StreamId StreamID;
15201 MS_U32 i;
15202 MS_U8 u8Idx;
15203
15204 _VDEC_Memset(&StreamID,0,sizeof(VDEC_StreamId));
15205
15206 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
15207
15208 if (u16PowerState == E_POWER_SUSPEND)
15209 {
15210 if(pVdecExContext->_Attr[0].bInit == TRUE)
15211 {
15212 pVdecExContext->_power_state[0] = E_VDEC_EX_POWER_SUSPEND_ING;
15213 StreamID.u32Version = 0;
15214 StreamID.u32Id = (E_VDEC_EX_MAIN_STREAM << 24 | pVdecExContext->_Attr[0].u32DrvId);
15215 _MApi_VDEC_EX_V2_Exit(&StreamID);
15216 pVdecExContext->u32ResumeStream[0] = TRUE;
15217 pVdecExContext->eCodecType[0] = pVdecExContext->_Attr[0].eCodecType;
15218 }
15219
15220 if(pVdecExContext->_Attr[1].bInit == TRUE)
15221 {
15222 pVdecExContext->_power_state[1] = E_VDEC_EX_POWER_SUSPEND_ING;
15223 StreamID.u32Version = 0;
15224 StreamID.u32Id = (E_VDEC_EX_SUB_STREAM << 24 | pVdecExContext->_Attr[1].u32DrvId);
15225 _MApi_VDEC_EX_V2_Exit(&StreamID);
15226 pVdecExContext->u32ResumeStream[1] = TRUE;
15227 pVdecExContext->eCodecType[1] = pVdecExContext->_Attr[1].eCodecType;
15228 }
15229 pVdecExContext->_prev_u16PowerState = u16PowerState;
15230 ret = E_VDEC_EX_OK;
15231 }
15232 else if (u16PowerState == E_POWER_RESUME)
15233 {
15234 if (pVdecExContext->_prev_u16PowerState == E_POWER_SUSPEND)
15235 {
15236 if(pVdecExContext->u32ResumeStream[0] == TRUE)
15237 {
15238 pVdecExContext->_power_state[0] = E_VDEC_EX_POWER_RESUME_ING;
15239 MApi_VDEC_EX_V2_GetFreeStream(&StreamID,
15240 sizeof(VDEC_StreamId),
15241 E_VDEC_EX_MAIN_STREAM,
15242 pVdecExContext->eCodecType[0]);
15243 MApi_VDEC_EX_V2_Init(&StreamID,&(pVdecExContext->_Attr[0].vdecExInitParam));
15244
15245 // to do, set control
15246 pVdecExContext->store_set_cmd_read_pointer[_VDEC_GET_IDX(StreamID.u32Id)] = 0;
15247 u8Idx = _VDEC_GET_IDX(StreamID.u32Id);
15248 for(i=0;i<pVdecExContext->store_set_cmd_write_pointer[u8Idx];i++)
15249 {
15250 MApi_VDEC_EX_V2_SetControl(&StreamID,
15251 pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].cmd,
15252 NULL,
15253 TRUE);
15254 }
15255 pVdecExContext->store_set_cmd_write_pointer[u8Idx] = 0;
15256 //~
15257
15258 _MApi_VDEC_EX_V2_Play(&StreamID);
15259 pVdecExContext->u32ResumeStream[0] = FALSE;
15260 pVdecExContext->_power_state[0] = E_VDEC_EX_POWER_RESUME_DONE;
15261 }
15262
15263 if(pVdecExContext->u32ResumeStream[1] == TRUE)
15264 {
15265 pVdecExContext->_power_state[1] = E_VDEC_EX_POWER_RESUME_ING;
15266 MApi_VDEC_EX_V2_GetFreeStream(&StreamID,
15267 sizeof(VDEC_StreamId),
15268 E_VDEC_EX_SUB_STREAM,
15269 pVdecExContext->eCodecType[1]);
15270 MApi_VDEC_EX_V2_Init(&StreamID,&(pVdecExContext->_Attr[1].vdecExInitParam));
15271
15272 // to do, set control
15273 pVdecExContext->store_set_cmd_read_pointer[_VDEC_GET_IDX(StreamID.u32Id)] = 0;
15274 u8Idx = _VDEC_GET_IDX(StreamID.u32Id);
15275 for(i=0;i<pVdecExContext->store_set_cmd_write_pointer[u8Idx];i++)
15276 {
15277 MApi_VDEC_EX_V2_SetControl(&StreamID,
15278 pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].cmd,
15279 NULL,
15280 TRUE);
15281 }
15282 pVdecExContext->store_set_cmd_write_pointer[u8Idx] = 0;
15283 //~
15284
15285 _MApi_VDEC_EX_V2_Play(&StreamID);
15286 pVdecExContext->u32ResumeStream[1] = FALSE;
15287 pVdecExContext->_power_state[1] = E_VDEC_EX_POWER_RESUME_DONE;
15288 }
15289 pVdecExContext->_prev_u16PowerState = u16PowerState;
15290 ret = E_VDEC_EX_OK;
15291 }
15292 else
15293 {
15294 VDEC_ERR("[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
15295 ret = E_VDEC_EX_FAIL;
15296 }
15297 }
15298 else
15299 {
15300 VDEC_ERR("[%s,%5d]Do Nothing: %d\n",__FUNCTION__,__LINE__,u16PowerState);
15301 ret = E_VDEC_EX_FAIL;
15302 }
15303 return ret;
15304 }
15305
15306
_MApi_VDEC_EX_IsFrameRdy(VDEC_StreamId * pStreamId)15307 VDEC_EX_Result _MApi_VDEC_EX_IsFrameRdy(VDEC_StreamId *pStreamId)
15308 {
15309 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
15310 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15311 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15312
15313 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15314 {
15315 case E_VDEC_EX_DECODER_MVD:
15316 {
15317 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_Is1stFrmRdy(u32Id));
15318 break;
15319 }
15320 case E_VDEC_EX_DECODER_HVD:
15321 {
15322 _BOOL_TO_VDEC_RESULT(eRet, MDrv_HVD_EX_Is1stFrmRdy(u32Id));
15323 break;
15324 }
15325 case E_VDEC_EX_DECODER_MJPEG:
15326 {
15327 eRet = E_VDEC_EX_OK;
15328 break;
15329 }
15330 default:
15331 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15332 break;
15333 }
15334
15335 return eRet;
15336 }
15337
15338
_MApi_VDEC_EX_V2_StoreUserCmd(VDEC_EX_RESUME_SET_CMD * pData)15339 void _MApi_VDEC_EX_V2_StoreUserCmd(VDEC_EX_RESUME_SET_CMD* pData)
15340 {
15341 MS_U32 i = 0;
15342 MS_U8 status = 0;
15343
15344 if(pVdecExContext->u8enable_store_set_cmd[pData->u8Idx] == TRUE)
15345 {
15346 if(pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx] < MAX_NUM_OF_STORE_USER_SET_CMD)
15347 {
15348 pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx]].cmd = pData->cmd_id;
15349
15350 #if 1
15351 if(pData->structArg_num == 1)
15352 {
15353 #if 0
15354 pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx]].pStructArg = malloc(pData->struct_size);
15355 _VDEC_Memcpy(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx]].pStructArg,
15356 pData->param[pData->position[MAX_NUM_OF_STORE_USER_SET_CMD_U32ARG]],
15357 pData->struct_size);
15358 #endif
15359 status = 1;
15360 }
15361 else if(pData->structArg_num > 1)
15362 {
15363 VDEC_ERR("[Error]:%s,struct param number(%d) should not over than 1\n",__FUNCTION__,pData->structArg_num);
15364 return;
15365 }
15366 #endif
15367 if(pData->u32Arg_num > 0)
15368 {
15369 if(pData->u32Arg_num > MAX_NUM_OF_STORE_USER_SET_CMD_U32ARG)
15370 {
15371 VDEC_ERR("[Error]:%s,param_num(%d) is over %d\n",__FUNCTION__,(unsigned int)pData->u32Arg_num,MAX_NUM_OF_STORE_USER_SET_CMD_U32ARG);
15372 #if 0
15373 if(pData->structArg_num == 1)
15374 {
15375 free(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx]].pStructArg);
15376 }
15377 #endif
15378 return;
15379 }
15380
15381 for(i = 0;i < pData->u32Arg_num; i++)
15382 {
15383 pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx]].u32Arg[i] =
15384 *(MS_U32*)(pData->param[pData->position[i]]);
15385 }
15386 status = 1;
15387 }
15388
15389 if(status == 1)
15390 {
15391 pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx]++;
15392 }
15393 }
15394 else
15395 {
15396 VDEC_PRINT("[Error]%s,Stored user set command(%d) is over %d\n",__FUNCTION__,pVdecExContext->store_set_cmd_write_pointer[pData->u8Idx],MAX_NUM_OF_STORE_USER_SET_CMD);
15397 }
15398 }
15399 }
15400
15401
_MApi_VDEC_EX_SetTimeIncPredictParam(VDEC_StreamId * pStreamId,MS_U32 u32Para)15402 static VDEC_EX_Result _MApi_VDEC_EX_SetTimeIncPredictParam(VDEC_StreamId *pStreamId,MS_U32 u32Para)
15403 {
15404 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15405 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15406 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15407
15408 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15409 {
15410
15411 case E_VDEC_EX_DECODER_MVD:
15412 _MVD_RET_HANDLE(MDrv_MVD_SetTimeIncPredictParam(u32Id,u32Para));
15413 eRet = E_VDEC_EX_OK;
15414 break;
15415 case E_VDEC_EX_DECODER_HVD:
15416 case E_VDEC_EX_DECODER_MJPEG:
15417 default:
15418 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15419 break;
15420 }
15421 return eRet;
15422
15423 }
15424
15425
_VDEC_EX_SetDecodeTimeoutParam(VDEC_StreamId * pStreamId,VDEC_EX_Decode_Timeout_Param * u32Para)15426 static VDEC_EX_Result _VDEC_EX_SetDecodeTimeoutParam(VDEC_StreamId *pStreamId,VDEC_EX_Decode_Timeout_Param* u32Para)
15427 {
15428 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15429 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15430 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15431
15432 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15433 {
15434
15435 case E_VDEC_EX_DECODER_MVD:
15436 if(TRUE == MDrv_MVD_SetDcodeTimeoutParam(u32Id,u32Para->bEnable,u32Para->u32Timeout))
15437 {
15438 eRet = E_VDEC_EX_OK;
15439 }
15440 else
15441 {
15442 eRet = E_VDEC_EX_FAIL;
15443 }
15444 break;
15445 case E_VDEC_EX_DECODER_HVD:
15446 case E_VDEC_EX_DECODER_MJPEG:
15447 default:
15448 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15449 break;
15450 }
15451 return eRet;
15452
15453 }
15454
_MApi_VDEC_EX_SetFramebufferAutoMode(VDEC_StreamId * pStreamId,MS_BOOL bEnable)15455 static VDEC_EX_Result _MApi_VDEC_EX_SetFramebufferAutoMode(VDEC_StreamId *pStreamId,MS_BOOL bEnable)
15456 {
15457 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15458 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15459 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15460
15461 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15462 {
15463 case E_VDEC_EX_DECODER_MVD:
15464 if(MDrv_MVD_SetFramebufferAutoMode(u32Id,bEnable) == TRUE)
15465 {
15466 eRet = E_VDEC_EX_OK;
15467 }
15468 else
15469 {
15470 eRet = E_VDEC_EX_FAIL;
15471 }
15472 break;
15473 case E_VDEC_EX_DECODER_HVD:
15474 case E_VDEC_EX_DECODER_MJPEG:
15475 default:
15476 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15477 break;
15478 }
15479 return eRet;
15480
15481 }
15482
15483 //-------------------------------------------------------------------------------------------------
15484 // API Layer set smooth rewind Internal Function
15485 //-------------------------------------------------------------------------------------------------
_MApi_VDEC_EX_SetSmooth_Rewind(VDEC_StreamId * pStreamId,MS_U8 u8type)15486 static VDEC_EX_Result _MApi_VDEC_EX_SetSmooth_Rewind(VDEC_StreamId *pStreamId,MS_U8 u8type)
15487 {
15488 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15489 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15490 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15491
15492 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15493 {
15494 case E_VDEC_EX_DECODER_MVD:
15495 _MVD_RET_HANDLE(MDrv_MVD_Set_Smooth_Rewind(u32Id, u8type));
15496 break;
15497 case E_VDEC_EX_DECODER_HVD:
15498 case E_VDEC_EX_DECODER_MJPEG:
15499 default:
15500 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
15501 break;
15502 }
15503
15504 return eRet;
15505 }
15506
15507
15508 //-------------------------------------------------------------------------------------------------
15509 // API Layer set error tolerance Internal Function
15510 //-------------------------------------------------------------------------------------------------
_MApi_VDEC_EX_SetError_Tolerance(VDEC_StreamId * pStreamId,VDEC_EX_Err_Tolerance * pstErrTolerance)15511 static VDEC_EX_Result _MApi_VDEC_EX_SetError_Tolerance(VDEC_StreamId *pStreamId,VDEC_EX_Err_Tolerance *pstErrTolerance)
15512 {
15513 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15514 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15515 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15516 MS_U16 u16Para;
15517 u16Para = (((pstErrTolerance->u8Tolerance << 8)&0xff00) | (pstErrTolerance->bEnable &0x00ff));
15518 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15519 {
15520 case E_VDEC_EX_DECODER_MVD:
15521 _MVD_RET_HANDLE(MDrv_MVD_Set_Err_Tolerance(u32Id, u16Para));
15522 break;
15523 case E_VDEC_EX_DECODER_HVD:
15524 _HVD_RET_HANDLE(MDrv_HVD_EX_Set_Err_Tolerance(u32Id, (MS_U32)u16Para));
15525 break;
15526 case E_VDEC_EX_DECODER_MJPEG:
15527 default:
15528 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
15529 break;
15530 }
15531
15532 return eRet;
15533 }
15534
15535 #ifdef VDEC_CAP_DV_OTT_API
15536 //-------------------------------------------------------------------------------------------------
15537 // API Layer set DV profile and level Internal Function
15538 //-------------------------------------------------------------------------------------------------
_MApi_VDEC_EX_SetDVInfo(VDEC_StreamId * pStreamId,VDEC_EX_DV_Info * pDV_Info)15539 static VDEC_EX_Result _MApi_VDEC_EX_SetDVInfo(VDEC_StreamId *pStreamId, VDEC_EX_DV_Info *pDV_Info)
15540 {
15541 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15542 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15543 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15544 MS_U32 u32Para;
15545 #ifdef VDEC_CAP_DV_OTT_API_V2
15546 u32Para = (((pDV_Info->eDVMetaReorder << 16) & 0xff0000) | ((pDV_Info->eDVProfile << 8) & 0xff00) | (pDV_Info->eDVLevel & 0x00ff));
15547 #else
15548 u32Para = (((pDV_Info->eDVProfile << 8) & 0xff00) | (pDV_Info->eDVLevel & 0x00ff));
15549 #endif
15550 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15551 {
15552 case E_VDEC_EX_DECODER_MVD:
15553 break;
15554 case E_VDEC_EX_DECODER_HVD:
15555 _HVD_RET_HANDLE(MDrv_HVD_EX_SetDVInfo(u32Id, u32Para));
15556 break;
15557 case E_VDEC_EX_DECODER_MJPEG:
15558 default:
15559 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
15560 break;
15561 }
15562
15563 return eRet;
15564 }
15565 #endif
15566
_MApi_VDEC_EX_V2_GetEventFlag(VDEC_StreamId * pStreamId,MS_U32 * u32EventFlag,MS_U32 cb_idx)15567 VDEC_EX_Result _MApi_VDEC_EX_V2_GetEventFlag(VDEC_StreamId *pStreamId,MS_U32* u32EventFlag, MS_U32 cb_idx)
15568 {
15569 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15570 MS_U32 u32VdecEventFlag = 0;
15571
15572 if(pVdecExContext->_u32PreVdecExIsrEventFlag[u8Idx] != pVdecExContext->_u32VdecExIsrEventFlag[u8Idx])
15573 {
15574 MsOS_ClearEvent(s32VdecExEventId[u8Idx], VDEC_U32_MAX);
15575 pVdecExContext->_u32PreVdecExIsrEventFlag[u8Idx] = pVdecExContext->_u32VdecExIsrEventFlag[u8Idx];
15576 }
15577
15578
15579 MsOS_WaitEvent(s32VdecExEventId[u8Idx],
15580 (pVdecExContext->_u32PreVdecExIsrEventFlag[u8Idx] & ~E_VDEC_EX_EVENT_DEC_CMA_ACTION),
15581 &u32VdecEventFlag,
15582 E_OR_CLEAR,
15583 TICK_PER_ONE_MS*10);
15584
15585
15586 if ((u32VdecEventFlag & ~E_VDEC_EX_EVENT_ISR_EVENT_CHANGE) & pVdecExContext->_u32VdecExIsrEventFlag[u8Idx])
15587 {
15588 if(u32EventFlag!=NULL)
15589 {
15590 *u32EventFlag = u32VdecEventFlag;
15591 }
15592 }
15593
15594 return E_VDEC_EX_OK;
15595 }
15596
_MApi_VDEC_EX_Set_PTS_USec_Mode(VDEC_StreamId * pStreamId,MS_BOOL bEnable)15597 static VDEC_EX_Result _MApi_VDEC_EX_Set_PTS_USec_Mode(VDEC_StreamId *pStreamId,MS_BOOL bEnable)
15598 {
15599 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15600 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15601 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15602
15603 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15604 {
15605 case E_VDEC_EX_DECODER_HVD:
15606 _HVD_RET_HANDLE(MDrv_HVD_EX_SetPTSUsecMode(u32Id,bEnable));
15607 break;
15608 case E_VDEC_EX_DECODER_MVD:
15609 case E_VDEC_EX_DECODER_MJPEG:
15610 default:
15611 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15612 break;
15613 }
15614 return eRet;
15615
15616 }
15617
_MApi_VDEC_EX_Enable_AutoInsertDummyPattern(VDEC_StreamId * pStreamId,MS_BOOL bEnable)15618 static VDEC_EX_Result _MApi_VDEC_EX_Enable_AutoInsertDummyPattern(VDEC_StreamId *pStreamId,MS_BOOL bEnable)
15619 {
15620 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15621 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15622 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15623
15624 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15625 {
15626 case E_VDEC_EX_DECODER_MVD:
15627 pVdecExContext->bEnableAutoInsertDummyPattern[u8Idx] = bEnable;
15628 MDrv_MVD_EnableAutoInsertDummyPattern(u32Id,bEnable);
15629 break;
15630 case E_VDEC_EX_DECODER_HVD:
15631 case E_VDEC_EX_DECODER_MJPEG:
15632 default:
15633 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15634 break;
15635 }
15636 return eRet;
15637
15638 }
15639
15640
_MApi_VDEC_EX_Drop_One_PTS(VDEC_StreamId * pStreamId)15641 static VDEC_EX_Result _MApi_VDEC_EX_Drop_One_PTS(VDEC_StreamId *pStreamId)
15642 {
15643 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15644 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15645 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15646
15647 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15648 {
15649 case E_VDEC_EX_DECODER_MVD:
15650 MDrv_MVD_Drop_One_PTS(u32Id);
15651 break;
15652 case E_VDEC_EX_DECODER_HVD:
15653 case E_VDEC_EX_DECODER_MJPEG:
15654 default:
15655 eRet = E_VDEC_EX_OK;
15656 break;
15657 }
15658 return eRet;
15659
15660 }
15661
15662
_MApi_VDEC_EX_PVR_Seamless_mode(VDEC_StreamId * pStreamId,MS_U8 u8Arg)15663 static VDEC_EX_Result _MApi_VDEC_EX_PVR_Seamless_mode(VDEC_StreamId *pStreamId,MS_U8 u8Arg)
15664 {
15665 VDEC_EX_Result eRet = E_VDEC_EX_OK;
15666 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15667 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15668
15669 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15670 {
15671 case E_VDEC_EX_DECODER_MVD:
15672 if(MDrv_MVD_PVR_Seamless_mode(u32Id,u8Arg) != E_MVD_RET_OK)
15673 {
15674 eRet = E_VDEC_EX_FAIL;
15675 }
15676 break;
15677 case E_VDEC_EX_DECODER_HVD:
15678 _HVD_RET_HANDLE(MDrv_HVD_EX_PVRTimeShiftSeamlessMode(u32Id, u8Arg));
15679 eRet = E_VDEC_EX_OK;
15680 break;
15681 case E_VDEC_EX_DECODER_MJPEG:
15682 default:
15683 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15684 break;
15685 }
15686 return eRet;
15687
15688 }
15689
_VDEC_EX_GetPVRSeamlessInfo(VDEC_StreamId * pStreamId,VDEC_EX_PVR_Seamless_Info * param)15690 static VDEC_EX_Result _VDEC_EX_GetPVRSeamlessInfo(VDEC_StreamId *pStreamId, VDEC_EX_PVR_Seamless_Info* param)
15691 {
15692 VDEC_EX_Result eRet = E_VDEC_EX_FAIL;
15693 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15694
15695 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15696 {
15697 case E_VDEC_EX_DECODER_HVD:
15698 {
15699 HVD_EX_PVR_Seamless_Info info;
15700
15701 _VDEC_Memset(&info, 0, sizeof(HVD_EX_PVR_Seamless_Info));
15702
15703 if(MDrv_HVD_EX_GetPVRSeamlessInfo(u8Idx, &info) == TRUE)
15704 {
15705 _VDEC_Memcpy(param, &info, sizeof(HVD_EX_PVR_Seamless_Info));
15706
15707 eRet = E_VDEC_EX_OK;
15708 }
15709
15710 break;
15711 }
15712 case E_VDEC_EX_DECODER_MVD:
15713 {
15714 if(MDrv_MVD_GetPVRSeamlessInfo(u8Idx,(void*)param) == TRUE)
15715 {
15716 eRet = E_VDEC_EX_OK;
15717 }
15718 break;
15719 }
15720 case E_VDEC_EX_DECODER_MJPEG:
15721 default:
15722 {
15723 eRet = E_VDEC_EX_RET_UNSUPPORTED;
15724 break;
15725 }
15726 }
15727
15728 return eRet;
15729 }
15730
_MApi_VDEC_EX_V2_GetFWStatusFlag(VDEC_StreamId * pStreamId,MS_U32 * param)15731 static VDEC_EX_Result _MApi_VDEC_EX_V2_GetFWStatusFlag(VDEC_StreamId *pStreamId, MS_U32 *param)
15732 {
15733 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
15734 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15735 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15736 _VDEC_INVALID_IDX_RET(u8Idx);
15737
15738 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15739 {
15740 case E_VDEC_EX_DECODER_HVD:
15741 *param = MDrv_HVD_EX_GetData(u32Id, E_HVD_EX_GDATA_TYPE_FW_STATUS_FLAG);
15742 ret = E_VDEC_EX_OK;
15743 break;
15744 case E_VDEC_EX_DECODER_MVD:
15745 case E_VDEC_EX_DECODER_MJPEG:
15746 default:
15747 ret = E_VDEC_EX_RET_UNSUPPORTED;
15748 break;
15749 }
15750
15751 return ret;
15752
15753 }
15754
_MApi_VDEC_EX_IsSecureModeEnable(void)15755 MS_BOOL _MApi_VDEC_EX_IsSecureModeEnable(void)
15756 {
15757 MS_BOOL bSecureMode = FALSE;
15758 VDEC_EX_V2_IO_Param IO_arg;
15759 VDEC_EX_Result ret;
15760
15761 if (pu32VDEC_EX_Inst == NULL)
15762 {
15763 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
15764 {
15765 VPRINTF("UtopiaOpen VDEC_EX failed\n");
15766 return E_VDEC_EX_FAIL;
15767 }
15768 }
15769
15770 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_SECURE_MODE;
15771 IO_arg.param[0] = (void*)(&bSecureMode);
15772 IO_arg.pRet = (void*)(&ret);
15773
15774 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
15775 {
15776 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
15777 ret = E_VDEC_EX_FAIL;
15778 }
15779 return bSecureModeEnableUser;
15780 }
15781
_MApi_VDEC_EX_V2_IsSecureMode(MS_BOOL * bIsSecureMode)15782 VDEC_EX_Result _MApi_VDEC_EX_V2_IsSecureMode(MS_BOOL* bIsSecureMode)
15783 {
15784 #ifdef MSOS_TYPE_LINUX_KERNEL
15785 printk("[_MApi_VDEC_EX_V2_IsSecureMode] bSecureModeEnable = %d \n",bSecureModeEnable);
15786 #endif
15787 #if defined(ForceToNonteeTestmode)
15788 *bIsSecureMode = 0; //Force to non-tee mode,test mode
15789 #else
15790 *bIsSecureMode = bSecureModeEnable;
15791 #endif
15792 return E_VDEC_EX_OK;
15793 }
15794
_MApi_VDEC_EX_Set_MBX_param(MS_U8 u8APIMbxMsgClass)15795 MS_BOOL _MApi_VDEC_EX_Set_MBX_param(MS_U8 u8APIMbxMsgClass)
15796 {
15797 VDEC_EX_V2_IO_Param IO_arg;
15798 VDEC_EX_Result ret;
15799
15800 if (pu32VDEC_EX_Inst == NULL)
15801 {
15802 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
15803 {
15804 VPRINTF("UtopiaOpen VDEC_EX failed\n");
15805 return E_VDEC_EX_FAIL;
15806 }
15807 }
15808
15809 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_MBX_PARAM;
15810 IO_arg.param[0] = (void*)(&u8APIMbxMsgClass);
15811 IO_arg.pRet = (void*)(&ret);
15812
15813 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
15814 {
15815 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
15816 ret = E_VDEC_EX_FAIL;
15817 }
15818 return E_VDEC_EX_OK;
15819 }
15820
_MApi_VDEC_EX_V2_Set_MBX_param(MS_U8 u8APIMbxMsgClass)15821 MS_BOOL _MApi_VDEC_EX_V2_Set_MBX_param(MS_U8 u8APIMbxMsgClass)
15822 {
15823 MDrv_MVD_Set_MBX_param(u8APIMbxMsgClass);
15824 return E_VDEC_EX_OK;
15825 }
15826
15827 #ifndef MSOS_TYPE_LINUX_KERNEL
_MApi_VDEC_EX_RegisterMBX(void)15828 static MS_BOOL _MApi_VDEC_EX_RegisterMBX(void)
15829 {
15830
15831 VPRINTF("_MApi_VDEC_EX_RegisterMBX \n");
15832 MBX_Result mbxRet = 0;
15833
15834 mbxRet = MApi_MBX_Init(E_MBX_CPU_MIPS,E_MBX_ROLE_HK,1000);
15835 if (mbxRet != E_MBX_SUCCESS && mbxRet != E_MBX_ERR_SLOT_AREADY_OPENNED)
15836 {
15837 VPRINTF("VDEC_TEE MApi_MBX_Init fail\n");
15838 return FALSE;
15839 }
15840 else
15841 {
15842 MApi_MBX_Enable(TRUE);
15843 }
15844 #if 0
15845 MS_U8 ClassNum = 0;
15846 MBX_Result result;
15847 if (E_MBX_SUCCESS != MApi_MBX_QueryDynamicClass(E_MBX_CPU_MIPS_VPE1, "VDEC_TEE", (MS_U8 *)&ClassNum))
15848 {
15849 VPRINTF("VDEC_TEE MApi_MBX_QueryDynamicClass fail\n");
15850 return FALSE;
15851 }
15852
15853 result = MApi_MBX_RegisterMSG(ClassNum, 10);
15854
15855 if (( E_MBX_SUCCESS != result) && ( E_MBX_ERR_SLOT_AREADY_OPENNED != result ))
15856 {
15857 VPRINTF("%s fail\n",__FUNCTION__);
15858 return FALSE;
15859 }
15860 else
15861 {
15862 _MApi_VDEC_EX_Set_MBX_param(ClassNum);
15863 return TRUE;
15864 }
15865 #endif
15866 return TRUE;
15867 }
15868 #endif
15869
15870 //------------------------------------------------------------------------------
15871 /// set share memory base address between driver with fw
15872 /// @param u32FrmBuffAddr \b IN : frame buffer address
15873 /// @param u32FrmBuffSize \b IN : frame buffer size
15874 /// @return VDEC_Result
15875 //------------------------------------------------------------------------------
_MApi_VDEC_EX_SetFrameBuff2(VDEC_StreamId * pStreamId,MS_VIRT u32FrmBuffAddr,MS_U32 u32FrmBuffSize)15876 static VDEC_EX_Result _MApi_VDEC_EX_SetFrameBuff2(VDEC_StreamId *pStreamId, MS_VIRT u32FrmBuffAddr, MS_U32 u32FrmBuffSize)
15877 {
15878 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
15879 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15880 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15881
15882 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
15883
15884 if (!pVdecExContext->_Attr[u8Idx].bInit)
15885 {
15886 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
15887 }
15888
15889 #if !VDEC_EX_ALLOCATOR_ENABLE_NDECODE_FB2
15890 if(_VDEC_EX_NdecAllocator_IsNDecode() == TRUE)
15891 {
15892 return E_VDEC_EX_OK;
15893 }
15894 #endif
15895
15896 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15897 {
15898 case E_VDEC_EX_DECODER_MVD:
15899 ret = E_VDEC_EX_RET_UNSUPPORTED;
15900 break;
15901 case E_VDEC_EX_DECODER_HVD:
15902 if((pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_HEVC) ||
15903 (pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_HEVC_DV) ||
15904 (pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_VP9))
15905 {
15906 _HVD_RET_TO_VDEC_RESULT(ret, MDrv_HVD_EX_SetFrmBuff2(u32Id, u32FrmBuffAddr, u32FrmBuffSize));
15907 if(bSecureModeEnable == TRUE)
15908 {
15909 SYS_TEEINFO teemode;
15910 MDrv_SYS_ReadKernelCmdLine();
15911 MDrv_SYS_GetTEEInfo(&teemode);
15912
15913 if(teemode.OsType == SYS_TEEINFO_OSTYPE_OPTEE)
15914 {
15915 VDEC_EX_OPTEE_SecureFB2 SecureFB2;
15916 SecureFB2.FBuf2Addr = u32FrmBuffAddr;
15917 SecureFB2.FBuf2Size = u32FrmBuffSize;
15918 SecureFB2.u32streamID = pStreamId->u32Id;
15919 VPRINTF("[VDEC][OPTEE]Send Frame Buffer 2 command\n");
15920 if(_MApi_VDEC_EX_V2_Send_OPTEE_CMD(E_VDEC_EX_OPTEE_SECURE_FB2,&SecureFB2,sizeof(SecureFB2)) == FALSE)
15921 {
15922 VPRINTF("[VDEC][OPTEE]Set Frame Buffer 2 command fail\n");
15923 return E_VDEC_EX_FAIL;
15924 }
15925 }
15926 }
15927 }
15928 else
15929 {
15930 ret = E_VDEC_EX_RET_UNSUPPORTED;
15931 }
15932 break;
15933 case E_VDEC_EX_DECODER_MJPEG:
15934 ret = E_VDEC_EX_RET_UNSUPPORTED;
15935 break;
15936 default:
15937 ret = E_VDEC_EX_RET_UNSUPPORTED;
15938 break;
15939 }
15940
15941 return ret ;
15942 }
15943
_MApi_VDEC_EX_V2_SetDVXCShmAddr(VDEC_StreamId * pStreamId,MS_PHY u32DVXCShmAddr)15944 static VDEC_EX_Result _MApi_VDEC_EX_V2_SetDVXCShmAddr(VDEC_StreamId *pStreamId, MS_PHY u32DVXCShmAddr)
15945 {
15946 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
15947 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15948 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
15949
15950 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
15951
15952 if (!pVdecExContext->_Attr[u8Idx].bInit)
15953 {
15954 return E_VDEC_EX_RET_ILLEGAL_ACCESS;
15955 }
15956
15957 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15958 {
15959 case E_VDEC_EX_DECODER_MVD:
15960 /*
15961 if(MDrv_MVD_SetDVXCShmAddr(u32Id,pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32CodeBufAddr,u32DVXCShmAddr) == E_MVD_RET_OK)
15962 {
15963 ret = E_VDEC_EX_OK;
15964 }
15965 */
15966 ret = E_VDEC_EX_RET_UNSUPPORTED;
15967 break;
15968 case E_VDEC_EX_DECODER_HVD:
15969 _HVD_RET_TO_VDEC_RESULT(ret, MDrv_HVD_EX_SetDVXCShmBuff(u32Id, pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32CodeBufAddr,
15970 u32DVXCShmAddr, (MS_SIZE)0));
15971
15972 break;
15973 case E_VDEC_EX_DECODER_MJPEG:
15974 ret = E_VDEC_EX_RET_UNSUPPORTED;
15975 break;
15976 default:
15977 ret = E_VDEC_EX_RET_UNSUPPORTED;
15978 break;
15979 }
15980
15981 return ret ;
15982 }
15983
_MApi_VDEC_EX_SetTrickPlay_2X_MODE(VDEC_StreamId * pStreamId,VDEC_EX_TrickPlay2xMode eMode)15984 static VDEC_EX_Result _MApi_VDEC_EX_SetTrickPlay_2X_MODE(VDEC_StreamId *pStreamId, VDEC_EX_TrickPlay2xMode eMode)
15985 {
15986 VDEC_EX_Result ret = E_VDEC_EX_FAIL;
15987 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
15988
15989 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
15990 {
15991 case E_VDEC_EX_DECODER_MVD:
15992
15993 if(eMode == E_VDEC_EX_TRICKPLAY2X_COUNTVSYNC)
15994 {
15995 MDrv_MVD_TrickPlay2xAVSync(pStreamId->u32Id,FALSE);
15996 }
15997 else if(eMode == E_VDEC_EX_TRICKPLAY2X_AVSYNC)
15998 {
15999 MDrv_MVD_TrickPlay2xAVSync(pStreamId->u32Id,TRUE);
16000 }
16001 else
16002 {
16003 MDrv_MVD_TrickPlay2xAVSync(pStreamId->u32Id,FALSE);
16004 }
16005 ret = E_VDEC_EX_OK;
16006 break;
16007 case E_VDEC_EX_DECODER_HVD:
16008 case E_VDEC_EX_DECODER_MJPEG:
16009 ret = E_VDEC_EX_RET_UNSUPPORTED;
16010 break;
16011 default:
16012 ret = E_VDEC_EX_RET_UNSUPPORTED;
16013 break;
16014 }
16015
16016 return ret ;
16017
16018 }
16019
_MApi_VDEC_EX_FRC_OnlyShowTopField(VDEC_StreamId * pStreamId,MS_BOOL bEnable)16020 static VDEC_EX_Result _MApi_VDEC_EX_FRC_OnlyShowTopField(VDEC_StreamId *pStreamId,MS_BOOL bEnable)
16021 {
16022 VDEC_EX_Result eRet = E_VDEC_EX_OK;
16023 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
16024 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
16025
16026 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
16027 {
16028 case E_VDEC_EX_DECODER_HVD:
16029 _HVD_RET_HANDLE(MDrv_HVD_EX_FRC_OnlyShowTopField(u32Id,bEnable));
16030 break;
16031 case E_VDEC_EX_DECODER_MVD:
16032 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_FRC_OnlyShowTopField(u32Id, bEnable));
16033 break;
16034 case E_VDEC_EX_DECODER_MJPEG:
16035 default:
16036 eRet = E_VDEC_EX_RET_UNSUPPORTED;
16037 break;
16038 }
16039 return eRet;
16040
16041 }
16042
_MApi_VDEC_EX_DisableEsFullStop(VDEC_StreamId * pStreamId,MS_BOOL bDisable)16043 static VDEC_EX_Result _MApi_VDEC_EX_DisableEsFullStop(VDEC_StreamId *pStreamId,MS_BOOL bDisable)
16044 {
16045 VDEC_EX_Result eRet = E_VDEC_EX_OK;
16046 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
16047 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
16048
16049 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
16050 {
16051 case E_VDEC_EX_DECODER_MVD:
16052 _BOOL_TO_VDEC_RESULT(eRet, MDrv_MVD_DisableEsFullStop(u32Id, bDisable));
16053 break;
16054 case E_VDEC_EX_DECODER_HVD:
16055 _HVD_RET_HANDLE(MDrv_HVD_EX_DisableEsFullStop(u32Id,bDisable));
16056 break;
16057 case E_VDEC_EX_DECODER_MJPEG:
16058 default:
16059 eRet = E_VDEC_EX_RET_UNSUPPORTED;
16060 break;
16061 }
16062 return eRet;
16063
16064 }
16065
16066 //-------------------------------------------------------------------------------------------------
16067 // API Layer set slow syncl Function
16068 //-------------------------------------------------------------------------------------------------
_MApi_VDEC_EX_SetSlow_Sync(VDEC_StreamId * pStreamId,VDEC_EX_Slow_Sync * pstSlowSync)16069 static VDEC_EX_Result _MApi_VDEC_EX_SetSlow_Sync(VDEC_StreamId *pStreamId,VDEC_EX_Slow_Sync *pstSlowSync)
16070 {
16071 VDEC_EX_Result eRet = E_VDEC_EX_OK;
16072 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
16073 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
16074 MS_U16 u16Para;
16075 u16Para = (((pstSlowSync->u8RepeatPeriod<< 8)&0xff00) | (pstSlowSync->u8DropPeriod&0x00ff));
16076 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
16077 {
16078 case E_VDEC_EX_DECODER_HVD:
16079 _HVD_RET_HANDLE(MDrv_HVD_EX_Set_Slow_Sync(u32Id, (MS_U32)u16Para));
16080 break;
16081 case E_VDEC_EX_DECODER_MVD:
16082 _MVD_RET_HANDLE(MDrv_MVD_Set_SlowSyncParam(u32Id, pstSlowSync->u8RepeatPeriod,pstSlowSync->u8DropPeriod));
16083 break;
16084 case E_VDEC_EX_DECODER_MJPEG:
16085 eRet = E_VDEC_EX_RET_UNSUPPORTED;
16086 break;
16087 default:
16088 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
16089 break;
16090 }
16091
16092 return eRet;
16093 }
16094
_MApi_VDEC_EX_Direct_STC_Mode(VDEC_StreamId * pStreamId,MS_U32 u32StcInMs)16095 static VDEC_EX_Result _MApi_VDEC_EX_Direct_STC_Mode(VDEC_StreamId *pStreamId, MS_U32 u32StcInMs)
16096 {
16097 VDEC_EX_Result eRet = E_VDEC_EX_OK;
16098 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
16099 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
16100 MS_U16 u16ChipECORev = (MS_U16)MDrv_SYS_GetChipRev();
16101
16102 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
16103 {
16104 case E_VDEC_EX_DECODER_HVD:
16105 #if defined(CHIP_KANO) || defined(CHIP_CURRY)
16106 if(u16ChipECORev == 0)
16107 {
16108 _HVD_RET_HANDLE(MDrv_HVD_EX_DirectSTCMode(u32Id, u32StcInMs));
16109 }
16110 #endif
16111 eRet = E_VDEC_EX_OK;
16112 break;
16113 case E_VDEC_EX_DECODER_MVD:
16114 case E_VDEC_EX_DECODER_MJPEG:
16115 default:
16116 eRet = E_VDEC_EX_RET_UNSUPPORTED;
16117 break;
16118 }
16119
16120 return eRet;
16121 }
16122
16123 //-------------------------------------------------------------------------------------------------
16124 // Global Functions
16125 //-------------------------------------------------------------------------------------------------
16126
16127 //------------------------------------------------------------------------------
16128 /// Get VDEC version
16129 /// @return -the pointer to the VDEC version
16130 //------------------------------------------------------------------------------
16131
MApi_VDEC_EX_GetLibVer(const MSIF_Version ** ppVersion)16132 VDEC_EX_Result MApi_VDEC_EX_GetLibVer(const MSIF_Version **ppVersion)
16133 {
16134 VDEC_EX_V2_IO_Param IO_arg;
16135 VDEC_EX_Result ret;
16136 MSIF_Version Version;
16137
16138 if (pu32VDEC_EX_Inst == NULL)
16139 {
16140 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
16141 {
16142 VPRINTF("UtopiaOpen VDEC_EX failed\n");
16143 return E_VDEC_EX_FAIL;
16144 }
16145 }
16146
16147 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GETLIBVER;
16148 IO_arg.param[0] = (void*)(&Version);
16149 IO_arg.pRet = (void*)(&ret);
16150
16151 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16152 {
16153 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16154 ret = E_VDEC_EX_FAIL;
16155 }
16156 else
16157 {
16158 *ppVersion = &_api_vdec_version;
16159 }
16160 return ret;
16161 }
16162
16163
16164 //-----------------------------------------------------------------------------
16165 /// Get VDEC info
16166 /// @brief \b Function \b Description: Get information of VDEC API
16167 /// @return - the pointer to the VDEC information
16168 //-----------------------------------------------------------------------------
MApi_VDEC_EX_GetInfo(const VDEC_EX_Info ** ppInfo)16169 VDEC_EX_Result MApi_VDEC_EX_GetInfo(const VDEC_EX_Info **ppInfo)
16170 {
16171 VDEC_EX_V2_IO_Param IO_arg;
16172 VDEC_EX_Result ret;
16173 VDEC_EX_Info Info;
16174
16175 if (pu32VDEC_EX_Inst == NULL)
16176 {
16177 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
16178 {
16179 VPRINTF("UtopiaOpen VDEC_EX failed\n");
16180 return E_VDEC_EX_FAIL;
16181 }
16182 }
16183
16184 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GETINFO;
16185 IO_arg.param[0] = (void*)(&Info);
16186 IO_arg.pRet = (void*)(&ret);
16187
16188 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16189 {
16190 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16191 ret = E_VDEC_EX_FAIL;
16192 }
16193 else
16194 {
16195 *ppInfo = &_api_vdec_info;
16196 }
16197 return ret;
16198 }
16199
16200 //------------------------------------------------------------------------------
16201 /// Get decoder status
16202 /// @param eStream \b IN : stream type
16203 /// @param pStatus \b OUT : VDEC_EX_Status
16204 /// @return TRUE or FALSE
16205 /// - TRUE: Useful status got
16206 /// - FALSE: No status because of not init yet
16207 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetStatus(VDEC_StreamId * pStreamId,VDEC_EX_Status * pStatus)16208 MS_BOOL MApi_VDEC_EX_GetStatus(VDEC_StreamId* pStreamId, VDEC_EX_Status* pStatus)
16209 {
16210 VDEC_EX_V2_IO_Param IO_arg;
16211 VDEC_EX_Result ret;
16212
16213 if (pu32VDEC_EX_Inst == NULL)
16214 {
16215 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16216 return FALSE;
16217 }
16218
16219 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16220 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_PREGETSTATUS;
16221 IO_arg.param[0] = (void*)pStatus;
16222 IO_arg.pRet = (void*)(&ret);
16223
16224 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_PRE_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16225 {
16226 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16227 return FALSE;
16228 }
16229 else
16230 {
16231 if(ret != E_VDEC_EX_OK)
16232 {
16233 return FALSE;
16234 }
16235 else
16236 {
16237 return TRUE;
16238 }
16239 }
16240 }
16241
16242
16243 //------------------------------------------------------------------------------
16244 /// Check if codec type is supported or not.
16245 /// @param eCodecType \b IN : codec type
16246 /// @return TRUE or FALSE
16247 /// - TRUE: Success
16248 /// - FALSE: Failed
16249 //------------------------------------------------------------------------------
MApi_VDEC_EX_CheckCaps(VDEC_StreamId * pStreamId,VDEC_EX_CodecType eCodecType)16250 MS_BOOL MApi_VDEC_EX_CheckCaps(VDEC_StreamId *pStreamId, VDEC_EX_CodecType eCodecType)
16251 {
16252 VDEC_EX_V2_IO_Param IO_arg;
16253 VDEC_EX_Result ret;
16254 MS_BOOL bCaps = FALSE;
16255
16256 if (pu32VDEC_EX_Inst == NULL)
16257 {
16258 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16259 return bCaps;
16260 }
16261
16262 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16263 IO_arg.param[0] = (void*)(&eCodecType);
16264 IO_arg.param[1] = (void*)(&bCaps);
16265 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CHECKCAPS;
16266 IO_arg.pRet = (void*)(&ret);
16267
16268 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16269 {
16270 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16271 }
16272
16273 return bCaps;
16274 }
16275
16276
16277 //------------------------------------------------------------------------------
16278 /// Enable turbo mode for VDEC.
16279 /// @param bTurbo \b IN : TRUE for enable or FALSE for disable
16280 /// @return VDEC_EX_Result
16281 /// - E_VDEC_EX_OK: success
16282 /// - E_VDEC_EX_FAIL: failed
16283 //------------------------------------------------------------------------------
MApi_VDEC_EX_EnableTurboMode(MS_BOOL bEnable)16284 VDEC_EX_Result MApi_VDEC_EX_EnableTurboMode(MS_BOOL bEnable)
16285 {
16286 VDEC_EX_V2_IO_Param IO_arg;
16287 VDEC_EX_Result ret;
16288
16289 if (pu32VDEC_EX_Inst == NULL)
16290 {
16291 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
16292 {
16293 VPRINTF("UtopiaOpen VDEC_EX failed\n");
16294 return E_VDEC_EX_FAIL;
16295 }
16296 }
16297
16298 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_PRESET_ENABLETURBOMODE;
16299 IO_arg.param[0] = (void*)(&bEnable);
16300 IO_arg.pRet = (void*)(&ret);
16301
16302 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_PRE_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16303 {
16304 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16305 ret = E_VDEC_EX_FAIL;
16306 }
16307
16308 return ret;
16309 }
16310
16311
MApi_VDEC_EX_SetSingleDecode(MS_BOOL bEnable)16312 VDEC_EX_Result MApi_VDEC_EX_SetSingleDecode(MS_BOOL bEnable)
16313 {
16314 VDEC_EX_V2_IO_Param IO_arg;
16315 VDEC_EX_Result ret;
16316
16317 if (pu32VDEC_EX_Inst == NULL)
16318 {
16319 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
16320 {
16321 VPRINTF("UtopiaOpen VDEC_EX failed\n");
16322 return E_VDEC_EX_FAIL;
16323 }
16324 }
16325
16326 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_PRESETSINGLEDECODE;
16327 IO_arg.param[0] = (void*)(&bEnable);
16328 IO_arg.pRet = (void*)(&ret);
16329
16330 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_PRE_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16331 {
16332 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16333 ret = E_VDEC_EX_FAIL;
16334 }
16335
16336 return ret;
16337 }
16338
16339
16340
16341 //------------------------------------------------------------------------------
16342 /// Check if information for display setting is ready or not
16343 /// @param eStream \b IN : stream type
16344 /// @return VDEC_EX_Result
16345 //------------------------------------------------------------------------------
MApi_VDEC_EX_CheckDispInfoRdy(VDEC_StreamId * pStreamId)16346 VDEC_EX_Result MApi_VDEC_EX_CheckDispInfoRdy(VDEC_StreamId *pStreamId)
16347 {
16348 VDEC_EX_V2_IO_Param IO_arg;
16349 VDEC_EX_Result ret;
16350
16351 if (pu32VDEC_EX_Inst == NULL)
16352 {
16353 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16354 return E_VDEC_EX_FAIL;
16355 }
16356
16357 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16358 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CHECK_DISPINFO_READY;
16359 IO_arg.pRet = (void*)(&ret);
16360
16361 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16362 {
16363 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16364 ret = E_VDEC_EX_FAIL;
16365 }
16366
16367 return ret;
16368 }
16369
16370 //------------------------------------------------------------------------------
16371 /// Set up frame rate conversion mode
16372 /// @param eStream \b IN : stream type
16373 /// @param eFrcMode \b IN : frame rate conversion mode
16374 /// @return VDEC_EX_Result
16375 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetFrcMode(VDEC_StreamId * pStreamId,VDEC_EX_FrcMode eFrcMode)16376 VDEC_EX_Result MApi_VDEC_EX_SetFrcMode(VDEC_StreamId *pStreamId, VDEC_EX_FrcMode eFrcMode)
16377 {
16378 VDEC_EX_V2_IO_Param IO_arg;
16379 VDEC_EX_Result ret;
16380
16381 if (pu32VDEC_EX_Inst == NULL)
16382 {
16383 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16384 return E_VDEC_EX_FAIL;
16385 }
16386
16387 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16388 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_FRC_MODE;
16389 IO_arg.param[0] = (void*)(&eFrcMode);
16390 IO_arg.pRet = (void*)(&ret);
16391
16392 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16393 {
16394 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16395 ret = E_VDEC_EX_FAIL;
16396 }
16397
16398 return ret;
16399 }
16400
16401 //------------------------------------------------------------------------------
16402 /// Set up some parameters about dynamic scaling in FW
16403 /// @param eStream \b IN : stream type
16404 /// @param u32Addr \b IN : the physical start address of parameter set
16405 /// @param u32Size \b IN : the size of parameter set
16406 /// @return VDEC_EX_Result
16407 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetDynScalingParams(VDEC_StreamId * pStreamId,MS_PHY u32Addr,MS_U32 u32Size)16408 VDEC_EX_Result MApi_VDEC_EX_SetDynScalingParams(VDEC_StreamId *pStreamId, MS_PHY u32Addr, MS_U32 u32Size)
16409 {
16410 VDEC_EX_V2_IO_Param IO_arg;
16411 VDEC_EX_Result ret;
16412
16413 if (pu32VDEC_EX_Inst == NULL)
16414 {
16415 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16416 return E_VDEC_EX_FAIL;
16417 }
16418
16419 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16420 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DYNSCALING_PARAMS;
16421 IO_arg.param[0] = (void*)(&u32Addr);
16422 IO_arg.param[1] = (void*)(&u32Size);
16423 IO_arg.pRet = (void*)(&ret);
16424
16425 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16426 {
16427 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16428 ret = E_VDEC_EX_FAIL;
16429 }
16430
16431 return ret;
16432 }
16433
16434 //------------------------------------------------------------------------------
16435 /// Set up debug message level
16436 /// @param eStream \b IN : stream type
16437 /// @param eDbgLevel \b IN : message level
16438 /// @return VDEC_EX_Result
16439 /// - E_VDEC_EX_OK: Success
16440 /// - E_VDEC_EX_FAIL: Failed
16441 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetDbgLevel(VDEC_StreamId * pStreamId,VDEC_EX_DbgLevel eDbgLevel)16442 VDEC_EX_Result MApi_VDEC_EX_SetDbgLevel(VDEC_StreamId *pStreamId, VDEC_EX_DbgLevel eDbgLevel)
16443 {
16444 VDEC_EX_V2_IO_Param IO_arg;
16445 VDEC_EX_Result ret;
16446
16447 if (pu32VDEC_EX_Inst == NULL)
16448 {
16449 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16450 return E_VDEC_EX_FAIL;
16451 }
16452
16453 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16454 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_DBG_LEVEL;
16455 IO_arg.param[0] = (void*)(&eDbgLevel);
16456 IO_arg.pRet = (void*)(&ret);
16457
16458 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16459 {
16460 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16461 ret = E_VDEC_EX_FAIL;
16462 }
16463
16464 return ret;
16465 }
16466
16467
16468 //------------------------------------------------------------------------------
16469 /// Start playback
16470 /// @param pStreamId \b IN : the pointer to stream ID
16471 /// @return return VDEC_EX_Result
16472 //------------------------------------------------------------------------------
MApi_VDEC_EX_Play(VDEC_StreamId * pStreamId)16473 VDEC_EX_Result MApi_VDEC_EX_Play(VDEC_StreamId *pStreamId)
16474 {
16475 VDEC_EX_V2_IO_Param IO_arg;
16476 VDEC_EX_Result ret;
16477
16478 if (pu32VDEC_EX_Inst == NULL)
16479 {
16480 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16481 return E_VDEC_EX_FAIL;
16482 }
16483
16484 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16485 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_PLAY;
16486 IO_arg.pRet = (void*)(&ret);
16487
16488 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16489 {
16490 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16491 ret = E_VDEC_EX_FAIL;
16492 }
16493
16494 return ret;
16495 }
16496
16497 //------------------------------------------------------------------------------
16498 /// Pause decode and display
16499 /// @param eStream \b IN : stream type
16500 /// @return return VDEC_EX_Result
16501 //-----------------------------------------------------------------------------
MApi_VDEC_EX_Pause(VDEC_StreamId * pStreamId)16502 VDEC_EX_Result MApi_VDEC_EX_Pause(VDEC_StreamId *pStreamId)
16503 {
16504 VDEC_EX_V2_IO_Param IO_arg;
16505 VDEC_EX_Result ret;
16506
16507 if (pu32VDEC_EX_Inst == NULL)
16508 {
16509 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16510 return E_VDEC_EX_FAIL;
16511 }
16512
16513 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16514 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_PAUSE;
16515 IO_arg.pRet = (void*)(&ret);
16516
16517 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16518 {
16519 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16520 ret = E_VDEC_EX_FAIL;
16521 }
16522
16523 return ret;
16524 }
16525
16526 //------------------------------------------------------------------------------
16527 /// Resume decode and display
16528 /// @param eStream \b IN : stream type
16529 /// @return return VDEC_EX_Result
16530 //------------------------------------------------------------------------------
MApi_VDEC_EX_Resume(VDEC_StreamId * pStreamId)16531 VDEC_EX_Result MApi_VDEC_EX_Resume(VDEC_StreamId *pStreamId)
16532 {
16533 VDEC_EX_V2_IO_Param IO_arg;
16534 VDEC_EX_Result ret;
16535
16536 if (pu32VDEC_EX_Inst == NULL)
16537 {
16538 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16539 return E_VDEC_EX_FAIL;
16540 }
16541
16542 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16543 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_RESUME;
16544 IO_arg.pRet = (void*)(&ret);
16545
16546 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16547 {
16548 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16549 ret = E_VDEC_EX_FAIL;
16550 }
16551
16552 return ret;
16553 }
16554
16555
16556 //------------------------------------------------------------------------------
16557 /// Trigger to display one frame (background may still decoding)
16558 /// @param eStream \b IN : stream type
16559 /// @return return VDEC_EX_Result
16560 //------------------------------------------------------------------------------
MApi_VDEC_EX_StepDisp(VDEC_StreamId * pStreamId)16561 VDEC_EX_Result MApi_VDEC_EX_StepDisp(VDEC_StreamId *pStreamId)
16562 {
16563 VDEC_EX_V2_IO_Param IO_arg;
16564 VDEC_EX_Result ret;
16565
16566 if (pu32VDEC_EX_Inst == NULL)
16567 {
16568 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16569 return E_VDEC_EX_FAIL;
16570 }
16571
16572 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16573 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_STEP_DISP;
16574 IO_arg.pRet = (void*)(&ret);
16575
16576 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16577 {
16578 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16579 ret = E_VDEC_EX_FAIL;
16580 }
16581
16582 return ret;
16583 }
16584 /*
16585 VDEC_EX_Result MApi_VDEC_EX_SetFrmBuff2(VDEC_StreamId *pStreamId, VDEC_FRAMEBuff *framebuff)
16586 {
16587
16588 VDEC_EX_V2_IO_Param IO_arg;
16589 VDEC_EX_Result ret;
16590
16591 if (pu32VDEC_EX_Inst == NULL)
16592 {
16593 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16594 return E_VDEC_EX_FAIL;
16595 }
16596
16597 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16598 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_FRAMEBUFF2;
16599 IO_arg.param[0] = (void*)(&framebuff);
16600 IO_arg.pRet = (void*)(&ret);
16601
16602 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16603 {
16604 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16605 ret = E_VDEC_EX_FAIL;
16606 }
16607
16608 return ret;
16609 }
16610 */
16611
16612 //------------------------------------------------------------------------------
16613 /// Check if step play done or not
16614 /// @param eStream \b IN : stream type
16615 /// @return VDEC_EX_Result
16616 /// - E_VDEC_EX_OK: step display done
16617 /// - E_VDEC_EX_FAIL: not yet
16618 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
16619 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
16620 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsStepDispDone(VDEC_StreamId * pStreamId)16621 VDEC_EX_Result MApi_VDEC_EX_IsStepDispDone(VDEC_StreamId *pStreamId)
16622 {
16623 VDEC_EX_V2_IO_Param IO_arg;
16624 VDEC_EX_Result ret;
16625
16626 if (pu32VDEC_EX_Inst == NULL)
16627 {
16628 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16629 return E_VDEC_EX_FAIL;
16630 }
16631
16632 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16633 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_STEP_DISP_DONE;
16634 IO_arg.pRet = (void*)(&ret);
16635
16636 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16637 {
16638 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16639 ret = E_VDEC_EX_FAIL;
16640 }
16641
16642 return ret;
16643 }
16644
16645 //------------------------------------------------------------------------------
16646 /// Trigger VDEC to decode one frame
16647 /// @param eStream \b IN : stream type
16648 /// @return return VDEC_EX_Result
16649 //------------------------------------------------------------------------------
MApi_VDEC_EX_StepDecode(VDEC_StreamId * pStreamId)16650 VDEC_EX_Result MApi_VDEC_EX_StepDecode(VDEC_StreamId *pStreamId)
16651 {
16652 VDEC_EX_V2_IO_Param IO_arg;
16653 VDEC_EX_Result ret;
16654
16655 if (pu32VDEC_EX_Inst == NULL)
16656 {
16657 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16658 return E_VDEC_EX_FAIL;
16659 }
16660
16661 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16662 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_STEP_DECODE;
16663 IO_arg.pRet = (void*)(&ret);
16664
16665 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16666 {
16667 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16668 ret = E_VDEC_EX_FAIL;
16669 }
16670
16671 return ret;
16672 }
16673
16674 //------------------------------------------------------------------------------
16675 /// Check if step decode done or not
16676 /// @param eStream \b IN : stream type
16677 /// @return VDEC_EX_Result
16678 /// - E_VDEC_EX_OK: step decode done
16679 /// - E_VDEC_EX_FAIL: not yet
16680 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
16681 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
16682 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsStepDecodeDone(VDEC_StreamId * pStreamId)16683 VDEC_EX_Result MApi_VDEC_EX_IsStepDecodeDone(VDEC_StreamId *pStreamId)
16684 {
16685 VDEC_EX_V2_IO_Param IO_arg;
16686 VDEC_EX_Result ret;
16687
16688 if (pu32VDEC_EX_Inst == NULL)
16689 {
16690 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16691 return E_VDEC_EX_FAIL;
16692 }
16693
16694 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16695 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_STEP_DECODE_DONE;
16696 IO_arg.pRet = (void*)(&ret);
16697
16698 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16699 {
16700 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16701 ret = E_VDEC_EX_FAIL;
16702 }
16703
16704 return ret;
16705 }
16706
16707
16708 //------------------------------------------------------------------------------
16709 /// Set up trick decode mode for decode I, decode IP and decode all.
16710 /// @param eStream \b IN : stream type
16711 /// @param eTrickDec \b IN : trick decode mode
16712 /// @return VDEC_EX_Result
16713 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetTrickMode(VDEC_StreamId * pStreamId,VDEC_EX_TrickDec eTrickDec)16714 VDEC_EX_Result MApi_VDEC_EX_SetTrickMode(VDEC_StreamId *pStreamId, VDEC_EX_TrickDec eTrickDec)
16715 {
16716 VDEC_EX_V2_IO_Param IO_arg;
16717 VDEC_EX_Result ret;
16718
16719 if (pu32VDEC_EX_Inst == NULL)
16720 {
16721 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16722 return E_VDEC_EX_FAIL;
16723 }
16724
16725 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16726 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_TRICK_MODE;
16727 IO_arg.param[0] = (void*)(&eTrickDec);
16728 IO_arg.pRet = (void*)(&ret);
16729
16730 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16731 {
16732 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16733 ret = E_VDEC_EX_FAIL;
16734 }
16735
16736 return ret;
16737 }
16738
16739 //------------------------------------------------------------------------------
16740 /// Push decode command queue
16741 /// @param pStreamId \b IN : the pointer to stream ID
16742 /// @param pCmd \b IN : the pointer to decode command
16743 /// @return VDEC_EX_Result
16744 //------------------------------------------------------------------------------
MApi_VDEC_EX_PushDecQ(VDEC_StreamId * pStreamId,VDEC_EX_DecCmd * pCmd)16745 VDEC_EX_Result MApi_VDEC_EX_PushDecQ(VDEC_StreamId *pStreamId, VDEC_EX_DecCmd *pCmd)
16746 {
16747 VDEC_EX_V2_IO_Param IO_arg;
16748 VDEC_EX_Result ret;
16749
16750 if (pu32VDEC_EX_Inst == NULL)
16751 {
16752 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16753 return E_VDEC_EX_FAIL;
16754 }
16755
16756 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16757 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_PUSH_DECQ;
16758 IO_arg.param[0] = (void*)(pCmd);
16759 IO_arg.pRet = (void*)(&ret);
16760
16761 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16762 {
16763 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16764 ret = E_VDEC_EX_FAIL;
16765 }
16766
16767 return ret;
16768 }
16769
16770 //------------------------------------------------------------------------------
16771 /// Fire the decode command which be pushed since last fired
16772 /// @param pStreamId \b IN : the pointer to stream ID
16773 /// @return VDEC_EX_Result
16774 //------------------------------------------------------------------------------
MApi_VDEC_EX_FireDecCmd(VDEC_StreamId * pStreamId)16775 VDEC_EX_Result MApi_VDEC_EX_FireDecCmd(VDEC_StreamId *pStreamId)
16776 {
16777 VDEC_EX_V2_IO_Param IO_arg;
16778 VDEC_EX_Result ret;
16779
16780 if (pu32VDEC_EX_Inst == NULL)
16781 {
16782 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16783 return E_VDEC_EX_FAIL;
16784 }
16785
16786 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16787 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_FIRE_DEC;
16788 IO_arg.pRet = (void*)(&ret);
16789
16790 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16791 {
16792 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16793 ret = E_VDEC_EX_FAIL;
16794 }
16795
16796 return ret;
16797 }
16798
16799 //------------------------------------------------------------------------------
16800 /// Get current queue vacancy
16801 /// @param eStream \b IN : stream type
16802 /// @return vacancy number
16803 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDecQVacancy(VDEC_StreamId * pStreamId)16804 MS_U32 MApi_VDEC_EX_GetDecQVacancy(VDEC_StreamId *pStreamId)
16805 {
16806 VDEC_EX_V2_IO_Param IO_arg;
16807 VDEC_EX_Result ret;
16808 MS_U32 u32num = 0;
16809
16810 if (pu32VDEC_EX_Inst == NULL)
16811 {
16812 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16813 return u32num;
16814 }
16815
16816 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16817 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DECQ_VACANCY;
16818 IO_arg.param[0] = (void*)(&u32num);
16819 IO_arg.pRet = (void*)(&ret);
16820
16821 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16822 {
16823 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16824 }
16825
16826 return u32num;
16827 }
16828
16829 //------------------------------------------------------------------------------
16830 /// Flush command queue and internal data of decoder
16831 /// @param eStream \b IN : stream type
16832 /// @return VDEC_EX_Result
16833 //------------------------------------------------------------------------------
MApi_VDEC_EX_Flush(VDEC_StreamId * pStreamId,VDEC_EX_FreezePicSelect eFreezePic)16834 VDEC_EX_Result MApi_VDEC_EX_Flush(VDEC_StreamId *pStreamId, VDEC_EX_FreezePicSelect eFreezePic)
16835 {
16836 VDEC_EX_V2_IO_Param IO_arg;
16837 VDEC_EX_Result ret;
16838
16839 if (pu32VDEC_EX_Inst == NULL)
16840 {
16841 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16842 return E_VDEC_EX_FAIL;
16843 }
16844
16845 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16846 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_FLUSH;
16847 IO_arg.param[0] = (void*)(&eFreezePic);
16848 IO_arg.pRet = (void*)(&ret);
16849
16850 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16851 {
16852 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16853 ret = E_VDEC_EX_FAIL;
16854 }
16855
16856 return ret;
16857 }
16858
16859 //------------------------------------------------------------------------------
16860 /// Enable to let decoder force to display all decoded frame when out of input data
16861 /// @param eStream \b IN : stream type
16862 /// @param bEnable \b IN : TRUE - enable; FALSE - disable
16863 /// @return VDEC_EX_Result
16864 //------------------------------------------------------------------------------
MApi_VDEC_EX_EnableLastFrameShow(VDEC_StreamId * pStreamId,MS_BOOL bEnable)16865 VDEC_EX_Result MApi_VDEC_EX_EnableLastFrameShow(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
16866 {
16867 VDEC_EX_V2_IO_Param IO_arg;
16868 VDEC_EX_Result ret;
16869
16870 if (pu32VDEC_EX_Inst == NULL)
16871 {
16872 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16873 return E_VDEC_EX_FAIL;
16874 }
16875
16876 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16877 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_ENABLE_LAST_FRAME_SHOW;
16878 IO_arg.param[0] = (void*)(&bEnable);
16879 IO_arg.pRet = (void*)(&ret);
16880
16881 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16882 {
16883 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16884 ret = E_VDEC_EX_FAIL;
16885 }
16886
16887 return ret;
16888 }
16889
16890 //------------------------------------------------------------------------------
16891 /// Check if all decoded frames are displayed when input stream is run out
16892 /// @param eStream \b IN : stream type
16893 /// @return VDEC_EX_Result
16894 /// - E_VDEC_EX_OK: finished
16895 /// - E_VDEC_EX_FAIL: not yet
16896 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
16897 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
16898 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsDispFinish(VDEC_StreamId * pStreamId)16899 VDEC_EX_Result MApi_VDEC_EX_IsDispFinish(VDEC_StreamId *pStreamId)
16900 {
16901 VDEC_EX_V2_IO_Param IO_arg;
16902 VDEC_EX_Result ret;
16903
16904 if (pu32VDEC_EX_Inst == NULL)
16905 {
16906 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16907 return E_VDEC_EX_FAIL;
16908 }
16909
16910 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16911 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_DISP_FINISH;
16912 IO_arg.pRet = (void*)(&ret);
16913
16914 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16915 {
16916 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16917 ret = E_VDEC_EX_FAIL;
16918 }
16919
16920 return ret;
16921 }
16922
16923 //------------------------------------------------------------------------------
16924 /// Set up display speed
16925 /// @param eStream \b IN : stream type
16926 /// @param eSpeedType \b IN : display speed type
16927 /// @param eSpeed \b IN : multiple
16928 /// @return VDEC_EX_Result
16929 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetSpeed(VDEC_StreamId * pStreamId,VDEC_EX_SpeedType eSpeedType,VDEC_EX_DispSpeed eSpeed)16930 VDEC_EX_Result MApi_VDEC_EX_SetSpeed(VDEC_StreamId *pStreamId, VDEC_EX_SpeedType eSpeedType, VDEC_EX_DispSpeed eSpeed)
16931 {
16932 VDEC_EX_V2_IO_Param IO_arg;
16933 VDEC_EX_Result ret;
16934
16935 if (pu32VDEC_EX_Inst == NULL)
16936 {
16937 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16938 return E_VDEC_EX_FAIL;
16939 }
16940
16941 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16942 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_SPEED;
16943 IO_arg.param[0] = (void*)(&eSpeedType);
16944 IO_arg.param[1] = (void*)(&eSpeed);
16945 IO_arg.pRet = (void*)(&ret);
16946
16947 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16948 {
16949 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16950 ret = E_VDEC_EX_FAIL;
16951 }
16952
16953 return ret;
16954 }
16955
16956 //------------------------------------------------------------------------------
16957 /// Let FW stop updating frames when vsync, but decoding process is still going.
16958 /// @param eStream \b IN : stream type
16959 /// @param bEnable \b IN : Enable/Disable
16960 /// @return -The result of command freeze image.
16961 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetFreezeDisp(VDEC_StreamId * pStreamId,MS_BOOL bEnable)16962 VDEC_EX_Result MApi_VDEC_EX_SetFreezeDisp(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
16963 {
16964 VDEC_EX_V2_IO_Param IO_arg;
16965 VDEC_EX_Result ret;
16966
16967 if (pu32VDEC_EX_Inst == NULL)
16968 {
16969 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16970 return E_VDEC_EX_FAIL;
16971 }
16972
16973 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
16974 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_FREEZE_DISP;
16975 IO_arg.param[0] = (void*)(&bEnable);
16976 IO_arg.pRet = (void*)(&ret);
16977
16978 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
16979 {
16980 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
16981 ret = E_VDEC_EX_FAIL;
16982 }
16983
16984 return ret;
16985 }
16986
16987 //------------------------------------------------------------------------------
16988 /// Set blue screen on/off
16989 /// @param eStream \b IN : stream type
16990 /// @param bOn \b IN : turn on / off blue screen
16991 /// @return VDEC_EX_Result
16992 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetBlueScreen(VDEC_StreamId * pStreamId,MS_BOOL bOn)16993 VDEC_EX_Result MApi_VDEC_EX_SetBlueScreen(VDEC_StreamId *pStreamId, MS_BOOL bOn)
16994 {
16995 VDEC_EX_V2_IO_Param IO_arg;
16996 VDEC_EX_Result ret;
16997
16998 if (pu32VDEC_EX_Inst == NULL)
16999 {
17000 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17001 return E_VDEC_EX_FAIL;
17002 }
17003
17004 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17005 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_BLUE_SCREEN;
17006 IO_arg.param[0] = (void*)(&bOn);
17007 IO_arg.pRet = (void*)(&ret);
17008
17009 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17010 {
17011 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17012 ret = E_VDEC_EX_FAIL;
17013 }
17014
17015 return ret;
17016 }
17017
17018 //------------------------------------------------------------------------------
17019 /// Reset PTS
17020 /// @param eStream \b IN : stream type
17021 /// @param u32PtsBase \b IN : new PTS base value
17022 /// @return VDEC_EX_Result
17023 //------------------------------------------------------------------------------
MApi_VDEC_EX_ResetPTS(VDEC_StreamId * pStreamId,MS_U32 u32PtsBase)17024 VDEC_EX_Result MApi_VDEC_EX_ResetPTS(VDEC_StreamId *pStreamId, MS_U32 u32PtsBase)
17025 {
17026 VDEC_EX_V2_IO_Param IO_arg;
17027 VDEC_EX_Result ret;
17028
17029 if (pu32VDEC_EX_Inst == NULL)
17030 {
17031 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17032 return E_VDEC_EX_FAIL;
17033 }
17034
17035 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17036 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_RESET_PTS;
17037 IO_arg.param[0] = (void*)(&u32PtsBase);
17038 IO_arg.pRet = (void*)(&ret);
17039
17040 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17041 {
17042 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17043 ret = E_VDEC_EX_FAIL;
17044 }
17045
17046 return ret;
17047 }
17048
17049 //------------------------------------------------------------------------------
17050 /// Switch AV sync on/off
17051 /// @param pStreamId \b IN : the pointer to stream ID
17052 /// @param bOn \b IN : on/off
17053 /// @param u32SyncDelay \b IN : delay value
17054 /// @param u16SyncTolerance \b IN : tolerance value
17055 /// @return VDEC_EX_Result
17056 //------------------------------------------------------------------------------
MApi_VDEC_EX_AVSyncOn(VDEC_StreamId * pStreamId,MS_BOOL bOn,MS_U32 u32SyncDelay,MS_U16 u16SyncTolerance)17057 VDEC_EX_Result MApi_VDEC_EX_AVSyncOn(VDEC_StreamId *pStreamId, MS_BOOL bOn, MS_U32 u32SyncDelay, MS_U16 u16SyncTolerance)
17058 {
17059 VDEC_EX_V2_IO_Param IO_arg;
17060 VDEC_EX_Result ret;
17061
17062 if (pu32VDEC_EX_Inst == NULL)
17063 {
17064 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17065 return E_VDEC_EX_FAIL;
17066 }
17067
17068 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17069 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_AVSYNC_ON;
17070 IO_arg.param[0] = (void*)(&bOn);
17071 IO_arg.param[1] = (void*)(&u32SyncDelay);
17072 IO_arg.param[2] = (void*)(&u16SyncTolerance);
17073 IO_arg.pRet = (void*)(&ret);
17074
17075 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17076 {
17077 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17078 ret = E_VDEC_EX_FAIL;
17079 }
17080
17081 return ret;
17082 }
17083
17084 //------------------------------------------------------------------------------
17085 /// Switch AV sync free run threshold
17086 /// @param eStream \b IN : stream type
17087 /// @param u32Threshold \b IN : threshold value
17088 /// @return VDEC_EX_Result
17089 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetAVSyncFreerunThreshold(VDEC_StreamId * pStreamId,MS_U32 u32Threshold)17090 VDEC_EX_Result MApi_VDEC_EX_SetAVSyncFreerunThreshold(VDEC_StreamId *pStreamId, MS_U32 u32Threshold)
17091 {
17092 VDEC_EX_V2_IO_Param IO_arg;
17093 VDEC_EX_Result ret;
17094
17095 if (pu32VDEC_EX_Inst == NULL)
17096 {
17097 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17098 return E_VDEC_EX_FAIL;
17099 }
17100
17101 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17102 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_AVSYNC_FREERUN_THRESHOLD;
17103 IO_arg.param[0] = (void*)(&u32Threshold);
17104 IO_arg.pRet = (void*)(&ret);
17105
17106 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17107 {
17108 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17109 ret = E_VDEC_EX_FAIL;
17110 }
17111
17112 return ret;
17113 }
17114
17115 //------------------------------------------------------------------------------
17116 /// Check if AV sync on or not
17117 /// @param eStream \b IN : stream type
17118 /// @return VDEC_EX_Result
17119 /// - E_VDEC_EX_OK: AV sync on
17120 /// - E_VDEC_EX_FAIL: freerun
17121 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17122 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17123 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsAVSyncOn(VDEC_StreamId * pStreamId)17124 VDEC_EX_Result MApi_VDEC_EX_IsAVSyncOn(VDEC_StreamId *pStreamId)
17125 {
17126 VDEC_EX_V2_IO_Param IO_arg;
17127 VDEC_EX_Result ret;
17128
17129 if (pu32VDEC_EX_Inst == NULL)
17130 {
17131 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17132 return E_VDEC_EX_FAIL;
17133 }
17134
17135 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17136 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_AVSYNC_ON;
17137 IO_arg.pRet = (void*)(&ret);
17138
17139 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17140 {
17141 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17142 ret = E_VDEC_EX_FAIL;
17143 }
17144
17145 return ret;
17146 }
17147
17148 //------------------------------------------------------------------------------
17149 /// Get display information
17150 /// @param eStream \b IN : stream type
17151 /// @param pDispinfo \b OUT : pointer to display setting information
17152 /// @return VDEC_EX_Result
17153 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDispInfo(VDEC_StreamId * pStreamId,VDEC_EX_DispInfo * pDispinfo)17154 VDEC_EX_Result MApi_VDEC_EX_GetDispInfo(VDEC_StreamId *pStreamId, VDEC_EX_DispInfo *pDispinfo)
17155 {
17156 VDEC_EX_V2_IO_Param IO_arg;
17157 VDEC_EX_Result ret;
17158
17159 if (pu32VDEC_EX_Inst == NULL)
17160 {
17161 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17162 return E_VDEC_EX_FAIL;
17163 }
17164
17165 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17166 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DISP_INFO;
17167 IO_arg.param[0] = (void*)(pDispinfo);
17168 IO_arg.pRet = (void*)(&ret);
17169
17170 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17171 {
17172 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17173 ret = E_VDEC_EX_FAIL;
17174 }
17175
17176 return ret;
17177 }
17178
17179 //------------------------------------------------------------------------------
17180 /// Check if decoder got valid stream to decode
17181 /// @param eStream \b IN : stream type
17182 /// @return TRUE or FALSE
17183 /// - TRUE: find valid stream
17184 /// - FALSE: not yet
17185 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsWithValidStream(VDEC_StreamId * pStreamId)17186 VDEC_EX_Result MApi_VDEC_EX_IsWithValidStream(VDEC_StreamId *pStreamId)
17187 {
17188 VDEC_EX_V2_IO_Param IO_arg;
17189 VDEC_EX_Result ret;
17190
17191 if (pu32VDEC_EX_Inst == NULL)
17192 {
17193 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17194 return E_VDEC_EX_FAIL;
17195 }
17196
17197 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17198 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_WITH_VALID_STREAM;
17199 IO_arg.pRet = (void*)(&ret);
17200
17201 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17202 {
17203 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17204 ret = E_VDEC_EX_FAIL;
17205 }
17206
17207 return ret;
17208 }
17209
17210 //------------------------------------------------------------------------------
17211 /// Check if decoder found I frame after reset or flush queue
17212 /// @param eStream \b IN : stream type
17213 /// @return VDEC_EX_Result
17214 /// - E_VDEC_EX_OK: found
17215 /// - E_VDEC_EX_FAIL: not found
17216 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17217 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17218 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsIFrameFound(VDEC_StreamId * pStreamId)17219 VDEC_EX_Result MApi_VDEC_EX_IsIFrameFound(VDEC_StreamId *pStreamId)
17220 {
17221 VDEC_EX_V2_IO_Param IO_arg;
17222 VDEC_EX_Result ret;
17223
17224 if (pu32VDEC_EX_Inst == NULL)
17225 {
17226 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17227 return E_VDEC_EX_FAIL;
17228 }
17229
17230 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17231 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_IFRAME_FOUND;
17232 IO_arg.pRet = (void*)(&ret);
17233
17234 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17235 {
17236 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17237 ret = E_VDEC_EX_FAIL;
17238 }
17239
17240 return ret;
17241 }
17242
17243 //------------------------------------------------------------------------------
17244 /// Check if sequence header is different from previous one
17245 /// @param eStream \b IN : stream type
17246 /// @return VDEC_EX_Result
17247 /// - E_VDEC_EX_OK: changed
17248 /// - E_VDEC_EX_FAIL: not changed
17249 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17250 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17251 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsSeqChg(VDEC_StreamId * pStreamId)17252 VDEC_EX_Result MApi_VDEC_EX_IsSeqChg(VDEC_StreamId *pStreamId)
17253 {
17254 VDEC_EX_V2_IO_Param IO_arg;
17255 VDEC_EX_Result ret;
17256
17257 if (pu32VDEC_EX_Inst == NULL)
17258 {
17259 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17260 return E_VDEC_EX_FAIL;
17261 }
17262
17263 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17264 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_SEQ_CHG;
17265 IO_arg.pRet = (void*)(&ret);
17266
17267 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17268 {
17269 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17270 ret = E_VDEC_EX_FAIL;
17271 }
17272
17273 return ret;
17274 }
17275
17276 //------------------------------------------------------------------------------
17277 /// Check if the distance of Video time stamp and STC is closed enough.
17278 /// @param eStream \b IN : stream type
17279 /// @return VDEC_EX_Result
17280 /// - E_VDEC_EX_OK: sync complete
17281 /// - E_VDEC_EX_FAIL: sync is incomplete
17282 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17283 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17284 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsReachSync(VDEC_StreamId * pStreamId)17285 VDEC_EX_Result MApi_VDEC_EX_IsReachSync(VDEC_StreamId *pStreamId)
17286 {
17287 VDEC_EX_V2_IO_Param IO_arg;
17288 VDEC_EX_Result ret;
17289
17290 if (pu32VDEC_EX_Inst == NULL)
17291 {
17292 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17293 return E_VDEC_EX_FAIL;
17294 }
17295
17296 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17297 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_REACH_SYNC;
17298 IO_arg.pRet = (void*)(&ret);
17299
17300 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17301 {
17302 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17303 ret = E_VDEC_EX_FAIL;
17304 }
17305
17306 return ret;
17307 }
17308
17309 //------------------------------------------------------------------------------
17310 /// Check if decoder is doing AV sync now
17311 /// @param eStream \b IN : stream type
17312 /// @return VDEC_EX_Result
17313 /// - E_VDEC_EX_OK: doing AV sync
17314 /// - E_VDEC_EX_FAIL: still freerun
17315 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17316 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17317 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsStartSync(VDEC_StreamId * pStreamId)17318 VDEC_EX_Result MApi_VDEC_EX_IsStartSync(VDEC_StreamId *pStreamId)
17319 {
17320 VDEC_EX_V2_IO_Param IO_arg;
17321 VDEC_EX_Result ret;
17322
17323 if (pu32VDEC_EX_Inst == NULL)
17324 {
17325 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17326 return E_VDEC_EX_FAIL;
17327 }
17328
17329 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17330 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_START_SYNC;
17331 IO_arg.pRet = (void*)(&ret);
17332
17333 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17334 {
17335 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17336 ret = E_VDEC_EX_FAIL;
17337 }
17338
17339 return ret;
17340 }
17341
17342
17343 //------------------------------------------------------------------------------
17344 /// Check if decoder is avsync freerun
17345 /// @return VDEC_Result
17346 /// - E_VDEC_OK: freerun
17347 /// - E_VDEC_FAIL: not freerun
17348 /// - E_VDEC_RET_NOT_INIT: not initial yet
17349 /// - E_VDEC_RET_UNSUPPORTED: not supported with current decoder configuration
17350 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsFreerun(VDEC_StreamId * pStreamId)17351 VDEC_EX_Result MApi_VDEC_EX_IsFreerun(VDEC_StreamId *pStreamId)
17352 {
17353 VDEC_EX_V2_IO_Param IO_arg;
17354 VDEC_EX_Result ret;
17355
17356 if (pu32VDEC_EX_Inst == NULL)
17357 {
17358 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17359 return E_VDEC_EX_FAIL;
17360 }
17361
17362 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17363 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_FREERUN;
17364 IO_arg.pRet = (void*)(&ret);
17365
17366 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17367 {
17368 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17369 ret = E_VDEC_EX_FAIL;
17370 }
17371
17372 return ret;
17373 }
17374
17375 //------------------------------------------------------------------------------
17376 /// Check if input stream is with low delay flag
17377 /// @param eStream \b IN : stream type
17378 /// @return VDEC_EX_Result
17379 /// - E_VDEC_EX_OK: with low delay
17380 /// - E_VDEC_EX_FAIL: without low delay
17381 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17382 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17383 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsWithLowDelay(VDEC_StreamId * pStreamId)17384 VDEC_EX_Result MApi_VDEC_EX_IsWithLowDelay(VDEC_StreamId *pStreamId)
17385 {
17386 VDEC_EX_V2_IO_Param IO_arg;
17387 VDEC_EX_Result ret;
17388
17389 if (pu32VDEC_EX_Inst == NULL)
17390 {
17391 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17392 return E_VDEC_EX_FAIL;
17393 }
17394
17395 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17396 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_WITH_LOW_DELAY;
17397 IO_arg.pRet = (void*)(&ret);
17398
17399 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17400 {
17401 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17402 ret = E_VDEC_EX_FAIL;
17403 }
17404
17405 return ret;
17406 }
17407
17408 //------------------------------------------------------------------------------
17409 /// Check if all date buffers are empty or not
17410 /// @param eStream \b IN : stream type
17411 /// @return VDEC_EX_Result
17412 /// - E_VDEC_EX_OK: All of the buffers are empty
17413 /// - E_VDEC_EX_FAIL: Some of the buffers are not empty
17414 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17415 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17416 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsAllBufferEmpty(VDEC_StreamId * pStreamId)17417 VDEC_EX_Result MApi_VDEC_EX_IsAllBufferEmpty(VDEC_StreamId *pStreamId)
17418 {
17419 VDEC_EX_V2_IO_Param IO_arg;
17420 VDEC_EX_Result ret;
17421
17422 if (pu32VDEC_EX_Inst == NULL)
17423 {
17424 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17425 return E_VDEC_EX_FAIL;
17426 }
17427
17428 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17429 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_ALL_BUFFER_EMPTY;
17430 IO_arg.pRet = (void*)(&ret);
17431
17432 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17433 {
17434 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17435 ret = E_VDEC_EX_FAIL;
17436 }
17437
17438 return ret;
17439 }
17440
17441 //------------------------------------------------------------------------------
17442 /// Get the extension information of decoded frame.
17443 /// @param pExtDispinfo \b IN : the extension information of decoded frame.
17444 /// @return -VDEC_Result
17445 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetExtDispInfo(VDEC_StreamId * pStreamId,VDEC_EX_ExtDispInfo * pExtDispinfo)17446 VDEC_EX_Result MApi_VDEC_EX_GetExtDispInfo(VDEC_StreamId *pStreamId, VDEC_EX_ExtDispInfo *pExtDispinfo)
17447 {
17448 VDEC_EX_V2_IO_Param IO_arg;
17449 VDEC_EX_Result ret;
17450
17451 if (pu32VDEC_EX_Inst == NULL)
17452 {
17453 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17454 return E_VDEC_EX_FAIL;
17455 }
17456
17457 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17458 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_EXT_DISP_INFO;
17459 IO_arg.param[0] = (void*)(pExtDispinfo);
17460 IO_arg.pRet = (void*)(&ret);
17461
17462 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17463 {
17464 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17465 ret = E_VDEC_EX_FAIL;
17466 }
17467
17468 return ret;
17469 }
17470
17471
17472 //------------------------------------------------------------------------------
17473 /// Get the information of the latest decoded frame.
17474 /// @param eStream \b IN : stream type
17475 /// @param pFrmInfo \b IN : the information of the latest decoded frame
17476 /// @return -VDEC_EX_Result
17477 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDecFrameInfo(VDEC_StreamId * pStreamId,VDEC_EX_FrameInfo * pFrmInfo)17478 VDEC_EX_Result MApi_VDEC_EX_GetDecFrameInfo(VDEC_StreamId *pStreamId, VDEC_EX_FrameInfo *pFrmInfo)
17479 {
17480 VDEC_EX_V2_IO_Param IO_arg;
17481 VDEC_EX_Result ret;
17482
17483 if (pu32VDEC_EX_Inst == NULL)
17484 {
17485 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17486 return E_VDEC_EX_FAIL;
17487 }
17488
17489 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17490 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DEC_FRAME_INFO;
17491 IO_arg.param[0] = (void*)(pFrmInfo);
17492 IO_arg.pRet = (void*)(&ret);
17493
17494 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17495 {
17496 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17497 ret = E_VDEC_EX_FAIL;
17498 }
17499
17500 return ret;
17501 }
17502
17503 //------------------------------------------------------------------------------
17504 /// Get the information of current displaying frame.
17505 /// @param eStream \b IN : stream type
17506 /// @param pFrmInfo \b IN : the information of displaying frame
17507 /// @return -VDEC_EX_Result
17508 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDispFrameInfo(VDEC_StreamId * pStreamId,VDEC_EX_FrameInfo * pFrmInfo)17509 VDEC_EX_Result MApi_VDEC_EX_GetDispFrameInfo(VDEC_StreamId *pStreamId, VDEC_EX_FrameInfo *pFrmInfo)
17510 {
17511 VDEC_EX_V2_IO_Param IO_arg;
17512 VDEC_EX_Result ret;
17513
17514 if (pu32VDEC_EX_Inst == NULL)
17515 {
17516 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17517 return E_VDEC_EX_FAIL;
17518 }
17519
17520 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17521 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DISP_FRAME_INFO;
17522 IO_arg.param[0] = (void*)(pFrmInfo);
17523 IO_arg.pRet = (void*)(&ret);
17524
17525 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17526 {
17527 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17528 ret = E_VDEC_EX_FAIL;
17529 }
17530
17531 return ret;
17532 }
17533
17534 //------------------------------------------------------------------------------
17535 /// Get the time_code of the latest decoded frame.
17536 /// @param eStream \b IN : stream type
17537 /// @param pTimeCode \b IN : the time_code of the latest decoded frame
17538 /// @return -VDEC_EX_Result
17539 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDecTimeCode(VDEC_StreamId * pStreamId,VDEC_EX_TimeCode * pTimeCode)17540 VDEC_EX_Result MApi_VDEC_EX_GetDecTimeCode(VDEC_StreamId *pStreamId, VDEC_EX_TimeCode* pTimeCode)
17541 {
17542 VDEC_EX_V2_IO_Param IO_arg;
17543 VDEC_EX_Result ret;
17544
17545 if (pu32VDEC_EX_Inst == NULL)
17546 {
17547 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17548 return E_VDEC_EX_FAIL;
17549 }
17550
17551 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17552 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DEC_TIMECODE;
17553 IO_arg.param[0] = (void*)(pTimeCode);
17554 IO_arg.pRet = (void*)(&ret);
17555
17556 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17557 {
17558 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17559 ret = E_VDEC_EX_FAIL;
17560 }
17561
17562 return ret;
17563 }
17564
17565 //------------------------------------------------------------------------------
17566 /// Get the time_code of the latest displayed frame.
17567 /// @param eStream \b IN : stream type
17568 /// @param pTimeCode \b IN : the time_code of the latest displayed frame
17569 /// @return -VDEC_EX_Result
17570 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDispTimeCode(VDEC_StreamId * pStreamId,VDEC_EX_TimeCode * pTimeCode)17571 VDEC_EX_Result MApi_VDEC_EX_GetDispTimeCode(VDEC_StreamId *pStreamId, VDEC_EX_TimeCode* pTimeCode)
17572 {
17573 VDEC_EX_V2_IO_Param IO_arg;
17574 VDEC_EX_Result ret;
17575
17576 if (pu32VDEC_EX_Inst == NULL)
17577 {
17578 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17579 return E_VDEC_EX_FAIL;
17580 }
17581
17582 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17583 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DISP_TIMECODE;
17584 IO_arg.param[0] = (void*)(pTimeCode);
17585 IO_arg.pRet = (void*)(&ret);
17586
17587 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17588 {
17589 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17590 ret = E_VDEC_EX_FAIL;
17591 }
17592
17593 return ret;
17594 }
17595
17596 //------------------------------------------------------------------------------
17597 /// Check if the first frame is showed after play function is called
17598 /// @param eStream \b IN : stream type
17599 /// @return VDEC_EX_Result
17600 /// - E_VDEC_EX_OK: ready
17601 /// - E_VDEC_EX_FAIL: not ready
17602 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
17603 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
17604 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsFrameRdy(VDEC_StreamId * pStreamId)17605 VDEC_EX_Result MApi_VDEC_EX_IsFrameRdy(VDEC_StreamId *pStreamId)
17606 {
17607 VDEC_EX_V2_IO_Param IO_arg;
17608 VDEC_EX_Result ret;
17609
17610 if (pu32VDEC_EX_Inst == NULL)
17611 {
17612 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17613 return E_VDEC_EX_FAIL;
17614 }
17615
17616 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17617 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_FRAME_RDY;
17618 IO_arg.pRet = (void*)(&ret);
17619
17620 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17621 {
17622 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17623 ret = E_VDEC_EX_FAIL;
17624 }
17625
17626 return ret;
17627 }
17628
17629
17630 //------------------------------------------------------------------------------
17631 /// Set decoder event and register it's callback function
17632 /// @param eStream \b IN : stream type
17633 /// @param u32EventFlag \b In : the events want to be turned on/off
17634 /// @param pfn \b In : callback function
17635 /// @param param \b In : parameter for callback function
17636 /// @return -VDEC_EX_Result
17637 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetEvent(VDEC_StreamId * pStreamId,MS_U32 u32EventFlag,VDEC_EX_EventCb pfn,void * param)17638 VDEC_EX_Result MApi_VDEC_EX_SetEvent(VDEC_StreamId *pStreamId, MS_U32 u32EventFlag, VDEC_EX_EventCb pfn, void *param)
17639 {
17640 VDEC_EX_V2_IO_Param IO_arg;
17641 VDEC_EX_Result ret;
17642 VDEC_EX_CB_TYPE type = E_VDEC_EX_CB_MAIN;
17643
17644 if (pu32VDEC_EX_Inst == NULL)
17645 {
17646 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17647 return E_VDEC_EX_FAIL;
17648 }
17649
17650 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17651 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_EVENT_MULTICALLBACK;
17652 IO_arg.param[0] = (void*)(&type);
17653 IO_arg.param[1] = (void*)(&u32EventFlag);
17654 IO_arg.param[2] = (void*)(pfn);
17655 IO_arg.param[3] = (param);
17656 IO_arg.pRet = (void*)(&ret);
17657
17658 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17659 {
17660 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17661 ret = E_VDEC_EX_FAIL;
17662 }
17663
17664 #if 1//#ifdef VDEC_UTOPIA_2K
17665 _VDEC_EX_Create_Callback_task(pStreamId, type, pfn, param,u32EventFlag);
17666 #endif
17667
17668 return ret;
17669 }
17670
MApi_VDEC_EX_UnsetEvent(VDEC_StreamId * pStreamId,MS_U32 u32EventFlag)17671 VDEC_EX_Result MApi_VDEC_EX_UnsetEvent(VDEC_StreamId *pStreamId, MS_U32 u32EventFlag)
17672 {
17673 VDEC_EX_V2_IO_Param IO_arg;
17674 VDEC_EX_Result ret;
17675 VDEC_EX_CB_TYPE type = E_VDEC_EX_CB_MAIN;
17676
17677 if (pu32VDEC_EX_Inst == NULL)
17678 {
17679 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17680 return E_VDEC_EX_FAIL;
17681 }
17682
17683 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17684 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_UNSET_EVENT_MULTICALLBACK;
17685 IO_arg.param[0] = (void*)(&type);
17686 IO_arg.param[1] = (void*)(&u32EventFlag);
17687 IO_arg.pRet = (void*)(&ret);
17688
17689 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17690 {
17691 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17692 ret = E_VDEC_EX_FAIL;
17693 }
17694
17695 #if 1//#ifdef VDEC_UTOPIA_2K
17696 _VDEC_EX_UnSetEvent(pStreamId, type, u32EventFlag);
17697 #endif
17698
17699 return ret;
17700 }
17701
17702 //------------------------------------------------------------------------------
17703 /// Set decoder event and register it's callback function
17704 /// @param eStream \b IN : stream type
17705 /// @param u32EventFlag \b In : the events want to be turned on/off
17706 /// @param pfn \b In : callback function
17707 /// @param param \b In : parameter for callback function
17708 /// @return -VDEC_EX_Result
17709 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetEvent_MultiCallback(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,MS_U32 u32EventFlag,VDEC_EX_EventCb pfn,void * param)17710 VDEC_EX_Result MApi_VDEC_EX_SetEvent_MultiCallback(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, MS_U32 u32EventFlag, VDEC_EX_EventCb pfn, void *param)
17711 {
17712 VDEC_EX_V2_IO_Param IO_arg;
17713 VDEC_EX_Result ret;
17714
17715 if (pu32VDEC_EX_Inst == NULL)
17716 {
17717 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17718 return E_VDEC_EX_FAIL;
17719 }
17720
17721 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17722 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_EVENT_MULTICALLBACK;
17723 IO_arg.param[0] = (void*)(&cb_type);
17724 IO_arg.param[1] = (void*)(&u32EventFlag);
17725 IO_arg.param[2] = (void*)(pfn);
17726 IO_arg.param[3] = (param);
17727 IO_arg.pRet = (void*)(&ret);
17728
17729 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17730 {
17731 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17732 ret = E_VDEC_EX_FAIL;
17733 }
17734
17735 #if 1//#ifdef VDEC_UTOPIA_2K
17736 _VDEC_EX_Create_Callback_task(pStreamId, cb_type, pfn, param,u32EventFlag);
17737 #endif
17738
17739 return ret;
17740 }
17741
MApi_VDEC_EX_UnsetEvent_MultiCallback(VDEC_StreamId * pStreamId,VDEC_EX_CB_TYPE cb_type,MS_U32 u32EventFlag)17742 VDEC_EX_Result MApi_VDEC_EX_UnsetEvent_MultiCallback(VDEC_StreamId *pStreamId, VDEC_EX_CB_TYPE cb_type, MS_U32 u32EventFlag)
17743 {
17744 VDEC_EX_V2_IO_Param IO_arg;
17745 VDEC_EX_Result ret;
17746
17747 if (pu32VDEC_EX_Inst == NULL)
17748 {
17749 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17750 return E_VDEC_EX_FAIL;
17751 }
17752
17753 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17754 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_UNSET_EVENT_MULTICALLBACK;
17755 IO_arg.param[0] = (void*)(&cb_type);
17756 IO_arg.param[1] = (void*)(&u32EventFlag);
17757 IO_arg.pRet = (void*)(&ret);
17758
17759 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17760 {
17761 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17762 ret = E_VDEC_EX_FAIL;
17763 }
17764
17765 #if 1//#ifdef VDEC_UTOPIA_2K
17766 _VDEC_EX_UnSetEvent(pStreamId, cb_type, u32EventFlag);
17767 #endif
17768
17769 return ret;
17770 }
17771
17772 //------------------------------------------------------------------------------
17773 /// Get ISR event status
17774 /// @param eStream \b IN : stream type
17775 /// @param u32EventFlag \b OUT : vdec event bitmap
17776 /// @return status
17777 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetEventInfo(VDEC_StreamId * pStreamId,MS_U32 * u32EventFlag)17778 VDEC_EX_Result MApi_VDEC_EX_GetEventInfo(VDEC_StreamId *pStreamId, MS_U32* u32EventFlag)
17779 {
17780 VDEC_EX_V2_IO_Param IO_arg;
17781 VDEC_EX_Result ret;
17782
17783 if (pu32VDEC_EX_Inst == NULL)
17784 {
17785 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17786 return E_VDEC_EX_FAIL;
17787 }
17788
17789 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17790 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_EVENT_INFO;
17791 IO_arg.param[0] = (void*)(u32EventFlag);
17792 IO_arg.pRet = (void*)(&ret);
17793
17794 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17795 {
17796 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17797 ret = E_VDEC_EX_FAIL;
17798 }
17799
17800 return ret;
17801 }
17802
17803 //------------------------------------------------------------------------------
17804 /// Decoder will start decode with full speed until target PTS is reached (equal or larger) then pause.
17805 /// @param eStream \b IN : stream type
17806 /// @param u32PTS \b IN : target PTS
17807 /// @return VDEC_EX_Result
17808 //------------------------------------------------------------------------------
MApi_VDEC_EX_SeekToPTS(VDEC_StreamId * pStreamId,MS_U32 u32PTS)17809 VDEC_EX_Result MApi_VDEC_EX_SeekToPTS(VDEC_StreamId *pStreamId, MS_U32 u32PTS)
17810 {
17811 VDEC_EX_V2_IO_Param IO_arg;
17812 VDEC_EX_Result ret;
17813
17814 if (pu32VDEC_EX_Inst == NULL)
17815 {
17816 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17817 return E_VDEC_EX_FAIL;
17818 }
17819
17820 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17821 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SEEK_TO_PTS;
17822 IO_arg.param[0] = (void*)(&u32PTS);
17823 IO_arg.pRet = (void*)(&ret);
17824
17825 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17826 {
17827 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17828 ret = E_VDEC_EX_FAIL;
17829 }
17830
17831 return ret;
17832 }
17833
17834 //------------------------------------------------------------------------------
17835 /// Decoder will skip all frames before target PTS, and start decode with full speed after target PTS is reached.
17836 /// @param eStream \b IN : stream type
17837 /// @param u32PTS \b IN : target PTS
17838 /// - 0: turn off this mode.
17839 /// - any not zero: enable this mode.
17840 /// @return VDEC_EX_Result
17841 //------------------------------------------------------------------------------
MApi_VDEC_EX_SkipToPTS(VDEC_StreamId * pStreamId,MS_U32 u32PTS)17842 VDEC_EX_Result MApi_VDEC_EX_SkipToPTS(VDEC_StreamId *pStreamId, MS_U32 u32PTS)
17843 {
17844 VDEC_EX_V2_IO_Param IO_arg;
17845 VDEC_EX_Result ret;
17846
17847 if (pu32VDEC_EX_Inst == NULL)
17848 {
17849 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17850 return E_VDEC_EX_FAIL;
17851 }
17852
17853 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17854 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SKIP_TO_PTS;
17855 IO_arg.param[0] = (void*)(&u32PTS);
17856 IO_arg.pRet = (void*)(&ret);
17857
17858 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17859 {
17860 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17861 ret = E_VDEC_EX_FAIL;
17862 }
17863
17864 return ret;
17865 }
17866
17867 //------------------------------------------------------------------------------
17868 /// Set deblocking process on/off
17869 /// @param eStream \b IN : stream type
17870 /// @param bOn \b IN : turn on / off deblocking process
17871 /// @return VDEC_EX_Result
17872 //------------------------------------------------------------------------------
MApi_VDEC_EX_DisableDeblocking(VDEC_StreamId * pStreamId,MS_BOOL bDisable)17873 VDEC_EX_Result MApi_VDEC_EX_DisableDeblocking(VDEC_StreamId *pStreamId, MS_BOOL bDisable)
17874 {
17875 VDEC_EX_V2_IO_Param IO_arg;
17876 VDEC_EX_Result ret;
17877
17878 if (pu32VDEC_EX_Inst == NULL)
17879 {
17880 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17881 return E_VDEC_EX_FAIL;
17882 }
17883
17884 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17885 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_DISABLE_DEBLOCKING;
17886 IO_arg.param[0] = (void*)(&bDisable);
17887 IO_arg.pRet = (void*)(&ret);
17888
17889 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17890 {
17891 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17892 ret = E_VDEC_EX_FAIL;
17893 }
17894
17895 return ret;
17896 }
17897
17898 //------------------------------------------------------------------------------
17899 /// Set Quarter Pixel process on/off
17900 /// @param eStream \b IN : stream type
17901 /// @param bOn \b IN : turn on / off Quarter Pixel process
17902 /// @return VDEC_EX_Result
17903 //------------------------------------------------------------------------------
MApi_VDEC_EX_DisableQuarterPixel(VDEC_StreamId * pStreamId,MS_BOOL bDisable)17904 VDEC_EX_Result MApi_VDEC_EX_DisableQuarterPixel(VDEC_StreamId *pStreamId, MS_BOOL bDisable)
17905 {
17906 VDEC_EX_V2_IO_Param IO_arg;
17907 VDEC_EX_Result ret;
17908
17909 if (pu32VDEC_EX_Inst == NULL)
17910 {
17911 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17912 return E_VDEC_EX_FAIL;
17913 }
17914
17915 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17916 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_DISABLE_QUARTER_PIXEL;
17917 IO_arg.param[0] = (void*)(&bDisable);
17918 IO_arg.pRet = (void*)(&ret);
17919
17920 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17921 {
17922 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17923 ret = E_VDEC_EX_FAIL;
17924 }
17925
17926 return ret;
17927 }
17928
17929 //------------------------------------------------------------------------------
17930 /// Turn on/off Auto Remove Last Zero Byte process
17931 /// @param eStream \b IN : stream type
17932 /// @param bOn \b IN : turn on / off Auto Remove Last Zero Byte process
17933 /// @return VDEC_EX_Result
17934 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetAutoRmLstZeroByte(VDEC_StreamId * pStreamId,MS_BOOL bOn)17935 VDEC_EX_Result MApi_VDEC_EX_SetAutoRmLstZeroByte(VDEC_StreamId *pStreamId, MS_BOOL bOn)
17936 {
17937 VDEC_EX_V2_IO_Param IO_arg;
17938 VDEC_EX_Result ret;
17939
17940 if (pu32VDEC_EX_Inst == NULL)
17941 {
17942 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17943 return E_VDEC_EX_FAIL;
17944 }
17945
17946 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17947 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_AUTO_RM_LST_ZERO_BYTE;
17948 IO_arg.param[0] = (void*)(&bOn);
17949 IO_arg.pRet = (void*)(&ret);
17950
17951 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17952 {
17953 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17954 ret = E_VDEC_EX_FAIL;
17955 }
17956
17957 return ret;
17958 }
17959
17960 //------------------------------------------------------------------------------
17961 /// Set the parameters of Balancing BW
17962 /// @param eStream \b IN : stream type
17963 /// @param u8QuarPixelTH \b IN : set Quarter pixel threshold
17964 /// @param u8DeBlockingTH \b IN : set deblocking threshold
17965 /// @param u8UpperBound \b IN : set upper boundary of BW control counter
17966 /// @param u8SafeCoef \b IN : set safety coeffecient of average MB tick.
17967 /// @return VDEC_EX_Result
17968 //------------------------------------------------------------------------------
MApi_VDEC_EX_SetBalanceBW(VDEC_StreamId * pStreamId,MS_U8 u8QuarPixelTH,MS_U8 u8DeBlockingTH,MS_U8 u8UpperBound,MS_U8 u8SafeCoef)17969 VDEC_EX_Result MApi_VDEC_EX_SetBalanceBW(VDEC_StreamId *pStreamId, MS_U8 u8QuarPixelTH, MS_U8 u8DeBlockingTH, MS_U8 u8UpperBound, MS_U8 u8SafeCoef)
17970 {
17971 VDEC_EX_V2_IO_Param IO_arg;
17972 VDEC_EX_Result ret;
17973
17974 if (pu32VDEC_EX_Inst == NULL)
17975 {
17976 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17977 return E_VDEC_EX_FAIL;
17978 }
17979
17980 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
17981 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_BALANCE_BW;
17982 IO_arg.param[0] = (void*)(&u8QuarPixelTH);
17983 IO_arg.param[1] = (void*)(&u8DeBlockingTH);
17984 IO_arg.param[2] = (void*)(&u8UpperBound);
17985 IO_arg.param[3] = (void*)(&u8SafeCoef);
17986 IO_arg.pRet = (void*)(&ret);
17987
17988 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
17989 {
17990 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
17991 ret = E_VDEC_EX_FAIL;
17992 }
17993
17994 return ret;
17995 }
17996
17997 //------------------------------------------------------------------------------
17998 /// Get stream active format which decoder retrieved
17999 /// @param eStream \b IN : stream type
18000 /// @return active format ID
18001 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetActiveFormat(VDEC_StreamId * pStreamId)18002 MS_U8 MApi_VDEC_EX_GetActiveFormat(VDEC_StreamId *pStreamId)
18003 {
18004 VDEC_EX_V2_IO_Param IO_arg;
18005 VDEC_EX_Result ret;
18006 MS_U8 u8ActFmt = 0;
18007
18008 if (pu32VDEC_EX_Inst == NULL)
18009 {
18010 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18011 return u8ActFmt;
18012 }
18013
18014 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18015 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ACTIVE_FORMAT;
18016 IO_arg.param[0] = (void*)(&u8ActFmt);
18017 IO_arg.pRet = (void*)(&ret);
18018
18019 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18020 {
18021 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18022 }
18023
18024 return u8ActFmt;
18025 }
18026
18027
18028 //------------------------------------------------------------------------------
18029 /// Get stream colour primaries
18030 /// @param eStream \b IN : stream type
18031 /// @return stream colour primaries
18032 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetColourPrimaries(VDEC_StreamId * pStreamId)18033 MS_U8 MApi_VDEC_EX_GetColourPrimaries(VDEC_StreamId *pStreamId)
18034 {
18035 VDEC_EX_V2_IO_Param IO_arg;
18036 VDEC_EX_Result ret;
18037 MS_U8 u8ColourPrimaries = 0;
18038
18039 if (pu32VDEC_EX_Inst == NULL)
18040 {
18041 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18042 return u8ColourPrimaries;
18043 }
18044
18045 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18046 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_COLOUR_PRIMARIES;
18047 IO_arg.param[0] = (void*)(&u8ColourPrimaries);
18048 IO_arg.pRet = (void*)(&ret);
18049
18050 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18051 {
18052 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18053 }
18054
18055 return u8ColourPrimaries;
18056 }
18057
MApi_VDEC_EX_GetFwVersion(VDEC_StreamId * pStreamId,VDEC_EX_FwType eFwType)18058 MS_U32 MApi_VDEC_EX_GetFwVersion(VDEC_StreamId *pStreamId, VDEC_EX_FwType eFwType)
18059 {
18060 VDEC_EX_V2_IO_Param IO_arg;
18061 VDEC_EX_Result ret;
18062 MS_U32 u32FWVer = 0;
18063
18064 if (pu32VDEC_EX_Inst == NULL)
18065 {
18066 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18067 return u32FWVer;
18068 }
18069
18070 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18071 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FW_VERSION;
18072 IO_arg.param[0] = (void*)(&eFwType);
18073 IO_arg.param[1] = (void*)(&u32FWVer);
18074 IO_arg.pRet = (void*)(&ret);
18075
18076 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18077 {
18078 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18079 }
18080
18081 return u32FWVer;
18082 }
18083
18084 //------------------------------------------------------------------------------
18085 /// Get picture counter of current GOP
18086 /// @param eStream \b IN : stream type
18087 /// @return picture counter
18088 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetGOPCnt(VDEC_StreamId * pStreamId)18089 MS_U8 MApi_VDEC_EX_GetGOPCnt(VDEC_StreamId *pStreamId)
18090 {
18091 VDEC_EX_V2_IO_Param IO_arg;
18092 VDEC_EX_Result ret;
18093 MS_U8 u8Cnt = 0;
18094
18095 if (pu32VDEC_EX_Inst == NULL)
18096 {
18097 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18098 return u8Cnt;
18099 }
18100
18101 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18102 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_GOP_CNT;
18103 IO_arg.param[0] = (void*)(&u8Cnt);
18104 IO_arg.pRet = (void*)(&ret);
18105
18106 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18107 {
18108 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18109 }
18110
18111 return u8Cnt;
18112 }
18113
18114 //------------------------------------------------------------------------------
18115 /// Get ES buffer write pointer
18116 /// @param eStream \b IN : stream type
18117 /// @return write pointer
18118 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetESWritePtr(VDEC_StreamId * pStreamId)18119 MS_U32 MApi_VDEC_EX_GetESWritePtr(VDEC_StreamId *pStreamId)
18120 {
18121 VDEC_EX_V2_IO_Param IO_arg;
18122 VDEC_EX_Result ret;
18123 MS_U32 u32Ptr = 0;
18124
18125 if (pu32VDEC_EX_Inst == NULL)
18126 {
18127 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18128 return u32Ptr;
18129 }
18130
18131 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18132 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ES_WRITE_PTR;
18133 IO_arg.param[0] = (void*)(&u32Ptr);
18134 IO_arg.pRet = (void*)(&ret);
18135
18136 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18137 {
18138 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18139 }
18140
18141 return u32Ptr;
18142 }
18143
18144 //------------------------------------------------------------------------------
18145 /// Get decoder ES buffer read pointer
18146 /// @param eStream \b IN : stream type
18147 /// @return read pointer
18148 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetESReadPtr(VDEC_StreamId * pStreamId)18149 MS_U32 MApi_VDEC_EX_GetESReadPtr(VDEC_StreamId *pStreamId)
18150 {
18151 VDEC_EX_V2_IO_Param IO_arg;
18152 VDEC_EX_Result ret;
18153 MS_U32 u32Ptr = 0;
18154
18155 if (pu32VDEC_EX_Inst == NULL)
18156 {
18157 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18158 return u32Ptr;
18159 }
18160
18161 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18162 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ES_READ_PTR;
18163 IO_arg.param[0] = (void*)(&u32Ptr);
18164 IO_arg.pRet = (void*)(&ret);
18165
18166 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18167 {
18168 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18169 }
18170
18171 return u32Ptr;
18172 }
18173
18174
18175 //------------------------------------------------------------------------------
18176 /// Get the PTS of current displayed frame
18177 /// @param eStream \b IN : stream type
18178 /// @return PTS
18179 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetPTS(VDEC_StreamId * pStreamId)18180 MS_U32 MApi_VDEC_EX_GetPTS(VDEC_StreamId *pStreamId)
18181 {
18182 VDEC_EX_V2_IO_Param IO_arg;
18183 VDEC_EX_Result ret;
18184 MS_U32 u32Pts = 0;
18185
18186 if (pu32VDEC_EX_Inst == NULL)
18187 {
18188 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18189 return u32Pts;
18190 }
18191
18192 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18193 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_PTS;
18194 IO_arg.param[0] = (void*)(&u32Pts);
18195 IO_arg.pRet = (void*)(&ret);
18196
18197 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18198 {
18199 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18200 }
18201
18202 return u32Pts;
18203 }
18204
18205 //------------------------------------------------------------------------------
18206 /// Get the PTS of next displayed frame
18207 /// @return next PTS (unit:ms)
18208 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetNextPTS(VDEC_StreamId * pStreamId)18209 MS_U32 MApi_VDEC_EX_GetNextPTS(VDEC_StreamId *pStreamId)
18210 {
18211 VDEC_EX_V2_IO_Param IO_arg;
18212 VDEC_EX_Result ret;
18213 MS_U32 u32Pts = 0;
18214
18215 if (pu32VDEC_EX_Inst == NULL)
18216 {
18217 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18218 return u32Pts;
18219 }
18220
18221 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18222 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_NEXT_PTS;
18223 IO_arg.param[0] = (void*)(&u32Pts);
18224 IO_arg.pRet = (void*)(&ret);
18225
18226 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18227 {
18228 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18229 }
18230
18231 return u32Pts;
18232 }
18233
18234 //------------------------------------------------------------------------------
18235 /// Get the value of PTS - STC for video
18236 /// @return the value of PTS - STC for video
18237 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetVideoPtsStcDelta(VDEC_StreamId * pStreamId)18238 MS_S64 MApi_VDEC_EX_GetVideoPtsStcDelta(VDEC_StreamId *pStreamId)
18239 {
18240 VDEC_EX_V2_IO_Param IO_arg;
18241 VDEC_EX_Result ret;
18242 MS_S64 s64Pts = 0;
18243
18244 if (pu32VDEC_EX_Inst == NULL)
18245 {
18246 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18247 return s64Pts;
18248 }
18249
18250 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18251 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_VIDEO_PTS_STC_DELTA;
18252 IO_arg.param[0] = (void*)(&s64Pts);
18253 IO_arg.pRet = (void*)(&ret);
18254
18255 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18256 {
18257 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18258 }
18259
18260 return s64Pts;
18261 }
18262
18263 //------------------------------------------------------------------------------
18264 /// Get error code
18265 /// @param eStream \b IN : stream type
18266 /// @return error code
18267 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetErrCode(VDEC_StreamId * pStreamId)18268 MS_U32 MApi_VDEC_EX_GetErrCode(VDEC_StreamId *pStreamId)
18269 {
18270 VDEC_EX_V2_IO_Param IO_arg;
18271 VDEC_EX_Result ret;
18272 VDEC_EX_ErrCode eErrCode = E_VDEC_EX_ERR_CODE_ILLEGAL_ACCESS;
18273
18274 if (pu32VDEC_EX_Inst == NULL)
18275 {
18276 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18277 return eErrCode;
18278 }
18279
18280 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18281 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ERR_CODE;
18282 IO_arg.param[0] = (void*)(&eErrCode);
18283 IO_arg.pRet = (void*)(&ret);
18284
18285 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18286 {
18287 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18288 }
18289
18290 return eErrCode;
18291 }
18292
18293 //------------------------------------------------------------------------------
18294 /// Get accumulated error counter
18295 /// @param eStream \b IN : stream type
18296 /// @return error counter
18297 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetErrCnt(VDEC_StreamId * pStreamId)18298 MS_U32 MApi_VDEC_EX_GetErrCnt(VDEC_StreamId *pStreamId)
18299 {
18300 VDEC_EX_V2_IO_Param IO_arg;
18301 VDEC_EX_Result ret;
18302 MS_U32 u32Cnt = 0;
18303
18304 if (pu32VDEC_EX_Inst == NULL)
18305 {
18306 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18307 return u32Cnt;
18308 }
18309
18310 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18311 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ERR_CNT;
18312 IO_arg.param[0] = (void*)(&u32Cnt);
18313 IO_arg.pRet = (void*)(&ret);
18314
18315 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18316 {
18317 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18318 }
18319
18320 return u32Cnt;
18321 }
18322
18323 //------------------------------------------------------------------------------
18324 /// Get bitrate which decoder retrieved from stream
18325 /// @param eStream \b IN : stream type
18326 /// @return bitrate
18327 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetBitsRate(VDEC_StreamId * pStreamId)18328 MS_U32 MApi_VDEC_EX_GetBitsRate(VDEC_StreamId *pStreamId)
18329 {
18330 VDEC_EX_V2_IO_Param IO_arg;
18331 VDEC_EX_Result ret;
18332 MS_U32 u32Bitrate = 0;
18333
18334 if (pu32VDEC_EX_Inst == NULL)
18335 {
18336 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18337 return u32Bitrate;
18338 }
18339
18340 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18341 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_BITRATE;
18342 IO_arg.param[0] = (void*)(&u32Bitrate);
18343 IO_arg.pRet = (void*)(&ret);
18344
18345 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18346 {
18347 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18348 }
18349
18350 return u32Bitrate;
18351 }
18352
18353 //-----------------------------------------------------------------------------
18354 /// Get accumulated decoded frame Count
18355 /// @param eStream \b IN : stream type
18356 /// @return - decoded frame Count
18357 //-----------------------------------------------------------------------------
MApi_VDEC_EX_GetFrameCnt(VDEC_StreamId * pStreamId)18358 MS_U32 MApi_VDEC_EX_GetFrameCnt(VDEC_StreamId *pStreamId)
18359 {
18360 VDEC_EX_V2_IO_Param IO_arg;
18361 VDEC_EX_Result ret;
18362 MS_U32 u32Cnt = 0;
18363
18364 if (pu32VDEC_EX_Inst == NULL)
18365 {
18366 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18367 return u32Cnt;
18368 }
18369
18370 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18371 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_FRAME_CNT;
18372 IO_arg.param[0] = (void*)(&u32Cnt);
18373 IO_arg.pRet = (void*)(&ret);
18374
18375 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18376 {
18377 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18378 }
18379
18380 return u32Cnt;
18381 }
18382
18383 //------------------------------------------------------------------------------
18384 /// Get skipped counter
18385 /// @param eStream \b IN : stream type
18386 /// @return counter
18387 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetSkipCnt(VDEC_StreamId * pStreamId)18388 MS_U32 MApi_VDEC_EX_GetSkipCnt(VDEC_StreamId *pStreamId)
18389 {
18390 VDEC_EX_V2_IO_Param IO_arg;
18391 VDEC_EX_Result ret;
18392 MS_U32 u32Cnt = 0;
18393
18394 if (pu32VDEC_EX_Inst == NULL)
18395 {
18396 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18397 return u32Cnt;
18398 }
18399
18400 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18401 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_SKIP_CNT;
18402 IO_arg.param[0] = (void*)(&u32Cnt);
18403 IO_arg.pRet = (void*)(&ret);
18404
18405 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18406 {
18407 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18408 }
18409
18410 return u32Cnt;
18411 }
18412
18413 //------------------------------------------------------------------------------
18414 /// Get dropped frame counter
18415 /// @param eStream \b IN : stream type
18416 /// @return counter
18417 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDropCnt(VDEC_StreamId * pStreamId)18418 MS_U32 MApi_VDEC_EX_GetDropCnt(VDEC_StreamId *pStreamId)
18419 {
18420 VDEC_EX_V2_IO_Param IO_arg;
18421 VDEC_EX_Result ret;
18422 MS_U32 u32Cnt = 0;
18423
18424 if (pu32VDEC_EX_Inst == NULL)
18425 {
18426 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18427 return u32Cnt;
18428 }
18429
18430 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18431 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DROP_CNT;
18432 IO_arg.param[0] = (void*)(&u32Cnt);
18433 IO_arg.pRet = (void*)(&ret);
18434
18435 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18436 {
18437 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18438 }
18439
18440 return u32Cnt;
18441 }
18442
18443 //------------------------------------------------------------------------------
18444 /// Get displayed frame counter
18445 /// @param pStreamId \b IN : pointer to stream ID
18446 /// @return counter
18447 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetDispCnt(VDEC_StreamId * pStreamId)18448 MS_U32 MApi_VDEC_EX_GetDispCnt(VDEC_StreamId *pStreamId)
18449 {
18450 VDEC_EX_V2_IO_Param IO_arg;
18451 VDEC_EX_Result ret;
18452 MS_U32 u32Cnt = 0;
18453
18454 if (pu32VDEC_EX_Inst == NULL)
18455 {
18456 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18457 return u32Cnt;
18458 }
18459
18460 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18461 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_DISP_CNT;
18462 IO_arg.param[0] = (void*)(&u32Cnt);
18463 IO_arg.pRet = (void*)(&ret);
18464
18465 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18466 {
18467 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18468 }
18469
18470 return u32Cnt;
18471 }
18472
18473 //------------------------------------------------------------------------------
18474 /// Get 3:2 pull down flag which decoder retrieved from stream
18475 /// @param eStream \b IN : stream type
18476 /// @return TRUE/FALSE
18477 //------------------------------------------------------------------------------
MApi_VDEC_EX_Is32PullDown(VDEC_StreamId * pStreamId)18478 MS_BOOL MApi_VDEC_EX_Is32PullDown(VDEC_StreamId *pStreamId)
18479 {
18480 VDEC_EX_V2_IO_Param IO_arg;
18481 VDEC_EX_Result ret;
18482 MS_BOOL bIs32PullDown = FALSE;
18483
18484 if (pu32VDEC_EX_Inst == NULL)
18485 {
18486 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18487 return bIs32PullDown;
18488 }
18489
18490 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18491 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_32_PULLDOWN;
18492 IO_arg.param[0] = (void*)(&bIs32PullDown);
18493 IO_arg.pRet = (void*)(&ret);
18494
18495 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18496 {
18497 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18498 }
18499
18500 return bIs32PullDown;
18501 }
18502
18503 //------------------------------------------------------------------------------
18504 /// Check whether the status of decoder is running or not.
18505 /// @param eStream \b IN : stream type
18506 /// @return VDEC_EX_Result: E_VDEC_EX_OK/E_VDEC_EX_RET_NOT_RUNNING/E_VDEC_EX_RET_NOT_INIT
18507 //------------------------------------------------------------------------------
MApi_VDEC_EX_IsAlive(VDEC_StreamId * pStreamId)18508 VDEC_EX_Result MApi_VDEC_EX_IsAlive(VDEC_StreamId *pStreamId)
18509 {
18510 VDEC_EX_V2_IO_Param IO_arg;
18511 VDEC_EX_Result ret;
18512
18513 if (pu32VDEC_EX_Inst == NULL)
18514 {
18515 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18516 return E_VDEC_EX_FAIL;
18517 }
18518
18519 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18520 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_ALIVE;
18521 IO_arg.pRet = (void*)(&ret);
18522
18523 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18524 {
18525 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18526 ret = E_VDEC_EX_FAIL;
18527 }
18528
18529 return ret;
18530 }
18531
MApi_VDEC_EX_IsCCAvailable(VDEC_StreamId * pStreamId)18532 MS_BOOL MApi_VDEC_EX_IsCCAvailable(VDEC_StreamId *pStreamId)
18533 {
18534 VDEC_EX_V2_IO_Param IO_arg;
18535 VDEC_EX_Result ret;
18536 MS_BOOL isavailable = FALSE;
18537
18538 if (pu32VDEC_EX_Inst == NULL)
18539 {
18540 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18541 return isavailable;
18542 }
18543
18544 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18545 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_IS_CC_AVAILABLE;
18546 IO_arg.param[0] = (void*)(&isavailable);
18547 IO_arg.pRet = (void*)(&ret);
18548
18549 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18550 {
18551 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18552 }
18553
18554 return isavailable;
18555 }
18556
MApi_VDEC_EX_GetCCInfo(VDEC_StreamId * pStreamId,void * pInfo,MS_U32 u32Size)18557 VDEC_EX_Result MApi_VDEC_EX_GetCCInfo(VDEC_StreamId *pStreamId, void *pInfo, MS_U32 u32Size)
18558 {
18559 VDEC_EX_V2_IO_Param IO_arg;
18560 VDEC_EX_Result ret;
18561
18562 if (pu32VDEC_EX_Inst == NULL)
18563 {
18564 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18565 return E_VDEC_EX_FAIL;
18566 }
18567
18568 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18569 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_CC_INFO;
18570 IO_arg.param[0] = (pInfo);
18571 IO_arg.param[1] = (void*)(&u32Size);
18572 IO_arg.pRet = (void*)(&ret);
18573
18574 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18575 {
18576 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18577 ret = E_VDEC_EX_FAIL;
18578 }
18579
18580 #if 1//#ifdef VDEC_UTOPIA_2K
18581 VDEC_EX_CC_Info *ptr = pInfo;
18582 ptr->u32UserDataBuf = MsOS_PA2KSEG1(ptr->u32UserDataBuf);
18583 #endif
18584
18585 return ret;
18586 }
18587
18588 //------------------------------------------------------------------------------
18589 /// Get current trick decode mode of decoder
18590 /// @param eStream \b IN : stream type
18591 /// @return VDEC_EX_TrickDec
18592 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetTrickMode(VDEC_StreamId * pStreamId)18593 VDEC_EX_TrickDec MApi_VDEC_EX_GetTrickMode(VDEC_StreamId *pStreamId)
18594 {
18595 VDEC_EX_V2_IO_Param IO_arg;
18596 VDEC_EX_Result ret;
18597 VDEC_EX_TrickDec eTrick = E_VDEC_EX_TRICK_DEC_ALL;
18598
18599 if (pu32VDEC_EX_Inst == NULL)
18600 {
18601 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18602 return eTrick;
18603 }
18604
18605 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18606 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_TRICK_MODE;
18607 IO_arg.param[0] = (void*)(&eTrick);
18608 IO_arg.pRet = (void*)(&ret);
18609
18610 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18611 {
18612 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18613 }
18614
18615 return eTrick;
18616 }
18617
18618 //------------------------------------------------------------------------------
18619 /// Get codec type which be initialed
18620 /// @param eStream \b IN : stream type
18621 /// @return VDEC_EX_CodecType
18622 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetActiveCodecType(VDEC_StreamId * pStreamId)18623 VDEC_EX_CodecType MApi_VDEC_EX_GetActiveCodecType(VDEC_StreamId *pStreamId)
18624 {
18625 VDEC_EX_V2_IO_Param IO_arg;
18626 VDEC_EX_Result ret;
18627 VDEC_EX_CodecType CodecType = E_VDEC_EX_CODEC_TYPE_NONE;
18628
18629 if (pu32VDEC_EX_Inst == NULL)
18630 {
18631 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18632 return CodecType;
18633 }
18634
18635 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18636 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ACTIVE_CODEC_TYPE;
18637 IO_arg.param[0] = (void*)(&CodecType);
18638 IO_arg.pRet = (void*)(&ret);
18639
18640 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18641 {
18642 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18643 }
18644
18645 return CodecType;
18646 }
18647
18648
18649 //------------------------------------------------------------------------------
18650 /// Generate a special pattern to work with specific functions
18651 /// @param eStream \b IN : stream type
18652 /// @param ePatternType \b IN : Pattern type
18653 /// @param u32Addr \b IN : Pattern buffer physical start address
18654 /// @param u32Size \b IN,OUT : Pattern buffer size
18655 /// IN: Pattern buffer size
18656 /// OUT: Used Pattern buffer size
18657 /// @return VDEC_EX_Result
18658 //------------------------------------------------------------------------------
MApi_VDEC_EX_GenPattern(VDEC_StreamId * pStreamId,VDEC_EX_PatternType ePatternType,MS_PHY u32Addr,MS_U32 * u32Size)18659 VDEC_EX_Result MApi_VDEC_EX_GenPattern(VDEC_StreamId *pStreamId, VDEC_EX_PatternType ePatternType, MS_PHY u32Addr, MS_U32* u32Size)
18660 {
18661 VDEC_EX_V2_IO_Param IO_arg;
18662 VDEC_EX_Result ret;
18663
18664 if (pu32VDEC_EX_Inst == NULL)
18665 {
18666 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18667 return E_VDEC_EX_FAIL;
18668 }
18669
18670 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18671 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GEN_PATTERN;
18672 IO_arg.param[0] = (void*)(&ePatternType);
18673 IO_arg.param[1] = (void*)(&u32Addr);
18674 IO_arg.param[2] = (void*)(u32Size);
18675 IO_arg.pRet = (void*)(&ret);
18676
18677 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18678 {
18679 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18680 ret = E_VDEC_EX_FAIL;
18681 }
18682
18683 return ret;
18684 }
18685
18686 //------------------------------------------------------------------------------
18687 /// Get the information of the least length of pattern used for specific function
18688 /// @param eStream \b IN : stream type
18689 /// @param pFrmInfo \b IN : the information of the least length of pattern used for specific function
18690 /// @return -the length (Bytes)
18691 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetPatternLeastLength(VDEC_StreamId * pStreamId,VDEC_EX_PatternType ePatternType)18692 MS_U32 MApi_VDEC_EX_GetPatternLeastLength(VDEC_StreamId *pStreamId, VDEC_EX_PatternType ePatternType)
18693 {
18694 VDEC_EX_V2_IO_Param IO_arg;
18695 VDEC_EX_Result ret;
18696 MS_U32 length = 0;
18697
18698 if (pu32VDEC_EX_Inst == NULL)
18699 {
18700 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18701 return length;
18702 }
18703
18704 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18705 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_PATTERN_LEAST_LENGTH;
18706 IO_arg.param[0] = (void*)(&ePatternType);
18707 IO_arg.param[1] = (void*)(&length);
18708 IO_arg.pRet = (void*)(&ret);
18709
18710 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18711 {
18712 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18713 }
18714
18715 return length;
18716 }
18717
18718
18719 //------------------------------------------------------------------------------
18720 /// For MHEG5 MW, decode one I frame
18721 /// @param eStream \b IN : stream type
18722 /// @param u32FrameBufAddr \b IN : output buffer address
18723 /// @param u32SrcSt \b IN : source start address
18724 /// @param u32SrcEnd \b IN : source end address
18725 /// @return VDEC_EX_Result
18726 //------------------------------------------------------------------------------
MApi_VDEC_EX_MHEG_DecodeIFrame(VDEC_StreamId * pStreamId,MS_PHY u32FrameBufAddr,MS_PHY u32SrcSt,MS_PHY u32SrcEnd)18727 VDEC_EX_Result MApi_VDEC_EX_MHEG_DecodeIFrame(VDEC_StreamId *pStreamId,
18728 MS_PHY u32FrameBufAddr,
18729 MS_PHY u32SrcSt,
18730 MS_PHY u32SrcEnd)
18731 {
18732 VDEC_EX_V2_IO_Param IO_arg;
18733 VDEC_EX_Result ret;
18734
18735 if (pu32VDEC_EX_Inst == NULL)
18736 {
18737 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18738 return E_VDEC_EX_FAIL;
18739 }
18740
18741 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18742 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_MHEG_DECODE_IFRAME;
18743 IO_arg.param[0] = (void*)(&u32FrameBufAddr);
18744 IO_arg.param[1] = (void*)(&u32SrcSt);
18745 IO_arg.param[2] = (void*)(&u32SrcEnd);
18746 IO_arg.pRet = (void*)(&ret);
18747
18748 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18749 {
18750 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18751 ret = E_VDEC_EX_FAIL;
18752 }
18753
18754 return ret;
18755 }
18756
18757 //------------------------------------------------------------------------------
18758 /// For MHEG5 MW, check if I frame decode done
18759 /// @param eStream \b IN : stream type
18760 /// @return VDEC_EX_Result
18761 /// - E_VDEC_EX_OK: decode done
18762 /// - E_VDEC_EX_FAIL: not yet
18763 /// - E_VDEC_EX_RET_NOT_INIT: not initial yet
18764 /// - E_VDEC_EX_RET_UNSUPPORTED: not supported with current decoder configuration
18765 //------------------------------------------------------------------------------
MApi_VDEC_EX_MHEG_IsIFrameDecoding(VDEC_StreamId * pStreamId)18766 VDEC_EX_Result MApi_VDEC_EX_MHEG_IsIFrameDecoding(VDEC_StreamId *pStreamId)
18767 {
18768 VDEC_EX_V2_IO_Param IO_arg;
18769 VDEC_EX_Result ret;
18770
18771 if (pu32VDEC_EX_Inst == NULL)
18772 {
18773 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18774 return E_VDEC_EX_FAIL;
18775 }
18776
18777 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18778 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_MHEG_IS_IFRAME_DECODING;
18779 IO_arg.pRet = (void*)(&ret);
18780
18781 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18782 {
18783 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18784 ret = E_VDEC_EX_FAIL;
18785 }
18786
18787 return ret;
18788 }
18789
18790 //------------------------------------------------------------------------------
18791 /// For MHEG5 MW, reset decoder after I frame decode done
18792 /// @param eStream \b IN : stream type
18793 /// @return VDEC_EX_Result
18794 //------------------------------------------------------------------------------
MApi_VDEC_EX_MHEG_RstIFrameDec(VDEC_StreamId * pStreamId)18795 VDEC_EX_Result MApi_VDEC_EX_MHEG_RstIFrameDec(VDEC_StreamId *pStreamId)
18796 {
18797 VDEC_EX_V2_IO_Param IO_arg;
18798 VDEC_EX_Result ret;
18799
18800 if (pu32VDEC_EX_Inst == NULL)
18801 {
18802 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18803 return E_VDEC_EX_FAIL;
18804 }
18805
18806 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18807 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_MHEG_RST_IFRAME_DEC;
18808 IO_arg.pRet = (void*)(&ret);
18809
18810 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18811 {
18812 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18813 ret = E_VDEC_EX_FAIL;
18814 }
18815
18816 return ret;
18817 }
18818
18819
18820 //------------------------------------------------------------------------------
18821 /// [Obsolete] Start CC data parsing.
18822 /// @param eStream \b IN : stream type
18823 /// @param pCCParam \b IN : CC configuration
18824 /// @return -VDEC_EX_Result
18825 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_StartParsing(VDEC_StreamId * pStreamId,VDEC_EX_CCCfg * pCCParam)18826 VDEC_EX_Result MApi_VDEC_EX_CC_StartParsing(VDEC_StreamId *pStreamId, VDEC_EX_CCCfg *pCCParam)
18827 {
18828 VDEC_EX_V2_IO_Param IO_arg;
18829 VDEC_EX_Result ret;
18830
18831 if (pu32VDEC_EX_Inst == NULL)
18832 {
18833 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18834 return E_VDEC_EX_FAIL;
18835 }
18836
18837 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18838 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_START_PARSING;
18839 IO_arg.param[0] = (void*)(pCCParam);
18840 IO_arg.pRet = (void*)(&ret);
18841
18842 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18843 {
18844 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18845 ret = E_VDEC_EX_FAIL;
18846 }
18847
18848 return ret;
18849 }
18850
18851 //------------------------------------------------------------------------------
18852 /// [Obsolete] Stop CC data parsing.
18853 /// @param eStream \b IN : stream type
18854 /// @return -VDEC_EX_Result
18855 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_StopParsing(VDEC_StreamId * pStreamId)18856 VDEC_EX_Result MApi_VDEC_EX_CC_StopParsing(VDEC_StreamId *pStreamId)
18857 {
18858 VDEC_EX_V2_IO_Param IO_arg;
18859 VDEC_EX_Result ret;
18860
18861 if (pu32VDEC_EX_Inst == NULL)
18862 {
18863 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18864 return E_VDEC_EX_FAIL;
18865 }
18866
18867 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18868 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_STOP_PARSING;
18869 IO_arg.pRet = (void*)(&ret);
18870
18871 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18872 {
18873 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18874 ret = E_VDEC_EX_FAIL;
18875 }
18876
18877 return ret;
18878 }
18879
18880 //------------------------------------------------------------------------------
18881 /// [Obsolete] Get write pointer of CC data buffer.
18882 /// @param eStream \b IN : stream type
18883 /// @param pu32Write \b OUT : current write pointer
18884 /// @return -VDEC_EX_Result
18885 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetWritePtr(VDEC_StreamId * pStreamId,MS_U32 * pu32Write)18886 VDEC_EX_Result MApi_VDEC_EX_CC_GetWritePtr(VDEC_StreamId *pStreamId, MS_U32 *pu32Write)
18887 {
18888 VDEC_EX_V2_IO_Param IO_arg;
18889 VDEC_EX_Result ret;
18890
18891 if (pu32VDEC_EX_Inst == NULL)
18892 {
18893 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18894 return E_VDEC_EX_FAIL;
18895 }
18896
18897 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18898 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_WRITE_PTR;
18899 IO_arg.param[0] = (void*)(pu32Write);
18900 IO_arg.pRet = (void*)(&ret);
18901
18902 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18903 {
18904 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18905 ret = E_VDEC_EX_FAIL;
18906 }
18907
18908 return ret;
18909 }
18910
18911 //------------------------------------------------------------------------------
18912 /// [Obsolete] Get the read pointer of CC data buffer.
18913 /// @param eStream \b IN : stream type
18914 /// @param pu32Read \b OUT : current read pointer
18915 /// @return -VDEC_EX_Result
18916 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetReadPtr(VDEC_StreamId * pStreamId,MS_U32 * pu32Read)18917 VDEC_EX_Result MApi_VDEC_EX_CC_GetReadPtr(VDEC_StreamId *pStreamId, MS_U32 *pu32Read)
18918 {
18919 VDEC_EX_V2_IO_Param IO_arg;
18920 VDEC_EX_Result ret;
18921
18922 if (pu32VDEC_EX_Inst == NULL)
18923 {
18924 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18925 return E_VDEC_EX_FAIL;
18926 }
18927
18928 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18929 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_READ_PTR;
18930 IO_arg.param[0] = (void*)(pu32Read);
18931 IO_arg.pRet = (void*)(&ret);
18932
18933 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18934 {
18935 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18936 ret = E_VDEC_EX_FAIL;
18937 }
18938
18939 return ret;
18940 }
18941
18942 //------------------------------------------------------------------------------
18943 /// [Obsolete] Update the read pointer of CC data buffer.
18944 /// @param eStream \b IN : stream type
18945 /// @param u32EachPacketSize \b IN : new read pointer
18946 /// @return -VDEC_EX_Result
18947 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_UpdateReadPtr(VDEC_StreamId * pStreamId,MS_U32 u32EachPacketSize)18948 VDEC_EX_Result MApi_VDEC_EX_CC_UpdateReadPtr(VDEC_StreamId *pStreamId, MS_U32 u32EachPacketSize)
18949 {
18950 VDEC_EX_V2_IO_Param IO_arg;
18951 VDEC_EX_Result ret;
18952
18953 if (pu32VDEC_EX_Inst == NULL)
18954 {
18955 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18956 return E_VDEC_EX_FAIL;
18957 }
18958
18959 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18960 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_UPDATE_READ_PTR;
18961 IO_arg.param[0] = (void*)(&u32EachPacketSize);
18962 IO_arg.pRet = (void*)(&ret);
18963
18964 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18965 {
18966 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18967 ret = E_VDEC_EX_FAIL;
18968 }
18969
18970 return ret;
18971 }
18972
18973 //------------------------------------------------------------------------------
18974 /// [Obsolete] Get if CC data buffer is overflow.
18975 /// @param eStream \b IN : stream type
18976 /// @param pbOverflow \b OUT : overflow flag
18977 /// @return -VDEC_EX_Result
18978 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetIsOverflow(VDEC_StreamId * pStreamId,MS_BOOL * pbOverflow)18979 VDEC_EX_Result MApi_VDEC_EX_CC_GetIsOverflow(VDEC_StreamId *pStreamId, MS_BOOL *pbOverflow)
18980 {
18981 VDEC_EX_V2_IO_Param IO_arg;
18982 VDEC_EX_Result ret;
18983
18984 if (pu32VDEC_EX_Inst == NULL)
18985 {
18986 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18987 return E_VDEC_EX_FAIL;
18988 }
18989
18990 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
18991 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_IS_OVERFLOW;
18992 IO_arg.param[0] = (void*)(pbOverflow);
18993 IO_arg.pRet = (void*)(&ret);
18994
18995 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
18996 {
18997 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
18998 ret = E_VDEC_EX_FAIL;
18999 }
19000
19001 return ret;
19002 }
19003
19004
19005 //------------------------------------------------------------------------------
19006 /// @brief Get the HW Key currently not support
19007 /// @param eStream \b IN : stream type
19008 /// @param [out] pu8Key 8bit HW key
19009 /// @retval E_VDEC_EX_OK Success
19010 /// @retval E_VDEC_EX_FAIL Failure
19011 /// @retval E_VDEC_EX_RET_NOT_INIT The decoder is not initialized
19012 /// @retval E_VDEC_EX_RET_UNSUPPORTED Not supported for current decoder configuration or codec type
19013 /// @retval E_VDEC_EX_RET_ILLEGAL_ACCESS Illegal access
19014 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetHWKey(VDEC_StreamId * pStreamId,MS_U8 * pu8Key)19015 VDEC_EX_Result MApi_VDEC_EX_GetHWKey(VDEC_StreamId *pStreamId, MS_U8 *pu8Key)
19016 {
19017 VDEC_EX_V2_IO_Param IO_arg;
19018 VDEC_EX_Result ret;
19019
19020 if (pu32VDEC_EX_Inst == NULL)
19021 {
19022 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19023 return E_VDEC_EX_FAIL;
19024 }
19025
19026 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19027 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_HW_KEY;
19028 IO_arg.param[0] = (void*)(pu8Key);
19029 IO_arg.pRet = (void*)(&ret);
19030
19031 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19032 {
19033 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19034 ret = E_VDEC_EX_FAIL;
19035 }
19036
19037 return ret;
19038 }
19039
19040
MApi_VDEC_EX_SetBlockDisplay(VDEC_StreamId * pStreamId,MS_BOOL bEnable)19041 VDEC_EX_Result MApi_VDEC_EX_SetBlockDisplay(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
19042 {
19043 VDEC_EX_V2_IO_Param IO_arg;
19044 VDEC_EX_Result ret;
19045
19046 if (pu32VDEC_EX_Inst == NULL)
19047 {
19048 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19049 return E_VDEC_EX_FAIL;
19050 }
19051
19052 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19053 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_SET_BLOCK_DISPLAY;
19054 IO_arg.param[0] = (void*)(&bEnable);
19055 IO_arg.pRet = (void*)(&ret);
19056
19057 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19058 {
19059 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19060 ret = E_VDEC_EX_FAIL;
19061 }
19062
19063 return ret;
19064 }
19065
MApi_VDEC_EX_EnableESBuffMalloc(VDEC_StreamId * pStreamId,MS_BOOL bEnable)19066 VDEC_EX_Result MApi_VDEC_EX_EnableESBuffMalloc(VDEC_StreamId *pStreamId, MS_BOOL bEnable)
19067 {
19068 VDEC_EX_V2_IO_Param IO_arg;
19069 VDEC_EX_Result ret;
19070
19071 if (pu32VDEC_EX_Inst == NULL)
19072 {
19073 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19074 return E_VDEC_EX_FAIL;
19075 }
19076
19077 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19078 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_ENABLE_ES_BUFF_MALLOC;
19079 IO_arg.param[0] = (void*)(&bEnable);
19080 IO_arg.pRet = (void*)(&ret);
19081
19082 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19083 {
19084 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19085 ret = E_VDEC_EX_FAIL;
19086 }
19087
19088 return ret;
19089 }
19090
MApi_VDEC_EX_GetESBuffVacancy(VDEC_StreamId * pStreamId,void * pData)19091 MS_U32 MApi_VDEC_EX_GetESBuffVacancy(VDEC_StreamId *pStreamId, void *pData)
19092 {
19093 VDEC_EX_V2_IO_Param IO_arg;
19094 VDEC_EX_Result ret;
19095 MS_U32 u32ESBuffVacancy = 0;
19096
19097 UNUSED(pData);
19098
19099 if (pu32VDEC_EX_Inst == NULL)
19100 {
19101 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19102 return u32ESBuffVacancy;
19103 }
19104
19105 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19106 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ES_BUFF_VACANCY;
19107 IO_arg.param[0] = (void*)(&u32ESBuffVacancy);
19108 IO_arg.pRet = (void*)(&ret);
19109
19110 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19111 {
19112 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19113 }
19114
19115 return u32ESBuffVacancy;
19116 }
19117
MApi_VDEC_EX_GetESBuff(VDEC_StreamId * pStreamId,MS_U32 u32ReqSize,MS_U32 * u32AvailSize,MS_PHY * u32Addr)19118 VDEC_EX_Result MApi_VDEC_EX_GetESBuff(VDEC_StreamId *pStreamId, MS_U32 u32ReqSize, MS_U32 *u32AvailSize, MS_PHY *u32Addr)
19119 {
19120 VDEC_EX_V2_IO_Param IO_arg;
19121 VDEC_EX_Result ret;
19122
19123 if (pu32VDEC_EX_Inst == NULL)
19124 {
19125 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19126 return E_VDEC_EX_FAIL;
19127 }
19128
19129 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19130 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_ES_BUFF;
19131 IO_arg.param[0] = (void*)(&u32ReqSize);
19132 IO_arg.param[1] = (void*)(u32AvailSize);
19133 IO_arg.param[2] = (void*)(u32Addr);
19134 IO_arg.pRet = (void*)(&ret);
19135
19136 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19137 {
19138 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19139 ret = E_VDEC_EX_FAIL;
19140 }
19141
19142 return ret;
19143 }
19144
MApi_VDEC_EX_GetNextDispFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame ** ppDispFrm)19145 VDEC_EX_Result MApi_VDEC_EX_GetNextDispFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame **ppDispFrm)
19146 {
19147 VDEC_EX_V2_IO_Param IO_arg;
19148 VDEC_EX_Result ret;
19149 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
19150
19151 *ppDispFrm = &(DispFrame_temp[u8Idx]);
19152
19153 if (pu32VDEC_EX_Inst == NULL)
19154 {
19155 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19156 return E_VDEC_EX_FAIL;
19157 }
19158
19159 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19160 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_GET_NEXT_DISP_FRAME;
19161 IO_arg.param[0] = (void*)(&(DispFrame_temp[u8Idx]));
19162 IO_arg.pRet = (void*)(&ret);
19163
19164 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19165 {
19166 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19167 ret = E_VDEC_EX_FAIL;
19168 }
19169
19170 return ret;
19171 }
19172
19173 //------------------------------------------------------------------------------
19174 /// Notify FW to display the specified frame
19175 /// @param pDispFrm \b IN : the pointer of the frame to be displayed
19176 /// @return VDEC_EX_Result
19177 /// @retval -E_VDEC_EX_RET_NOT_INIT: VDEC is not initialized.
19178 /// @retval -E_VDEC_EX_RET_INVALID_PARAM: the pointer is NULL.
19179 /// @retval -E_VDEC_EX_RET_ILLEGAL_ACCESS: the pointer is invalid.
19180 /// There might be multiple frame display/release.
19181 //------------------------------------------------------------------------------
MApi_VDEC_EX_DisplayFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame * pDispFrm)19182 VDEC_EX_Result MApi_VDEC_EX_DisplayFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame *pDispFrm)
19183 {
19184 VDEC_EX_V2_IO_Param IO_arg;
19185 VDEC_EX_Result ret;
19186
19187 if (pu32VDEC_EX_Inst == NULL)
19188 {
19189 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19190 return E_VDEC_EX_FAIL;
19191 }
19192
19193 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19194 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_DISPLAY_FRAME;
19195 IO_arg.param[0] = (void*)(pDispFrm);
19196 IO_arg.pRet = (void*)(&ret);
19197
19198 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19199 {
19200 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19201 ret = E_VDEC_EX_FAIL;
19202 }
19203
19204 return ret;
19205 }
19206
MApi_VDEC_EX_ReleaseFrame(VDEC_StreamId * pStreamId,VDEC_EX_DispFrame * pDispFrm)19207 VDEC_EX_Result MApi_VDEC_EX_ReleaseFrame(VDEC_StreamId *pStreamId, VDEC_EX_DispFrame *pDispFrm)
19208 {
19209 VDEC_EX_V2_IO_Param IO_arg;
19210 VDEC_EX_Result ret;
19211
19212 if (pu32VDEC_EX_Inst == NULL)
19213 {
19214 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19215 return E_VDEC_EX_FAIL;
19216 }
19217
19218 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19219 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_RELEASE_FRAME;
19220 IO_arg.param[0] = (void*)(pDispFrm);
19221 IO_arg.pRet = (void*)(&ret);
19222
19223 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19224 {
19225 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19226 ret = E_VDEC_EX_FAIL;
19227 }
19228
19229 return ret;
19230 }
19231
MApi_VDEC_EX_CaptureFrame(VDEC_StreamId * pStreamId,MS_U32 u32FrmPriData,MS_BOOL bEnable)19232 VDEC_EX_Result MApi_VDEC_EX_CaptureFrame(VDEC_StreamId *pStreamId, MS_U32 u32FrmPriData, MS_BOOL bEnable)
19233 {
19234 VDEC_EX_V2_IO_Param IO_arg;
19235 VDEC_EX_Result ret;
19236
19237 if (pu32VDEC_EX_Inst == NULL)
19238 {
19239 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19240 return E_VDEC_EX_FAIL;
19241 }
19242
19243 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19244 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CAPTURE_FRAME;
19245 IO_arg.param[0] = (void*)(&u32FrmPriData);
19246 IO_arg.param[1] = (void*)(&bEnable);
19247 IO_arg.pRet = (void*)(&ret);
19248
19249 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19250 {
19251 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19252 ret = E_VDEC_EX_FAIL;
19253 }
19254
19255 return ret;
19256 }
19257
MApi_VDEC_EX_CC_Init(VDEC_StreamId * pStreamId,MS_U32 * pIn)19258 VDEC_EX_Result MApi_VDEC_EX_CC_Init(VDEC_StreamId *pStreamId, MS_U32 *pIn)
19259 {
19260 VDEC_EX_V2_IO_Param IO_arg;
19261 VDEC_EX_Result ret;
19262
19263 if (pu32VDEC_EX_Inst == NULL)
19264 {
19265 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19266 return E_VDEC_EX_FAIL;
19267 }
19268
19269 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19270 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_INIT;
19271 IO_arg.param[0] = (void*)(pIn);
19272 IO_arg.pRet = (void*)(&ret);
19273
19274 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19275 {
19276 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19277 ret = E_VDEC_EX_FAIL;
19278 }
19279
19280 return ret;
19281 }
19282
MApi_VDEC_EX_CC_SetCfg(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,VDEC_EX_CCType eType,MS_U32 * pIn)19283 VDEC_EX_Result MApi_VDEC_EX_CC_SetCfg(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, VDEC_EX_CCType eType, MS_U32 *pIn)
19284 {
19285 VDEC_EX_V2_IO_Param IO_arg;
19286 VDEC_EX_Result ret;
19287
19288 if (pu32VDEC_EX_Inst == NULL)
19289 {
19290 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19291 return E_VDEC_EX_FAIL;
19292 }
19293
19294 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19295 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_SET_CFG;
19296 IO_arg.param[0] = (void*)(&eFmt);
19297 IO_arg.param[1] = (void*)(&eType);
19298 IO_arg.param[2] = (void*)(pIn);
19299 IO_arg.pRet = (void*)(&ret);
19300
19301 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19302 {
19303 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19304 ret = E_VDEC_EX_FAIL;
19305 }
19306
19307 return ret;
19308 }
19309
MApi_VDEC_EX_CC_SetBuffStartAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)19310 VDEC_EX_Result MApi_VDEC_EX_CC_SetBuffStartAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
19311 {
19312 VDEC_EX_V2_IO_Param IO_arg;
19313 VDEC_EX_Result ret;
19314
19315 if (pu32VDEC_EX_Inst == NULL)
19316 {
19317 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19318 return E_VDEC_EX_FAIL;
19319 }
19320
19321 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19322 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_SET_BUFF_START_ADDR;
19323 IO_arg.param[0] = (void*)(&eFmt);
19324 IO_arg.param[1] = (void*)(pIn);
19325 IO_arg.pRet = (void*)(&ret);
19326
19327 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19328 {
19329 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19330 ret = E_VDEC_EX_FAIL;
19331 }
19332
19333 return ret;
19334 }
19335
MApi_VDEC_EX_CC_UpdateWriteAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)19336 VDEC_EX_Result MApi_VDEC_EX_CC_UpdateWriteAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
19337 {
19338 VDEC_EX_V2_IO_Param IO_arg;
19339 VDEC_EX_Result ret;
19340
19341 if (pu32VDEC_EX_Inst == NULL)
19342 {
19343 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19344 return E_VDEC_EX_FAIL;
19345 }
19346
19347 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19348 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_UPDATE_WRITE_ADDR;
19349 IO_arg.param[0] = (void*)(&eFmt);
19350 IO_arg.param[1] = (void*)(pIn);
19351 IO_arg.pRet = (void*)(&ret);
19352
19353 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19354 {
19355 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19356 ret = E_VDEC_EX_FAIL;
19357 }
19358
19359 return ret;
19360 }
19361
MApi_VDEC_EX_CC_UpdateReadAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,MS_U32 * pIn)19362 VDEC_EX_Result MApi_VDEC_EX_CC_UpdateReadAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, MS_U32 *pIn)
19363 {
19364 VDEC_EX_V2_IO_Param IO_arg;
19365 VDEC_EX_Result ret;
19366
19367 if (pu32VDEC_EX_Inst == NULL)
19368 {
19369 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19370 return E_VDEC_EX_FAIL;
19371 }
19372
19373 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19374 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_UPDATE_READ_ADDR;
19375 IO_arg.param[0] = (void*)(&eFmt);
19376 IO_arg.param[1] = (void*)(pIn);
19377 IO_arg.pRet = (void*)(&ret);
19378
19379 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19380 {
19381 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19382 ret = E_VDEC_EX_FAIL;
19383 }
19384
19385 return ret;
19386 }
19387
MApi_VDEC_EX_CC_DisableParsing(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)19388 VDEC_EX_Result MApi_VDEC_EX_CC_DisableParsing(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
19389 {
19390 VDEC_EX_V2_IO_Param IO_arg;
19391 VDEC_EX_Result ret;
19392
19393 if (pu32VDEC_EX_Inst == NULL)
19394 {
19395 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19396 return E_VDEC_EX_FAIL;
19397 }
19398
19399 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19400 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_DISABLE_PARSING;
19401 IO_arg.param[0] = (void*)(&eFmt);
19402 IO_arg.pRet = (void*)(&ret);
19403
19404 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19405 {
19406 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19407 ret = E_VDEC_EX_FAIL;
19408 }
19409
19410 return ret;
19411 }
19412
MApi_VDEC_EX_CC_GetInfo(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt,VDEC_EX_CCInfoCmd eCmd,MS_U32 * pOut)19413 VDEC_EX_Result MApi_VDEC_EX_CC_GetInfo(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt, VDEC_EX_CCInfoCmd eCmd, MS_U32 *pOut)
19414 {
19415 VDEC_EX_V2_IO_Param IO_arg;
19416 VDEC_EX_Result ret;
19417
19418 if (pu32VDEC_EX_Inst == NULL)
19419 {
19420 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19421 return E_VDEC_EX_FAIL;
19422 }
19423
19424 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19425 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_INFO;
19426 IO_arg.param[0] = (void*)(&eFmt);
19427 IO_arg.param[1] = (void*)(&eCmd);
19428 IO_arg.param[2] = (void*)(pOut);
19429 IO_arg.pRet = (void*)(&ret);
19430
19431 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19432 {
19433 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19434 ret = E_VDEC_EX_FAIL;
19435 }
19436
19437 return ret;
19438 }
19439
MApi_VDEC_EX_CC_GetIsRstDone(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)19440 VDEC_EX_Result MApi_VDEC_EX_CC_GetIsRstDone(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
19441 {
19442 VDEC_EX_V2_IO_Param IO_arg;
19443 VDEC_EX_Result ret;
19444
19445 if (pu32VDEC_EX_Inst == NULL)
19446 {
19447 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19448 return E_VDEC_EX_FAIL;
19449 }
19450
19451 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19452 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_IS_RST_DONE;
19453 IO_arg.param[0] = (void*)(&eFmt);
19454 IO_arg.pRet = (void*)(&ret);
19455
19456 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19457 {
19458 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19459 ret = E_VDEC_EX_FAIL;
19460 }
19461
19462 return ret;
19463 }
19464
MApi_VDEC_EX_CC_GetIsBuffOverflow(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)19465 VDEC_EX_Result MApi_VDEC_EX_CC_GetIsBuffOverflow(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
19466 {
19467 VDEC_EX_V2_IO_Param IO_arg;
19468 VDEC_EX_Result ret;
19469
19470 if (pu32VDEC_EX_Inst == NULL)
19471 {
19472 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19473 return E_VDEC_EX_FAIL;
19474 }
19475
19476 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19477 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_IS_BUFF_OVERFLOW;
19478 IO_arg.param[0] = (void*)(&eFmt);
19479 IO_arg.pRet = (void*)(&ret);
19480
19481 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19482 {
19483 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19484 ret = E_VDEC_EX_FAIL;
19485 }
19486
19487 return ret;
19488 }
19489
19490 //------------------------------------------------------------------------------
19491 /// Report the physical address of write pointer
19492 /// @param eFmt \b IN : the format of closed caption
19493 /// @return MS_PHY
19494 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetWriteAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)19495 MS_PHY MApi_VDEC_EX_CC_GetWriteAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
19496 {
19497 VDEC_EX_V2_IO_Param IO_arg;
19498 VDEC_EX_Result ret;
19499 MS_PHY u32CCWrPtr = VDEC_U32_MAX;
19500
19501 if (pu32VDEC_EX_Inst == NULL)
19502 {
19503 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19504 return u32CCWrPtr;
19505 }
19506
19507 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19508 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_WRITE_ADDR;
19509 IO_arg.param[0] = (void*)(&eFmt);
19510 IO_arg.param[1] = (void*)(&u32CCWrPtr);
19511 IO_arg.pRet = (void*)(&ret);
19512
19513 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19514 {
19515 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19516 }
19517
19518 return u32CCWrPtr;
19519 }
19520
19521 //------------------------------------------------------------------------------
19522 /// Report the physical address of read pointer
19523 /// @param eFmt \b IN : the format of closed caption
19524 /// @return MS_PHY
19525 //------------------------------------------------------------------------------
MApi_VDEC_EX_CC_GetReadAdd(VDEC_StreamId * pStreamId,VDEC_EX_CCFormat eFmt)19526 MS_PHY MApi_VDEC_EX_CC_GetReadAdd(VDEC_StreamId *pStreamId, VDEC_EX_CCFormat eFmt)
19527 {
19528 VDEC_EX_V2_IO_Param IO_arg;
19529 VDEC_EX_Result ret;
19530 MS_PHY u32CCRdPtr = VDEC_U32_MAX;
19531
19532 if (pu32VDEC_EX_Inst == NULL)
19533 {
19534 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19535 return u32CCRdPtr;
19536 }
19537
19538 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19539 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_CC_GET_READ_ADDR;
19540 IO_arg.param[0] = (void*)(&eFmt);
19541 IO_arg.param[1] = (void*)(&u32CCRdPtr);
19542 IO_arg.pRet = (void*)(&ret);
19543
19544 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19545 {
19546 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19547 }
19548
19549 return u32CCRdPtr;
19550 }
19551
MApi_VDEC_EX_Rst(VDEC_StreamId * pStreamId)19552 VDEC_EX_Result MApi_VDEC_EX_Rst(VDEC_StreamId *pStreamId)
19553 {
19554 VDEC_EX_V2_IO_Param IO_arg;
19555 VDEC_EX_Result ret;
19556
19557 if (pu32VDEC_EX_Inst == NULL)
19558 {
19559 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19560 return E_VDEC_EX_FAIL;
19561 }
19562
19563 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19564 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_RST;
19565 IO_arg.pRet = (void*)(&ret);
19566
19567 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19568 {
19569 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19570 ret = E_VDEC_EX_FAIL;
19571 }
19572
19573 return ret;
19574 }
19575
19576
MApi_VDEC_EX_Exit(VDEC_StreamId * pStreamId)19577 VDEC_EX_Result MApi_VDEC_EX_Exit(VDEC_StreamId *pStreamId)
19578 {
19579 VDEC_EX_V2_IO_Param IO_arg;
19580 VDEC_EX_Result ret;
19581
19582 if (pu32VDEC_EX_Inst == NULL)
19583 {
19584 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
19585 {
19586 VPRINTF("UtopiaOpen VDEC_EX failed\n");
19587 return E_VDEC_EX_FAIL;
19588 }
19589 }
19590
19591 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
19592 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_EXIT;
19593 IO_arg.pRet = (void*)(&ret);
19594
19595 if(UtopiaIoctl(pu32VDEC_EX_Inst,(MS_U32)E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19596 {
19597 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19598 ret = E_VDEC_EX_FAIL;
19599 }
19600
19601 #if 0
19602 if(UtopiaClose(pu32VDEC_EX_Inst) != UTOPIA_STATUS_SUCCESS)
19603 {
19604 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
19605 return FALSE;
19606 }
19607
19608 pu32VDEC_EX_Inst = NULL;
19609 #endif
19610 return ret;
19611 }
19612
MApi_VDEC_GetCaps(VDEC_HwCap * pVDECHWCap)19613 VDEC_EX_Result MApi_VDEC_GetCaps(VDEC_HwCap *pVDECHWCap)
19614 {
19615 MS_U16 u16CopiedLength = 0;
19616 VDEC_HwCap stVDECHWCap;
19617
19618 _VDEC_Memset(&stVDECHWCap,0,sizeof(VDEC_HwCap));
19619
19620 if(pVDECHWCap == NULL)
19621 {
19622 VPRINTF("Null paramter in %s\n",__FUNCTION__);
19623 return E_VDEC_EX_FAIL;
19624 }
19625
19626 if(pVDECHWCap->u16ApiHW_Length == 0)
19627 {
19628 VPRINTF("Zero u16ApiHW_Length in %s\n",__FUNCTION__);
19629 return E_VDEC_EX_FAIL;
19630 }
19631
19632 if(pVDECHWCap->u32ApiHW_Version < 1)
19633 {
19634 VPRINTF("Wrong u32ApiHW_Version(%d) in %s\n",(unsigned int)pVDECHWCap->u32ApiHW_Version,__FUNCTION__);
19635 return E_VDEC_EX_FAIL;
19636 }
19637
19638 //new AP + old lib, only the length corresponding to old lib has meaning.
19639 if(pVDECHWCap->u32ApiHW_Version > API_HWCAP_VERSION)
19640 {
19641 VPRINTF("[VDEC] old lib version has only length:%lx\n",(unsigned long)sizeof(VDEC_HwCap));
19642 u16CopiedLength = sizeof(VDEC_HwCap);
19643 }
19644
19645 //old AP + new lib, driver shouldn't access to the space which doesn't exist in old structure
19646 if((pVDECHWCap->u32ApiHW_Version < API_HWCAP_VERSION) || (pVDECHWCap->u16ApiHW_Length < sizeof(VDEC_HwCap)))
19647 {
19648 VPRINTF("new lib version access by old structure!!\n");
19649 u16CopiedLength = pVDECHWCap->u16ApiHW_Length;
19650 }
19651
19652 stVDECHWCap.u32ApiHW_Version = API_HWCAP_VERSION;
19653 stVDECHWCap.u16ApiHW_Length = u16CopiedLength;
19654
19655 if(MDrv_HVD_EX_CHIP_Capability(&stVDECHWCap) == TRUE)
19656 {
19657 memcpy(pVDECHWCap, &stVDECHWCap, u16CopiedLength);
19658 return E_VDEC_EX_OK;
19659 }
19660 else
19661 {
19662 VPRINTF("[VDEC] chip cap is not ready\n");
19663 return E_VDEC_EX_FAIL;
19664 }
19665 }
19666
19667 //------------------------------------------------------------------------------
19668 /// Get Stream ID from VDEC.
19669 /// @param pInfo \b IN : pointer to VDEC_StreamId
19670 /// @param u32Size \b IN : size of VDEC_StreamId
19671 /// @param eStream \b IN : stream type
19672 /// @param eCodecType \b IN : codec type
19673 /// @return VDEC_EX_Result
19674 /// - E_VDEC_EX_OK: success
19675 /// - E_VDEC_EX_FAIL: failed
19676 /// - E_VDEC_EX_RET_NOT_EXIT: not ext after last initialization
19677 /// - E_VDEC_EX_RET_INVALID_PARAM: input parameter is invalid
19678 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetFreeStream(void * pInfo,MS_U32 u32Size,VDEC_EX_Stream eStreamType,VDEC_EX_CodecType eCodecType)19679 VDEC_EX_Result MApi_VDEC_EX_GetFreeStream(void *pInfo, MS_U32 u32Size, VDEC_EX_Stream eStreamType, VDEC_EX_CodecType eCodecType)
19680 {
19681 VDEC_EX_V2_IO_Param IO_arg;
19682 VDEC_EX_Result ret;
19683
19684 if (pu32VDEC_EX_Inst == NULL)
19685 {
19686 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
19687 {
19688 VPRINTF("UtopiaOpen VDEC_EX failed\n");
19689 return E_VDEC_EX_FAIL;
19690 }
19691 }
19692
19693 #ifndef MSOS_TYPE_LINUX_KERNEL
19694 if(_MApi_VDEC_EX_IsSecureModeEnable())// move mailbox register/enable to user mode
19695 {
19696 _MApi_VDEC_EX_RegisterMBX();
19697 }
19698 #endif
19699
19700 IO_arg.param[0] = pInfo;
19701 IO_arg.param[1] = (void*)(&u32Size);
19702 IO_arg.param[2] = (void*)(&eStreamType);
19703 IO_arg.param[3] = (void*)(&eCodecType);
19704 IO_arg.pRet = (void*)(&ret);
19705
19706 if(UtopiaIoctl(pu32VDEC_EX_Inst, E_VDEC_EX_V2_CMD_GET_FREE_STREAM_ID, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
19707 {
19708 VPRINTF("[Fail]%s,%d\n",__FUNCTION__,__LINE__);
19709 ret = E_VDEC_EX_FAIL;
19710 }
19711
19712 return ret;
19713 }
19714
19715
MApi_VDEC_EX_V2_GetFreeStream(VDEC_StreamId * pInfo,MS_U32 u32Size,VDEC_EX_Stream eStreamType,VDEC_EX_CodecType eCodecType)19716 VDEC_EX_Result MApi_VDEC_EX_V2_GetFreeStream(VDEC_StreamId *pInfo, MS_U32 u32Size, VDEC_EX_Stream eStreamType, VDEC_EX_CodecType eCodecType)
19717 {
19718 MS_U32 u32Version;
19719 MS_U8 i;
19720
19721 if(_VDEC_Init_Share_Mem(eStreamType) != E_VDEC_EX_OK)
19722 {
19723 VDEC_PRINT("Init Share Mem fail\n");
19724 return E_VDEC_EX_FAIL;
19725 }
19726
19727 #if (defined(MSOS_TYPE_LINUX)||defined(MSOS_TYPE_LINUX_KERNEL)) && !defined(SUPPORT_X_MODEL_FEATURE)
19728 //REE
19729 if(MDrv_MVD_EnableVPUSecurityMode(bSecureModeEnable) != TRUE)
19730 {
19731 return E_VDEC_EX_FAIL;
19732 }
19733
19734 if (MDrv_HVD_EX_SetVPUSecureMode(bSecureModeEnable) != TRUE)
19735 {
19736 return E_VDEC_EX_FAIL;
19737 }
19738
19739 if(bSecureModeEnable == TRUE)
19740 {
19741 SYS_TEEINFO teemode;
19742 MDrv_SYS_ReadKernelCmdLine();
19743 MDrv_SYS_GetTEEInfo(&teemode);
19744 VPRINTF("[VDEC][TEE/OPTEE]%s,TEE_type=%d\n",__FUNCTION__,teemode.OsType);
19745 if(teemode.OsType == SYS_TEEINFO_OSTYPE_NUTTX)
19746 {
19747 if (MDrv_MVD_REE_RegisterMBX() == FALSE)
19748 {
19749 return E_VDEC_EX_FAIL;
19750 }
19751
19752 if(MDrv_MVD_REE_SetSHMBaseAddr((MS_U32)SYS_TEEINFO_OSTYPE_NUTTX,0,0,0) == FALSE)
19753 {
19754 return E_VDEC_EX_FAIL;
19755 }
19756 }
19757 else if(teemode.OsType == SYS_TEEINFO_OSTYPE_OPTEE)
19758 {
19759 MS_PHY SHM_Param[3] = {0};
19760 VPRINTF("[VDEC][OPTEE]Send get sharememory command\n");
19761 if(_MApi_VDEC_EX_V2_Send_OPTEE_CMD(E_VDEC_EX_OPTEE_GETSHMADDR,(void*)SHM_Param,sizeof(MS_PHY)*3) == TRUE)
19762 {
19763 VPRINTF("[VDEC][OPTEE]Get sharememory success\n");
19764 if(MDrv_MVD_REE_SetSHMBaseAddr((MS_U32)SYS_TEEINFO_OSTYPE_OPTEE,SHM_Param[0],SHM_Param[1],SHM_Param[2]) == FALSE)
19765 {
19766 VPRINTF("[VDEC][OPTEE]Set sharememory fail\n");
19767 return E_VDEC_EX_FAIL;
19768 }
19769 }
19770 else
19771 {
19772 VPRINTF("[VDEC][OPTEE]Get sharememory fail\n");
19773 return E_VDEC_EX_FAIL;
19774 }
19775 }
19776 }
19777 #endif
19778
19779 if(pInfo == NULL)
19780 {
19781 return E_VDEC_EX_FAIL;
19782 }
19783
19784 u32Version = pInfo->u32Version;
19785
19786 _VDEC_EX_API_MutexLock();
19787
19788 #ifdef VDEC3
19789 if (eStreamType == E_VDEC_EX_N_STREAM)
19790 {
19791 //pVdecExContext->bFWdecideFB = TRUE;
19792 pVdecExContext->bDRVdecideBS = TRUE;
19793 }
19794 else if (pVdecExContext->bDRVdecideBS && eStreamType != E_VDEC_EX_N_STREAM)
19795 {
19796 VDEC_PRINT("Stream type isn't consistant with the previous call\n");
19797 _VDEC_EX_API_MutexUnlock();
19798 return E_VDEC_EX_FAIL;
19799 }
19800 #endif
19801
19802 if (u32Version == 0 && u32Size == sizeof(VDEC_StreamId))
19803 {
19804 // Determine streamID from vdec layer
19805 VDEC_StreamId *pStreamId = pInfo;
19806 VDEC_EX_Decoder eDecoder = _VDEC_EX_GetDecoderByCodecType(eCodecType);
19807 MS_U8 u8Idx = (MS_U8) eStreamType; //u8Idx = 0(main), 1(sub).
19808 #ifdef VDEC3
19809 if (eStreamType == E_VDEC_EX_N_STREAM)
19810 {
19811 #if 1
19812 u8Idx = MDrv_MVD_CheckFreeStream();
19813
19814 if (u8Idx == -1)
19815 {
19816 VDEC_PRINT("No available stream \n");
19817 _VDEC_EX_API_MutexUnlock();
19818 return E_VDEC_EX_FAIL;
19819 }
19820 #else
19821 for (u8Idx = 0; u8Idx < VDEC_MAX_SUPPORT_STREAM_NUM; u8Idx++)
19822 {
19823 if (!pVdecExContext->_Attr[u8Idx].bUsed)
19824 break;
19825 }
19826
19827 if (u8Idx >= VDEC_MAX_SUPPORT_STREAM_NUM)
19828 {
19829 VDEC_PRINT("all streams are in used!\n");
19830 return E_VDEC_EX_FAIL;
19831 }
19832 #endif
19833 }
19834 #endif
19835
19836 if (TRUE == pVdecExContext->_Attr[u8Idx].bUsed)
19837 {
19838 VDEC_PRINT("eStreamType(%x) is used!\n", eStreamType);
19839 _VDEC_EX_API_MutexUnlock();
19840 return E_VDEC_EX_FAIL;
19841 }
19842
19843 #ifdef VDEC3
19844 _VDEC_EX_Context_Init_Function_Pointer(u8Idx);
19845 #endif
19846
19847 // Get streamID from driver/hal layer
19848 switch (eDecoder)
19849 {
19850 case E_VDEC_EX_DECODER_MVD:
19851 {
19852 MVD_DRV_StreamType eMvdStreamType = E_MVD_DRV_STREAM_NONE;
19853 #ifndef VDEC3
19854 if (eStreamType == E_VDEC_EX_MAIN_STREAM)
19855 {
19856 eMvdStreamType = E_MVD_DRV_MAIN_STREAM;
19857 }
19858 else if (eStreamType == E_VDEC_EX_SUB_STREAM)
19859 {
19860 eMvdStreamType = E_MVD_DRV_SUB_STREAM;
19861 }
19862 #else
19863 eMvdStreamType = E_MVD_DRV_N_STREAM+u8Idx;
19864 #endif
19865 //VDEC_PRINT("eMvdStreamType = 0x%x\n", eMvdStreamType);
19866 if (eMvdStreamType != E_MVD_DRV_STREAM_NONE)
19867 {
19868 MS_U32 u32VdecStreamId = 0;
19869
19870 #ifdef VDEC3
19871 if(MDrv_MVD_GetFreeStream(&u32VdecStreamId, eMvdStreamType, pVdecExContext->bDRVdecideBS) != E_MVD_RET_OK)
19872 #else
19873 if(MDrv_MVD_GetFreeStream(&u32VdecStreamId, eMvdStreamType) != E_MVD_RET_OK)
19874 #endif
19875 {
19876 _VDEC_EX_API_MutexUnlock();
19877 return E_VDEC_EX_FAIL;
19878 }
19879 VDEC_PRINT("=========> vdec_u8Idx=0x%x, u32VdecStreamId=0%x\n", u8Idx, u32VdecStreamId);
19880
19881 if (u32VdecStreamId)
19882 {
19883 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
19884 _SET_DISPLAYMODE_INVALID(u8Idx);
19885 _VDEC_EX_API_MutexUnlock();
19886 return E_VDEC_EX_OK;
19887 }
19888 }
19889
19890 break;
19891 }
19892 case E_VDEC_EX_DECODER_HVD:
19893 {
19894 MS_BOOL bIsEVD = FALSE;
19895 if ((eCodecType == E_VDEC_EX_CODEC_TYPE_HEVC) || (eCodecType == E_VDEC_EX_CODEC_TYPE_VP9))
19896 {
19897 bIsEVD = TRUE;
19898 }
19899
19900 // Special case: MVC.
19901 // - No other tasks can be run when MVC is running.
19902 // - MVC must be task0 and use main index (u8Idx=0).
19903 if (E_VDEC_EX_CODEC_TYPE_MVC == eCodecType)
19904 {
19905 MS_U32 u32VdecStreamId = 0;
19906
19907 for (i = 0; i < VDEC_MAX_SUPPORT_STREAM_NUM; i++)
19908 {
19909 if (TRUE == pVdecExContext->_Attr[i].bUsed)
19910 {
19911 _VDEC_EX_API_MutexUnlock();
19912 return E_VDEC_EX_FAIL;
19913 }
19914 }
19915
19916 /// MVC use main stream.
19917 #ifdef VDEC3
19918 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFreeStream(&u32VdecStreamId, E_HVD_EX_DRV_MVC_STREAM, bIsEVD, pVdecExContext->bDRVdecideBS))
19919 #else
19920 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFreeStream(&u32VdecStreamId, E_HVD_EX_DRV_MVC_STREAM, bIsEVD))
19921 #endif
19922 {
19923 u8Idx = 0; /// main stream
19924 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
19925 _SET_DISPLAYMODE_INVALID(u8Idx);
19926 _VDEC_EX_API_MutexUnlock();
19927 return E_VDEC_EX_OK;
19928 }
19929 else
19930 {
19931 _VDEC_EX_API_MutexUnlock();
19932 return E_VDEC_EX_FAIL;
19933 }
19934 }
19935 #ifndef VDEC3
19936 else if((E_VDEC_EX_CODEC_TYPE_VP8 == eCodecType) //VP8 using esb3, esb4 in the same time
19937 || (E_VDEC_EX_CODEC_TYPE_HEVC == eCodecType)) //EVD support one esb now
19938 {
19939 for (i = 0; i < VDEC_MAX_SUPPORT_STREAM_NUM; i++)
19940 {
19941 if (((E_VDEC_EX_CODEC_TYPE_VP8 == pVdecExContext->_Attr[i].eCodecType) && (E_VDEC_EX_CODEC_TYPE_VP8 == eCodecType))
19942 || ((E_VDEC_EX_CODEC_TYPE_HEVC == pVdecExContext->_Attr[i].eCodecType) && (E_VDEC_EX_CODEC_TYPE_HEVC == eCodecType)))
19943 {
19944 _VDEC_EX_API_MutexUnlock();
19945 return E_VDEC_EX_FAIL;
19946 }
19947 }
19948
19949 if (E_VDEC_EX_MAIN_STREAM == eStreamType)
19950 {
19951 MS_U32 u32VdecStreamId = 0;
19952
19953 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFreeStream(&u32VdecStreamId, E_HVD_EX_DRV_MAIN_STREAM, bIsEVD))
19954 {
19955 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
19956 _SET_DISPLAYMODE_INVALID(u8Idx);
19957 _VDEC_EX_API_MutexUnlock();
19958 return E_VDEC_EX_OK;
19959 }
19960 }
19961 else if (E_VDEC_EX_SUB_STREAM == eStreamType)
19962 {
19963 MS_U32 u32VdecStreamId = 0;
19964
19965 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFreeStream(&u32VdecStreamId, E_HVD_EX_DRV_SUB_STREAM, bIsEVD))
19966 {
19967 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
19968 _SET_DISPLAYMODE_INVALID(u8Idx);
19969 _VDEC_EX_API_MutexUnlock();
19970 return E_VDEC_EX_OK;
19971 }
19972 }
19973 }
19974 #endif
19975 else
19976 {
19977 #ifdef VDEC3
19978 MS_U32 u32VdecStreamId = 0;
19979
19980 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFreeStream(&u32VdecStreamId, E_HVD_EX_DRV_N_STREAM + u8Idx, bIsEVD, pVdecExContext->bDRVdecideBS))
19981 {
19982 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
19983 _SET_DISPLAYMODE_INVALID(u8Idx);
19984 _VDEC_EX_API_MutexUnlock();
19985 return E_VDEC_EX_OK;
19986 }
19987 #else
19988 if (E_VDEC_EX_MAIN_STREAM == eStreamType)
19989 {
19990 MS_U32 u32VdecStreamId = 0;
19991
19992 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFreeStream(&u32VdecStreamId, E_HVD_EX_DRV_MAIN_STREAM, bIsEVD))
19993 {
19994 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
19995 _SET_DISPLAYMODE_INVALID(u8Idx);
19996 _VDEC_EX_API_MutexUnlock();
19997 return E_VDEC_EX_OK;
19998 }
19999 }
20000 else if (E_VDEC_EX_SUB_STREAM == eStreamType)
20001 {
20002 MS_U32 u32VdecStreamId = 0;
20003
20004 if (E_HVD_EX_OK == MDrv_HVD_EX_GetFreeStream(&u32VdecStreamId, E_HVD_EX_DRV_SUB_STREAM, bIsEVD))
20005 {
20006 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
20007 _SET_DISPLAYMODE_INVALID(u8Idx);
20008 _VDEC_EX_API_MutexUnlock();
20009 return E_VDEC_EX_OK;
20010 }
20011 }
20012 #endif
20013 }
20014
20015 break;
20016 }
20017 case E_VDEC_EX_DECODER_MJPEG:
20018 {
20019 #ifdef VDEC3
20020 MS_U32 u32VdecStreamId = 0;
20021
20022 if (E_MJPEG_RET_SUCCESS == MApi_MJPEG_GetFreeStream(&u32VdecStreamId, E_MJPEG_API_N_STREAM + u8Idx))
20023 {
20024 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
20025 _SET_DISPLAYMODE_INVALID(u8Idx);
20026 _VDEC_EX_API_MutexUnlock();
20027 return E_VDEC_EX_OK;
20028 }
20029 #else
20030 if (E_VDEC_EX_MAIN_STREAM == eStreamType)
20031 {
20032 MS_U32 u32VdecStreamId = 0;
20033
20034 if (E_MJPEG_RET_SUCCESS == MApi_MJPEG_GetFreeStream(&u32VdecStreamId, E_MJPEG_API_MAIN_STREAM))
20035 {
20036 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
20037 _SET_DISPLAYMODE_INVALID(u8Idx);
20038 _VDEC_EX_API_MutexUnlock();
20039 return E_VDEC_EX_OK;
20040 }
20041 }
20042 else if (E_VDEC_EX_SUB_STREAM == eStreamType)
20043 {
20044 MS_U32 u32VdecStreamId = 0;
20045
20046 if (E_MJPEG_RET_SUCCESS == MApi_MJPEG_GetFreeStream(&u32VdecStreamId, E_MJPEG_API_SUB_STREAM))
20047 {
20048 pStreamId->u32Id = (u8Idx << 24 | u32VdecStreamId);
20049 _SET_DISPLAYMODE_INVALID(u8Idx);
20050 _VDEC_EX_API_MutexUnlock();
20051 return E_VDEC_EX_OK;
20052 }
20053 }
20054 #endif
20055 break;
20056 }
20057 default:
20058 break;
20059 }
20060 }
20061 else
20062 {
20063 VDEC_PRINT("%s: invalid u32Version(%d) or u32Size(%d)\n", __FUNCTION__, u32Version, (MS_U32)sizeof(VDEC_StreamId));
20064 }
20065 _VDEC_EX_API_MutexUnlock();
20066 return E_VDEC_EX_FAIL;
20067 }
20068
20069 //------------------------------------------------------------------------------
20070 ///Map context for multi process use
20071 /// @param eStream \b IN : stream type
20072 /// @return VDEC_EX_Result
20073 /// - E_VDEC_EX_OK: success
20074 /// - E_VDEC_EX_FAIL: failed
20075 /// - E_VDEC_EX_RET_NOT_EXIT: not ext after last initialization
20076 /// - E_VDEC_EX_RET_INVALID_PARAM: input parameter is invalid
20077 //------------------------------------------------------------------------------
MApi_VDEC_EX_GetConfig(VDEC_EX_Stream eStreamType)20078 VDEC_EX_Result MApi_VDEC_EX_GetConfig(VDEC_EX_Stream eStreamType)
20079 {
20080 MApi_VDEC_EX_GetFreeStream(NULL, 0, 0, E_VDEC_EX_CODEC_TYPE_NONE);
20081
20082 VDEC_StreamId stStreamId, stGetStreamId;
20083 VDEC_EX_User_Cmd cmd_id;
20084
20085 if(eStreamType == E_VDEC_EX_MAIN_STREAM)
20086 {
20087 cmd_id = E_VDEC_EX_USER_CMD_GET_MAIN_STREAM_ID;
20088 }
20089 else if(eStreamType == E_VDEC_EX_SUB_STREAM)
20090 {
20091 cmd_id = E_VDEC_EX_USER_CMD_GET_SUB_STREAM_ID;
20092 }
20093 else
20094 {
20095 VPRINTF("[Fail][%s,%d], eStreamType: %d\n",__FUNCTION__,__LINE__, eStreamType);
20096 return E_VDEC_EX_FAIL;
20097 }
20098
20099 VDEC_EX_Result res = MApi_VDEC_EX_GetControl( &stStreamId, cmd_id, (MS_U32*)(&stGetStreamId));
20100
20101 if(E_VDEC_EX_OK == res)
20102 {
20103 VDEC_EX_Status stGetStatus;
20104 MApi_VDEC_EX_GetStatus(&stGetStreamId, &stGetStatus);
20105
20106 if(E_VDEC_EX_STAGE_STOP != stGetStatus.eStage)
20107 return E_VDEC_EX_OK;
20108 else
20109 return E_VDEC_EX_FAIL;
20110 }
20111 else
20112 return E_VDEC_EX_FAIL;
20113 }
20114
20115 //------------------------------------------------------------------------------
20116 /// Initial VDEC.
20117 /// @param pStreamId \b IN : the pointer to stream ID
20118 /// @param pInitParam \b IN : pointer to initial parameter
20119 /// @return VDEC_EX_Result
20120 /// - E_VDEC_EX_OK: success
20121 /// - E_VDEC_EX_FAIL: failed
20122 /// - E_VDEC_EX_RET_NOT_EXIT: not ext after last initialization
20123 /// - E_VDEC_EX_RET_INVALID_PARAM: input parameter is invalid
20124 //------------------------------------------------------------------------------
MApi_VDEC_EX_Init(VDEC_StreamId * pStreamId,VDEC_EX_InitParam * pInitParam)20125 VDEC_EX_Result MApi_VDEC_EX_Init(VDEC_StreamId *pStreamId, VDEC_EX_InitParam *pInitParam)
20126 {
20127 VDEC_EX_V2_IO_Param IO_arg;
20128 VDEC_EX_Result ret;
20129
20130 if (pu32VDEC_EX_Inst == NULL)
20131 {
20132 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
20133 #if 0//!defined(VDEC_UTOPIA_2K)
20134 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
20135 MDrv_MVD_ReleaseFreeStream(u32Id);TODO: fix me
20136 #endif
20137 return E_VDEC_EX_FAIL;
20138 }
20139
20140 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
20141 IO_arg.param[0] = (void*)pInitParam;
20142 IO_arg.pRet = (void*)(&ret);
20143
20144 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_INIT, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
20145 {
20146 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
20147 ret = E_VDEC_EX_FAIL;
20148 }
20149
20150 if(ret != E_VDEC_EX_OK)
20151 {
20152 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
20153 #if 0//!defined(VDEC_UTOPIA_2K)
20154 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
20155 MDrv_MVD_ReleaseFreeStream(u32Id);TODO: fix me
20156 #endif
20157 }
20158
20159 return ret;
20160 }
20161
20162 #ifdef VDEC3
_MApi_VDEC_EX_BS_Init(MS_PHY addr,MS_U32 size)20163 static void _MApi_VDEC_EX_BS_Init(MS_PHY addr, MS_U32 size)
20164 {
20165 if (!pVdecExContext)
20166 return;
20167
20168 pVdecExContext->u32BitstreamBufAddr = addr;
20169 pVdecExContext->u32BitstreamBufSize = size;
20170 }
20171
20172 /*
20173 static MS_PHY _MApi_VDEC_EX_BS_GetAddr(MS_U8 u8Idx)
20174 {
20175 if (u8Idx >= VDEC_MAX_SUPPORT_STREAM_NUM || !pVdecExContext)
20176 return 0;
20177
20178 return pVdecExContext->u32BitstreamBufAddr + (pVdecExContext->u32BitstreamBufSize / VDEC_MAX_SUPPORT_STREAM_NUM * u8Idx);
20179 }
20180
20181 static MS_U32 _MApi_VDEC_EX_BS_GetSize(MS_U8 u8Idx)
20182 {
20183 if (u8Idx >= VDEC_MAX_SUPPORT_STREAM_NUM || !pVdecExContext)
20184 return 0;
20185
20186 return pVdecExContext->u32BitstreamBufSize / VDEC_MAX_SUPPORT_STREAM_NUM;
20187 }
20188 */
20189 #endif
20190
MApi_VDEC_EX_V2_Init(VDEC_StreamId * pStreamId,VDEC_EX_InitParam * pInitParam)20191 VDEC_EX_Result MApi_VDEC_EX_V2_Init(VDEC_StreamId *pStreamId, VDEC_EX_InitParam *pInitParam)
20192 {
20193 MS_BOOL bNotReloadFW = FALSE;
20194 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
20195 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
20196 VDEC_EX_CapCmd cap;
20197 #ifdef CMA_DRV_DIRECT_INIT
20198 MS_SIZE unUseSize = 0;
20199 #endif
20200 MS_BOOL bNDecAllocator = _VDEC_EX_NdecAllocator_IsNDecode();//VDEC_EX_ALLOCATOR_ENABLE;
20201
20202 _VDEC_INVALID_IDX_RET(u8Idx);
20203
20204 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
20205
20206 if (pVdecExContext->_Attr[u8Idx].bInit)
20207 {
20208 VDEC_PRINT("VDEC Warn: re-init VDEC Driver\n");
20209 #if defined( MS_DEBUG )
20210 return E_VDEC_EX_RET_NOT_EXIT;
20211 #endif
20212 }
20213
20214 if(bSecureModeEnable == TRUE)
20215 {
20216 SYS_TEEINFO teemode;
20217 MDrv_SYS_ReadKernelCmdLine();
20218 MDrv_SYS_GetTEEInfo(&teemode);
20219 VPRINTF("[VDEC][TEE/OPTEE]%s,TEEmode_type=%d\n",__FUNCTION__,teemode.OsType);
20220 if(teemode.OsType == SYS_TEEINFO_OSTYPE_OPTEE)
20221 {
20222 pVdecExContext->_Pre_Ctrl[u8Idx].bEnableDynamicCMA = 0;
20223 VPRINTF("[VDEC][OPTEE]secure mode can't use dynamic CMA\n");
20224 }
20225 }
20226
20227 u8CodecCompare[u8Idx] = 0;
20228
20229 _VDEC_EX_InitLocalVar(u8Idx);
20230
20231 _VDEC_Memcpy(&(pVdecExContext->_Attr[u8Idx].vdecExInitParam), pInitParam, sizeof(VDEC_EX_InitParam));
20232
20233 pVdecExContext->_Attr[u8Idx].eCodecType = pInitParam->eCodecType;
20234 pVdecExContext->_Attr[u8Idx].eDecoder = _VDEC_EX_GetDecoderByCodecType(pInitParam->eCodecType);
20235 pVdecExContext->_Attr[u8Idx].eSrcMode = pInitParam->VideoInfo.eSrcMode;
20236 pVdecExContext->_Attr[u8Idx].eDbgMsgLevel = pInitParam->SysConfig.eDbgMsgLevel;
20237
20238 #if defined(CHIP_KANO) || defined(CHIP_CURRY) //|| defined(HAL_CHIP_SUPPORT_DUAL_R2)
20239 MS_BOOL bIsEVD = FALSE;
20240 MS_U8 u8Cidx = 0;
20241 MS_U16 u16ChipECORev = (MS_U16)MDrv_SYS_GetChipRev();
20242 bIsEVD = (E_VDEC_EX_CODEC_TYPE_HEVC == pVdecExContext->_Attr[u8Idx].eCodecType) || (E_VDEC_EX_CODEC_TYPE_VP9 == pVdecExContext->_Attr[u8Idx].eCodecType);
20243
20244 _VDEC_EX_API_MutexLock();
20245
20246 #ifdef VDEC3
20247 _VDEC_EX_SetCidx(pStreamId, bIsEVD, pVdecExContext->bDRVdecideBS);
20248 #else
20249 _VDEC_EX_SetCidx(pStreamId, bIsEVD);
20250 #endif
20251 _VDEC_EX_GetCidx(pStreamId, &u8Cidx);
20252
20253 #if VDEC_EXCHANGE_CIDX_PATCH
20254 if(u16ChipECORev == 0)
20255 {
20256 if (u8Cidx == 1)
20257 {
20258 if ((E_VDEC_EX_SRC_MODE_DTV == pVdecExContext->_Attr[u8Idx].eSrcMode) ||
20259 (E_VDEC_EX_SRC_MODE_TS_FILE == pVdecExContext->_Attr[u8Idx].eSrcMode) ||
20260 (E_VDEC_EX_SRC_MODE_TS_FILE_DUAL_ES == pVdecExContext->_Attr[u8Idx].eSrcMode))
20261 {
20262 _VDEC_EX_ExchangeCidx(pStreamId);
20263 u8Cidx = 0;
20264 }
20265 }
20266 }
20267 #endif
20268
20269 #ifdef VDEC3
20270 VDEC_EX_SysCfg* tmpCfg = &(pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig);
20271 #else
20272 VDEC_EX_SysCfg* tmpCfg = &(pInitParam->SysConfig);
20273 #endif
20274
20275 //for MMAP with E_MMAP_ID_VDEC_CPU_LEN smaller than 0x600000, use HI_CODEC decoder only
20276 #define SIZE_3MB 0x300000
20277 #define SIZE_6MB 0x600000
20278
20279 if (tmpCfg->u32CodeBufSize < SIZE_6MB)
20280 {
20281 if (u8Cidx == 1)
20282 {
20283 _VDEC_EX_ExchangeCidx(pStreamId);
20284 u8Cidx = 0;
20285 }
20286 }
20287
20288 if (u8Cidx == 1)
20289 {
20290 tmpCfg->u32CodeBufAddr = tmpCfg->u32CodeBufAddr + SIZE_3MB;
20291 }
20292
20293 _VDEC_EX_API_MutexUnlock();
20294 #endif
20295
20296 if(bNDecAllocator == FALSE)
20297 {
20298 #ifdef CMA_DRV_DIRECT_INIT
20299 if (pVdecExContext->bCMAUsed && u8Idx == 0 && (pVdecExContext->_power_state[u8Idx] != E_VDEC_EX_POWER_RESUME_ING))
20300 {
20301 pVdecExContext->cmaInitParam[0].heap_id = ION_VDEC_HEAP_ID;
20302 pVdecExContext->cmaInitParam[0].flags = CMA_FLAG_MAP_VMA| CMA_FLAG_CACHED;
20303
20304 if (MApi_CMA_Pool_Init(&pVdecExContext->cmaInitParam[0]) == FALSE)
20305 {
20306 VPRINTF("[%s][%d]CMA init fail\n",__FUNCTION__,__LINE__);
20307 return E_VDEC_EX_FAIL;
20308 }
20309 else
20310 {
20311 bCMAInitPool[0] = TRUE;
20312 if(pInitParam->SysConfig.u32FrameBufAddr != 0)
20313 {
20314 MS_PHY temp_addr;
20315 _miu_offset_to_phy(pVdecExContext->cmaInitParam[0].miu,
20316 pVdecExContext->cmaInitParam[0].heap_miu_start_offset,
20317 temp_addr);
20318
20319 unUseSize = pInitParam->SysConfig.u32FrameBufAddr - temp_addr;
20320 }
20321
20322 VPRINTF("[VDEC][%d] MApi_CMA_Pool_Init[0]: pool_handle_id=%x, miu=%d, offset=%llx, length=%x , FrameBuffer=%llx, unUseSize=%x\n",
20323 (unsigned int)u8Idx,
20324 (unsigned int)pVdecExContext->cmaInitParam[0].pool_handle_id,
20325 (unsigned int)pVdecExContext->cmaInitParam[0].miu,
20326 (unsigned long long int)pVdecExContext->cmaInitParam[0].heap_miu_start_offset,
20327 (unsigned int)pVdecExContext->cmaInitParam[0].heap_length,
20328 (unsigned long long int)pInitParam->SysConfig.u32FrameBufAddr,
20329 (unsigned int)unUseSize);
20330 }
20331 pVdecExContext->cmaInitParam[1].heap_id = ION_VDEC_HEAP_ID + 1;
20332 pVdecExContext->cmaInitParam[1].flags = CMA_FLAG_MAP_VMA | CMA_FLAG_CACHED;
20333
20334 if (MApi_CMA_Pool_Init(&pVdecExContext->cmaInitParam[1]) == FALSE)
20335 {
20336 VPRINTF("[VDEC][%d] MApi_CMA_Pool_Init[1] Failed\n", (unsigned int)u8Idx);
20337 }
20338 else
20339 {
20340 bCMAInitPool[1] = TRUE;
20341 /*
20342 BALANCE_BW CMA ID=20, and always start from 0
20343 if(pInitParam->SysConfig.u32FrameBufAddr != 0)
20344 {
20345 MS_PHY temp_addr;
20346 _miu_offset_to_phy(pVdecExContext->cmaInitParam[1].miu,
20347 pVdecExContext->cmaInitParam[1].heap_miu_start_offset,
20348 temp_addr);
20349
20350 unUseSize = pInitParam->SysConfig.u32FrameBufAddr - temp_addr;
20351 }*/
20352
20353 VPRINTF("[VDEC][%d] MApi_CMA_Pool_Init[1]: pool_handle_id=%x, miu=%d, offset=%llx, length=%x , FrameBuffer=%llx, unUseSize=%x\n",
20354 (unsigned int)u8Idx,
20355 (unsigned int)pVdecExContext->cmaInitParam[1].pool_handle_id,
20356 (unsigned int)pVdecExContext->cmaInitParam[1].miu,
20357 (unsigned long long int)pVdecExContext->cmaInitParam[1].heap_miu_start_offset,
20358 (unsigned int)pVdecExContext->cmaInitParam[1].heap_length,
20359 (unsigned long long int)pInitParam->SysConfig.u32FrameBufAddr,
20360 (unsigned int)unUseSize);
20361 }
20362 }
20363 #endif
20364 }
20365
20366 #if (VDEC_EX_ISR_MONITOR)
20367 //if (FALSE == pVdecExContext->_Attr[u8Idx].stEventMon.bIsSysEnable)
20368 {
20369 if (FALSE == _VDEC_EX_SYS_Init(u8Idx))
20370 {
20371 return E_VDEC_EX_FAIL;
20372 }
20373 //pVdecExContext->_Attr[u8Idx].stEventMon.bIsSysEnable = TRUE;
20374 }
20375 #else
20376 //_VDEC_EX_MutexInit(u8Idx);
20377 #endif
20378
20379 if(bNDecAllocator == FALSE)
20380 {
20381 #ifdef CMA_DRV_DIRECT_INIT
20382 if (pVdecExContext->bCMAUsed && bCMAInitPool[0] && u8Idx == 0 && (pVdecExContext->_power_state[u8Idx] != E_VDEC_EX_POWER_RESUME_ING))
20383 {
20384 struct CMA_Pool_Alloc_Param alloc_param;
20385
20386 memset(&alloc_param,0,sizeof(struct CMA_Pool_Alloc_Param));
20387
20388 alloc_param.pool_handle_id = pVdecExContext->cmaInitParam[0].pool_handle_id;
20389 alloc_param.flags = CMA_FLAG_VIRT_ADDR;
20390 MS_BOOL result = MDrv_HVD_EX_GetCMAMemSize(
20391 pVdecExContext->_Attr[u8Idx].eCodecType, pVdecExContext->_Attr[u8Idx].eSrcMode,
20392 &alloc_param.offset_in_pool, &alloc_param.length, pVdecExContext->cmaInitParam[0].heap_length, unUseSize);
20393
20394 #if VDEC_DUAL_FRAME_BUFFER_MANAGEMENT
20395 alloc_param.length = pVdecExContext->cmaInitParam[0].heap_length - unUseSize;
20396 #endif
20397
20398 if( result == FALSE )
20399 {
20400 VPRINTF("[%s][%d]CMA FB resource is not enough\n",__FUNCTION__,__LINE__);
20401 return E_VDEC_EX_FAIL;
20402 }
20403
20404 if(pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize != 0)
20405 {
20406 if(pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize > alloc_param.length )
20407 {
20408 VPRINTF("[VDEC][%d][CMA]u32FrameBufSize is not 0\n",(unsigned int)u8Idx);
20409 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = alloc_param.length;
20410 }
20411 else //using min value to setup frame buffer from cma
20412 {
20413 VPRINTF("[VDEC][%d][CMA]u32FrameBufSize is not 0 and small than cma length\n",(unsigned int)u8Idx);
20414 alloc_param.length = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize;
20415 }
20416 }
20417 else //frame buffer size = 0 , using minimun size as frame buffer size, the alloc_param.length already be decided as min value
20418 {
20419 VPRINTF("[VDEC][%d][CMA]u32FrameBufSize is 0\n",(unsigned int)u8Idx);
20420 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = alloc_param.length;
20421 }
20422
20423 if (pVdecExContext->bCMAGetMem[0][u8Idx] == FALSE)
20424 {
20425 pVdecExContext->bCMAGetMem[0][u8Idx] = TRUE;
20426 if (MApi_CMA_Pool_GetMem(&alloc_param) == FALSE)
20427 {
20428 pVdecExContext->bCMAGetMem[0][u8Idx] = FALSE;
20429 VPRINTF("[%s][%d]CMA GET fail\n",__FUNCTION__,__LINE__);
20430 return E_VDEC_EX_FAIL;
20431 }
20432 else
20433 {
20434 VPRINTF("[VDEC][%d]MApi_CMA_Pool_GetMem0: alloc_param.pool_handle_id=%x, alloc_param.flags=%x, alloc_param.offset_in_pool=%llx, alloc_param.length=%x\n",
20435 (unsigned int)u8Idx,
20436 (unsigned int)alloc_param.pool_handle_id,
20437 (unsigned int)alloc_param.flags,
20438 (unsigned long long int)alloc_param.offset_in_pool,
20439 (unsigned int)alloc_param.length);
20440 }
20441 }
20442
20443 pVdecExContext->cmaFreeParam[0][u8Idx].pool_handle_id = pVdecExContext->cmaInitParam[0].pool_handle_id;
20444 pVdecExContext->cmaFreeParam[0][u8Idx].offset_in_pool = alloc_param.offset_in_pool;
20445 pVdecExContext->cmaFreeParam[0][u8Idx].length = alloc_param.length;
20446
20447 _miu_offset_to_phy(pVdecExContext->cmaInitParam[0].miu,
20448 pVdecExContext->cmaInitParam[0].heap_miu_start_offset + alloc_param.offset_in_pool,
20449 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr);
20450 #if 0
20451 if(pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize != 0)
20452 {
20453 if(pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize > alloc_param.length )
20454 {
20455 VPRINTF("[VDEC][%d][CMA]u32FrameBufSize is not 0\n",(unsigned int)u8Idx);
20456 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = alloc_param.length;
20457 }
20458 }
20459 else
20460 {
20461 VPRINTF("[VDEC][%d][CMA]u32FrameBufSize is 0 \n",(unsigned int)u8Idx);
20462 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = alloc_param.length;
20463 }
20464 #endif
20465 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = alloc_param.length;
20466 }
20467 #endif
20468
20469 #if VDEC_DUAL_FRAME_BUFFER_MANAGEMENT
20470 VDEC_EX_CodecType eCodecType = pVdecExContext->_Attr[u8Idx].eCodecType;
20471 VDEC_EX_Decoder eDecoder = pVdecExContext->_Attr[u8Idx].eDecoder;
20472 MS_BOOL bTaskIsMVD = (eDecoder==E_VDEC_EX_DECODER_MVD)?(TRUE):(FALSE);
20473 MS_BOOL bTaskIsHVD = ((eDecoder==E_VDEC_EX_DECODER_HVD)&&(eCodecType!=E_VDEC_EX_CODEC_TYPE_HEVC)&&(eCodecType!=E_VDEC_EX_CODEC_TYPE_VP9))?(TRUE):(FALSE);
20474 MS_BOOL bTaskIsMJPEG = (eDecoder==E_VDEC_EX_DECODER_MJPEG)?(TRUE):(FALSE);
20475 MS_BOOL bCodecIsVP8 = (eCodecType==E_VDEC_EX_CODEC_TYPE_VP8)?(TRUE):(FALSE);
20476
20477 MS_U8 u8AnoIdx = 1 - u8Idx;
20478 VDEC_EX_CodecType eAnoCodecType = pVdecExContext->_Attr[u8AnoIdx].eCodecType;
20479 VDEC_EX_Decoder eAnoDecoder = pVdecExContext->_Attr[u8AnoIdx].eDecoder;
20480 MS_BOOL bAnoTaskIsMVD = (eAnoDecoder==E_VDEC_EX_DECODER_MVD)?(TRUE):(FALSE);
20481 MS_BOOL bAnoTaskIsHVD = ((eAnoDecoder==E_VDEC_EX_DECODER_HVD)&&(eAnoCodecType!=E_VDEC_EX_CODEC_TYPE_HEVC)&&(eAnoCodecType!=E_VDEC_EX_CODEC_TYPE_VP9))?(TRUE):(FALSE);
20482 MS_BOOL bAnoTaskIsEVD = (eAnoCodecType==E_VDEC_EX_CODEC_TYPE_HEVC) || (eAnoCodecType==E_VDEC_EX_CODEC_TYPE_VP9);
20483
20484 MS_U8 u8MiuSel;
20485 MS_U8 u8IdxSel;
20486 MS_U32 u32StartOffset;
20487 _phy_to_miu_offset(u8MiuSel, u32StartOffset, pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr);
20488 pVdecExContext->_stFBMng[u8Idx].u8Miu = u8MiuSel;
20489
20490 pVdecExContext->_stFBMng[u8Idx].u32FrameBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr;
20491 pVdecExContext->_stFBMng[u8Idx].u32FrameBufSize = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize;
20492
20493 // dispatch eLocation and frame buffer
20494 if (pVdecExContext->_stFBMng[u8Idx].u32FrameBufSize >= FBMNG_AVC4K_SIZE)
20495 {
20496 if (pVdecExContext->_Attr[u8AnoIdx].bUsed)
20497 {
20498 if(bTaskIsMJPEG || bCodecIsVP8)
20499 {
20500 VDEC_EX_FB_LOCATION eAnoLocation = pVdecExContext->_stFBMng[u8AnoIdx].eLocation;
20501 MS_U8 u8AnoIdxSel = (eAnoLocation & FBLOC_TASK_FB_MASK)?(1):(0);
20502
20503 if((bAnoTaskIsEVD && pVdecExContext->_stFBMng[u8AnoIdxSel].u8Miu == 1) ||
20504 (bAnoTaskIsHVD && pVdecExContext->_stFBMng[u8AnoIdxSel].u8Miu == 0 && bCodecIsVP8))
20505 {
20506 _VDEC_EX_API_MutexLock();
20507 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20508 _VDEC_EX_API_MutexUnlock();
20509 VDEC_ERR("[VDEC][%s][%d] VP8 or MJPEG FB must use MIU1\n", __FUNCTION__, __LINE__);
20510 return E_VDEC_EX_FAIL;
20511 }
20512 else
20513 {
20514 if(pVdecExContext->_stFBMng[u8AnoIdxSel].u8Miu == 1)
20515 {
20516 pVdecExContext->_stFBMng[u8Idx].eLocation = eAnoLocation^FBLOC_FRONT_TAIL_MASK;
20517 u8IdxSel = ((pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_TASK_FB_MASK)?(1):(0);
20518
20519 if (pVdecExContext->_stFBMng[u8Idx].eLocation & FBLOC_FRONT_TAIL_MASK) //tail
20520 {
20521 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufAddr + FBMNG_AVC4K_SIZE;
20522 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufSize - FBMNG_AVC4K_SIZE;
20523 }
20524 else //front
20525 {
20526 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufAddr;
20527 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = FBMNG_AVC4K_SIZE;
20528 }
20529 }
20530 else
20531 {
20532 pVdecExContext->_stFBMng[u8Idx].eLocation = eAnoLocation^FBLOC_TASK_FB_MASK;
20533 pVdecExContext->_stFBMng[u8Idx].eLocation = (pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_FORCE_FRONT_MASK; //force front
20534
20535 u8IdxSel = ((pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_TASK_FB_MASK)?(1):(0);
20536
20537 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufAddr;
20538 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = FBMNG_AVC4K_SIZE;
20539 }
20540 }
20541 }
20542 else
20543 {
20544 if (pVdecExContext->_stFBMng[u8Idx].u8Miu != pVdecExContext->_stFBMng[u8AnoIdx].u8Miu)
20545 {
20546 if ((bTaskIsMVD && bAnoTaskIsMVD) || (bTaskIsHVD && bAnoTaskIsHVD)) // allocate from the same frame buffer of another task
20547 {
20548 if (pVdecExContext->_stFBMng[u8AnoIdx].eLocation != E_VDEC_EX_FB_NONE)
20549 {
20550 pVdecExContext->_stFBMng[u8Idx].eLocation = (pVdecExContext->_stFBMng[u8AnoIdx].eLocation)^FBLOC_FRONT_TAIL_MASK;
20551 u8IdxSel = ((pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_TASK_FB_MASK)?(1):(0);
20552
20553 if (pVdecExContext->_stFBMng[u8Idx].eLocation & FBLOC_FRONT_TAIL_MASK) //tail
20554 {
20555 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufAddr + FBMNG_AVC4K_SIZE;
20556 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufSize - FBMNG_AVC4K_SIZE;
20557 }
20558 else //front
20559 {
20560 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufAddr;
20561 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = FBMNG_AVC4K_SIZE;
20562 }
20563 }
20564 else
20565 {
20566 VDEC_PRINT("[%s][%d] The behavior of FrameBuffer Allocation is abnormal \n", __FUNCTION__, __LINE__);
20567 }
20568 }
20569 else if (bTaskIsMVD || bTaskIsHVD)
20570 {
20571 pVdecExContext->_stFBMng[u8Idx].eLocation = (pVdecExContext->_stFBMng[u8AnoIdx].eLocation)^FBLOC_TASK_FB_MASK;
20572 pVdecExContext->_stFBMng[u8Idx].eLocation = (pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_FORCE_FRONT_MASK; //force front
20573
20574 u8IdxSel = ((pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_TASK_FB_MASK)?(1):(0);
20575
20576 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufAddr;
20577 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = FBMNG_AVC4K_SIZE;
20578 }
20579 else
20580 {
20581 pVdecExContext->_stFBMng[u8Idx].eLocation = (pVdecExContext->_stFBMng[u8AnoIdx].eLocation)^FBLOC_TASK_FB_MASK;
20582 pVdecExContext->_stFBMng[u8Idx].eLocation = (pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_FORCE_FRONT_MASK; //force front
20583
20584 u8IdxSel = ((pVdecExContext->_stFBMng[u8Idx].eLocation)&FBLOC_TASK_FB_MASK)?(1):(0);
20585
20586 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pVdecExContext->_stFBMng[u8IdxSel].u32FrameBufAddr;
20587 }
20588 }
20589 else
20590 {
20591 VDEC_PRINT("[%s][%d] Two frame buffer on the same miu, no need to run FrameBuffer Allocation \n", __FUNCTION__, __LINE__);
20592 }
20593 }
20594 }
20595 else
20596 {
20597 if (bTaskIsMVD || bTaskIsHVD || bTaskIsMJPEG) // allocate front for MVD/HVD/MJPEG
20598 {
20599 pVdecExContext->_stFBMng[u8Idx].eLocation = (u8Idx)?(E_VDEC_EX_FB1_FRONT):(E_VDEC_EX_FB0_FRONT); //front
20600 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = FBMNG_AVC4K_SIZE;
20601 }
20602 else // EVD use the whole FB, marked as front
20603 {
20604 pVdecExContext->_stFBMng[u8Idx].eLocation = (u8Idx)?(E_VDEC_EX_FB1_FRONT):(E_VDEC_EX_FB0_FRONT); //front
20605 }
20606 }
20607 }
20608 else
20609 {
20610 VDEC_PRINT("[%s][%d] Two frame buffer on the same miu, no need to run FrameBuffer Allocation \n", __FUNCTION__, __LINE__);
20611 }
20612
20613 VDEC_PRINT("VDEC FBMng0 0x%x, 0x%x, 0x%x \n", pVdecExContext->_stFBMng[0].eLocation, (MS_U32)(pVdecExContext->_stFBMng[0].u32FrameBufAddr), pVdecExContext->_stFBMng[0].u32FrameBufSize);
20614 VDEC_PRINT("VDEC FBMng1 0x%x, 0x%x, 0x%x \n", pVdecExContext->_stFBMng[1].eLocation, (MS_U32)(pVdecExContext->_stFBMng[1].u32FrameBufAddr), pVdecExContext->_stFBMng[1].u32FrameBufSize);
20615 VDEC_PRINT("VDEC FB Used 0x%x, 0x%x \n", (MS_U32)(pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr), pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize);
20616 #endif
20617 }
20618 else
20619 {
20620 VDEC_EX_Allocator_Block *pstBlockFB1 = NULL, *pstBlockBS = NULL;
20621 VDEC_EX_Result eRet;
20622 VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType;
20623 VDEC_EX_NDecBufRangeParam stBufRgnFB1, stBufRgnBS;
20624
20625 _VDEC_EX_API_MutexLock();
20626
20627 // frame Buffer 1 allocating setting
20628
20629 eBufType = E_VDEC_EX_ALLOCATOR_BUFFER_FB1;
20630
20631 _VDEC_Memset(&stBufRgnFB1, 0, sizeof(VDEC_EX_NDecBufRangeParam));
20632 if(pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB1.bSetTotalBuf == TRUE)
20633 {
20634 stBufRgnFB1.bSetTotalBuf = TRUE;
20635 stBufRgnFB1.phyTotalBufAddr = pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB1.phyTotalBufAddr;
20636 stBufRgnFB1.szTotalBufSize = pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB1.szTotalBufSize;
20637 }
20638 stBufRgnFB1.phyBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr;
20639 stBufRgnFB1.szBufSize = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize;
20640
20641 // start allocating frame buffer 1
20642
20643 eRet = _VDEC_EX_NdecAllocator_MallocFrameBuffer(u8Idx, eBufType, &stBufRgnFB1, &pstBlockFB1);
20644 if(eRet != E_VDEC_EX_OK)
20645 {
20646 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20647 _VDEC_EX_API_MutexUnlock();
20648 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d][%d] Alloc Frame Buffer Fail\n", __FUNCTION__, __LINE__, u8Idx);
20649 return E_VDEC_EX_FAIL;
20650 }
20651 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr = pstBlockFB1->stBlockInfo.phyAddr;
20652 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize = pstBlockFB1->stBlockInfo.szSize;
20653
20654 // bitstream Buffer allocating setting
20655
20656 eBufType = E_VDEC_EX_ALLOCATOR_BUFFER_BS;
20657
20658 _VDEC_Memset(&stBufRgnBS, 0, sizeof(VDEC_EX_NDecBufRangeParam));
20659 if(pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnBS.bSetTotalBuf == TRUE)
20660 {
20661 stBufRgnBS.bSetTotalBuf = TRUE;
20662 stBufRgnBS.phyTotalBufAddr = pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnBS.phyTotalBufAddr;
20663 stBufRgnBS.szTotalBufSize = pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnBS.szTotalBufSize;
20664 }
20665 stBufRgnBS.phyBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufAddr;
20666 stBufRgnBS.szBufSize = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufSize;
20667
20668 // start allocating bitstream buffer
20669
20670 eRet = _VDEC_EX_NdecAllocator_MallocBitstreamBuffer(u8Idx, eBufType, &stBufRgnBS, &pstBlockBS);
20671 if(eRet != E_VDEC_EX_OK)
20672 {
20673 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20674 _VDEC_EX_API_MutexUnlock();
20675 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d][%d] Alloc Bitstream Buffer Fail\n", __FUNCTION__, __LINE__, u8Idx);
20676 return E_VDEC_EX_FAIL;
20677 }
20678 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufAddr = pstBlockBS->stBlockInfo.phyAddr;
20679 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufSize = pstBlockBS->stBlockInfo.szSize;
20680
20681 if(_VDEC_EX_NdecAllocator_IsNDecode() == TRUE)
20682 {
20683 MS_PHY phyBSTotalAddrStart = 0;
20684 MS_SIZE szBSToltalSize = 0;
20685
20686 if(stBufRgnBS.bSetTotalBuf == TRUE)
20687 {
20688 phyBSTotalAddrStart = stBufRgnBS.phyTotalBufAddr;
20689 szBSToltalSize = stBufRgnBS.szTotalBufSize;
20690 }
20691 else
20692 {
20693 eRet = _VDEC_EX_NdecAllocator_GetBitstreamBufferTotalAddrSize(&phyBSTotalAddrStart, &szBSToltalSize);
20694 if(eRet != E_VDEC_EX_OK)
20695 {
20696 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20697 _VDEC_EX_API_MutexUnlock();
20698 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d][%d] Get Total BS AddrSize Fail\n", __FUNCTION__, __LINE__, u8Idx);
20699 return E_VDEC_EX_FAIL;
20700 }
20701 }
20702
20703 _MApi_VDEC_EX_BS_Init(phyBSTotalAddrStart, szBSToltalSize);
20704
20705 VPRINTF("[ALLOC][DBG][%s][%d][%d] BSTotalAddrStart=0x%llx, BSToltalSize=0x%x\n", __FUNCTION__, __LINE__, u8Idx,
20706 phyBSTotalAddrStart, szBSToltalSize);
20707 }
20708 VPRINTF("[ALLOC][DBG][%s][%d][%d] FB=0x%llx, Size=0x%x\n", __FUNCTION__, __LINE__, u8Idx,
20709 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr,
20710 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize);
20711 VPRINTF("[ALLOC][DBG][%s][%d][%d] BS=0x%llx, Size=0x%x\n", __FUNCTION__, __LINE__, u8Idx,
20712 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufAddr,
20713 pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufSize);
20714
20715 _VDEC_EX_API_MutexUnlock();
20716 }
20717
20718 //Check HW capability
20719 if(pInitParam->EnableDynaScale)
20720 {
20721 MS_U32 u32Caps = 0;
20722 cap = E_VDEC_EX_CAP_XC_NOT_SUPPORT_DS;
20723 if(E_VDEC_EX_OK == _VDEC_EX_GetCaps(cap, &u32Caps))
20724 {
20725 if(u32Caps)
20726 {
20727 VDEC_PRINT("VDEC_EX Warn: DS unsupported! Force EnableDynaScale as FALSE.\n");
20728 pInitParam->EnableDynaScale = FALSE;
20729 pVdecExContext->_Attr[u8Idx].vdecExInitParam.EnableDynaScale = FALSE;
20730 }
20731 }
20732 }
20733
20734 // init debug message
20735 _VDEC_EX_SetDbgLevel(pStreamId, pVdecExContext->_Attr[u8Idx].eDbgMsgLevel);
20736
20737 #if VDEC_ENABLE_LINK_WEAK_SYMBOL
20738 // it is critical very any nos compile envi
20739 _VDEC_LinkWeakSymbolPatch();
20740 #endif
20741
20742 _VDEC_EX_API_MutexLock();
20743
20744 if(bSecureModeEnable == TRUE)
20745 {
20746 SYS_TEEINFO teemode;
20747 MDrv_SYS_ReadKernelCmdLine();
20748 MDrv_SYS_GetTEEInfo(&teemode);
20749 VPRINTF("[VDEC][TEE/OPTEE]%s,TEEmode_type=%d\n",__FUNCTION__,teemode.OsType);
20750
20751 if(teemode.OsType == SYS_TEEINFO_OSTYPE_OPTEE)
20752 {
20753 VPRINTF("[VDEC][OPTEE]Send Loadcode command\n");
20754 if(_MApi_VDEC_EX_V2_Send_OPTEE_CMD(E_VDEC_EX_OPTEE_LOADCODE,NULL,0) == FALSE)
20755 {
20756 VPRINTF("[VDEC][OPTEE]Loadcode command fail\n");
20757 return E_VDEC_EX_FAIL;
20758 }
20759
20760 VDEC_EX_OPTEE_SecureBuffer SecureBuffer;
20761 SecureBuffer.VPUBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32CodeBufAddr;
20762 SecureBuffer.VPUBufSize = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32CodeBufSize;
20763 SecureBuffer.BSBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufAddr;
20764 SecureBuffer.BSBufSize = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufSize;
20765 SecureBuffer.FBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr;
20766 SecureBuffer.FBufSize = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize;
20767 SecureBuffer.u32streamID = pStreamId->u32Id;
20768 SecureBuffer.eCodecType = pVdecExContext->_Attr[u8Idx].eCodecType;
20769
20770 VPRINTF("[VDEC][OPTEE]Send Set Buffer command\n");
20771 if(_MApi_VDEC_EX_V2_Send_OPTEE_CMD(E_VDEC_EX_OPTEE_SECURE_BUFFER,&SecureBuffer,sizeof(SecureBuffer)) == FALSE)
20772 {
20773 VPRINTF("[VDEC][OPTEE]Set Buffer command fail\n");
20774 return E_VDEC_EX_FAIL;
20775 }
20776 }
20777 }
20778
20779 _VDEC_EX_SetDecodeMode(pStreamId, &(pVdecExContext->_Pre_DecModeCfg));
20780
20781 if (pVdecExContext->bTurboMode)
20782 {
20783 bNotReloadFW = TRUE;
20784 }
20785
20786 if (pVdecExContext->_bSingleDecodeMode == TRUE)
20787 {
20788 _VDEC_EX_HandleSingleDecodeMode(pVdecExContext->_Attr[u8Idx].eDecoder);
20789 }
20790
20791 _VDEC_EX_API_MutexUnlock();
20792
20793 switch (pVdecExContext->_Attr[u8Idx].eDecoder)
20794 {
20795 case E_VDEC_EX_DECODER_MVD:
20796 _RET_VDEC_MVD_LINT_CHECK_AND_RETURN_MUTEX();
20797 {
20798 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_INIT;
20799 MVD_RecordStreamId(u32Id);
20800
20801 if (pVdecExContext->_Pre_Ctrl[u8Idx].bHWBufferReMapping)
20802 {
20803 MDrv_MVD_HWBuffer_ReMappingMode(u32Id,pVdecExContext->_Pre_Ctrl[u8Idx].bHWBufferReMapping);
20804 }
20805
20806 #ifdef VDEC3
20807 VDEC_EX_SysCfg cfg = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig;
20808 #else
20809 VDEC_EX_SysCfg cfg = pInitParam->SysConfig;
20810 #endif
20811 MVD_FWCfg fwCfg;
20812 MVD_MEMCfg memCfg;
20813 MVD_CodecType eMvdCodecType = E_MVD_CODEC_UNKNOWN;
20814 MVD_SrcMode eMvdSrcMode;
20815 MVD_TIMESTAMP_TYPE eSyncType = E_MVD_TIMESTAMP_FREERUN;
20816 //MS_BOOL bHDmode = TRUE;
20817 // check codec type
20818 eMvdCodecType = _VDEC_EX_Map2MVDCodecType(pVdecExContext->_Attr[u8Idx].eCodecType);
20819 if (eMvdCodecType == E_MVD_CODEC_UNKNOWN)
20820 {
20821 _VDEC_EX_API_MutexLock();
20822 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20823 _VDEC_EX_API_MutexUnlock();
20824 //VDEC_PRINT("%s(%d): Unknown eMvdCodecType!\n", __FUNCTION__, __LINE__);
20825 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20826 return E_VDEC_EX_FAIL;
20827 }
20828
20829 // check source type
20830 eMvdSrcMode = _VDEC_EX_Map2MVDSrcMode(pVdecExContext->_Attr[u8Idx].eSrcMode);
20831 if ((eMvdSrcMode == 0xff) || (eMvdSrcMode >= MVD_SRCMODE_MAX))
20832 {
20833 _VDEC_EX_API_MutexLock();
20834 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20835 _VDEC_EX_API_MutexUnlock();
20836 //VDEC_PRINT("%s(%d): Invalid eMvdSrcMode!\n", __FUNCTION__, __LINE__);
20837 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20838 return E_VDEC_EX_FAIL;
20839 }
20840
20841 _VDEC_Memset(&fwCfg, 0, sizeof(MVD_FWCfg));
20842 _VDEC_Memset(&memCfg, 0, sizeof(MVD_MEMCfg));
20843
20844 fwCfg.eCodecType = eMvdCodecType;
20845 fwCfg.eSrcMode = eMvdSrcMode;
20846 fwCfg.bDisablePESParsing = bMvdParserDisable[eMvdSrcMode];
20847 fwCfg.bNotReload = bNotReloadFW; //TRUE for not load fw more than once
20848 fwCfg.stFBReduction.LumaFBReductionMode = (MVD_FB_Reduction_Type)pInitParam->stFBReduction.eLumaFBReduction;
20849 fwCfg.stFBReduction.ChromaFBReductionMode = (MVD_FB_Reduction_Type)pInitParam->stFBReduction.eChromaFBReduction;
20850 memCfg.eFWSrcType = (MVD_FWSrcType)cfg.eFWSourceType;
20851 memCfg.u32FWBinAddr = cfg.u32FWBinaryAddr;
20852 memCfg.u32FWBinSize = cfg.u32FWBinarySize;
20853 memCfg.u32FWCodeAddr = cfg.u32CodeBufAddr;
20854 memCfg.u32FWCodeSize = cfg.u32CodeBufSize;
20855 memCfg.u32FBAddr = cfg.u32FrameBufAddr;
20856 memCfg.u32FBSize = cfg.u32FrameBufSize;
20857 #if v3_thinplayer//def VDEC3
20858 if (pVdecExContext->bDRVdecideBS)
20859 {
20860 memCfg.u32BSAddr=pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufAddr;
20861 memCfg.u32BSSize=pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32BitstreamBufSize;
20862 }
20863 #else
20864 memCfg.u32BSAddr = cfg.u32BitstreamBufAddr;
20865 memCfg.u32BSSize = cfg.u32BitstreamBufSize;
20866 #endif
20867 memCfg.u32DrvBufAddr = cfg.u32DrvProcBufAddr;
20868 memCfg.u32DrvBufSize = cfg.u32DrvProcBufSize;
20869 memCfg.bEnableDynScale = pInitParam->EnableDynaScale;
20870 // memCfg.bSupportSDModeOnly = !bHDmode;
20871
20872 //the very first step: Get register base addr
20873 //notice: must do this first before accessing any register.
20874 MS_PHY u32NonPMBankSize;
20875 MS_VIRT u32NonPMBankAddr = 0;
20876 if (!MDrv_MMIO_GetBASE(&u32NonPMBankAddr, &u32NonPMBankSize, MS_MODULE_MVD))
20877 {
20878 _VDEC_EX_API_MutexLock();
20879 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20880 _VDEC_EX_API_MutexUnlock();
20881 VDEC_PRINT("_MVD_Init: IOMap failure\n");
20882 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20883 return E_VDEC_EX_FAIL;
20884 }
20885 else
20886 {
20887 MDrv_HVD_EX_SetOSRegBase(u32NonPMBankAddr);
20888 MDrv_MVD_RegSetBase(u32NonPMBankAddr);
20889 //VDEC_PRINT("_MVD_Init: u32RiuBaseAdd = %lx\n", u32NonPMBankAddr);
20890 }
20891
20892 if(MDrv_MVD_SetCfg(u32Id, &fwCfg, &memCfg) != E_MVD_RET_OK)
20893 {
20894 _VDEC_EX_API_MutexLock();
20895 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20896 _VDEC_EX_API_MutexUnlock();
20897 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20898 return E_VDEC_EX_FAIL;
20899 }
20900
20901
20902
20903 if (!MDrv_MVD_Init(u32Id,fwCfg.eCodecType))
20904 {
20905 _VDEC_EX_API_MutexLock();
20906 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20907 _VDEC_EX_API_MutexUnlock();
20908 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20909 return E_VDEC_EX_FAIL;
20910 }
20911
20912 if(MDrv_MVD_SetCodecInfo(u32Id, eMvdCodecType, eMvdSrcMode, bMvdParserDisable[eMvdSrcMode]) == FALSE)
20913 {
20914 return E_VDEC_EX_FAIL;
20915 }
20916
20917 if (eMvdSrcMode == E_MVD_TS_FILE_MODE)
20918 {
20919 MS_U32 u32bsBufUnderflowTH = ((((cfg.u32BitstreamBufSize*15)/16)>>3)<<3);
20920 MS_U32 u32bsBufOverflowTH = (((cfg.u32BitstreamBufSize-0x4000)>>3)<<3); //16K
20921 MDrv_MVD_SetUnderflowTH(u32Id, u32bsBufUnderflowTH);
20922 MDrv_MVD_SetOverflowTH(u32Id, u32bsBufOverflowTH);
20923 }
20924
20925 if (FALSE == MDrv_MVD_DropErrorFrame(u32Id, !pInitParam->bDisableDropErrFrame))
20926 {
20927 _VDEC_EX_API_MutexLock();
20928 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20929 _VDEC_EX_API_MutexUnlock();
20930 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20931 return E_VDEC_EX_FAIL;
20932 }
20933 pVdecExContext->bDropErrFrm[u8Idx] = (!pInitParam->bDisableDropErrFrame);
20934
20935 if (FALSE == MDrv_MVD_DispRepeatField(u32Id, pInitParam->bRepeatLastField))
20936 {
20937 _VDEC_EX_API_MutexLock();
20938 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20939 _VDEC_EX_API_MutexUnlock();
20940 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20941 return E_VDEC_EX_FAIL;
20942 }
20943
20944 MDrv_MVD_DisableErrConceal(u32Id, !pInitParam->bDisableErrConceal);
20945 /*
20946 E_MVD_Result ret = MDrv_MVD_DisableErrConceal(pInitParam->bDisableErrConceal);
20947
20948
20949 if (E_MVD_RET_OK != ret)
20950 {
20951 return E_VDEC_EX_FAIL;
20952 }
20953 */
20954
20955 MDrv_MVD_SetVirtualBox(u32Id, pInitParam->u32DSVirtualBoxWidth, pInitParam->u32DSVirtualBoxHeight);
20956
20957 if (eMvdSrcMode == E_MVD_SLQ_TBL_MODE || eMvdSrcMode == E_MVD_TS_FILE_MODE)
20958 {
20959 if (E_VDEC_EX_TIME_STAMP_DTS == pInitParam->VideoInfo.eTimeStampType)
20960 {
20961 eSyncType = E_MVD_TIMESTAMP_DTS;
20962 }
20963 else if (E_VDEC_EX_TIME_STAMP_PTS == pInitParam->VideoInfo.eTimeStampType)
20964 {
20965 eSyncType = E_MVD_TIMESTAMP_PTS;
20966 }
20967 else if (E_VDEC_EX_TIME_STAMP_DTS_MPEG_DIRECTV_SD == pInitParam->VideoInfo.eTimeStampType)
20968 {
20969 eSyncType = E_MVD_TIMESTAMP_DTS_RVU;
20970 }
20971 else if (E_VDEC_EX_TIME_STAMP_PTS_MPEG_DIRECTV_SD == pInitParam->VideoInfo.eTimeStampType)
20972 {
20973 eSyncType = E_MVD_TIMESTAMP_PTS_RVU;
20974 }
20975 else if (E_VDEC_EX_TIME_STAMP_STS == pInitParam->VideoInfo.eTimeStampType)
20976 {
20977 eSyncType = E_MVD_TIMESTAMP_NEW_STS;
20978 //eSyncType = E_MVD_TIMESTAMP_STS;
20979 }
20980 else if (E_VDEC_EX_TIME_STAMP_NONE == pInitParam->VideoInfo.eTimeStampType)
20981 {
20982 eSyncType = E_MVD_TIMESTAMP_FREERUN;
20983 }
20984 else
20985 {
20986 _VDEC_EX_API_MutexLock();
20987 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20988 _VDEC_EX_API_MutexUnlock();
20989 VDEC_PRINT("Invalid sync type %d for MVD\n", pInitParam->VideoInfo.eTimeStampType);
20990 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20991 return E_VDEC_EX_FAIL;
20992 }
20993 if (FALSE == MDrv_MVD_SetFileModeAVSync(u32Id, eSyncType))
20994 {
20995 _VDEC_EX_API_MutexLock();
20996 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
20997 _VDEC_EX_API_MutexUnlock();
20998 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
20999 return E_VDEC_EX_FAIL;
21000 }
21001 }
21002
21003 if ((eMvdSrcMode == E_MVD_TS_FILE_MODE)||(eMvdSrcMode == E_MVD_SLQ_TBL_MODE))
21004 { //set up MVD for MediaCodec playback
21005 _VDEC_EX_MVDCfgDivX(u32Id, pVdecExContext->_Attr[u8Idx].eCodecType);
21006
21007 if (eMvdCodecType == E_MVD_CODEC_DIVX311)
21008 {
21009 MVD_FrameInfo stFrminfo;
21010 _VDEC_Memset(&stFrminfo, 0, sizeof(MVD_FrameInfo));
21011 stFrminfo.u16HorSize = pInitParam->VideoInfo.u16Width[0];
21012 stFrminfo.u16VerSize = pInitParam->VideoInfo.u16Height[0];
21013 if(pInitParam->VideoInfo.u32FrameRateBase == 0)
21014 {
21015 VDEC_PRINT("Invalid FrameRate base!\n");
21016 pInitParam->VideoInfo.u32FrameRateBase = 1;
21017 }
21018 #ifdef MSOS_TYPE_LINUX_KERNEL
21019 MS_U64 u64Tmp = (MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000;
21020 do_div(u64Tmp, pInitParam->VideoInfo.u32FrameRateBase);
21021 stFrminfo.u32FrameRate = (MS_U32)u64Tmp;
21022 #else
21023 stFrminfo.u32FrameRate =
21024 (MS_U32)(((MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000) / pInitParam->VideoInfo.u32FrameRateBase);
21025 #endif
21026 #if 0
21027 VDEC_PRINT("==>DivX311 w=0x%x h=0x%x fr=0x%lx,0x%lx\n",
21028 pInitParam->VideoInfo.u16Width[0],pInitParam->VideoInfo.u16Height[0],
21029 pInitParam->VideoInfo.u32FrameRate, pInitParam->VideoInfo.u32FrameRateBase);
21030 VDEC_PRINT("==>DivX311 w=0x%x h=0x%x fr=%ld\n",
21031 stFrminfo.u16HorSize, stFrminfo.u16VerSize, stFrminfo.u32FrameRate);
21032 #endif
21033 MDrv_MVD_SetFrameInfo(u32Id, &stFrminfo);
21034 }
21035 else if (eMvdCodecType != E_MVD_CODEC_MPEG2)
21036 {
21037 MVD_FrameInfo stFrminfo1;
21038 _VDEC_Memset(&stFrminfo1, 0, sizeof(MVD_FrameInfo));
21039 if(pInitParam->VideoInfo.u32FrameRateBase == 0)
21040 {
21041 VDEC_PRINT("Invalid FrameRate base\n");
21042 pInitParam->VideoInfo.u32FrameRateBase = 1;
21043 }
21044 #ifdef MSOS_TYPE_LINUX_KERNEL
21045 MS_U64 u64Tmp = (MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000;
21046 do_div(u64Tmp, pInitParam->VideoInfo.u32FrameRateBase);
21047 stFrminfo1.u32FrameRate = (MS_U32)u64Tmp;
21048 #else
21049 stFrminfo1.u32FrameRate =
21050 (MS_U32)(((MS_U64)pInitParam->VideoInfo.u32FrameRate * 1000) / pInitParam->VideoInfo.u32FrameRateBase);
21051 #endif
21052 MDrv_MVD_SetFrameInfo(u32Id, &stFrminfo1);
21053 }
21054
21055 if (MDrv_MVD_SkipToIFrame(u32Id) != TRUE)
21056 {
21057 _VDEC_EX_API_MutexLock();
21058 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21059 _VDEC_EX_API_MutexUnlock();
21060 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
21061 return E_VDEC_EX_FAIL;
21062 }
21063 }
21064 //mvd Temp solution will remove when mvd ok in future
21065 if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode != 0xFF)
21066 {
21067 if (pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode == E_VDEC_EX_DISPLAY_MODE_MCU)
21068 {
21069 pVdecExContext->u32FrameBaseMode[u8Idx] = TRUE;
21070 MDrv_MVD_SetMStreamerMode(u32Id, TRUE);
21071 MDrv_MVD_SetMcuMode(u32Id, TRUE);
21072 }
21073 else if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode == E_VDEC_EX_DISPLAY_MODE_HARDWIRE)
21074 {
21075
21076 pVdecExContext->u32FrameBaseMode[u8Idx] = FALSE;
21077 MDrv_MVD_SetMStreamerMode(u32Id, FALSE);
21078 MDrv_MVD_SetMcuMode(u32Id, FALSE);
21079 }
21080 }
21081
21082 if(pVdecExContext->_Pre_Ctrl[u8Idx].bCalFrameRate == TRUE)
21083 {
21084 if (MDrv_MVD_VariableFrameRate(u32Id) != TRUE)
21085 {
21086 _VDEC_EX_API_MutexLock();
21087 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21088 _VDEC_EX_API_MutexUnlock();
21089 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
21090 return E_VDEC_EX_FAIL;
21091 }
21092 }
21093
21094 break;
21095 }
21096 case E_VDEC_EX_DECODER_HVD:
21097 _RET_VDEC_HVD_LINT_CHECK_AND_RETURN_MUTEX();
21098 {
21099 if (pVdecExContext->_Pre_Ctrl[u8Idx].bOnePendingBuffer)
21100 {
21101 MDrv_HVD_EX_OnePendingBufferMode(u32Id,pVdecExContext->_Pre_Ctrl[u8Idx].bOnePendingBuffer);
21102 }
21103
21104 if (pVdecExContext->_Pre_Ctrl[u8Idx].bDisableTspInBbuMode)
21105 {
21106 MDrv_HVD_EX_TsInBbuMode(u32Id,pVdecExContext->_Pre_Ctrl[u8Idx].bDisableTspInBbuMode);
21107 }
21108
21109 if (pVdecExContext->_Pre_Ctrl[u8Idx].stIapGnShBWMode.bEnable)
21110 {
21111 MDrv_HVD_EX_IapGnBufShareBWMode(u32Id,pVdecExContext->_Pre_Ctrl[u8Idx].stIapGnShBWMode.bEnable,
21112 pVdecExContext->_Pre_Ctrl[u8Idx].stIapGnShBWMode.u32IapGnBufAddr, pVdecExContext->_Pre_Ctrl[u8Idx].stIapGnShBWMode.u32IapGnBufSize);
21113 }
21114
21115 if (pVdecExContext->_Pre_Ctrl[u8Idx].bCalFrameRate)
21116 {
21117 MDrv_HVD_EX_SetCalFrameRate(u32Id,pVdecExContext->_Pre_Ctrl[u8Idx].bCalFrameRate);
21118 }
21119
21120 MDrv_HVD_EX_PreSetMFCodecMode(u32Id, _VDEC_Map2HVDMFCodecMode(pVdecExContext->_Pre_Ctrl[u8Idx].eMFCodecMode));
21121 if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode != 0xFF)
21122 {
21123 MDrv_HVD_EX_PreSetDisplayMode(u32Id, _VDEC_Map2HVDDispMode(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode));
21124 }
21125 MDrv_HVD_EX_PreSetForce8BitMode(u32Id, pVdecExContext->_Pre_Ctrl[u8Idx].bForce8bitMode);
21126 MDrv_HVD_EX_PreSetVdecFeature(u32Id, pVdecExContext->_Pre_Ctrl[u8Idx].eVdecFeature);
21127 #ifdef VDEC3
21128 VDEC_EX_SysCfg cfg = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig;
21129 #else
21130 VDEC_EX_SysCfg cfg = pInitParam->SysConfig;
21131 #endif
21132 HVD_EX_MemCfg stMemCfg;
21133 HVD_EX_InitSettings stInitSettings;
21134 HVD_EX_RVInfo stRVInfo;
21135
21136 _VDEC_Memset(&stMemCfg, 0, sizeof(HVD_EX_MemCfg));
21137 _VDEC_Memset(&stInitSettings, 0, sizeof(HVD_EX_InitSettings));
21138 _VDEC_Memset(&stRVInfo, 0, sizeof(HVD_EX_RVInfo));
21139
21140 stInitSettings.pRVFileInfo = &stRVInfo;
21141
21142 stMemCfg.eFWSourceType = (HVD_EX_FWSourceType) cfg.eFWSourceType;
21143 stMemCfg.u32FWBinaryAddr = (MS_PHY) cfg.u32FWBinaryAddr;
21144
21145 if ((E_HVD_EX_FW_SOURCE_DRAM == stMemCfg.eFWSourceType)
21146 || (E_HVD_EX_FW_SOURCE_FLASH == stMemCfg.eFWSourceType))
21147 {
21148 stMemCfg.u32FWBinaryVAddr = MS_PA2KSEG1((MS_VIRT) cfg.u32FWBinaryAddr);
21149 }
21150
21151 stMemCfg.u32FWBinarySize = cfg.u32FWBinarySize;
21152 stMemCfg.u32VLCBinaryAddr = (MS_PHY) cfg.u32VlcBinarySrcAddr;
21153
21154 if ((E_HVD_EX_FW_SOURCE_DRAM == stMemCfg.eFWSourceType)
21155 || (E_HVD_EX_FW_SOURCE_FLASH == stMemCfg.eFWSourceType))
21156 {
21157 stMemCfg.u32VLCBinaryVAddr = MS_PA2KSEG1((MS_VIRT) cfg.u32VlcBinarySrcAddr);
21158 }
21159
21160 stMemCfg.u32VLCBinarySize = cfg.u32VlcTabBinarySize;
21161 stMemCfg.u32CodeBufAddr = (MS_PHY) cfg.u32CodeBufAddr;
21162 stMemCfg.u32CodeBufVAddr = MS_PA2KSEG1((MS_VIRT) cfg.u32CodeBufAddr);
21163 stMemCfg.u32CodeBufSize = cfg.u32CodeBufSize;
21164 stMemCfg.u32FrameBufAddr = (MS_PHY) cfg.u32FrameBufAddr;
21165 stMemCfg.u32FrameBufVAddr = MS_PA2KSEG1((MS_VIRT) cfg.u32FrameBufAddr);
21166 stMemCfg.u32FrameBufSize = cfg.u32FrameBufSize;
21167 stMemCfg.u32BitstreamBufAddr = (MS_PHY) cfg.u32BitstreamBufAddr;
21168 stMemCfg.u32BitstreamBufVAddr = MS_PA2KSEG1((MS_VIRT) cfg.u32BitstreamBufAddr);
21169 stMemCfg.u32BitstreamBufSize = cfg.u32BitstreamBufSize;
21170 stMemCfg.u32DrvProcessBufAddr = (MS_PHY) cfg.u32DrvProcBufAddr;
21171 stMemCfg.u32DrvProcessBufVAddr = MS_PA2KSEG1((MS_VIRT) cfg.u32DrvProcBufAddr);
21172 stMemCfg.u32DrvProcessBufSize = cfg.u32DrvProcBufSize;
21173 #ifdef VDEC3
21174 if (pVdecExContext->bDRVdecideBS)
21175 {
21176 stMemCfg.u32TotalBitstreamBufAddr = pVdecExContext->u32BitstreamBufAddr;
21177 stMemCfg.u32TotalBitstreamBufSize = pVdecExContext->u32BitstreamBufSize;
21178 }
21179 else
21180 {
21181 stMemCfg.u32TotalBitstreamBufAddr = cfg.u32BitstreamBufAddr;
21182 stMemCfg.u32TotalBitstreamBufSize = cfg.u32BitstreamBufSize;
21183 }
21184 #endif
21185
21186 // set codec flag
21187 if (E_VDEC_EX_CODEC_TYPE_H264 == pVdecExContext->_Attr[u8Idx].eCodecType)
21188 {
21189 stInitSettings.u32ModeFlag |= HVD_INIT_HW_AVC;
21190 }
21191 else if (E_VDEC_EX_CODEC_TYPE_AVS == pVdecExContext->_Attr[u8Idx].eCodecType)
21192 {
21193 stInitSettings.u32ModeFlag |= HVD_INIT_HW_AVS;
21194 }
21195 else if (E_VDEC_EX_CODEC_TYPE_RV8 == pVdecExContext->_Attr[u8Idx].eCodecType
21196 || E_VDEC_EX_CODEC_TYPE_RV9 == pVdecExContext->_Attr[u8Idx].eCodecType)
21197 {
21198 stInitSettings.u32ModeFlag |= HVD_INIT_HW_RM;
21199 }
21200 else if (E_VDEC_EX_CODEC_TYPE_MVC == pVdecExContext->_Attr[u8Idx].eCodecType)
21201 {
21202 stInitSettings.u32ModeFlag |= HVD_INIT_HW_MVC;
21203 }
21204 else if (E_VDEC_EX_CODEC_TYPE_VP8 == pVdecExContext->_Attr[u8Idx].eCodecType)
21205 {
21206 stInitSettings.u32ModeFlag |= HVD_INIT_HW_VP8;
21207 }
21208 else if (E_VDEC_EX_CODEC_TYPE_HEVC == pVdecExContext->_Attr[u8Idx].eCodecType)
21209 {
21210 stInitSettings.u32ModeFlag |= HVD_INIT_HW_HEVC;
21211 }
21212 else if (E_VDEC_EX_CODEC_TYPE_VP9 == pVdecExContext->_Attr[u8Idx].eCodecType)
21213 {
21214 stInitSettings.u32ModeFlag |= HVD_INIT_HW_VP9;
21215 }
21216
21217 // set input source mode
21218 if (E_VDEC_EX_SRC_MODE_DTV == pVdecExContext->_Attr[u8Idx].eSrcMode)
21219 {
21220 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_LIVE_STREAM;
21221 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_TSP;
21222 stInitSettings.u8SyncType = E_HVD_EX_SYNC_ATS;
21223 }
21224 else if ((E_VDEC_EX_SRC_MODE_TS_FILE == pVdecExContext->_Attr[u8Idx].eSrcMode) ||
21225 (E_VDEC_EX_SRC_MODE_TS_FILE_DUAL_ES == pVdecExContext->_Attr[u8Idx].eSrcMode) )
21226 {
21227 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_FILE_TS;
21228 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_TSP;
21229 stInitSettings.u8SyncType = E_HVD_EX_SYNC_ATS;
21230 if(E_VDEC_EX_SRC_MODE_TS_FILE_DUAL_ES == pVdecExContext->_Attr[u8Idx].eSrcMode)
21231 {
21232 stInitSettings.u32ModeFlag |= HVD_INIT_DUAL_ES_ENABLE;
21233 }
21234 else
21235 {
21236 stInitSettings.u32ModeFlag |= HVD_INIT_DUAL_ES_DISABLE;
21237 }
21238 }
21239 else if ((E_VDEC_EX_SRC_MODE_FILE == pVdecExContext->_Attr[u8Idx].eSrcMode) ||
21240 (E_VDEC_EX_SRC_MODE_FILE_DUAL_ES== pVdecExContext->_Attr[u8Idx].eSrcMode) )
21241 {
21242 stInitSettings.u32ModeFlag |= HVD_INIT_MAIN_FILE_RAW;
21243 stInitSettings.u32ModeFlag |= HVD_INIT_INPUT_DRV;
21244 if(E_VDEC_EX_SRC_MODE_FILE_DUAL_ES == pVdecExContext->_Attr[u8Idx].eSrcMode)
21245 {
21246 stInitSettings.u32ModeFlag |= HVD_INIT_DUAL_ES_ENABLE;
21247 }
21248 else
21249 {
21250 stInitSettings.u32ModeFlag |= HVD_INIT_DUAL_ES_DISABLE;
21251 }
21252
21253 if (E_VDEC_EX_TIME_STAMP_NONE == pInitParam->VideoInfo.eTimeStampType)
21254 {
21255 stInitSettings.u8SyncType = E_HVD_EX_SYNC_ATS;
21256 }
21257 else if (E_VDEC_EX_TIME_STAMP_STS == pInitParam->VideoInfo.eTimeStampType)
21258 {
21259 stInitSettings.u8SyncType = E_HVD_EX_SYNC_STS;
21260 }
21261 else if (E_VDEC_EX_TIME_STAMP_DTS == pInitParam->VideoInfo.eTimeStampType)
21262 {
21263 stInitSettings.u8SyncType = E_HVD_EX_SYNC_DTS;
21264 }
21265 else if (E_VDEC_EX_TIME_STAMP_PTS == pInitParam->VideoInfo.eTimeStampType)
21266 {
21267 stInitSettings.u8SyncType = E_HVD_EX_SYNC_PTS;
21268 }
21269 else
21270 {
21271 _VDEC_EX_API_MutexLock();
21272 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21273 _VDEC_EX_API_MutexUnlock();
21274 VDEC_PRINT("Invalid sync type %d\n", pInitParam->VideoInfo.eTimeStampType);
21275 return E_VDEC_EX_FAIL;
21276 }
21277 }
21278
21279 // set start code exist
21280 if (pInitParam->VideoInfo.bWithoutNalStCode)
21281 {
21282 stInitSettings.u32ModeFlag |= HVD_INIT_START_CODE_REMOVED;
21283 }
21284 else
21285 {
21286 stInitSettings.u32ModeFlag |= HVD_INIT_START_CODE_REMAINED;
21287 }
21288
21289 // pro settings
21290 stInitSettings.u32FrameRate = pInitParam->VideoInfo.u32FrameRate ;
21291 stInitSettings.u32FrameRateBase = pInitParam->VideoInfo.u32FrameRateBase;
21292
21293 if (E_VDEC_EX_SRC_MODE_FILE == pVdecExContext->_Attr[u8Idx].eSrcMode)
21294 {
21295 stInitSettings.u8MinFrmGap = 2; // default set
21296 }
21297 else
21298 {
21299 stInitSettings.u8MinFrmGap = 0; // default set
21300 }
21301
21302 stInitSettings.bAutoPowerSaving = TRUE;
21303 stInitSettings.bFastDisplay = TRUE;
21304 stInitSettings.u8TimeUnit = 1; // ms
21305 stInitSettings.bDynamicScaling = pInitParam->EnableDynaScale;
21306
21307 if (bNotReloadFW)
21308 {
21309 stInitSettings.u8TurboInit |= E_HVD_EX_TURBOINIT_FW_RELOAD; //set for not load fw more than once
21310 }
21311
21312 // for RM
21313 if (E_VDEC_EX_CODEC_TYPE_RV8 == pInitParam->eCodecType)
21314 {
21315 stRVInfo.RV_Version = 0;
21316 }
21317 else if (E_VDEC_EX_CODEC_TYPE_RV9 == pInitParam->eCodecType)
21318 {
21319 stRVInfo.RV_Version = 1;
21320 }
21321
21322 stRVInfo.ulNumSizes = pInitParam->VideoInfo.u16NumSizes;
21323
21324 _VDEC_Memcpy(stRVInfo.ulPicSizes_w, pInitParam->VideoInfo.u16Width, sizeof(pInitParam->VideoInfo.u16Width));
21325 _VDEC_Memcpy(stRVInfo.ulPicSizes_h, pInitParam->VideoInfo.u16Height, sizeof(pInitParam->VideoInfo.u16Height));
21326
21327 {
21328 MS_PHY u32NonPMBankSize = 0;
21329 MS_VIRT u32RiuBaseAddr = 0;
21330
21331 if (!MDrv_MMIO_GetBASE(&u32RiuBaseAddr, &u32NonPMBankSize, MS_MODULE_HW))
21332 {
21333 _VDEC_EX_API_MutexLock();
21334 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21335 _VDEC_EX_API_MutexUnlock();
21336 VDEC_PRINT("VDEC HVD Init Err: MMIO_GetBASE failure\n");
21337 return E_VDEC_EX_FAIL;
21338 }
21339 else
21340 {
21341 MDrv_HVD_EX_SetOSRegBase(u32RiuBaseAddr);
21342 MDrv_MVD_RegSetBase(u32RiuBaseAddr);
21343 }
21344 }
21345
21346 #ifdef VDEC3
21347 if(MDrv_HVD_EX_Init(u32Id, &stMemCfg, &stInitSettings, pVdecExContext->bFWdecideFB, pVdecExContext->bDRVdecideBS) != E_HVD_EX_OK)
21348 #else
21349 if(MDrv_HVD_EX_Init(u32Id, &stMemCfg, &stInitSettings) != E_HVD_EX_OK)
21350 #endif
21351 {
21352 _VDEC_EX_API_MutexLock();
21353 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21354 _VDEC_EX_API_MutexUnlock();
21355 return E_VDEC_EX_FAIL;
21356 }
21357
21358 _VDEC_EX_Create_BBU_Task(pStreamId->u32Id);
21359
21360 #if VDEC_DTV_DIRECT_STC_PATCH
21361 if ((u8Cidx == 1) && (E_VDEC_EX_SRC_MODE_DTV == pVdecExContext->_Attr[u8Idx].eSrcMode))
21362 {
21363 if (FALSE == _VDEC_EX_Create_DirectSTC_Task(pStreamId->u32Id))
21364 {
21365 _VDEC_EX_API_MutexLock();
21366 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21367 _VDEC_EX_API_MutexUnlock();
21368 return E_VDEC_EX_FAIL;
21369 }
21370 }
21371 #endif
21372
21373 // SPS filter
21374 if (E_VDEC_EX_SRC_MODE_DTV == pVdecExContext->_Attr[u8Idx].eSrcMode)
21375 {
21376 HVD_EX_DispInfoThreshold DispInfoTH;
21377 DispInfoTH.u32FrmrateLowBound=0;
21378 DispInfoTH.u32FrmrateUpBound=0;
21379 DispInfoTH.u32MvopLowBound=16000000;
21380 DispInfoTH.u32MvopUpBound=0;
21381 MDrv_HVD_EX_SetDispInfoTH(u32Id, &DispInfoTH);
21382 }
21383
21384 if (pInitParam->EnableDynaScale)
21385 {
21386 if(MDrv_HVD_EX_SetVirtualBox(u32Id,
21387 pInitParam->u32DSVirtualBoxWidth,
21388 pInitParam->u32DSVirtualBoxHeight) != E_HVD_EX_OK)
21389 {
21390 _VDEC_EX_API_MutexLock();
21391 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21392 _VDEC_EX_API_MutexUnlock();
21393 return E_VDEC_EX_FAIL;
21394 }
21395 }
21396
21397 if(MDrv_HVD_EX_SetDispErrFrm(u32Id, pInitParam->bDisableDropErrFrame) != E_HVD_EX_OK)
21398 {
21399 _VDEC_EX_API_MutexLock();
21400 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21401 _VDEC_EX_API_MutexUnlock();
21402 return E_VDEC_EX_FAIL;
21403 }
21404
21405 if(MDrv_HVD_EX_SetErrConceal(u32Id, !pInitParam->bDisableErrConceal) != E_HVD_EX_OK)
21406 {
21407 _VDEC_EX_API_MutexLock();
21408 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21409 _VDEC_EX_API_MutexUnlock();
21410 return E_VDEC_EX_FAIL;
21411 }
21412
21413 break;
21414 }
21415 case E_VDEC_EX_DECODER_MJPEG:
21416 {
21417 _VDEC_EX_API_MutexLock();
21418
21419 #ifdef VDEC3
21420 VDEC_EX_SysCfg cfg = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig;
21421 #else
21422 VDEC_EX_SysCfg cfg = pInitParam->SysConfig;
21423 #endif
21424 MJPEG_INIT_PARAM initParam;
21425 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_INIT;
21426 _VDEC_Memset(&initParam, 0, sizeof(MJPEG_INIT_PARAM));
21427
21428 initParam.u32FwBinAddr = cfg.u32FWBinaryAddr;
21429 initParam.u32FwBinSize = cfg.u32FWBinarySize;
21430 initParam.u32FwAddr = cfg.u32CodeBufAddr;
21431 initParam.u32FwSize = cfg.u32CodeBufSize;
21432 initParam.u32MRCBufAddr = cfg.u32BitstreamBufAddr;
21433 initParam.u32MRCBufSize = cfg.u32BitstreamBufSize;
21434 initParam.u32MWCBufAddr = cfg.u32FrameBufAddr;
21435 initParam.u32MWCBufSize = cfg.u32FrameBufSize;
21436 initParam.u32InternalBufAddr = cfg.u32DrvProcBufAddr;
21437 initParam.u32InternalBufSize = cfg.u32DrvProcBufSize;
21438 initParam.u32FrameRate = pInitParam->VideoInfo.u32FrameRate;
21439 initParam.u32FrameRateBase= pInitParam->VideoInfo.u32FrameRateBase;
21440 initParam.eFwSrcType = (MJPEG_FWSourceType)cfg.eFWSourceType;
21441 initParam.u32Width = (MS_U32)pInitParam->VideoInfo.u16Width[0];
21442 initParam.u32Height= (MS_U32)pInitParam->VideoInfo.u16Height[0];
21443
21444 MApi_MJPEG_EnableTurboFWMode(u32Id, bNotReloadFW);
21445
21446 // the very first step
21447 {
21448 MS_PHY u32NonPMBankSize = 0;
21449 MS_VIRT u32RiuBaseAddr = 0;
21450
21451 if (!MDrv_MMIO_GetBASE(&u32RiuBaseAddr, &u32NonPMBankSize, MS_MODULE_HW))
21452 {
21453 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21454 VDEC_PRINT("VDEC MJPEG Init Err: MMIO_GetBASE failure\n");
21455 _VDEC_EX_API_MutexUnlock();
21456 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
21457 return E_VDEC_EX_FAIL;
21458 }
21459 else
21460 {
21461 MDrv_HVD_EX_SetOSRegBase(u32RiuBaseAddr);
21462 MDrv_MVD_RegSetBase(u32RiuBaseAddr);
21463 }
21464 }
21465
21466 MDrv_HVD_EX_SetCtrlsBase(u32Id);
21467 MDrv_HVD_EX_MJPEG_InitSharemem(u32Id, MS_PA2KSEG1((MS_VIRT) cfg.u32CodeBufAddr));
21468 #ifdef VDEC3
21469 if(MApi_MJPEG_Init(u32Id, &initParam, pVdecExContext->bFWdecideFB) != E_MJPEG_RET_SUCCESS)
21470 #else
21471 if(MApi_MJPEG_Init(u32Id, &initParam) != E_MJPEG_RET_SUCCESS)
21472 #endif
21473 {
21474 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21475 _VDEC_EX_API_MutexUnlock();
21476 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
21477 return E_VDEC_EX_FAIL;
21478 }
21479 MDrv_HVD_EX_SetBurstMode(u32Id, TRUE);
21480 //Mjpeg Temp solution will remove in future
21481 if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode != 0xFF)
21482 {
21483 if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode == E_VDEC_EX_DISPLAY_MODE_MCU)
21484 {
21485 MApi_MJPEG_EnableDispCmdQ(u32Id, TRUE);
21486 MApi_MJPEG_SetControl(u32Id, E_MJPEG_VDEC_CMD_SET_DISPLAY_OUTSIDE_MODE, (MS_U32)TRUE);
21487 }
21488 else if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode == E_VDEC_EX_DISPLAY_MODE_HARDWIRE)
21489 {
21490 MApi_MJPEG_EnableDispCmdQ(u32Id, FALSE);
21491 MApi_MJPEG_SetControl(u32Id, E_MJPEG_VDEC_CMD_SET_DISPLAY_OUTSIDE_MODE, (MS_U32)FALSE);
21492 }
21493 }
21494 _VDEC_EX_API_MutexUnlock();
21495
21496 break;
21497 }
21498 default:
21499 {
21500 if(pVdecExContext->_Attr[u8Idx].eDbgMsgLevel >= E_VDEC_EX_DBG_LEVEL_ERR)
21501 {
21502 VDEC_PRINT("VDEC_EX Err(%d): Decoder is not supported!!\n", __LINE__);
21503 }
21504 _VDEC_EX_API_MutexLock();
21505 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21506 _VDEC_EX_API_MutexUnlock();
21507 return E_VDEC_EX_RET_INVALID_PARAM;
21508 }
21509 }
21510
21511 pVdecExContext->_bEsBufMgmt[u8Idx] = FALSE;
21512 pVdecExContext->_Attr[u8Idx].bInit = TRUE;
21513 pVdecExContext->_Attr[u8Idx].bUsed = TRUE;
21514 pVdecExContext->_Attr[u8Idx].u32DrvId = u32Id;
21515 pVdecExContext->bFlush[u8Idx] = TRUE;
21516 pVdecExContext->support_cc[u8Idx] = TRUE;
21517 #ifdef _MVD_EVENT_DBG
21518 _VDEC_Memcpy(&stTestStreamId, pStreamId, sizeof(VDEC_StreamId));
21519 _VDEC_MVDEventDbg();
21520 #endif
21521
21522 #ifdef _HVD_EVENT_DBG
21523 _VDEC_Memcpy(&stTestStreamId, pStreamId, sizeof(VDEC_StreamId));
21524 _VDEC_HVDEventDbg();
21525 #endif
21526
21527 if(bNDecAllocator == FALSE)
21528 {
21529 #ifdef CMA_DRV_DIRECT_INIT
21530 // Allocate the second miu if HEVC and VP9
21531 if (pVdecExContext->bCMAUsed && bCMAInitPool[1] && u8Idx == 0 &&
21532 ((pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_HEVC)||
21533 (pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_VP9)) &&
21534 pVdecExContext->_Attr[u8Idx].eSrcMode != E_VDEC_EX_SRC_MODE_DTV &&
21535 (pVdecExContext->_power_state[u8Idx] != E_VDEC_EX_POWER_RESUME_ING)
21536 )
21537 {
21538 MS_VIRT u32FrmBuffAddr;
21539 MS_U32 u32FrmBuffSize;
21540
21541 struct CMA_Pool_Alloc_Param alloc_param;
21542
21543 alloc_param.pool_handle_id = pVdecExContext->cmaInitParam[1].pool_handle_id;
21544 alloc_param.flags = CMA_FLAG_VIRT_ADDR;
21545 alloc_param.offset_in_pool = 0;
21546 alloc_param.length = pVdecExContext->cmaInitParam[1].heap_length;
21547
21548 if(pVdecExContext->bCMAGetMem[1][u8Idx] == FALSE)
21549 {
21550 pVdecExContext->bCMAGetMem[1][u8Idx] = TRUE;
21551 if (MApi_CMA_Pool_GetMem(&alloc_param) == FALSE)
21552 {
21553 pVdecExContext->bCMAGetMem[1][u8Idx] = FALSE;
21554 _VDEC_EX_API_MutexLock();
21555 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21556 _VDEC_EX_API_MutexUnlock();
21557 VPRINTF("[%s][%d]CMA GET fail\n",__FUNCTION__,__LINE__);
21558 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
21559 return E_VDEC_EX_FAIL;
21560 }
21561 else
21562 {
21563 VPRINTF("[VDEC][%d]MApi_CMA_Pool_GetMem1: alloc_param.pool_handle_id=%x, alloc_param.flags=%x, alloc_param.offset_in_pool=%llx, alloc_param.length=%x\n",
21564 (unsigned int)u8Idx,
21565 (unsigned int)alloc_param.pool_handle_id,
21566 (unsigned int)alloc_param.flags,
21567 (unsigned long long int)alloc_param.offset_in_pool,
21568 (unsigned int)alloc_param.length);
21569 }
21570 }
21571
21572 pVdecExContext->cmaFreeParam[1][u8Idx].pool_handle_id = pVdecExContext->cmaInitParam[1].pool_handle_id;
21573 pVdecExContext->cmaFreeParam[1][u8Idx].offset_in_pool = alloc_param.offset_in_pool;
21574 pVdecExContext->cmaFreeParam[1][u8Idx].length = alloc_param.length;
21575
21576 _miu_offset_to_phy(pVdecExContext->cmaInitParam[1].miu,
21577 pVdecExContext->cmaInitParam[1].heap_miu_start_offset + alloc_param.offset_in_pool,
21578 u32FrmBuffAddr);
21579
21580 u32FrmBuffSize = alloc_param.length;
21581
21582 _MApi_VDEC_EX_SetFrameBuff2(pStreamId, u32FrmBuffAddr, u32FrmBuffSize);
21583 }
21584 #endif
21585 }
21586 else
21587 {
21588 #if VDEC_EX_ALLOCATOR_ENABLE_NDECODE_FB2
21589 if (pVdecExContext->bCMAUsed && (u8Idx == 0 || pVdecExContext->bDRVdecideBS == TRUE) &&
21590 ((pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_HEVC)||
21591 (pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_VP9)/*||
21592 (pVdecExContext->_Attr[u8Idx].eCodecType == E_VDEC_EX_CODEC_TYPE_HEVC_DV)*/) &&
21593 pVdecExContext->_Attr[u8Idx].eSrcMode != E_VDEC_EX_SRC_MODE_DTV)
21594 {
21595 VDEC_EX_Allocator_Block *pstBlockFB2 = NULL;
21596 VDEC_EX_Result eRet;
21597 VDEC_EX_ALLOCATOR_BUFFER_TYPE eBufType;
21598 VDEC_EX_NDecBufRangeParam stBufRgnFB2;
21599
21600 _VDEC_EX_API_MutexLock();
21601
21602 // frame Buffer 2 allocating setting
21603
21604 eBufType = E_VDEC_EX_ALLOCATOR_BUFFER_FB2;
21605
21606 _VDEC_Memset(&stBufRgnFB2, 0, sizeof(VDEC_EX_NDecBufRangeParam));
21607 if(pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB2.bSetTotalBuf == TRUE)
21608 {
21609 stBufRgnFB2.bSetTotalBuf = TRUE;
21610 stBufRgnFB2.phyTotalBufAddr = pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB2.phyTotalBufAddr;
21611 stBufRgnFB2.szTotalBufSize = pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB2.szTotalBufSize;
21612 }
21613 stBufRgnFB2.phyBufAddr = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufAddr;
21614 stBufRgnFB2.szBufSize = pVdecExContext->_Attr[u8Idx].vdecExInitParam.SysConfig.u32FrameBufSize;
21615
21616 // start allocating frame buffer 2
21617
21618 eRet = _VDEC_EX_NdecAllocator_MallocFrameBuffer(u8Idx, eBufType, &stBufRgnFB2, &pstBlockFB2);
21619 if(eRet != E_VDEC_EX_OK)
21620 {
21621 _MApi_VDEC_EX_ReturnCMABuffer(pStreamId);
21622 ALLOCATOR_PRINTF_ERR("[ALLOC][ERR][%s][%d][%d] Alloc Frame Buffer2 Fail\n", __FUNCTION__, __LINE__, u8Idx);
21623 pVdecExContext->_Attr[u8Idx].eStage = E_VDEC_EX_STAGE_STOP;
21624 _VDEC_EX_API_MutexUnlock();
21625 return E_VDEC_EX_FAIL;
21626 }
21627
21628 _VDEC_EX_API_MutexUnlock();
21629
21630 VPRINTF("[ALLOC][DBG][%s][%d][%d] Alloc Frame Buffer2: Addr=0x%llx, Size=0x%x\n",
21631 __FUNCTION__, __LINE__, u8Idx, pstBlockFB2->stBlockInfo.phyAddr, pstBlockFB2->stBlockInfo.szSize);
21632
21633 _MApi_VDEC_EX_SetFrameBuff2(pStreamId, pstBlockFB2->stBlockInfo.phyAddr, pstBlockFB2->stBlockInfo.szSize);
21634 }
21635 #endif
21636 }
21637
21638 return E_VDEC_EX_OK;
21639 }
21640
21641
21642
MApi_VDEC_EX_SetControl(VDEC_StreamId * pStreamId,VDEC_EX_User_Cmd cmd_id,MS_VIRT param)21643 VDEC_EX_Result MApi_VDEC_EX_SetControl(VDEC_StreamId *pStreamId, VDEC_EX_User_Cmd cmd_id, MS_VIRT param)
21644 {
21645 VDEC_EX_V2_IO_Param IO_arg;
21646 VDEC_EX_Result ret;
21647
21648 if (pu32VDEC_EX_Inst == NULL)
21649 {
21650 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
21651 return E_VDEC_EX_FAIL;
21652 }
21653
21654 if(cmd_id == E_VDEC_EX_USER_CMD_SET_DECODE_MODE)
21655 {
21656 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
21657 IO_arg.eUserCmd = E_VDEC_EX_V2_USER_CMD_PRESET_DECODE_MODE;
21658 IO_arg.param[0] = (void*)(¶m);
21659 IO_arg.pRet = (void*)(&ret);
21660 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_PRE_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
21661 {
21662 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
21663 return E_VDEC_EX_FAIL;
21664 }
21665 else
21666 {
21667 return ret;
21668 }
21669 }
21670 else
21671 {
21672 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
21673 IO_arg.eUserCmd = _VDEC_MapUserCmd_V2(cmd_id);
21674 IO_arg.param[0] = (void*)(¶m);
21675 IO_arg.pRet = (void*)(&ret);
21676 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
21677 {
21678 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
21679 return E_VDEC_EX_FAIL;
21680 }
21681 else
21682 {
21683 return ret;
21684 }
21685 }
21686 }
21687
MApi_VDEC_EX_V2_SetControl(VDEC_StreamId * pStreamId,VDEC_EX_V2_User_Cmd cmd_id,void ** param,MS_BOOL IsResume)21688 VDEC_EX_Result MApi_VDEC_EX_V2_SetControl(VDEC_StreamId* pStreamId, VDEC_EX_V2_User_Cmd cmd_id, void** param,MS_BOOL IsResume)
21689 {
21690 VDEC_EX_Result ret = E_VDEC_EX_OK;
21691 MS_U8 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
21692 MS_U32 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
21693 VDEC_EX_RESUME_SET_CMD resume_data;
21694 //these cmd should receive between vdec init and vdec exit
21695
21696 _VDEC_INVALID_IDX_RET(u8Idx);
21697 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
21698
21699 if(cmd_id == E_VDEC_EX_V2_USER_CMD_EXIT)
21700 {
21701 MDrv_MVD_ReleaseFreeStream(u32Id);
21702 }
21703
21704 _VDEC_NOT_INIT_RET(u8Idx);
21705 _VDEC_INVALID_DRVID_RET(u8Idx, u32Id);
21706
21707 switch (cmd_id)
21708 {
21709 case E_VDEC_EX_V2_USER_CMD_REPEAT_LAST_FIELD:
21710 if(IsResume == TRUE)
21711 {
21712 ret = _VDEC_EX_RepeatLastField(pStreamId,
21713 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21714 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21715 }
21716 else
21717 {
21718 ret = _VDEC_EX_RepeatLastField(pStreamId,(MS_BOOL)(*((MS_U32*)(param[0]))));
21719 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21720 resume_data.u8Idx=u8Idx;
21721 resume_data.cmd_id=cmd_id;
21722 resume_data.param=param;
21723 resume_data.u32Arg_num=1;
21724 resume_data.structArg_num=0;
21725 //resume_data.struct_size=0;
21726 resume_data.position[0] = 0;
21727 resume_data.position[1] = 1;
21728 resume_data.position[2] = 2;
21729 resume_data.position[3] = 3;
21730 //resume_data.position[4] = 4;
21731 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21732 }
21733 break;
21734 case E_VDEC_EX_V2_USER_CMD_AVSYNC_REPEAT_TH:
21735 if(IsResume == TRUE)
21736 {
21737 ret = _VDEC_EX_SetAVSyncRepeatThreshold(pStreamId,
21738 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21739 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21740 }
21741 else
21742 {
21743 ret = _VDEC_EX_SetAVSyncRepeatThreshold(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
21744 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21745 resume_data.u8Idx=u8Idx;
21746 resume_data.cmd_id=cmd_id;
21747 resume_data.param=param;
21748 resume_data.u32Arg_num = 1;
21749 resume_data.structArg_num = 0;
21750 //resume_data.struct_size = 0;
21751 resume_data.position[0] = 0;
21752 resume_data.position[1] = 1;
21753 resume_data.position[2] = 2;
21754 resume_data.position[3] = 3;
21755 //resume_data.position[4] = 4;
21756 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21757 }
21758 break;
21759 case E_VDEC_EX_V2_USER_CMD_DISP_ONE_FIELD:
21760 if(IsResume == TRUE)
21761 {
21762 ret = _VDEC_EX_DispOneField(pStreamId,
21763 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21764 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21765 }
21766 else
21767 {
21768 ret = _VDEC_EX_DispOneField(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
21769 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21770 resume_data.u8Idx=u8Idx;
21771 resume_data.cmd_id=cmd_id;
21772 resume_data.param=param;
21773 resume_data.u32Arg_num = 1;
21774 resume_data.structArg_num = 0;
21775 //resume_data.struct_size = 0;
21776 resume_data.position[0] = 0;
21777 resume_data.position[1] = 1;
21778 resume_data.position[2] = 2;
21779 resume_data.position[3] = 3;
21780 //resume_data.position[4] = 4;
21781 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21782 }
21783 break;
21784 case E_VDEC_EX_V2_USER_CMD_FD_MASK_DELAY_COUNT:
21785 ret = _VDEC_EX_SetFdMaskDelayCnt(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
21786 break;
21787 case E_VDEC_EX_V2_USER_CMD_FRC_OUTPUT:
21788 if(IsResume == TRUE)
21789 {
21790 ret = _VDEC_EX_FrameRateConvert(pStreamId,&(pVdecExContext->store_FRC_OutputParam[u8Idx]));
21791 //free(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].pStructArg);
21792 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21793 }
21794 else
21795 {
21796 ret = _VDEC_EX_FrameRateConvert(pStreamId, (VDEC_EX_FRC_OutputParam*)(*((MS_VIRT*)(param[0]))));
21797 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,0,1,sizeof(VDEC_EX_FRC_OutputParam),0,1,2,3,0);
21798 resume_data.u8Idx=u8Idx;
21799 resume_data.cmd_id=cmd_id;
21800 resume_data.param=param;
21801 resume_data.u32Arg_num = 0;
21802 resume_data.structArg_num = 1;
21803 // resume_data.struct_size = sizeof(VDEC_EX_FRC_OutputParam);
21804 resume_data.position[0] = 0;
21805 resume_data.position[1] = 1;
21806 resume_data.position[2] = 2;
21807 resume_data.position[3] = 3;
21808 //resume_data.position[4] = 0;
21809 _VDEC_Memcpy((void*)(&(pVdecExContext->store_FRC_OutputParam[u8Idx])),
21810 param[0],
21811 sizeof(VDEC_EX_FRC_OutputParam));
21812 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21813 }
21814 break;
21815 case E_VDEC_EX_V2_USER_CMD_FRC_DROP_TYPE:
21816 if(IsResume == TRUE)
21817 {
21818 ret = _VDEC_EX_SetFRCDropType(pStreamId,
21819 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21820 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21821 }
21822 else
21823 {
21824 ret = _VDEC_EX_SetFRCDropType(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
21825 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21826 resume_data.u8Idx=u8Idx;
21827 resume_data.cmd_id=cmd_id;
21828 resume_data.param=param;
21829 resume_data.u32Arg_num = 1;
21830 resume_data.structArg_num = 0;
21831 //resume_data.struct_size = 0;
21832 resume_data.position[0] = 0;
21833 resume_data.position[1] = 1;
21834 resume_data.position[2] = 2;
21835 resume_data.position[3] = 3;
21836 //resume_data.position[4] = 4;
21837 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21838 }
21839 break;
21840 case E_VDEC_EX_V2_USER_CMD_FAST_DISPLAY:
21841 if(IsResume == TRUE)
21842 {
21843 ret = _VDEC_EX_SetFastDisplay(pStreamId,
21844 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21845 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21846 }
21847 else
21848 {
21849 ret = _VDEC_EX_SetFastDisplay(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
21850 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21851 resume_data.u8Idx=u8Idx;
21852 resume_data.cmd_id=cmd_id;
21853 resume_data.param=param;
21854 resume_data.u32Arg_num = 1;
21855 resume_data.structArg_num = 0;
21856 //resume_data.struct_size = 0;
21857 resume_data.position[0] = 0;
21858 resume_data.position[1] = 1;
21859 resume_data.position[2] = 2;
21860 resume_data.position[3] = 3;
21861 //resume_data.position[4] = 4;
21862 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21863 }
21864 break;
21865 case E_VDEC_EX_V2_USER_CMD_IGNORE_ERR_REF:
21866 if(IsResume == TRUE)
21867 {
21868 ret = _VDEC_EX_SetIgnoreErrRef(pStreamId,
21869 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21870 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21871 }
21872 else
21873 {
21874 ret = _VDEC_EX_SetIgnoreErrRef(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
21875 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21876 resume_data.u8Idx=u8Idx;
21877 resume_data.cmd_id=cmd_id;
21878 resume_data.param=param;
21879 resume_data.u32Arg_num = 1;
21880 resume_data.structArg_num = 0;
21881 //resume_data.struct_size = 0;
21882 resume_data.position[0] = 0;
21883 resume_data.position[1] = 1;
21884 resume_data.position[2] = 2;
21885 resume_data.position[3] = 3;
21886 //resume_data.position[4] = 4;
21887 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21888 }
21889 break;
21890 case E_VDEC_EX_V2_USER_CMD_FORCE_FOLLOW_DTV_SPEC:
21891 if(IsResume == TRUE)
21892 {
21893 ret = _VDEC_EX_ForceFollowDTVSpec(pStreamId,
21894 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21895 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21896 }
21897 else
21898 {
21899 ret = _VDEC_EX_ForceFollowDTVSpec(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
21900 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21901 resume_data.u8Idx=u8Idx;
21902 resume_data.cmd_id=cmd_id;
21903 resume_data.param=param;
21904 resume_data.u32Arg_num = 1;
21905 resume_data.structArg_num = 0;
21906 //resume_data.struct_size = 0;
21907 resume_data.position[0] = 0;
21908 resume_data.position[1] = 1;
21909 resume_data.position[2] = 2;
21910 resume_data.position[3] = 3;
21911 //resume_data.position[4] = 4;
21912 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21913 }
21914 break;
21915 case E_VDEC_EX_V2_USER_CMD_AVC_MIN_FRM_GAP:
21916 if(IsResume == TRUE)
21917 {
21918 ret = _VDEC_EX_AvcMinFrameGap(pStreamId,
21919 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21920 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21921 }
21922 else
21923 {
21924 ret = _VDEC_EX_AvcMinFrameGap(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
21925 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21926 resume_data.u8Idx=u8Idx;
21927 resume_data.cmd_id=cmd_id;
21928 resume_data.param=param;
21929 resume_data.u32Arg_num = 1;
21930 resume_data.structArg_num = 0;
21931 //resume_data.struct_size = 0;
21932 resume_data.position[0] = 0;
21933 resume_data.position[1] = 1;
21934 resume_data.position[2] = 2;
21935 resume_data.position[3] = 3;
21936 //resume_data.position[4] = 4;
21937 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21938 }
21939 break;
21940 case E_VDEC_EX_V2_USER_CMD_DISABLE_SEQ_CHG:
21941 if(IsResume == TRUE)
21942 {
21943 ret = _VDEC_EX_SetDisableSeqChange(pStreamId,
21944 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21945 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21946 }
21947 else
21948 {
21949 ret = _VDEC_EX_SetDisableSeqChange(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
21950 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21951 resume_data.u8Idx=u8Idx;
21952 resume_data.cmd_id=cmd_id;
21953 resume_data.param=param;
21954 resume_data.u32Arg_num = 1;
21955 resume_data.structArg_num = 0;
21956 //resume_data.struct_size = 0;
21957 resume_data.position[0] = 0;
21958 resume_data.position[1] = 1;
21959 resume_data.position[2] = 2;
21960 resume_data.position[3] = 3;
21961 //resume_data.position[4] = 4;
21962 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21963 }
21964 break;
21965 case E_VDEC_EX_V2_USER_CMD_AVC_DISABLE_ANTI_VDEAD:
21966 //_HVD_RET_HANDLE(MDrv_HVD_EX_SetSettings_Pro(u32Id, E_HVD_SSET_DISABLE_ANTI_VDEAD, *((MS_U32*)(param[0]))));
21967 break;
21968 case E_VDEC_EX_V2_USER_CMD_DTV_RESET_MVD_PARSER:
21969 ret = _VDEC_EX_ResetMvdParser(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
21970 break;
21971 case E_VDEC_EX_V2_USER_CMD_PVR_FLUSH_FRAME_BUFFER://PVR used,only used in S company
21972 //return _VDEC_DoFlushFrmBuffer(pStreamId, *((MS_BOOL*)(param[0])));
21973 break;
21974 case E_VDEC_EX_V2_USER_CMD_FORCE_INTERLACE_MODE:
21975 if(IsResume == TRUE)
21976 {
21977 ret = _VDEC_EX_ForceInterlaceMode(pStreamId,
21978 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
21979 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
21980 }
21981 else
21982 {
21983 ret = _VDEC_EX_ForceInterlaceMode(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
21984 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
21985 resume_data.u8Idx=u8Idx;
21986 resume_data.cmd_id=cmd_id;
21987 resume_data.param=param;
21988 resume_data.u32Arg_num = 1;
21989 resume_data.structArg_num = 0;
21990 //resume_data.struct_size = 0;
21991 resume_data.position[0] = 0;
21992 resume_data.position[1] = 1;
21993 resume_data.position[2] = 2;
21994 resume_data.position[3] = 3;
21995 //resume_data.position[4] = 4;
21996 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
21997 }
21998 break;
21999 #if VDEC_ENABLE_MVC
22000 case E_VDEC_EX_V2_USER_CMD_MVC_BBU2_PUSH_PACKET:
22001 ret = _MApi_VDEC_EX_MVC_SetControl(pStreamId, E_VDEC_EX_MVC_SET_BBU2_PUSH_PACKET, param);
22002 break;
22003 case E_VDEC_EX_V2_USER_CMD_MVC_BBU2_FIRE_DECCMD:
22004 ret = _MApi_VDEC_EX_MVC_SetControl(pStreamId, E_VDEC_EX_MVC_SET_BBU2_FIRE_DECCMD, param);
22005 break;
22006 #endif
22007 case E_VDEC_EX_V2_USER_CMD_SET_DISP_OUTSIDE_CTRL_MODE:
22008 if(IsResume == TRUE)
22009 {
22010 ret = _VDEC_EX_DISP_OUTSIDE_MODE(pStreamId,
22011 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22012 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22013 }
22014 else
22015 {
22016 ret = _VDEC_EX_DISP_OUTSIDE_MODE(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22017 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22018 resume_data.u8Idx=u8Idx;
22019 resume_data.cmd_id=cmd_id;
22020 resume_data.param=param;
22021 resume_data.u32Arg_num = 1;
22022 resume_data.structArg_num = 0;
22023 //resume_data.struct_size = 0;
22024 resume_data.position[0] = 0;
22025 resume_data.position[1] = 1;
22026 resume_data.position[2] = 2;
22027 resume_data.position[3] = 3;
22028 //resume_data.position[4] = 4;
22029 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22030 }
22031 break;
22032 case E_VDEC_EX_V2_USER_CMD_SET_DTV_USER_DATA_MODE:
22033 if(IsResume == TRUE)
22034 {
22035 ret = _VDEC_EX_SetDTVUserDataMode(pStreamId,
22036 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22037 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22038 }
22039 else
22040 {
22041 ret = _VDEC_EX_SetDTVUserDataMode(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22042 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22043 resume_data.u8Idx=u8Idx;
22044 resume_data.cmd_id=cmd_id;
22045 resume_data.param=param;
22046 resume_data.u32Arg_num = 1;
22047 resume_data.structArg_num = 0;
22048 //resume_data.struct_size = 0;
22049 resume_data.position[0] = 0;
22050 resume_data.position[1] = 1;
22051 resume_data.position[2] = 2;
22052 resume_data.position[3] = 3;
22053 //resume_data.position[4] = 4;
22054 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22055 }
22056 break;
22057 case E_VDEC_EX_V2_USER_CMD_RELEASE_FD_MASK:
22058 ret = _VDEC_EX_ReleaseFdMask(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22059 break;
22060 case E_VDEC_EX_V2_USER_CMD_FLUSH_PTS_BUF:
22061 ret = _VDEC_EX_FlushPTSBuf(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22062 break;
22063 case E_VDEC_EX_V2_USER_CMD_SUPPORT_AVC_TO_MVC:
22064 if(IsResume == TRUE)
22065 {
22066 ret = _VDEC_EX_Support_AVC2MVC(pStreamId,
22067 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22068 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22069 }
22070 else
22071 {
22072 ret = _VDEC_EX_Support_AVC2MVC(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22073 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22074 resume_data.u8Idx=u8Idx;
22075 resume_data.cmd_id=cmd_id;
22076 resume_data.param=param;
22077 resume_data.u32Arg_num = 1;
22078 resume_data.structArg_num = 0;
22079 //resume_data.struct_size = 0;
22080 resume_data.position[0] = 0;
22081 resume_data.position[1] = 1;
22082 resume_data.position[2] = 2;
22083 resume_data.position[3] = 3;
22084 //resume_data.position[4] = 4;
22085 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22086 }
22087 break;
22088 case E_VDEC_EX_V2_USER_CMD_3DLR_VIEW_EXCHANGE:
22089 if(IsResume == TRUE)
22090 {
22091 ret = _VDEC_EX_3DLR_View_Excahnge(pStreamId,
22092 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22093 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22094 }
22095 else
22096 {
22097 ret = _VDEC_EX_3DLR_View_Excahnge(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22098 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22099 resume_data.u8Idx=u8Idx;
22100 resume_data.cmd_id=cmd_id;
22101 resume_data.param=param;
22102 resume_data.u32Arg_num = 1;
22103 resume_data.structArg_num = 0;
22104 //resume_data.struct_size = 0;
22105 resume_data.position[0] = 0;
22106 resume_data.position[1] = 1;
22107 resume_data.position[2] = 2;
22108 resume_data.position[3] = 3;
22109 //resume_data.position[4] = 4;
22110 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22111 }
22112 break;
22113 case E_VDEC_EX_V2_USER_CMD_AVC_NEW_SLOW_MOTION:
22114 if(IsResume == TRUE)
22115 {
22116 ret = _VDEC_EX_AVC_Enable_New_Slow_Motion(pStreamId,
22117 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22118 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22119 }
22120 else
22121 {
22122 ret = _VDEC_EX_AVC_Enable_New_Slow_Motion(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22123 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22124 resume_data.u8Idx=u8Idx;
22125 resume_data.cmd_id=cmd_id;
22126 resume_data.param=param;
22127 resume_data.u32Arg_num = 1;
22128 resume_data.structArg_num = 0;
22129 //resume_data.struct_size = 0;
22130 resume_data.position[0] = 0;
22131 resume_data.position[1] = 1;
22132 resume_data.position[2] = 2;
22133 resume_data.position[3] = 3;
22134 //resume_data.position[4] = 4;
22135 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22136 }
22137 break;
22138 case E_VDEC_EX_V2_USER_CMD_SET_VSIZE_ALIGN:
22139 if(IsResume == TRUE)
22140 {
22141 ret = _VDEC_EX_SetVSizeAlign(pStreamId,
22142 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22143 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22144 }
22145 else
22146 {
22147 ret = _VDEC_EX_SetVSizeAlign(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22148 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22149 resume_data.u8Idx=u8Idx;
22150 resume_data.cmd_id=cmd_id;
22151 resume_data.param=param;
22152 resume_data.u32Arg_num = 1;
22153 resume_data.structArg_num = 0;
22154 //resume_data.struct_size = 0;
22155 resume_data.position[0] = 0;
22156 resume_data.position[1] = 1;
22157 resume_data.position[2] = 2;
22158 resume_data.position[3] = 3;
22159 //resume_data.position[4] = 4;
22160 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22161 }
22162 break;
22163 case E_VDEC_EX_V2_USER_CMD_SHOW_DECODE_ORDER:
22164 if(IsResume == TRUE)
22165 {
22166 ret = _VDEC_EX_ShowDecodeOrder(pStreamId,
22167 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22168 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22169 }
22170 else
22171 {
22172 ret = _VDEC_EX_ShowDecodeOrder(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22173 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22174 resume_data.u8Idx=u8Idx;
22175 resume_data.cmd_id=cmd_id;
22176 resume_data.param=param;
22177 resume_data.u32Arg_num = 1;
22178 resume_data.structArg_num = 0;
22179 //resume_data.struct_size = 0;
22180 resume_data.position[0] = 0;
22181 resume_data.position[1] = 1;
22182 resume_data.position[2] = 2;
22183 resume_data.position[3] = 3;
22184 //resume_data.position[4] = 4;
22185 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22186 }
22187 break;
22188 case E_VDEC_EX_V2_USER_CMD_AVC_DISP_IGNORE_CROP:
22189 if(IsResume == TRUE)
22190 {
22191 ret = _VDEC_EX_Disp_Ignore_Crop(pStreamId,
22192 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22193 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22194 }
22195 else
22196 {
22197 ret = _VDEC_EX_Disp_Ignore_Crop(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22198 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22199 resume_data.u8Idx=u8Idx;
22200 resume_data.cmd_id=cmd_id;
22201 resume_data.param=param;
22202 resume_data.u32Arg_num = 1;
22203 resume_data.structArg_num = 0;
22204 //resume_data.struct_size = 0;
22205 resume_data.position[0] = 0;
22206 resume_data.position[1] = 1;
22207 resume_data.position[2] = 2;
22208 resume_data.position[3] = 3;
22209 //resume_data.position[4] = 4;
22210 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22211 }
22212 break;
22213 case E_VDEC_EX_V2_USER_CMD_SUSPEND_DYNAMIC_SCALE:
22214 if(IsResume == TRUE)
22215 {
22216 ret = _VDEC_EX_SuspendDynamicScale(pStreamId,
22217 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22218 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22219 }
22220 else
22221 {
22222 ret = _VDEC_EX_SuspendDynamicScale(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22223 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22224 resume_data.u8Idx=u8Idx;
22225 resume_data.cmd_id=cmd_id;
22226 resume_data.param=param;
22227 resume_data.u32Arg_num = 1;
22228 resume_data.structArg_num = 0;
22229 //resume_data.struct_size = 0;
22230 resume_data.position[0] = 0;
22231 resume_data.position[1] = 1;
22232 resume_data.position[2] = 2;
22233 resume_data.position[3] = 3;
22234 //resume_data.position[4] = 4;
22235 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22236 }
22237 break;
22238 case E_VDEC_EX_V2_USER_CMD_FORCE_AUTO_MUTE:
22239 if(IsResume == TRUE)
22240 {
22241 ret = _VDEC_EX_ForceAutoMute(pStreamId,
22242 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22243 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22244 }
22245 else
22246 {
22247 ret = _VDEC_EX_ForceAutoMute(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22248 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22249 resume_data.u8Idx=u8Idx;
22250 resume_data.cmd_id=cmd_id;
22251 resume_data.param=param;
22252 resume_data.u32Arg_num = 1;
22253 resume_data.structArg_num = 0;
22254 //resume_data.struct_size = 0;
22255 resume_data.position[0] = 0;
22256 resume_data.position[1] = 1;
22257 resume_data.position[2] = 2;
22258 resume_data.position[3] = 3;
22259 //resume_data.position[4] = 4;
22260 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22261 }
22262 break;
22263 case E_VDEC_EX_V2_USER_CMD_SET_DISP_FINISH_MODE:
22264 ret = _VDEC_EX_SetDispFinishMode(pStreamId, (MS_U8)(*((MS_U32*)(param[0]))));
22265 break;
22266 case E_VDEC_EX_V2_USER_CMD_SET_AVSYNC_MODE:
22267 ret = _VDEC_EX_SetAVSyncMode(pStreamId, (MS_U8)(*((MS_U32*)(param[0]))));
22268 break;
22269 case E_VDEC_EX_V2_USER_CMD_PUSH_DISPQ_WITH_REF_NUM:
22270 if(IsResume == TRUE)
22271 {
22272 ret = _VDEC_EX_PushDispQWithRefNum(pStreamId,
22273 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22274 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22275 }
22276 else
22277 {
22278 ret = _VDEC_EX_PushDispQWithRefNum(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22279 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22280 resume_data.u8Idx=u8Idx;
22281 resume_data.cmd_id=cmd_id;
22282 resume_data.param=param;
22283 resume_data.u32Arg_num = 1;
22284 resume_data.structArg_num = 0;
22285 //resume_data.struct_size = 0;
22286 resume_data.position[0] = 0;
22287 resume_data.position[1] = 1;
22288 resume_data.position[2] = 2;
22289 resume_data.position[3] = 3;
22290 //resume_data.position[4] = 4;
22291 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22292 }
22293 break;
22294 case E_VDEC_EX_V2_USER_CMD_DS_RESV_N_BUFFER:
22295 if(IsResume == TRUE)
22296 {
22297 ret = _VDEC_EX_DynamicScalingResvNBuffer(pStreamId,
22298 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22299 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22300 }
22301 else
22302 {
22303 ret = _VDEC_EX_DynamicScalingResvNBuffer(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22304 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22305 resume_data.u8Idx=u8Idx;
22306 resume_data.cmd_id=cmd_id;
22307 resume_data.param=param;
22308 resume_data.u32Arg_num = 1;
22309 resume_data.structArg_num = 0;
22310 //resume_data.struct_size = 0;
22311 resume_data.position[0] = 0;
22312 resume_data.position[1] = 1;
22313 resume_data.position[2] = 2;
22314 resume_data.position[3] = 3;
22315 //resume_data.position[4] = 4;
22316 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22317 }
22318 break;
22319 case E_VDEC_EX_V2_USER_CMD_UT_SET_DBG_MODE:
22320 ret = _VDEC_EX_DbgMode(pStreamId,(VDEC_EX_DbgMode)(*((MS_U32*)(param[0]))), TRUE);
22321 break;
22322 case E_VDEC_EX_V2_USER_CMD_UT_CLR_DBG_MODE:
22323 ret = _VDEC_EX_DbgMode(pStreamId, (VDEC_EX_DbgMode)(*((MS_U32*)(param[0]))), FALSE);
22324 break;
22325 case E_VDEC_EX_V2_USER_CMD_RM_ENABLE_PTS_TBL:
22326 if(IsResume == TRUE)
22327 {
22328 ret = _VDEC_EX_RmEnablePtsTbl(pStreamId,
22329 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22330 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22331 }
22332 else
22333 {
22334 ret = _VDEC_EX_RmEnablePtsTbl(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22335 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22336 resume_data.u8Idx=u8Idx;
22337 resume_data.cmd_id=cmd_id;
22338 resume_data.param=param;
22339 resume_data.u32Arg_num = 1;
22340 resume_data.structArg_num = 0;
22341 //resume_data.struct_size = 0;
22342 resume_data.position[0] = 0;
22343 resume_data.position[1] = 1;
22344 resume_data.position[2] = 2;
22345 resume_data.position[3] = 3;
22346 //resume_data.position[4] = 4;
22347 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22348 }
22349 break;
22350 case E_VDEC_EX_V2_USER_CMD_SET_IDCT_MODE:
22351 if(IsResume == TRUE)
22352 {
22353 ret = _VDEC_EX_SetIdctMode(pStreamId,
22354 (MS_U8)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22355 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22356 }
22357 else
22358 {
22359 ret = _VDEC_EX_SetIdctMode(pStreamId, (MS_U8)(*((MS_U32*)(param[0]))));
22360 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22361 resume_data.u8Idx=u8Idx;
22362 resume_data.cmd_id=cmd_id;
22363 resume_data.param=param;
22364 resume_data.u32Arg_num = 1;
22365 resume_data.structArg_num = 0;
22366 //resume_data.struct_size = 0;
22367 resume_data.position[0] = 0;
22368 resume_data.position[1] = 1;
22369 resume_data.position[2] = 2;
22370 resume_data.position[3] = 3;
22371 //resume_data.position[4] = 4;
22372 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22373 }
22374 break;
22375 case E_VDEC_EX_V2_USER_CMD_DROP_ERR_FRAME:
22376 if(IsResume == TRUE)
22377 {
22378 ret = _VDEC_EX_DropErrFrame(pStreamId,
22379 (MS_U8)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22380 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22381 }
22382 else
22383 {
22384 ret = _VDEC_EX_DropErrFrame(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22385 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22386 resume_data.u8Idx=u8Idx;
22387 resume_data.cmd_id=cmd_id;
22388 resume_data.param=param;
22389 resume_data.u32Arg_num = 1;
22390 resume_data.structArg_num = 0;
22391 //resume_data.struct_size = 0;
22392 resume_data.position[0] = 0;
22393 resume_data.position[1] = 1;
22394 resume_data.position[2] = 2;
22395 resume_data.position[3] = 3;
22396 //resume_data.position[4] = 4;
22397 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22398 }
22399 break;
22400 case E_VDEC_EX_V2_USER_CMD_SET_CC608_INFO_ENHANCE_MODE:
22401 if(IsResume == TRUE)
22402 {
22403 ret = _VDEC_EX_SetCcInfoEnhanceMode(pStreamId,
22404 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22405 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22406 }
22407 else
22408 {
22409 ret = _VDEC_EX_SetCcInfoEnhanceMode(pStreamId,(MS_BOOL)(*((MS_U32*)(param[0]))));
22410 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22411 resume_data.u8Idx=u8Idx;
22412 resume_data.cmd_id=cmd_id;
22413 resume_data.param=param;
22414 resume_data.u32Arg_num = 1;
22415 resume_data.structArg_num = 0;
22416 //resume_data.struct_size = 0;
22417 resume_data.position[0] = 0;
22418 resume_data.position[1] = 1;
22419 resume_data.position[2] = 2;
22420 resume_data.position[3] = 3;
22421 //resume_data.position[4] = 4;
22422 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22423 }
22424 break;
22425 case E_VDEC_EX_V2_USER_CMD_IGNORE_PIC_OVERRUN:
22426 if(IsResume == TRUE)
22427 {
22428 ret = _VDEC_EX_IgnorePicOverrun(pStreamId,
22429 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22430 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22431 }
22432 else
22433 {
22434 ret = _VDEC_EX_IgnorePicOverrun(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22435 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22436 resume_data.u8Idx=u8Idx;
22437 resume_data.cmd_id=cmd_id;
22438 resume_data.param=param;
22439 resume_data.u32Arg_num = 1;
22440 resume_data.structArg_num = 0;
22441 //resume_data.struct_size = 0;
22442 resume_data.position[0] = 0;
22443 resume_data.position[1] = 1;
22444 resume_data.position[2] = 2;
22445 resume_data.position[3] = 3;
22446 //resume_data.position[4] = 4;
22447 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22448 }
22449 break;
22450 case E_VDEC_EX_V2_USER_CMD_SET_SELF_SEQCHANGE:
22451 if(IsResume == TRUE)
22452 {
22453 ret = _VDEC_EX_SetSelfSeqChange(pStreamId,
22454 (MS_U8)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22455 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22456 }
22457 else
22458 {
22459 ret = _VDEC_EX_SetSelfSeqChange(pStreamId,(MS_BOOL)(*((MS_U32*)(param[0]))));
22460 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22461 resume_data.u8Idx=u8Idx;
22462 resume_data.cmd_id=cmd_id;
22463 resume_data.param=param;
22464 resume_data.u32Arg_num = 1;
22465 resume_data.structArg_num = 0;
22466 //resume_data.struct_size = 0;
22467 resume_data.position[0] = 0;
22468 resume_data.position[1] = 1;
22469 resume_data.position[2] = 2;
22470 resume_data.position[3] = 3;
22471 //resume_data.position[4] = 4;
22472 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22473 }
22474 break;
22475 case E_VDEC_EX_V2_USER_CMD_AUTO_EXHAUST_ES_MODE:
22476 if(IsResume == TRUE)
22477 {
22478 ret = _VDEC_EX_SetAutoExhaustESMode(pStreamId,
22479 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22480 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22481 }
22482 else
22483 {
22484 ret = _VDEC_EX_SetAutoExhaustESMode(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22485 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22486 resume_data.u8Idx=u8Idx;
22487 resume_data.cmd_id=cmd_id;
22488 resume_data.param=param;
22489 resume_data.u32Arg_num = 1;
22490 resume_data.structArg_num = 0;
22491 //resume_data.struct_size = 0;
22492 resume_data.position[0] = 0;
22493 resume_data.position[1] = 1;
22494 resume_data.position[2] = 2;
22495 resume_data.position[3] = 3;
22496 //resume_data.position[4] = 4;
22497 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22498 }
22499 break;
22500 case E_VDEC_EX_V2_USER_CMD_CTL_SPEED_IN_DISP_ONLY:
22501 if(IsResume == TRUE)
22502 {
22503 ret = _VDEC_EX_CtlSpeedInDispOnly(pStreamId,
22504 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22505 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22506 }
22507 else
22508 {
22509 ret = _VDEC_EX_CtlSpeedInDispOnly(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22510 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22511 resume_data.u8Idx=u8Idx;
22512 resume_data.cmd_id=cmd_id;
22513 resume_data.param=param;
22514 resume_data.u32Arg_num = 1;
22515 resume_data.structArg_num = 0;
22516 //resume_data.struct_size = 0;
22517 resume_data.position[0] = 0;
22518 resume_data.position[1] = 1;
22519 resume_data.position[2] = 2;
22520 resume_data.position[3] = 3;
22521 //resume_data.position[4] = 4;
22522 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22523 }
22524 break;
22525 case E_VDEC_EX_V2_USER_CMD_AVC_SUPPORT_REF_NUM_OVER_MAX_DPB_SIZE:
22526 if(IsResume == TRUE)
22527 {
22528 ret = _VDEC_EX_AVCSupportRefNumOverMaxDBPSize(pStreamId,
22529 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22530 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22531 }
22532 else
22533 {
22534 ret = _VDEC_EX_AVCSupportRefNumOverMaxDBPSize(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22535 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22536 resume_data.u8Idx=u8Idx;
22537 resume_data.cmd_id=cmd_id;
22538 resume_data.param=param;
22539 resume_data.u32Arg_num = 1;
22540 resume_data.structArg_num = 0;
22541 //resume_data.struct_size = 0;
22542 resume_data.position[0] = 0;
22543 resume_data.position[1] = 1;
22544 resume_data.position[2] = 2;
22545 resume_data.position[3] = 3;
22546 //resume_data.position[4] = 4;
22547 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22548 }
22549 break;
22550 case E_VDEC_EX_V2_USER_CMD_RETURN_INVALID_AFD:
22551 if(IsResume == TRUE)
22552 {
22553 ret = _VDEC_EX_ReturnInvalidAFD(pStreamId,
22554 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22555 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22556 }
22557 else
22558 {
22559 ret = _VDEC_EX_ReturnInvalidAFD(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22560 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22561 resume_data.u8Idx=u8Idx;
22562 resume_data.cmd_id=cmd_id;
22563 resume_data.param=param;
22564 resume_data.u32Arg_num = 1;
22565 resume_data.structArg_num = 0;
22566 //resume_data.struct_size = 0;
22567 resume_data.position[0] = 0;
22568 resume_data.position[1] = 1;
22569 resume_data.position[2] = 2;
22570 resume_data.position[3] = 3;
22571 //resume_data.position[4] = 4;
22572 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22573 }
22574 break;
22575 case E_VDEC_EX_V2_USER_CMD_FIELD_POLARITY_DISPLAY_ONE_FIELD:
22576 if(IsResume == TRUE)
22577 {
22578 ret = _VDEC_EX_Field_Polarity_Display_One_Field(pStreamId,&(pVdecExContext->store_Field_Polarity[u8Idx]));
22579 //free(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].pStructArg);
22580 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22581 }
22582 else
22583 {
22584 ret = _VDEC_EX_Field_Polarity_Display_One_Field(pStreamId,(VDEC_EX_Field_Polarity*)(*((MS_VIRT*)(param[0]))));
22585 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,0,1,sizeof(VDEC_EX_Field_Polarity),0,1,2,3,0);
22586 resume_data.u8Idx=u8Idx;
22587 resume_data.cmd_id=cmd_id;
22588 resume_data.param=param;
22589 resume_data.u32Arg_num = 0;
22590 resume_data.structArg_num = 1;
22591 //resume_data.struct_size = sizeof(VDEC_EX_Field_Polarity);
22592 resume_data.position[0] = 0;
22593 resume_data.position[1] = 1;
22594 resume_data.position[2] = 2;
22595 resume_data.position[3] = 3;
22596 //resume_data.position[4] = 0;
22597 _VDEC_Memcpy((void*)(&(pVdecExContext->store_Field_Polarity[u8Idx])),
22598 param[0],
22599 sizeof(VDEC_EX_Field_Polarity));
22600 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22601 }
22602 break;
22603 case E_VDEC_EX_V2_USER_CMD_AVC_FORCE_BROKEN_BY_US:
22604 if(IsResume == TRUE)
22605 {
22606 ret = _VDEC_EX_AVCForceBrokenByUs(pStreamId,
22607 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22608 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22609 }
22610 else
22611 {
22612 ret = _VDEC_EX_AVCForceBrokenByUs(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22613 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22614 resume_data.u8Idx=u8Idx;
22615 resume_data.cmd_id=cmd_id;
22616 resume_data.param=param;
22617 resume_data.u32Arg_num = 1;
22618 resume_data.structArg_num = 0;
22619 //resume_data.struct_size = 0;
22620 resume_data.position[0] = 0;
22621 resume_data.position[1] = 1;
22622 resume_data.position[2] = 2;
22623 resume_data.position[3] = 3;
22624 //resume_data.position[4] = 4;
22625 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22626 }
22627 break;
22628 case E_VDEC_EX_V2_USER_CMD_SHOW_FIRST_FRAME_DIRECT:
22629 if(IsResume == TRUE)
22630 {
22631 ret = _VDEC_EX_ShowFirstFrameDirect(pStreamId,
22632 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22633 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22634 }
22635 else
22636 {
22637 ret = _VDEC_EX_ShowFirstFrameDirect(pStreamId,(MS_U32)(*((MS_U32*)(param[0]))));
22638 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22639 resume_data.u8Idx=u8Idx;
22640 resume_data.cmd_id=cmd_id;
22641 resume_data.param=param;
22642 resume_data.u32Arg_num = 1;
22643 resume_data.structArg_num = 0;
22644 //resume_data.struct_size = 0;
22645 resume_data.position[0] = 0;
22646 resume_data.position[1] = 1;
22647 resume_data.position[2] = 2;
22648 resume_data.position[3] = 3;
22649 //resume_data.position[4] = 4;
22650 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22651 }
22652 break;
22653 case E_VDEC_EX_V2_USER_CMD_AVC_RESIZE_DOS_DISP_PEND_BUF:
22654 ret = _VDEC_EX_AVCResizeDosDispPendBuf(pStreamId,(MS_U32)(*((MS_U32*)(param[0]))));
22655 break;
22656 case E_VDEC_EX_V2_USER_CMD_SET_XC_LOW_DELAY_PARA:
22657 ret = _VDEC_EX_SetXcLowDelayPara(pStreamId,(MS_U32)(*((MS_U32*)(param[0]))));
22658 break;
22659 case E_VDEC_EX_V2_USER_CMD_SET_SECURE_MODE:
22660 ret = _VDEC_EX_SetSecureMode(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22661 break;
22662 case E_VDEC_EX_V2_USER_CMD_FRAMERATE_HANDLING:
22663 ret = _VDEC_EX_FramerateHandling(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22664 break;
22665 case E_VDEC_EX_V2_USER_CMD_RVU_SETTING_MODE:
22666 ret = _VDEC_EX_RVU_Setting_Mode(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22667 break;
22668 case E_VDEC_EX_V2_USER_CMD_DUAL_NON_BLOCK_MODE:
22669 ret = _VDEC_EX_DualNonBlockMode(pStreamId, (MS_BOOL)(*((MS_U32*)(param[0]))));
22670 break;
22671 case E_VDEC_EX_V2_USER_CMD_IGNORE_PIC_STRUCT_DISPLAY:
22672 ret = _VDEC_EX_IgnorePicStructDisplay(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22673 break;
22674 case E_VDEC_EX_V2_USER_CMD_INPUT_PTS_FREERUN_MODE:
22675 ret = _VDEC_EX_InputPtsFreerunMode(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22676 break;
22677 case E_VDEC_EX_V2_USER_CMD_ERR_CONCEAL_SLICE_1ST_MB:
22678 ret = _VDEC_EX_ErrConcealStartSlice1stMB(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22679 break;
22680 case E_VDEC_EX_V2_USER_CMD_SET_EXTERNAL_DS_BUFFER:
22681 ret = _VDEC_EX_Set_External_DS_Buffer(pStreamId,(VDEC_EX_EXTERNAL_DS_BUFFER*)(*((MS_VIRT*)(param[0]))));
22682 break;
22683 case E_VDEC_EX_V2_USER_CMD_SET_MIN_TSP_DATA_SIZE:
22684 ret = _VDEC_EX_SetMinTspDataSize(pStreamId,(MS_U32)(*((MS_U32*)(param[0]))));
22685 break;
22686 case E_VDEC_EX_V2_USER_CMD_SET_DMX_FRAMERATE:
22687 ret = _VDEC_EX_SetDmxFrameRate(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22688 break;
22689 case E_VDEC_EX_V2_USER_CMD_SET_DMX_FRAMERATEBASE:
22690 ret = _VDEC_EX_SetDmxFrameRateBase(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
22691 break;
22692 case E_VDEC_EX_V2_USER_CMD_ENABLE_CC_608_EXTERNAL_BUFFER:
22693 ret = _VDEC_EX_Enable_External_CC_608_Buffer(pStreamId,(MS_VIRT)(*((MS_VIRT*)(param[0]))));
22694 break;
22695 case E_VDEC_EX_V2_USER_CMD_ENABLE_CC_708_EXTERNAL_BUFFER:
22696 ret = _VDEC_EX_Enable_External_CC_708_Buffer(pStreamId,(MS_VIRT)(*((MS_VIRT*)(param[0]))));
22697 break;
22698 case E_VDEC_EX_V2_USER_CMD_EXIT:
22699 ret = _MApi_VDEC_EX_V2_Exit(pStreamId);
22700 break;
22701 case E_VDEC_EX_V2_USER_CMD_RST:
22702 ret = _MApi_VDEC_EX_V2_Rst(pStreamId);
22703 break;
22704 case E_VDEC_EX_V2_USER_CMD_CHECK_DISPINFO_READY:
22705 ret = _MApi_VDEC_EX_V2_CheckDispInfoRdy(pStreamId);
22706 break;
22707 case E_VDEC_EX_V2_USER_CMD_SET_FRC_MODE:
22708 if(IsResume == TRUE)
22709 {
22710 ret = _MApi_VDEC_EX_V2_SetFrcMode(pStreamId,
22711 (VDEC_EX_FrcMode)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22712 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22713 }
22714 else
22715 {
22716 ret = _MApi_VDEC_EX_V2_SetFrcMode(pStreamId,*((VDEC_EX_FrcMode*)(param[0])));
22717 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22718 resume_data.u8Idx=u8Idx;
22719 resume_data.cmd_id=cmd_id;
22720 resume_data.param=param;
22721 resume_data.u32Arg_num = 1;
22722 resume_data.structArg_num = 0;
22723 //resume_data.struct_size = 0;
22724 resume_data.position[0] = 0;
22725 resume_data.position[1] = 1;
22726 resume_data.position[2] = 2;
22727 resume_data.position[3] = 3;
22728 //resume_data.position[4] = 4;
22729 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22730 }
22731 break;
22732 case E_VDEC_EX_V2_USER_CMD_SET_DYNSCALING_PARAMS:
22733 if(IsResume == TRUE)
22734 {
22735 ret = _MApi_VDEC_EX_V2_SetDynScalingParams(pStreamId,
22736 (MS_PHY)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
22737 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[1]));
22738 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22739 }
22740 else
22741 {
22742 ret = _MApi_VDEC_EX_V2_SetDynScalingParams(pStreamId,
22743 *((MS_PHY*)(param[0])),
22744 *((MS_U32*)(param[1])));
22745 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,2,0,0,0,1,2,3,4);
22746 resume_data.u8Idx=u8Idx;
22747 resume_data.cmd_id=cmd_id;
22748 resume_data.param=param;
22749 resume_data.u32Arg_num = 2;
22750 resume_data.structArg_num = 0;
22751 //resume_data.struct_size = 0;
22752 resume_data.position[0] = 0;
22753 resume_data.position[1] = 1;
22754 resume_data.position[2] = 2;
22755 resume_data.position[3] = 3;
22756 //resume_data.position[4] = 4;
22757 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22758 }
22759 break;
22760 case E_VDEC_EX_V2_USER_CMD_SET_DBG_LEVEL:
22761 ret = _VDEC_EX_SetDbgLevel(pStreamId,*((VDEC_EX_DbgLevel*)(param[0])));
22762 break;
22763 case E_VDEC_EX_V2_USER_CMD_PLAY:
22764 ret = _MApi_VDEC_EX_V2_Play(pStreamId);
22765 break;
22766 case E_VDEC_EX_V2_USER_CMD_PAUSE:
22767 ret = _MApi_VDEC_EX_V2_Pause(pStreamId);
22768 break;
22769 case E_VDEC_EX_V2_USER_CMD_RESUME:
22770 ret = _MApi_VDEC_EX_V2_Resume(pStreamId);
22771 break;
22772 case E_VDEC_EX_V2_USER_CMD_STEP_DISP:
22773 ret = _MApi_VDEC_EX_V2_StepDisp(pStreamId);
22774 break;
22775 case E_VDEC_EX_V2_USER_CMD_STEP_DECODE:
22776 ret = _MApi_VDEC_EX_V2_StepDecode(pStreamId);
22777 break;
22778 case E_VDEC_EX_V2_USER_CMD_SET_TRICK_MODE:
22779 ret = _MApi_VDEC_EX_V2_SetTrickMode(pStreamId,*((VDEC_EX_TrickDec*)(param[0])));
22780 break;
22781 case E_VDEC_EX_V2_USER_CMD_PUSH_DECQ:
22782 ret = _MApi_VDEC_EX_V2_PushDecQ(pStreamId,((VDEC_EX_DecCmd*)(param[0])));
22783 break;
22784 case E_VDEC_EX_V2_USER_CMD_FLUSH:
22785 ret = _MApi_VDEC_EX_V2_Flush(pStreamId,*((VDEC_EX_FreezePicSelect*)(param[0])));
22786 break;
22787 case E_VDEC_EX_V2_USER_CMD_ENABLE_LAST_FRAME_SHOW:
22788 ret = _MApi_VDEC_EX_V2_EnableLastFrameShow(pStreamId,*((MS_BOOL*)(param[0])));
22789 break;
22790 case E_VDEC_EX_V2_USER_CMD_SET_SPEED:
22791 ret = _MApi_VDEC_EX_V2_SetSpeed(pStreamId,
22792 *((VDEC_EX_SpeedType*)(param[0])),
22793 *((VDEC_EX_DispSpeed*)(param[1])));
22794 break;
22795 case E_VDEC_EX_V2_USER_CMD_SET_FREEZE_DISP:
22796 ret = _MApi_VDEC_EX_V2_SetFreezeDisp(pStreamId,*((MS_BOOL*)(param[0])));
22797 break;
22798 case E_VDEC_EX_V2_USER_CMD_SET_BLUE_SCREEN:
22799 ret = _MApi_VDEC_EX_V2_SetBlueScreen(pStreamId,*((MS_BOOL*)(param[0])));
22800 break;
22801 case E_VDEC_EX_V2_USER_CMD_RESET_PTS:
22802 ret = _MApi_VDEC_EX_V2_ResetPTS(pStreamId,*((MS_U32*)(param[0])));
22803 break;
22804 case E_VDEC_EX_V2_USER_CMD_AVSYNC_ON:
22805 if(IsResume == TRUE)
22806 {
22807 ret = _MApi_VDEC_EX_V2_AVSyncOn(pStreamId,
22808 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
22809 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[1]),
22810 (MS_U16)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[2]));
22811 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22812 }
22813 else
22814 {
22815 ret = _MApi_VDEC_EX_V2_AVSyncOn(pStreamId,
22816 *((MS_BOOL*)(param[0])),
22817 *((MS_U32*)(param[1])),
22818 *((MS_U16*)(param[2])));
22819 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,3,0,0,0,1,2,3,4);
22820 resume_data.u8Idx=u8Idx;
22821 resume_data.cmd_id=cmd_id;
22822 resume_data.param=param;
22823 resume_data.u32Arg_num = 3;
22824 resume_data.structArg_num = 0;
22825 //resume_data.struct_size = 0;
22826 resume_data.position[0] = 0;
22827 resume_data.position[1] = 1;
22828 resume_data.position[2] = 2;
22829 resume_data.position[3] = 3;
22830 //resume_data.position[4] = 4;
22831 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22832 }
22833 break;
22834 case E_VDEC_EX_V2_USER_CMD_AVSYNC_FREERUN_THRESHOLD:
22835 if(IsResume == TRUE)
22836 {
22837 ret = _MApi_VDEC_EX_V2_SetAVSyncFreerunThreshold(pStreamId,
22838 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22839 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22840 }
22841 else
22842 {
22843 ret = _MApi_VDEC_EX_V2_SetAVSyncFreerunThreshold(pStreamId,*((MS_U32*)(param[0])));
22844 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22845 resume_data.u8Idx=u8Idx;
22846 resume_data.cmd_id=cmd_id;
22847 resume_data.param=param;
22848 resume_data.u32Arg_num = 1;
22849 resume_data.structArg_num = 0;
22850 //resume_data.struct_size = 0;
22851 resume_data.position[0] = 0;
22852 resume_data.position[1] = 1;
22853 resume_data.position[2] = 2;
22854 resume_data.position[3] = 3;
22855 //resume_data.position[4] = 4;
22856 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22857 }
22858 break;
22859 case E_VDEC_EX_V2_USER_CMD_SET_EVENT_MULTICALLBACK:
22860 if(IsResume == TRUE)
22861 {
22862 ret = _MApi_VDEC_EX_V2_SetEvent_MultiCallback(pStreamId,
22863 (VDEC_EX_CB_TYPE)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
22864 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[1]),
22865 (VDEC_EX_EventCb)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[2]),
22866 (void*)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[3]));
22867 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22868 }
22869 else
22870 {
22871 ret = _MApi_VDEC_EX_V2_SetEvent_MultiCallback(pStreamId,
22872 *((VDEC_EX_CB_TYPE*)(param[0])),
22873 *((MS_U32*)(param[1])),
22874 ((VDEC_EX_EventCb)(param[2])),
22875 param[3]);
22876 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,4,0,0,0,1,2,3,4);
22877 resume_data.u8Idx=u8Idx;
22878 resume_data.cmd_id=cmd_id;
22879 resume_data.param=param;
22880 resume_data.u32Arg_num = 4;
22881 resume_data.structArg_num = 0;
22882 //resume_data.struct_size = 0;
22883 resume_data.position[0] = 0;
22884 resume_data.position[1] = 1;
22885 resume_data.position[2] = 2;
22886 resume_data.position[3] = 3;
22887 //resume_data.position[4] = 4;
22888 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22889 }
22890 break;
22891 case E_VDEC_EX_V2_USER_CMD_UNSET_EVENT_MULTICALLBACK:
22892 if(IsResume == TRUE)
22893 {
22894 ret = _MApi_VDEC_EX_V2_UnsetEvent_MultiCallback(pStreamId,
22895 (VDEC_EX_CB_TYPE)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
22896 (MS_U32)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[1]));
22897 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22898 }
22899 else
22900 {
22901 ret = _MApi_VDEC_EX_V2_UnsetEvent_MultiCallback(pStreamId,
22902 *((VDEC_EX_CB_TYPE*)(param[0])),
22903 *((MS_U32*)(param[1])));
22904 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,2,0,0,0,1,2,3,4);
22905 resume_data.u8Idx=u8Idx;
22906 resume_data.cmd_id=cmd_id;
22907 resume_data.param=param;
22908 resume_data.u32Arg_num = 2;
22909 resume_data.structArg_num = 0;
22910 //resume_data.struct_size = 0;
22911 resume_data.position[0] = 0;
22912 resume_data.position[1] = 1;
22913 resume_data.position[2] = 2;
22914 resume_data.position[3] = 3;
22915 //resume_data.position[4] = 4;
22916 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22917 }
22918 break;
22919 case E_VDEC_EX_V2_USER_CMD_FIRE_DEC:
22920 ret = _MApi_VDEC_EX_V2_FireDecCmd(pStreamId);
22921 break;
22922 case E_VDEC_EX_V2_USER_CMD_SEEK_TO_PTS:
22923 ret = _MApi_VDEC_EX_V2_SeekToPTS(pStreamId,*((MS_U32*)(param[0])));
22924 break;
22925 case E_VDEC_EX_V2_USER_CMD_SKIP_TO_PTS:
22926 ret = _MApi_VDEC_EX_V2_SkipToPTS(pStreamId,*((MS_U32*)(param[0])));
22927 break;
22928 case E_VDEC_EX_V2_USER_CMD_DISABLE_DEBLOCKING:
22929 if(IsResume == TRUE)
22930 {
22931 ret = _MApi_VDEC_EX_V2_DisableDeblocking(pStreamId,
22932 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22933 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22934 }
22935 else
22936 {
22937 ret = _MApi_VDEC_EX_V2_DisableDeblocking(pStreamId,*((MS_BOOL*)(param[0])));
22938 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22939 resume_data.u8Idx=u8Idx;
22940 resume_data.cmd_id=cmd_id;
22941 resume_data.param=param;
22942 resume_data.u32Arg_num = 1;
22943 resume_data.structArg_num = 0;
22944 //resume_data.struct_size = 0;
22945 resume_data.position[0] = 0;
22946 resume_data.position[1] = 1;
22947 resume_data.position[2] = 2;
22948 resume_data.position[3] = 3;
22949 //resume_data.position[4] = 4;
22950 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22951 }
22952 break;
22953 case E_VDEC_EX_V2_USER_CMD_DISABLE_QUARTER_PIXEL:
22954 if(IsResume == TRUE)
22955 {
22956 ret = _MApi_VDEC_EX_V2_DisableQuarterPixel(pStreamId,
22957 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22958 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22959 }
22960 else
22961 {
22962 ret = _MApi_VDEC_EX_V2_DisableQuarterPixel(pStreamId,*((MS_BOOL*)(param[0])));
22963 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22964 resume_data.u8Idx=u8Idx;
22965 resume_data.cmd_id=cmd_id;
22966 resume_data.param=param;
22967 resume_data.u32Arg_num = 1;
22968 resume_data.structArg_num = 0;
22969 //resume_data.struct_size = 0;
22970 resume_data.position[0] = 0;
22971 resume_data.position[1] = 1;
22972 resume_data.position[2] = 2;
22973 resume_data.position[3] = 3;
22974 //resume_data.position[4] = 4;
22975 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
22976 }
22977 break;
22978 case E_VDEC_EX_V2_USER_CMD_SET_AUTO_RM_LST_ZERO_BYTE:
22979 if(IsResume == TRUE)
22980 {
22981 ret = _MApi_VDEC_EX_V2_SetAutoRmLstZeroByte(pStreamId,
22982 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
22983 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
22984 }
22985 else
22986 {
22987 ret = _MApi_VDEC_EX_V2_SetAutoRmLstZeroByte(pStreamId,*((MS_BOOL*)(param[0])));
22988 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
22989 resume_data.u8Idx=u8Idx;
22990 resume_data.cmd_id=cmd_id;
22991 resume_data.param=param;
22992 resume_data.u32Arg_num = 1;
22993 resume_data.structArg_num = 0;
22994 //resume_data.struct_size = 0;
22995 resume_data.position[0] = 0;
22996 resume_data.position[1] = 1;
22997 resume_data.position[2] = 2;
22998 resume_data.position[3] = 3;
22999 //resume_data.position[4] = 4;
23000 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23001 }
23002 break;
23003 case E_VDEC_EX_V2_USER_CMD_SET_BALANCE_BW:
23004 if(IsResume == TRUE)
23005 {
23006 ret = _MApi_VDEC_EX_V2_SetBalanceBW(pStreamId,
23007 (MS_U8)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
23008 (MS_U8)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[1]),
23009 (MS_U8)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[2]),
23010 (MS_U8)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[3]));
23011 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23012 }
23013 else
23014 {
23015 ret = _MApi_VDEC_EX_V2_SetBalanceBW(pStreamId,
23016 *((MS_U8*)(param[0])),
23017 *((MS_U8*)(param[1])),
23018 *((MS_U8*)(param[2])),
23019 *((MS_U8*)(param[3])));
23020 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,4,0,0,0,1,2,3,4);
23021 resume_data.u8Idx=u8Idx;
23022 resume_data.cmd_id=cmd_id;
23023 resume_data.param=param;
23024 resume_data.u32Arg_num = 4;
23025 resume_data.structArg_num = 0;
23026 //resume_data.struct_size = 0;
23027 resume_data.position[0] = 0;
23028 resume_data.position[1] = 1;
23029 resume_data.position[2] = 2;
23030 resume_data.position[3] = 3;
23031 //resume_data.position[4] = 4;
23032 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23033 }
23034 break;
23035 case E_VDEC_EX_V2_USER_CMD_GEN_PATTERN:
23036 ret = _MApi_VDEC_EX_V2_GenPattern(pStreamId,
23037 *((VDEC_EX_PatternType*)(param[0])),
23038 *((MS_PHY*)(param[1])),
23039 ((MS_U32*)(param[2])));
23040 break;
23041 case E_VDEC_EX_V2_USER_CMD_MHEG_DECODE_IFRAME:
23042 ret = _MApi_VDEC_EX_V2_MHEG_DecodeIFrame(pStreamId,
23043 *((MS_PHY*)(param[0])),
23044 *((MS_PHY*)(param[1])),
23045 *((MS_PHY*)(param[2])));
23046 break;
23047 case E_VDEC_EX_V2_USER_CMD_MHEG_RST_IFRAME_DEC:
23048 ret = _MApi_VDEC_EX_V2_MHEG_RstIFrameDec(pStreamId);
23049 break;
23050 case E_VDEC_EX_V2_USER_CMD_CC_START_PARSING:
23051 ret = _MApi_VDEC_EX_V2_CC_StartParsing(pStreamId,((VDEC_EX_CCCfg*)(param[0])));
23052 break;
23053 case E_VDEC_EX_V2_USER_CMD_CC_STOP_PARSING:
23054 ret = _MApi_VDEC_EX_V2_CC_StopParsing(pStreamId);
23055 break;
23056 case E_VDEC_EX_V2_USER_CMD_CC_UPDATE_READ_PTR:
23057 ret = _MApi_VDEC_EX_V2_CC_UpdateReadPtr(pStreamId,*((MS_U32*)(param[0])));
23058 break;
23059 case E_VDEC_EX_V2_USER_CMD_SET_BLOCK_DISPLAY:
23060 if(IsResume == TRUE)
23061 {
23062 ret = _MApi_VDEC_EX_V2_SetBlockDisplay(pStreamId,
23063 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
23064 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23065 }
23066 else
23067 {
23068 ret = _MApi_VDEC_EX_V2_SetBlockDisplay(pStreamId,*((MS_BOOL*)(param[0])));
23069 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
23070 resume_data.u8Idx=u8Idx;
23071 resume_data.cmd_id=cmd_id;
23072 resume_data.param=param;
23073 resume_data.u32Arg_num = 1;
23074 resume_data.structArg_num = 0;
23075 //resume_data.struct_size = 0;
23076 resume_data.position[0] = 0;
23077 resume_data.position[1] = 1;
23078 resume_data.position[2] = 2;
23079 resume_data.position[3] = 3;
23080 //resume_data.position[4] = 4;
23081 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23082 }
23083 break;
23084 case E_VDEC_EX_V2_USER_CMD_ENABLE_ES_BUFF_MALLOC:
23085 if(IsResume == TRUE)
23086 {
23087 ret = _MApi_VDEC_EX_V2_EnableESBuffMalloc(pStreamId,
23088 (MS_BOOL)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
23089 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23090 }
23091 else
23092 {
23093 ret = _MApi_VDEC_EX_V2_EnableESBuffMalloc(pStreamId,*((MS_BOOL*)(param[0])));
23094 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
23095 resume_data.u8Idx=u8Idx;
23096 resume_data.cmd_id=cmd_id;
23097 resume_data.param=param;
23098 resume_data.u32Arg_num = 1;
23099 resume_data.structArg_num = 0;
23100 //resume_data.struct_size = 0;
23101 resume_data.position[0] = 0;
23102 resume_data.position[1] = 1;
23103 resume_data.position[2] = 2;
23104 resume_data.position[3] = 3;
23105 //resume_data.position[4] = 4;
23106 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23107 }
23108 break;
23109 case E_VDEC_EX_V2_USER_CMD_DISPLAY_FRAME:
23110 ret = _MApi_VDEC_EX_V2_DisplayFrame(pStreamId,((VDEC_EX_DispFrame*)(param[0])));
23111 break;
23112 case E_VDEC_EX_V2_USER_CMD_RELEASE_FRAME:
23113 ret = _MApi_VDEC_EX_V2_ReleaseFrame(pStreamId,((VDEC_EX_DispFrame*)(param[0])));
23114 break;
23115 case E_VDEC_EX_V2_USER_CMD_CAPTURE_FRAME:
23116 ret = _MApi_VDEC_EX_V2_CaptureFrame(pStreamId,*((MS_U32*)(param[0])),*((MS_BOOL*)(param[1])));
23117 break;
23118 case E_VDEC_EX_V2_USER_CMD_CC_INIT:
23119 ret = _MApi_VDEC_EX_V2_CC_Init(pStreamId,((MS_U32*)(param[0])));
23120 break;
23121 case E_VDEC_EX_V2_USER_CMD_CC_SET_CFG:
23122 if(IsResume == TRUE)
23123 {
23124 ret = _MApi_VDEC_EX_V2_CC_SetCfg(pStreamId,
23125 (VDEC_EX_CCFormat)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
23126 (VDEC_EX_CCType)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[1]),
23127 (MS_U32*)(&(pVdecExContext->store_InputPara_setcfg[u8Idx])));
23128 //free(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].pStructArg);
23129 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23130 }
23131 else
23132 {
23133 ret = _MApi_VDEC_EX_V2_CC_SetCfg(pStreamId,
23134 *((VDEC_EX_CCFormat*)(param[0])),
23135 *((VDEC_EX_CCType*)(param[1])),
23136 ((MS_U32*)(param[2])));
23137 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,2,1,sizeof(VDEC_EX_CC_InputPara),0,1,2,3,2);
23138 resume_data.u8Idx=u8Idx;
23139 resume_data.cmd_id=cmd_id;
23140 resume_data.param=param;
23141 resume_data.u32Arg_num = 2;
23142 resume_data.structArg_num = 1;
23143 //resume_data.struct_size = sizeof(VDEC_EX_CC_InputPara);
23144 resume_data.position[0] = 0;
23145 resume_data.position[1] = 1;
23146 resume_data.position[2] = 2;
23147 resume_data.position[3] = 3;
23148 //resume_data.position[4] = 2;
23149 _VDEC_Memcpy((void*)(&(pVdecExContext->store_InputPara_setcfg[u8Idx])),
23150 param[2],
23151 sizeof(VDEC_EX_CC_InputPara));
23152 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23153 }
23154 break;
23155 case E_VDEC_EX_V2_USER_CMD_CC_SET_BUFF_START_ADDR:
23156 if(IsResume == TRUE)
23157 {
23158 ret = _MApi_VDEC_EX_V2_CC_SetBuffStartAdd(pStreamId,
23159 (VDEC_EX_CCFormat)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
23160 (MS_U32*)(&(pVdecExContext->store_InputPara_startaddr[u8Idx])));
23161 //free(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].pStructArg);
23162 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23163 }
23164 else
23165 {
23166 ret = _MApi_VDEC_EX_V2_CC_SetBuffStartAdd(pStreamId,
23167 *((VDEC_EX_CCFormat*)(param[0])),
23168 ((MS_U32*)(param[1])));
23169 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,1,sizeof(VDEC_EX_CC_InputPara),0,1,2,3,1);
23170 resume_data.u8Idx=u8Idx;
23171 resume_data.cmd_id=cmd_id;
23172 resume_data.param=param;
23173 resume_data.u32Arg_num = 1;
23174 resume_data.structArg_num = 1;
23175 //resume_data.struct_size = sizeof(VDEC_EX_CC_InputPara);
23176 resume_data.position[0] = 0;
23177 resume_data.position[1] = 1;
23178 resume_data.position[2] = 2;
23179 resume_data.position[3] = 3;
23180 //resume_data.position[4] = 1;
23181 _VDEC_Memcpy((void*)(&(pVdecExContext->store_InputPara_startaddr[u8Idx])),
23182 param[1],
23183 sizeof(VDEC_EX_CC_InputPara));
23184 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23185 }
23186 break;
23187 case E_VDEC_EX_V2_USER_CMD_CC_UPDATE_WRITE_ADDR:
23188 if(IsResume == TRUE)
23189 {
23190 ret = _MApi_VDEC_EX_V2_CC_UpdateWriteAdd(pStreamId,
23191 (VDEC_EX_CCFormat)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
23192 NULL);
23193 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23194 }
23195 else
23196 {
23197 ret = _MApi_VDEC_EX_V2_CC_UpdateWriteAdd(pStreamId,
23198 *((VDEC_EX_CCFormat*)(param[0])),
23199 ((MS_U32*)(param[1])));
23200 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
23201 resume_data.u8Idx=u8Idx;
23202 resume_data.cmd_id=cmd_id;
23203 resume_data.param=param;
23204 resume_data.u32Arg_num = 1;
23205 resume_data.structArg_num = 0;
23206 //resume_data.struct_size = 0;
23207 resume_data.position[0] = 0;
23208 resume_data.position[1] = 1;
23209 resume_data.position[2] = 2;
23210 resume_data.position[3] = 3;
23211 //resume_data.position[4] = 4;
23212 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23213 }
23214 break;
23215 case E_VDEC_EX_V2_USER_CMD_CC_UPDATE_READ_ADDR:
23216 if(IsResume == TRUE)
23217 {
23218 ret = _MApi_VDEC_EX_V2_CC_UpdateReadAdd(pStreamId,
23219 (VDEC_EX_CCFormat)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]),
23220 (MS_U32*)(&(pVdecExContext->store_InputPara_readaddr[u8Idx])));
23221 //free(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].pStructArg);
23222 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23223 }
23224 else
23225 {
23226 ret = _MApi_VDEC_EX_V2_CC_UpdateReadAdd(pStreamId,
23227 *((VDEC_EX_CCFormat*)(param[0])),
23228 ((MS_U32*)(param[1])));
23229 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,1,sizeof(VDEC_EX_CC_InputPara),0,1,2,3,1);
23230 resume_data.u8Idx=u8Idx;
23231 resume_data.cmd_id=cmd_id;
23232 resume_data.param=param;
23233 resume_data.u32Arg_num = 1;
23234 resume_data.structArg_num = 1;
23235 //resume_data.struct_size = sizeof(VDEC_EX_CC_InputPara);
23236 resume_data.position[0] = 0;
23237 resume_data.position[1] = 1;
23238 resume_data.position[2] = 2;
23239 resume_data.position[3] = 3;
23240 //resume_data.position[4] = 1;
23241 _VDEC_Memcpy((void*)(&(pVdecExContext->store_InputPara_readaddr[u8Idx])),
23242 param[1],
23243 sizeof(VDEC_EX_CC_InputPara));
23244 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23245 }
23246 break;
23247 case E_VDEC_EX_V2_USER_CMD_CC_DISABLE_PARSING:
23248 if(IsResume == TRUE)
23249 {
23250 ret = _MApi_VDEC_EX_V2_CC_DisableParsing(pStreamId,
23251 (VDEC_EX_CCFormat)(pVdecExContext->store_set_cmd[pVdecExContext->store_set_cmd_read_pointer[u8Idx]].u32Arg[0]));
23252 pVdecExContext->store_set_cmd_read_pointer[u8Idx]++;
23253 }
23254 else
23255 {
23256 ret = _MApi_VDEC_EX_V2_CC_DisableParsing(pStreamId,*((VDEC_EX_CCFormat*)(param[0])));
23257 //_VDEC_PREPARE_RESUME_DATA(u8Idx,cmd_id,param,1,0,0,0,1,2,3,4);
23258 resume_data.u8Idx=u8Idx;
23259 resume_data.cmd_id=cmd_id;
23260 resume_data.param=param;
23261 resume_data.u32Arg_num = 1;
23262 resume_data.structArg_num = 0;
23263 //resume_data.struct_size = 0;
23264 resume_data.position[0] = 0;
23265 resume_data.position[1] = 1;
23266 resume_data.position[2] = 2;
23267 resume_data.position[3] = 3;
23268 //resume_data.position[4] = 4;
23269 _MApi_VDEC_EX_V2_StoreUserCmd(&resume_data);
23270 }
23271 break;
23272 case E_VDEC_EX_V2_USER_CMD_SET_TIME_INC_PREDICT_PARA:
23273 ret = _MApi_VDEC_EX_SetTimeIncPredictParam(pStreamId,(MS_U32)(*((MS_U32*)(param[0]))));
23274 break;
23275
23276 case E_VDEC_EX_V2_USER_CMD_ENABLE_DECODE_ENGINE_TIMEOUT:
23277 ret = _VDEC_EX_SetDecodeTimeoutParam(pStreamId,(VDEC_EX_Decode_Timeout_Param*)(*((MS_VIRT*)(param[0]))));
23278 break;
23279
23280 case E_VDEC_EX_V2_USER_CMD_FRAMEBUFFER_AUTO_MODE:
23281 ret = _MApi_VDEC_EX_SetFramebufferAutoMode(pStreamId,(MS_BOOL)(*((MS_U32*)(param[0]))));
23282 break;
23283
23284 case E_VDEC_EX_V2_USER_CMD_SET_SMOOTH_REWIND:
23285 ret = _MApi_VDEC_EX_SetSmooth_Rewind(pStreamId,(MS_U8)(*((MS_U32*)(param[0]))));
23286 break;
23287
23288 case E_VDEC_EX_V2_USER_CMD_SET_ERROR_TOLERANCE:
23289 ret = _MApi_VDEC_EX_SetError_Tolerance(pStreamId,(VDEC_EX_Err_Tolerance*)(*((MS_VIRT*)(param[0]))));
23290 break;
23291
23292 case E_VDEC_EX_V2_USER_CMD_SET_PTS_US_MODE:
23293 ret = _MApi_VDEC_EX_Set_PTS_USec_Mode(pStreamId,(MS_BOOL)(*((MS_U32*)(param[0]))));
23294 break;
23295
23296 case E_VDEC_EX_V2_USER_CMD_AUTO_INSERT_DUMMY_DATA:
23297 ret = _MApi_VDEC_EX_Enable_AutoInsertDummyPattern(pStreamId,(MS_BOOL)(*((MS_U32*)(param[0]))));
23298 break;
23299
23300 case E_VDEC_EX_V2_USER_CMD_DROP_ONE_PTS:
23301 ret = _MApi_VDEC_EX_Drop_One_PTS(pStreamId);
23302 break;
23303
23304 case E_VDEC_EX_V2_USER_CMD_PVR_TIMESHIFT_SEAMLESS_MODE:
23305 ret = _MApi_VDEC_EX_PVR_Seamless_mode(pStreamId,(MS_U8)(*((MS_U32*)(param[0]))));
23306 break;
23307
23308 case E_VDEC_EX_V2_USER_CMD_SET_MBX_PARAM:
23309 ret = _MApi_VDEC_EX_V2_Set_MBX_param((MS_U8)(*((MS_U8*)(param[0]))));
23310 break;
23311
23312 case E_VDEC_EX_V2_USER_CMD_SET_FRAMEBUFF2:
23313 {
23314 VDEC_FRAMEBuff *framebuff = (VDEC_FRAMEBuff *)(*((MS_VIRT*)(param[0])));
23315 ret = _MApi_VDEC_EX_SetFrameBuff2(pStreamId, framebuff->u32Addr, framebuff->u32Size);
23316 }
23317 break;
23318
23319 case E_VDEC_EX_V2_USER_CMD_ENABLE_PTS_DECTECTOR:
23320 ret = _VDEC_EX_EnablePTSDetector(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
23321 break;
23322
23323 case E_VDEC_EX_V2_USER_CMD_DISABLE_PBFRAME_MODE:
23324 ret = _VDEC_EX_DisablePBFrameMode(pStreamId, (MS_U32)(*((MS_U32*)(param[0]))));
23325 break;
23326
23327 case E_VDEC_EX_V2_USER_CMD_SET_TRICKPLAY_2X_MODE:
23328 ret = _MApi_VDEC_EX_SetTrickPlay_2X_MODE(pStreamId,(VDEC_EX_TrickPlay2xMode)(*((MS_U32*)(param[0]))));
23329 break;
23330
23331 case E_VDEC_EX_V2_USER_CMD_FRC_ONLY_SHOW_TOP_FIELD:
23332 ret = _MApi_VDEC_EX_FRC_OnlyShowTopField(pStreamId,(MS_BOOL)(*((MS_U32*)(param[0]))));
23333 break;
23334
23335 case E_VDEC_EX_V2_USER_CMD_DISABLE_ES_FULL_STOP:
23336 ret = _MApi_VDEC_EX_DisableEsFullStop(pStreamId,(MS_BOOL)(*((MS_BOOL*)(param[0]))));
23337 break;
23338
23339 case E_VDEC_EX_V2_USER_CMD_SET_SLOW_SYNC:
23340 ret = _MApi_VDEC_EX_SetSlow_Sync(pStreamId,(VDEC_EX_Slow_Sync*)(*((MS_VIRT*)(param[0]))));
23341 break;
23342
23343 case E_VDEC_EX_V2_USER_CMD_DIRECT_STC_MODE:
23344 ret = _MApi_VDEC_EX_Direct_STC_Mode(pStreamId,(MS_U32)(*((MS_U32*)(param[0]))));
23345 break;
23346 case E_VDEC_EX_V2_USER_CMD_SET_DV_XC_SHM_ADDR:
23347 {
23348 VDEC_PRINT("Warning: This is old function. Use MApi_VDEC_EX_PreSetControl(E_VDEC_EX_USER_CMD_SET_BUFFER_INFO) instead.");
23349 MS_PHY *pXCShmAddr = (MS_PHY *)(*((MS_VIRT*)(param[0])));
23350 ret = _MApi_VDEC_EX_V2_SetDVXCShmAddr(pStreamId, (MS_PHY)*pXCShmAddr);
23351 }
23352 break;
23353 #ifdef VDEC_CAP_DV_OTT_API
23354 case E_VDEC_EX_V2_USER_CMD_SET_DV_INFO:
23355 ret = _MApi_VDEC_EX_SetDVInfo(pStreamId,(VDEC_EX_DV_Info*)(*((MS_VIRT*)(param[0]))));
23356 break;
23357 #endif
23358
23359 default:
23360 ret = E_VDEC_EX_RET_ILLEGAL_ACCESS;
23361 break;
23362 }
23363
23364 return ret;
23365 }
23366
23367
MApi_VDEC_EX_GetControl(VDEC_StreamId * pStreamId,VDEC_EX_User_Cmd cmd_id,MS_U32 * param)23368 VDEC_EX_Result MApi_VDEC_EX_GetControl(VDEC_StreamId* pStreamId, VDEC_EX_User_Cmd cmd_id, MS_U32* param)
23369 {
23370 VDEC_EX_V2_IO_Param IO_arg;
23371 VDEC_EX_Result ret;
23372
23373 if (pu32VDEC_EX_Inst == NULL)
23374 {
23375 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
23376 {
23377 VPRINTF("UtopiaOpen VDEC_EX failed\n");
23378 return E_VDEC_EX_FAIL;
23379 }
23380 }
23381
23382 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
23383 IO_arg.eUserCmd = _VDEC_MapUserCmd_V2(cmd_id);
23384 IO_arg.param[0] = (void*)param;
23385 IO_arg.pRet = (void*)(&ret);
23386
23387 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
23388 {
23389 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
23390 return E_VDEC_EX_FAIL;
23391 }
23392 else
23393 {
23394 #if 1//#ifdef VDEC_UTOPIA_2K
23395 if(E_VDEC_EX_USER_CMD_GET_FPA_SEI_EX == cmd_id)
23396 {
23397 VDEC_EX_Frame_packing_SEI_EX* ptr = (VDEC_EX_Frame_packing_SEI_EX*)param;
23398 ptr->u32DataBuff = MsOS_PA2KSEG1(ptr->u32DataBuff);
23399 }
23400 #endif
23401 return ret;
23402 }
23403 }
23404
23405
MApi_VDEC_EX_V2_GetControl(VDEC_StreamId * pStreamId,VDEC_EX_V2_User_Cmd cmd_id,void ** param)23406 VDEC_EX_Result MApi_VDEC_EX_V2_GetControl(VDEC_StreamId* pStreamId,VDEC_EX_V2_User_Cmd cmd_id,void** param)
23407 {
23408 VDEC_EX_Result eRet = E_VDEC_EX_OK;
23409 MS_U8 u8Idx = 0;
23410
23411 if((cmd_id == E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_FB_MEMORY_USAGE_SIZE)
23412 #ifdef VDEC_CAP_SYSTEM_PREGET_API
23413 #ifdef VDEC_CAP_DV_OTT_API
23414 || (cmd_id == E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_PROFILE)
23415 || (cmd_id == E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_LEVEL)
23416 #endif
23417 #endif
23418 )
23419 {
23420 //do nothing
23421 }
23422 else
23423 {
23424 if(E_VDEC_EX_V2_USER_CMD_GET_CODEC_CAP == cmd_id)
23425 {
23426 return _VDEC_EX_GetCodecCapInfo((VDEC_EX_CODEC_CAP_INFO*)(param[0]));
23427 }
23428
23429 if(E_VDEC_EX_V2_USER_CMD_GET_SECURE_MODE == cmd_id)
23430 {
23431 return _MApi_VDEC_EX_V2_IsSecureMode((MS_BOOL*)(param[0]));
23432 }
23433
23434 if(pStreamId == NULL)
23435 return E_VDEC_EX_FAIL;
23436
23437 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
23438
23439 if(E_VDEC_EX_V2_USER_CMD_GET_MAIN_STREAM_ID == cmd_id)
23440 {
23441 u8Idx = 0;
23442 }
23443 else if(E_VDEC_EX_V2_USER_CMD_GET_SUB_STREAM_ID == cmd_id)
23444 {
23445 u8Idx = 1;
23446 }
23447
23448 //these cmd should receive between vdec init and vdec exit
23449 _VDEC_INVALID_IDX_RET(u8Idx);
23450 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
23451 _VDEC_NOT_INIT_RET(u8Idx);
23452
23453 if(cmd_id != E_VDEC_EX_V2_USER_CMD_GET_MAIN_STREAM_ID &&
23454 cmd_id != E_VDEC_EX_V2_USER_CMD_GET_SUB_STREAM_ID)
23455 {
23456 _VDEC_INVALID_STREAM_ID_RET(pStreamId->u32Id);
23457 }
23458 }
23459
23460 switch (cmd_id)
23461 {
23462 case E_VDEC_EX_V2_USER_CMD_GET_CHROMA_TYPE:
23463 eRet = _VDEC_EX_IsChroma420(pStreamId, ((MS_U32*)(param[0])));
23464 break;
23465 case E_VDEC_EX_V2_USER_CMD_GET_REAL_FRAMERATE:
23466 eRet = _VDEC_EX_GetRealFrameRate(pStreamId, ((MS_U32*)(param[0])));
23467 break;
23468 case E_VDEC_EX_V2_USER_CMD_GET_ES_QUANTITY:
23469 eRet = _VDEC_EX_GetESQuantity(pStreamId, ((MS_U32*)(param[0])));
23470 break;
23471 case E_VDEC_EX_V2_USER_CMD_GET_COLOR_MATRIX:
23472 eRet = _VDEC_EX_GetColorMatrixCoef(pStreamId, ((MS_U32*)(param[0])));
23473 break;
23474 case E_VDEC_EX_V2_USER_CMD_GET_DYNSCALE_ENABLED:
23475 eRet = _VDEC_EX_GetIsDynScalingEnabled(pStreamId, ((MS_U32*)(param[0])));
23476 break;
23477 // Report internal active stream ID, and will not use input pStreamId.
23478 case E_VDEC_EX_V2_USER_CMD_GET_MAIN_STREAM_ID:
23479 case E_VDEC_EX_V2_USER_CMD_GET_SUB_STREAM_ID:
23480 if (param)
23481 {
23482 VDEC_StreamId *pOutStreamID = ((VDEC_StreamId*)(param[0]));
23483 if (E_VDEC_EX_V2_USER_CMD_GET_MAIN_STREAM_ID == cmd_id)
23484 {
23485 u8Idx = (MS_U8)E_VDEC_EX_MAIN_STREAM;
23486 }
23487 else if (E_VDEC_EX_V2_USER_CMD_GET_SUB_STREAM_ID == cmd_id)
23488 {
23489 u8Idx = (MS_U8)E_VDEC_EX_SUB_STREAM;
23490 }
23491 pOutStreamID->u32Version = 0;
23492 pOutStreamID->u32Id = (u8Idx << 24 | pVdecExContext->_Attr[u8Idx].u32DrvId);
23493 }
23494 break;
23495
23496 case E_VDEC_EX_V2_USER_CMD_GET_FPA_SEI:
23497 eRet = _MApi_VDEC_EX_GetFrmPackingArrSEI(pStreamId, param[0]);
23498 break;
23499
23500 case E_VDEC_EX_V2_USER_CMD_GET_FPA_SEI_EX:
23501 eRet = _MApi_VDEC_EX_GetFrmPackingArrSEI_EX(pStreamId, param[0]);
23502 break;
23503
23504 case E_VDEC_EX_V2_USER_CMD_GET_CLLI_SEI:
23505 eRet = _MApi_VDEC_EX_GetContentLightLevelInfoSEI(pStreamId, param[0]);
23506 break;
23507
23508 case E_VDEC_EX_V2_USER_CMD_GET_DCV_SEI:
23509 eRet = _MApi_VDEC_EX_GetDisplayColourVolumeArrSEI(pStreamId, param[0]);
23510 break;
23511 case E_VDEC_EX_V2_USER_CMD_GET_VUI_DISP_INFO:
23512 eRet = _MApi_VDEC_EX_V2_GetVUI_DISP_INFO(pStreamId, param[0]);
23513 break;
23514 #if VDEC_ENABLE_MVC
23515 case E_VDEC_EX_V2_USER_CMD_GET_ES2_QUANTITY:
23516 {
23517 VDEC_StreamId stTmpId;
23518 stTmpId.u32Version = pStreamId->u32Version;
23519 stTmpId.u32Id = pStreamId->u32Id + 0x00011000;
23520 eRet = _VDEC_EX_GetESQuantity(&stTmpId, ((MS_U32*)(param[0])));
23521 break;
23522 }
23523 case E_VDEC_EX_V2_USER_CMD_GET_MVC_SUB_FRAME_DISP_INFO:
23524 {
23525 eRet = _MApi_VDEC_EX_MVC_SubFrameDispInfo(pStreamId, ((MS_U32*)(param[0])));
23526 break;
23527 }
23528 case E_VDEC_EX_V2_USER_CMD_GET_MVC_BBU2_DECQ_VACANCY:
23529 eRet = _MApi_VDEC_EX_MVC_GetControl(pStreamId, E_VDEC_EX_MVC_GET_BBU2_DECQ_VACANCY,((MS_U32*)(param[0])));
23530 break;
23531 case E_VDEC_EX_V2_USER_CMD_GET_MVC_ES2_READ_PTR:
23532 eRet = _MApi_VDEC_EX_MVC_GetControl(pStreamId, E_VDEC_EX_MVC_GET_ES2_READ_PTR,((MS_U32*)(param[0])));
23533 break;
23534 case E_VDEC_EX_V2_USER_CMD_GET_MVC_ES2_WRITE_PTR:
23535 eRet = _MApi_VDEC_EX_MVC_GetControl(pStreamId, E_VDEC_EX_MVC_GET_ES2_WRITE_PTR,((MS_U32*)(param[0])));
23536 break;
23537 #endif /// VDEC_ENABLE_MVC
23538 case E_VDEC_EX_V2_USER_CMD_GET_U64PTS:
23539 eRet = _MApi_VDEC_EX_Get_U64PTS(pStreamId,param[0]);
23540 break;
23541 case E_VDEC_EX_V2_USER_CMD_GET_PRE_PAS_U64PTS:
23542 eRet = _MApi_VDEC_EX_Get_PRE_PAS_U64PTS(pStreamId,param[0]);
23543 break;
23544 case E_VDEC_EX_V2_USER_CMD_GET_ORI_INTERLACE_MODE:
23545 eRet = _VDEC_EX_GetIsOriInterlaceMode(pStreamId,((MS_U32*)(param[0])));
23546 break;
23547 case E_VDEC_EX_V2_USER_CMD_GET_MBS_ONLY_FLAG:
23548 eRet = _VDEC_GetMbsOnlyFlag(pStreamId,((MS_U32*)(param[0])));
23549 break;
23550 case E_VDEC_EX_V2_USER_CMD_GET_CRC_VALUE:
23551 eRet = _VDEC_EX_GetCrcValue(pStreamId,((VDEC_EX_CrcValue*)(param[0])));
23552 break;
23553 case E_VDEC_EX_V2_USER_CMD_GET_BBU_Q_NUM:
23554 eRet = _VDEC_GetBBUQNum(pStreamId, ((MS_U32*)(param[0])));
23555 break;
23556 case E_VDEC_EX_V2_USER_CMD_GET_DISP_FRAME_NUM:
23557 eRet = _VDEC_EX_GetDispFrmNum(pStreamId, ((MS_U32*)(param[0])));
23558 break;
23559 case E_VDEC_EX_V2_USER_CMD_GET_ES_BUFFER_STATUS:
23560 eRet = _VDEC_EX_GetESBufferStatus(pStreamId, ((MS_U32*)(param[0])));
23561 break;
23562 case E_VDEC_EX_V2_USER_CMD_GET_CODEC_TYPE:
23563 eRet = _VDEC_EX_GetFWCodecType(pStreamId, ((MS_U32*)(param[0])));
23564 break;
23565 case E_VDEC_EX_V2_USER_CMD_GET_SHAREMEMORY_BASE:
23566 eRet = _VDEC_EX_Get_ShareMemory_Base(pStreamId, ((MS_VIRT*)(param[0])));
23567 break;
23568 case E_VDEC_EX_V2_USER_CMD_GET_XC_LOW_DELAY_INT_STATE:
23569 eRet = _VDEC_EX_GetXcLowDelayIntState(pStreamId, ((MS_U32*)(param[0])));
23570 break;
23571 case E_VDEC_EX_V2_USER_CMD_GET_IS_LEAST_DISPQ_SIZE_FLAG:
23572 eRet = _VDEC_IsLeastDispQSize(pStreamId, ((MS_U32*)(param[0])));
23573 break;
23574 case E_VDEC_EX_V2_USER_CMD_GET_FIELD_PIC_FLAG:
23575 eRet = _VDEC_EX_GetFieldPicFlag(pStreamId, ((MS_U32*)(param[0])));
23576 break;
23577 case E_VDEC_EX_V2_USER_CMD_GET_SUPPORT_2ND_MVOP_INTERFACE:
23578 eRet = _VDEC_EX_GetSupport2ndMVOPInterface(pStreamId, ((MS_BOOL*)(param[0])));
23579 break;
23580 case E_VDEC_EX_V2_USER_CMD_GET_VSYNC_BRIDGE_ADDR:
23581 eRet = _VDEC_EX_GetVsyncBridgeAddr(pStreamId, ((MS_VIRT*)(param[0])));
23582 break;
23583 case E_VDEC_EX_V2_USER_CMD_GET_SEQ_CHANGE_INFO:
23584 eRet = _VDEC_EX_GetSeqChangeInfo(pStreamId, ((MS_U32*)(param[0])));
23585 break;
23586 case E_VDEC_EX_V2_USER_CMD_IS_STEP_DISP_DONE:
23587 eRet = _MApi_VDEC_EX_V2_IsStepDispDone(pStreamId);
23588 break;
23589 case E_VDEC_EX_V2_USER_CMD_IS_STEP_DECODE_DONE:
23590 eRet = _MApi_VDEC_EX_V2_IsStepDecodeDone(pStreamId);
23591 break;
23592 case E_VDEC_EX_V2_USER_CMD_GET_DISP_INFO:
23593 eRet = _MApi_VDEC_EX_V2_GetDispInfo(pStreamId,((VDEC_EX_DispInfo*)(param[0])));
23594 break;
23595 case E_VDEC_EX_V2_USER_CMD_IS_AVSYNC_ON:
23596 eRet = _MApi_VDEC_EX_V2_IsAVSyncOn(pStreamId);
23597 break;
23598 case E_VDEC_EX_V2_USER_CMD_IS_WITH_VALID_STREAM:
23599 eRet = _MApi_VDEC_EX_V2_IsWithValidStream(pStreamId);
23600 break;
23601 case E_VDEC_EX_V2_USER_CMD_IS_DISP_FINISH:
23602 eRet = _MApi_VDEC_EX_V2_IsDispFinish(pStreamId);
23603 break;
23604 case E_VDEC_EX_V2_USER_CMD_IS_IFRAME_FOUND:
23605 eRet = _MApi_VDEC_EX_V2_IsIFrameFound(pStreamId);
23606 break;
23607 case E_VDEC_EX_V2_USER_CMD_IS_SEQ_CHG:
23608 eRet = _MApi_VDEC_EX_V2_IsSeqChg(pStreamId);
23609 break;
23610 case E_VDEC_EX_V2_USER_CMD_IS_REACH_SYNC:
23611 eRet = _MApi_VDEC_EX_V2_IsReachSync(pStreamId);
23612 break;
23613 case E_VDEC_EX_V2_USER_CMD_IS_START_SYNC:
23614 eRet = _MApi_VDEC_EX_V2_IsStartSync(pStreamId);
23615 break;
23616 case E_VDEC_EX_V2_USER_CMD_IS_FREERUN:
23617 eRet = _MApi_VDEC_EX_V2_IsFreerun(pStreamId);
23618 break;
23619 case E_VDEC_EX_V2_USER_CMD_IS_WITH_LOW_DELAY:
23620 eRet = _MApi_VDEC_EX_V2_IsWithLowDelay(pStreamId);
23621 break;
23622 case E_VDEC_EX_V2_USER_CMD_IS_ALL_BUFFER_EMPTY:
23623 eRet = _MApi_VDEC_EX_V2_IsAllBufferEmpty(pStreamId);
23624 break;
23625 case E_VDEC_EX_V2_USER_CMD_GET_EXT_DISP_INFO:
23626 eRet = _MApi_VDEC_EX_V2_GetExtDispInfo(pStreamId,((VDEC_EX_ExtDispInfo*)(param[0])));
23627 break;
23628 case E_VDEC_EX_V2_USER_CMD_GET_DEC_FRAME_INFO:
23629 eRet = _MApi_VDEC_EX_V2_GetDecFrameInfo(pStreamId,((VDEC_EX_FrameInfo*)(param[0])));
23630 break;
23631 case E_VDEC_EX_V2_USER_CMD_GET_DISP_FRAME_INFO:
23632 eRet = _MApi_VDEC_EX_V2_GetDispFrameInfo(pStreamId,((VDEC_EX_FrameInfo*)(param[0])));
23633 break;
23634 case E_VDEC_EX_V2_USER_CMD_GET_DEC_TIMECODE:
23635 eRet = _MApi_VDEC_EX_V2_GetDecTimeCode(pStreamId,((VDEC_EX_TimeCode*)(param[0])));
23636 break;
23637 case E_VDEC_EX_V2_USER_CMD_GET_DISP_TIMECODE:
23638 eRet = _MApi_VDEC_EX_V2_GetDispTimeCode(pStreamId,((VDEC_EX_TimeCode*)(param[0])));
23639 break;
23640 case E_VDEC_EX_V2_USER_CMD_GET_EVENT_INFO:
23641 eRet = _MApi_VDEC_EX_V2_GetEventInfo(pStreamId,((MS_U32*)(param[0])));
23642 break;
23643 case E_VDEC_EX_V2_USER_CMD_GET_ACTIVE_FORMAT:
23644 eRet = _MApi_VDEC_EX_V2_GetActiveFormat(pStreamId,((MS_U8*)(param[0])));
23645 break;
23646 case E_VDEC_EX_V2_USER_CMD_GET_COLOUR_PRIMARIES:
23647 eRet = _MApi_VDEC_EX_V2_GetColourPrimaries(pStreamId,((MS_U8*)(param[0])));
23648 break;
23649 case E_VDEC_EX_V2_USER_CMD_GET_FW_VERSION:
23650 eRet = _MApi_VDEC_EX_V2_GetFwVersion(pStreamId,*((VDEC_EX_FwType*)(param[0])),((MS_U32*)(param[1])));
23651 break;
23652 case E_VDEC_EX_V2_USER_CMD_GET_GOP_CNT:
23653 eRet = _MApi_VDEC_EX_V2_GetGOPCnt(pStreamId,((MS_U8*)(param[0])));
23654 break;
23655 case E_VDEC_EX_V2_USER_CMD_GET_ES_WRITE_PTR:
23656 eRet = _MApi_VDEC_EX_V2_GetESWritePtr(pStreamId,((MS_VIRT*)(param[0])));
23657 break;
23658 case E_VDEC_EX_V2_USER_CMD_GET_ES_READ_PTR:
23659 eRet = _MApi_VDEC_EX_V2_GetESReadPtr(pStreamId,((MS_VIRT*)(param[0])));
23660 break;
23661 case E_VDEC_EX_V2_USER_CMD_GET_PTS:
23662 eRet = _MApi_VDEC_EX_V2_GetPTS(pStreamId,((MS_U32*)(param[0])));
23663 break;
23664 case E_VDEC_EX_V2_USER_CMD_GET_NEXT_PTS:
23665 eRet = _MApi_VDEC_EX_V2_GetNextPTS(pStreamId,((MS_U32*)(param[0])));
23666 break;
23667 case E_VDEC_EX_V2_USER_CMD_GET_VIDEO_PTS_STC_DELTA:
23668 eRet = _MApi_VDEC_EX_V2_GetVideoPtsStcDelta(pStreamId,((MS_S64*)(param[0])));
23669 break;
23670 case E_VDEC_EX_V2_USER_CMD_GET_ERR_CODE:
23671 eRet = _MApi_VDEC_EX_V2_GetErrCode(pStreamId,((VDEC_EX_ErrCode*)(param[0])));
23672 break;
23673 case E_VDEC_EX_V2_USER_CMD_GET_ERR_CNT:
23674 eRet = _MApi_VDEC_EX_V2_GetErrCnt(pStreamId,((MS_U32*)(param[0])));
23675 break;
23676 case E_VDEC_EX_V2_USER_CMD_GET_BITRATE:
23677 eRet = _MApi_VDEC_EX_V2_GetBitsRate(pStreamId,((MS_U32*)(param[0])));
23678 break;
23679 case E_VDEC_EX_V2_USER_CMD_GET_FRAME_CNT:
23680 eRet = _MApi_VDEC_EX_V2_GetFrameCnt(pStreamId,((MS_U32*)(param[0])));
23681 break;
23682 case E_VDEC_EX_V2_USER_CMD_GET_SKIP_CNT:
23683 eRet = _MApi_VDEC_EX_V2_GetSkipCnt(pStreamId,((MS_U32*)(param[0])));
23684 break;
23685 case E_VDEC_EX_V2_USER_CMD_GET_DROP_CNT:
23686 eRet = _MApi_VDEC_EX_V2_GetDropCnt(pStreamId,((MS_U32*)(param[0])));
23687 break;
23688 case E_VDEC_EX_V2_USER_CMD_GET_DISP_CNT:
23689 eRet = _MApi_VDEC_EX_V2_GetDispCnt(pStreamId,((MS_U32*)(param[0])));
23690 break;
23691 case E_VDEC_EX_V2_USER_CMD_GET_DECQ_VACANCY:
23692 eRet = _MApi_VDEC_EX_V2_GetDecQVacancy(pStreamId,((MS_U32*)(param[0])));
23693 break;
23694 case E_VDEC_EX_V2_USER_CMD_IS_32_PULLDOWN:
23695 eRet = _MApi_VDEC_EX_V2_Is32PullDown(pStreamId,((MS_BOOL*)(param[0])));
23696 break;
23697 case E_VDEC_EX_V2_USER_CMD_IS_ALIVE:
23698 eRet = _MApi_VDEC_EX_V2_IsAlive(pStreamId);
23699 break;
23700 case E_VDEC_EX_V2_USER_CMD_IS_CC_AVAILABLE:
23701 eRet = _MApi_VDEC_EX_V2_IsCCAvailable(pStreamId,((MS_BOOL*)(param[0])));
23702 break;
23703 case E_VDEC_EX_V2_USER_CMD_GET_CC_INFO:
23704 eRet = _MApi_VDEC_EX_V2_GetCCInfo(pStreamId,param[0],*((MS_U32*)(param[1])));
23705 break;
23706 case E_VDEC_EX_V2_USER_CMD_GET_TRICK_MODE:
23707 eRet = _MApi_VDEC_EX_V2_GetTrickMode(pStreamId,((VDEC_EX_TrickDec*)(param[0])));
23708 break;
23709 case E_VDEC_EX_V2_USER_CMD_GET_ACTIVE_CODEC_TYPE:
23710 eRet = _MApi_VDEC_EX_V2_GetActiveCodecType(pStreamId,((VDEC_EX_CodecType*)(param[0])));
23711 break;
23712 case E_VDEC_EX_V2_USER_CMD_GET_PATTERN_LEAST_LENGTH:
23713 eRet = _MApi_VDEC_EX_V2_GetPatternLeastLength(pStreamId,*((VDEC_EX_PatternType*)(param[0])),((MS_U32*)(param[1])));
23714 break;
23715 case E_VDEC_EX_V2_USER_CMD_MHEG_IS_IFRAME_DECODING:
23716 eRet = _MApi_VDEC_EX_V2_MHEG_IsIFrameDecoding(pStreamId);
23717 break;
23718 case E_VDEC_EX_V2_USER_CMD_CC_GET_WRITE_PTR:
23719 eRet = _MApi_VDEC_EX_V2_CC_GetWritePtr(pStreamId,((MS_U32*)(param[0])));
23720 break;
23721 case E_VDEC_EX_V2_USER_CMD_CC_GET_READ_PTR:
23722 eRet = _MApi_VDEC_EX_V2_CC_GetReadPtr(pStreamId,((MS_U32*)(param[0])));
23723 break;
23724 case E_VDEC_EX_V2_USER_CMD_CC_GET_IS_OVERFLOW:
23725 eRet = _MApi_VDEC_EX_V2_CC_GetIsOverflow(pStreamId,((MS_BOOL*)(param[0])));
23726 break;
23727 case E_VDEC_EX_V2_USER_CMD_GET_HW_KEY:
23728 eRet = _MApi_VDEC_EX_V2_GetHWKey(pStreamId,((MS_U8*)(param[0])));
23729 break;
23730 case E_VDEC_EX_V2_USER_CMD_GET_ES_BUFF_VACANCY:
23731 eRet = _MApi_VDEC_EX_V2_GetESBuffVacancy(pStreamId,((MS_U32*)(param[0])));
23732 break;
23733 case E_VDEC_EX_V2_USER_CMD_GET_ES_BUFF:
23734 eRet = _MApi_VDEC_EX_V2_GetESBuff(pStreamId,
23735 *((MS_U32*)(param[0])),
23736 ((MS_U32*)(param[1])),
23737 ((MS_PHY*)(param[2])));
23738 break;
23739 case E_VDEC_EX_V2_USER_CMD_GET_NEXT_DISP_FRAME:
23740 eRet = _MApi_VDEC_EX_V2_GetNextDispFrame(pStreamId,((VDEC_EX_DispFrame*)(param[0])));
23741 break;
23742 case E_VDEC_EX_V2_USER_CMD_CC_GET_INFO:
23743 eRet = _MApi_VDEC_EX_V2_CC_GetInfo(pStreamId,
23744 *((VDEC_EX_CCFormat*)(param[0])),
23745 *((VDEC_EX_CCInfoCmd*)(param[1])),
23746 ((MS_U32*)(param[2])));
23747 break;
23748 case E_VDEC_EX_V2_USER_CMD_CC_GET_IS_RST_DONE:
23749 eRet = _MApi_VDEC_EX_V2_CC_GetIsRstDone(pStreamId,*((VDEC_EX_CCFormat*)(param[0])));
23750 break;
23751 case E_VDEC_EX_V2_USER_CMD_CC_GET_IS_BUFF_OVERFLOW:
23752 eRet = _MApi_VDEC_EX_V2_CC_GetIsBuffOverflow(pStreamId,*((VDEC_EX_CCFormat*)(param[0])));
23753 break;
23754 case E_VDEC_EX_V2_USER_CMD_CC_GET_WRITE_ADDR:
23755 eRet = _MApi_VDEC_EX_V2_CC_GetWriteAdd(pStreamId,
23756 *((VDEC_EX_CCFormat*)(param[0])),
23757 ((MS_PHY*)(param[1])));
23758 break;
23759 case E_VDEC_EX_V2_USER_CMD_CC_GET_READ_ADDR:
23760 eRet = _MApi_VDEC_EX_V2_CC_GetReadAdd(pStreamId,
23761 *((VDEC_EX_CCFormat*)(param[0])),
23762 ((MS_PHY*)(param[1])));
23763 break;
23764 case E_VDEC_EX_V2_USER_CMD_CHECKCAPS:
23765 eRet = _MApi_VDEC_EX_V2_CheckCaps(pStreamId,
23766 *((VDEC_EX_CodecType*)(param[0])),
23767 ((MS_BOOL*)(param[1])));
23768 break;
23769 case E_VDEC_EX_V2_USER_CMD_IS_FRAME_RDY:
23770 eRet = _MApi_VDEC_EX_IsFrameRdy(pStreamId);
23771 break;
23772 case E_VDEC_EX_V2_USER_CMD_GET_FRAME_INFO_EX:
23773 eRet = _MApi_VDEC_EX_V2_GetFrameInfoEx(pStreamId,((VDEC_EX_FrameInfoEX*)(param[0])));
23774 break;
23775 case E_VDEC_EX_V2_USER_CMD_GET_FLUSH_PATTEN_ENTRY_NUM:
23776 eRet = _VDEC_EX_GetFlushPatternEntryNum(pStreamId, ((MS_U32*)(param[0])));
23777 break;
23778
23779 case E_VDEC_EX_V2_USER_CMD_GET_DS_BUF_MIU_SEL:
23780 eRet = _VDEC_EX_GetDSBufMiuSel(pStreamId, ((MS_U32*)(param[0])));
23781 break;
23782 case E_VDEC_EX_V2_USER_CMD_GET_FW_STATUS_FLAG:
23783 eRet = _MApi_VDEC_EX_V2_GetFWStatusFlag(pStreamId,((MS_U32*)(param[0])));
23784 break;
23785 case E_VDEC_EX_V2_USER_CMD_GET_HW_MAX_PIXEL:
23786 eRet = _VDEC_EX_GetHWMaxPixel(pStreamId, ((MS_U32*)(param[0])));
23787 break;
23788 case E_VDEC_EX_V2_USER_CMD_GET_EVENT_FLAG:
23789 eRet = _MApi_VDEC_EX_V2_GetEventFlag(pStreamId,param[0] ,(*(MS_U32*)param[1]) );
23790 break;
23791 case E_VDEC_EX_V2_USER_CMD_GET_NEXT_DISP_FRAME_INFO_EXT:
23792 eRet = _MApi_VDEC_EX_V2_GetNextDispFrameInfoExt(pStreamId, param[0]);
23793 break;
23794 case E_VDEC_EX_V2_USER_CMD_GET_VSYNC_BRIDGE_EXT_ADDR:
23795 eRet = _VDEC_EX_GetVsyncBridgeExtAddr(pStreamId, ((MS_VIRT*)(param[0])));
23796 break;
23797
23798 case E_VDEC_EX_V2_USER_CMD_GET_PVRSEAMLESS_INFO:
23799 eRet = _VDEC_EX_GetPVRSeamlessInfo(pStreamId, (VDEC_EX_PVR_Seamless_Info*)(param[0]));
23800 break;
23801
23802 case E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_FB_MEMORY_USAGE_SIZE:
23803 eRet = _VDEC_EX_GetFbMemUsageSize((VDEC_EX_FbMemUsage_Param *)(param[0]));
23804 break;
23805
23806 case E_VDEC_EX_V2_USER_CMD_GET_NOT_SUPPORT_INFO:
23807 eRet = _VDEC_EX_GetNotSupportInfo(pStreamId, ((MS_U32*)(param[0])));
23808 break;
23809 #ifdef VDEC_CAP_SYSTEM_PREGET_API
23810 #ifdef VDEC_CAP_DV_OTT_API
23811 case E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_PROFILE:
23812 eRet = _MApi_VDEC_EX_GetDVSupportProfiles(((MS_VIRT*)(param[0])));
23813 break;
23814 case E_VDEC_EX_V2_USER_CMD_SYSTEM_PREGET_DV_SUPPORT_LEVEL:
23815 eRet = _MApi_VDEC_EX_GetDVSupportHighestLevel(((MS_VIRT*)(param[0])));
23816 break;
23817 #endif
23818 #endif
23819 case E_VDEC_EX_V2_USER_CMD_GET_DISP_QUEUE_EMPTY:
23820 eRet = _MApi_VDEC_EX_V2_IsDispQueueEmpty(pStreamId,((MS_BOOL*)(param[0])));
23821 break;
23822 case E_VDEC_EX_V2_USER_CMD_GET_MIN_TSP_DATA_SIZE:
23823 eRet = _VDEC_EX_GetMinTspDataSize(pStreamId, ((MS_U32*)(param[0])));
23824 break;
23825 default:
23826 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
23827 break;
23828 }
23829
23830 return eRet;
23831 }
23832
23833 #ifdef VDEC_CAP_SYSTEM_PREGET_API
MApi_VDEC_EX_SystemPreGetControl(VDEC_EX_User_Cmd cmd_id,void * pParam)23834 VDEC_EX_Result MApi_VDEC_EX_SystemPreGetControl(VDEC_EX_User_Cmd cmd_id, void* pParam)
23835 {
23836 VDEC_EX_V2_IO_Param IO_arg;
23837 VDEC_EX_Result ret;
23838
23839 if (pu32VDEC_EX_Inst == NULL)
23840 {
23841 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
23842 {
23843 VPRINTF("UtopiaOpen VDEC_EX failed\n");
23844 return E_VDEC_EX_FAIL;
23845 }
23846 }
23847
23848 IO_arg.eUserCmd = _VDEC_MapUserCmd_V2(cmd_id);
23849 IO_arg.param[0] = (pParam);
23850 IO_arg.pRet = (void*)(&ret);
23851
23852 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_GET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
23853 {
23854 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
23855 return E_VDEC_EX_FAIL;
23856 }
23857 else
23858 {
23859 return ret;
23860 }
23861 }
23862 #endif
23863
MApi_VDEC_EX_SystemPreSetControl(VDEC_EX_User_Cmd cmd_id,void * pParam)23864 VDEC_EX_Result MApi_VDEC_EX_SystemPreSetControl(VDEC_EX_User_Cmd cmd_id, void* pParam)
23865 {
23866 VDEC_EX_V2_IO_Param IO_arg;
23867 VDEC_EX_Result ret;
23868
23869 if (pu32VDEC_EX_Inst == NULL)
23870 {
23871 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
23872 {
23873 VPRINTF("UtopiaOpen VDEC_EX failed\n");
23874 return E_VDEC_EX_FAIL;
23875 }
23876 }
23877
23878 IO_arg.eUserCmd = _VDEC_MapUserCmd_V2(cmd_id);
23879 IO_arg.param[0] = (pParam);
23880 IO_arg.pRet = (void*)(&ret);
23881
23882 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_PRE_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
23883 {
23884 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
23885 return E_VDEC_EX_FAIL;
23886 }
23887 else
23888 {
23889 return ret;
23890 }
23891 }
23892
MApi_VDEC_EX_PreSetControl(VDEC_StreamId * pStreamId,VDEC_EX_User_Cmd cmd_id,MS_U32 param)23893 VDEC_EX_Result MApi_VDEC_EX_PreSetControl(VDEC_StreamId *pStreamId, VDEC_EX_User_Cmd cmd_id, MS_U32 param)
23894 {
23895 VDEC_EX_V2_IO_Param IO_arg;
23896 VDEC_EX_Result ret;
23897
23898 if (pu32VDEC_EX_Inst == NULL)
23899 {
23900 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
23901 {
23902 VPRINTF("UtopiaOpen VDEC_EX failed\n");
23903 return E_VDEC_EX_FAIL;
23904 }
23905 }
23906
23907 IO_arg.StreamID = (VDEC_EX_V2_StreamId*) pStreamId;
23908 IO_arg.eUserCmd = _VDEC_MapUserCmd_V2(cmd_id);
23909 IO_arg.param[0] = (void*)(¶m);
23910 IO_arg.pRet = (void*)(&ret);
23911
23912 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_PRE_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
23913 {
23914 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
23915 return E_VDEC_EX_FAIL;
23916 }
23917 else
23918 {
23919 return ret;
23920 }
23921 }
23922
MApi_VDEC_EX_V2_PreSetControl(VDEC_StreamId * pStreamId,VDEC_EX_V2_User_Cmd cmd_id,void ** param)23923 VDEC_EX_Result MApi_VDEC_EX_V2_PreSetControl(VDEC_StreamId* pStreamId,VDEC_EX_V2_User_Cmd cmd_id,void** param)
23924 {
23925 VDEC_EX_Result eRet = E_VDEC_EX_OK;
23926 MS_U8 i = 0;
23927 MS_U8 u8Idx = 0;
23928 MS_U32 u32Id = 0;
23929
23930 switch (cmd_id)
23931 {
23932 case E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_VPU_CLOCK:
23933 eRet = _VDEC_EX_SetVPUClockSpeed((VDEC_EX_ClockSpeed)(*((MS_U32*)(param[0]))));
23934 break;
23935 case E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_HVD_CLOCK:
23936 eRet = _VDEC_EX_SetHVDClockSpeed((VDEC_EX_ClockSpeed)(*((MS_U32*)(param[0]))));
23937 break;
23938 case E_VDEC_EX_V2_USER_CMD_SYSTEM_PRESET_MVD_CLOCK:
23939 eRet = _VDEC_EX_SetMVDClockSpeed((VDEC_EX_ClockSpeed)(*((MS_U32*)(param[0]))));
23940 break;
23941 case E_VDEC_EX_V2_USER_CMD_VPU_SECURITY_MODE:
23942 _VDEC_EX_Enable_VPU_SecurityMode((MS_BOOL)(*((MS_U32*)(param[0]))));
23943 break;
23944
23945 case E_VDEC_EX_V2_USER_CMD_PRESET_DECODE_MODE:
23946 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
23947 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
23948
23949 if (pVdecExContext->_Attr[u8Idx].bInit)
23950 {
23951 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
23952 break;
23953 }
23954
23955 if ((*((MS_VIRT*)(param[0]))) == NULL)
23956 {
23957 eRet = E_VDEC_EX_RET_INVALID_PARAM;
23958 break;
23959 }
23960
23961 if (((VDEC_EX_DecModCfg *)(*((MS_VIRT*)(param[0]))))->eDecMod != E_VDEC_EX_DEC_MODE_DUAL_INDIE)
23962 {
23963 for (i=0; i<VDEC_MAX_SUPPORT_STREAM_NUM; i++)
23964 {
23965 if (TRUE == pVdecExContext->_Attr[i].bInit)
23966 {
23967 VDEC_PRINT("DecMode must be set before init all tasks (%d)\n", i);
23968 eRet = E_VDEC_EX_FAIL;
23969 break;
23970 }
23971 }
23972 }
23973
23974 pVdecExContext->_Pre_DecModeCfg.eDecMod = ((VDEC_EX_DecModCfg *)(*((MS_VIRT*)(param[0]))))->eDecMod;
23975 for (i=0; i<VDEC_MAX_DEC_NUM; i++)
23976 {
23977 pVdecExContext->_Pre_DecModeCfg.pstCodecInfo[i] = ((VDEC_EX_DecModCfg *)(*((MS_VIRT*)(param[0]))))->pstCodecInfo[i];
23978 }
23979 pVdecExContext->_Pre_DecModeCfg.u8CodecCnt = ((VDEC_EX_DecModCfg *)(*((MS_VIRT*)(param[0]))))->u8CodecCnt;
23980 pVdecExContext->_Pre_DecModeCfg.u8ArgSize = ((VDEC_EX_DecModCfg *)(*((MS_VIRT*)(param[0]))))->u8ArgSize;
23981 pVdecExContext->_Pre_DecModeCfg.u32Arg = ((VDEC_EX_DecModCfg *)(*((MS_VIRT*)(param[0]))))->u32Arg;
23982
23983 break;
23984
23985 case E_VDEC_EX_V2_USER_CMD_PRESET_ENABLETURBOMODE:
23986 eRet = _MApi_VDEC_EX_V2_EnableTurboMode(*((MS_BOOL*)(param[0])));
23987 break;
23988 case E_VDEC_EX_V2_USER_CMD_PRESETSINGLEDECODE:
23989 eRet = _MApi_VDEC_EX_V2_SetSingleDecode(*((MS_BOOL*)(param[0])));
23990 break;
23991 case E_VDEC_EX_V2_USER_CMD_PREGETSTATUS:
23992 eRet = _MApi_VDEC_EX_V2_GetStatus(pStreamId,((VDEC_EX_Status*)(param[0])));
23993 break;
23994 case E_VDEC_EX_V2_USER_CMD_SETPOWERSTATE:
23995 eRet = _MApi_VDEC_EX_V2_SetPowerState((EN_POWER_MODE)(*((MS_U32*)(param[0]))));
23996 break;
23997
23998 case E_VDEC_EX_V2_USER_CMD_SET_SHAREMEMORY_BASE: //common HVD+MVD
23999 eRet = _VDEC_EX_Set_ShareMemory_Base(pStreamId,(MS_VIRT)(*((MS_VIRT*)(param[0]))));
24000 break;
24001 case E_VDEC_EX_V2_USER_CMD_HVD_COL_BBU_MODE: //HVD
24002 eRet = _VDEC_EX_SetHVDColBBUMode(pStreamId, (MS_BOOL)(*((MS_VIRT*)(param[0]))));
24003 break;
24004 case E_VDEC_EX_V2_USER_CMD_HVD_ONE_PENDING_BUFFER_MODE: //HVD
24005 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24006 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24007
24008 if (pVdecExContext->_Attr[u8Idx].bInit)
24009 {
24010 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24011 break;
24012 }
24013 pVdecExContext->_Pre_Ctrl[u8Idx].bOnePendingBuffer = (MS_BOOL)(*((MS_U32*)(param[0])));
24014 break;
24015 case E_VDEC_EX_V2_USER_CMD_HVD_TS_IN_BBU_MODE:
24016 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24017 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24018
24019 if (pVdecExContext->_Attr[u8Idx].bInit)
24020 {
24021 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24022 break;
24023 }
24024 pVdecExContext->_Pre_Ctrl[u8Idx].bDisableTspInBbuMode = (MS_BOOL)(*((MS_U32*)(param[0])));
24025 break;
24026 case E_VDEC_EX_V2_USER_CMD_MVD_HWBUFFER_REMAPPING_MODE: //MVD
24027 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24028 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24029
24030 if (pVdecExContext->_Attr[u8Idx].bInit)
24031 {
24032 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24033 break;
24034 }
24035 pVdecExContext->_Pre_Ctrl[u8Idx].bHWBufferReMapping = (MS_BOOL)(*((MS_U32*)(param[0])));
24036 break;
24037
24038 case E_VDEC_EX_V2_USER_CMD_HVD_IAPGN_BUF_SHARE_BW_MODE:
24039 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24040 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24041
24042 if (pVdecExContext->_Attr[u8Idx].bInit)
24043 {
24044 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24045 break;
24046 }
24047
24048 pVdecExContext->_Pre_Ctrl[u8Idx].stIapGnShBWMode.bEnable = ((VDEC_EX_IapGnBufShareBWMode*)(*((MS_VIRT*)(param[0]))))->bEnable;
24049 pVdecExContext->_Pre_Ctrl[u8Idx].stIapGnShBWMode.u32IapGnBufAddr= ((VDEC_EX_IapGnBufShareBWMode*)(*((MS_VIRT*)(param[0]))))->u32IapGnBufAddr;
24050 pVdecExContext->_Pre_Ctrl[u8Idx].stIapGnShBWMode.u32IapGnBufSize= ((VDEC_EX_IapGnBufShareBWMode*)(*((MS_VIRT*)(param[0]))))->u32IapGnBufSize;
24051
24052 break;
24053 case E_VDEC_EX_V2_USER_CMD_AUTO_ARRANGE_FRAMEBUFFER_USAGE:
24054 u32Id = _VDEC_GET_DRV_ID(pStreamId->u32Id);
24055 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24056
24057 MDrv_MVD_Dynamic_FB_Mode(u32Id,
24058 ((VDEC_Framebuffer_Ctrl*)(*((MS_VIRT*)(param[0]))))->bEnableFramebufferCtrl,
24059 ((VDEC_Framebuffer_Ctrl*)(*((MS_VIRT*)(param[0]))))->u32FramebufferAddress,
24060 ((VDEC_Framebuffer_Ctrl*)(*((MS_VIRT*)(param[0]))))->u32FramebufferTotalsize);
24061 break;
24062
24063 case E_VDEC_EX_V2_USER_CMD_MFCODEC_MODE: //EVD
24064 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24065 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24066
24067 if (pVdecExContext->_Attr[u8Idx].bInit)
24068 {
24069 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24070 break;
24071 }
24072 pVdecExContext->_Pre_Ctrl[u8Idx].eMFCodecMode = (VDEC_EX_MFCodec_mode)(*((MS_U32 *)(param[0])));
24073 break;
24074
24075 case E_VDEC_EX_V2_USER_CMD_FORCE_8BIT_DEC_MODE: //EVD
24076 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24077 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24078
24079 if (pVdecExContext->_Attr[u8Idx].bInit)
24080 {
24081 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24082 break;
24083 }
24084 pVdecExContext->_Pre_Ctrl[u8Idx].bForce8bitMode = (MS_BOOL)(*((MS_U32 *)(param[0])));
24085 break;
24086
24087 case E_VDEC_EX_V2_USER_CMD_VDEC_FEATURE:
24088 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24089 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24090
24091 if (pVdecExContext->_Attr[u8Idx].bInit)
24092 {
24093 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24094 break;
24095 }
24096 pVdecExContext->_Pre_Ctrl[u8Idx].eVdecFeature = (*((MS_U32 *)(param[0])));
24097 VDEC_PRINT("E_VDEC_EX_V2_USER_CMD_VDEC_FEATURE 0x%x\n", pVdecExContext->_Pre_Ctrl[u8Idx].eVdecFeature);
24098 break;
24099
24100 case E_VDEC_EX_V2_USER_CMD_DYNAMIC_CMA_MODE:
24101 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24102 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24103
24104 if (pVdecExContext->_Attr[u8Idx].bInit)
24105 {
24106 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24107 break;
24108 }
24109 pVdecExContext->_Pre_Ctrl[u8Idx].bEnableDynamicCMA = (*((MS_BOOL *)(param[0])));
24110 VDEC_PRINT("E_VDEC_EX_V2_USER_CMD_DYNAMIC_CMA_MODE 0x%x\n", pVdecExContext->_Pre_Ctrl[u8Idx].bEnableDynamicCMA);
24111 break;
24112
24113 case E_VDEC_EX_V2_USER_CMD_SET_DISPLAY_MODE:
24114 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24115 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24116 if (pVdecExContext->_Attr[u8Idx].bInit)
24117 {
24118 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24119 break;
24120 }
24121 pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode = (*((MS_U32 *)(param[0])));
24122 if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode == E_VDEC_EX_DISPLAY_MODE_MCU)
24123 {
24124 pVdecExContext->_bVdecDispOutSide[u8Idx] = TRUE;
24125 }
24126 else if(pVdecExContext->_Pre_Ctrl[u8Idx].eDisplayMode == E_VDEC_EX_DISPLAY_MODE_HARDWIRE)
24127 {
24128 pVdecExContext->_bVdecDispOutSide[u8Idx] = FALSE;
24129 }
24130 break;
24131 case E_VDEC_EX_V2_USER_CMD_PRESET_STC:
24132 eRet = _VDEC_EX_SetSTCMode(pStreamId,(VDEC_EX_STCMode)(*((MS_U32*)(param[0]))));
24133 break;
24134 case E_VDEC_EX_V2_USER_CMD_CONNECT_INPUT_TSP:
24135 break;
24136
24137 case E_VDEC_EX_V2_USER_CMD_CONNECT_DISPLAY_PATH:
24138 break;
24139
24140 case E_VDEC_EX_V2_USER_CMD_BITSTREAMBUFFER_MONOPOLY:
24141 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24142 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24143 pVdecExContext->_Pre_Ctrl[u8Idx].bMonopolyBitstreamBuffer = (MS_BOOL)(*((MS_U32 *)(param[0])));
24144 break;
24145
24146 case E_VDEC_EX_V2_USER_CMD_FRAMEBUFFER_MONOPOLY:
24147 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24148 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24149 pVdecExContext->_Pre_Ctrl[u8Idx].bMonopolyFrameBuffer = (MS_BOOL)(*((MS_U32 *)(param[0])));
24150 break;
24151
24152 case E_VDEC_EX_V2_USER_CMD_SPECIFY_TASK_SPEC:
24153 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24154 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24155 pVdecExContext->_Pre_Ctrl[u8Idx].eTaskSpec = (VDEC_EX_TASK_SPEC)(*((MS_U32 *)(param[0])));
24156 break;
24157
24158 case E_VDEC_EX_V2_USER_CMD_CAL_FRAMERATE:
24159 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24160 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24161 pVdecExContext->_Pre_Ctrl[u8Idx].bCalFrameRate = (*((MS_BOOL*)(param[0])));
24162 break;
24163
24164 case E_VDEC_EX_V2_USER_CMD_SET_TOTALRANGE_BITSTREAMBUFFER:
24165 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24166 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24167 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnBS.bSetTotalBuf = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->bSetTotalBuf;
24168 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnBS.phyTotalBufAddr = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->phyTotalBufAddr;
24169 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnBS.szTotalBufSize = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->szTotalBufSize;
24170 break;
24171
24172 case E_VDEC_EX_V2_USER_CMD_SET_TOTALRANGE_FRAMEBUFFER1:
24173 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24174 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24175 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB1.bSetTotalBuf = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->bSetTotalBuf;
24176 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB1.phyTotalBufAddr = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->phyTotalBufAddr;
24177 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB1.szTotalBufSize = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->szTotalBufSize;
24178 break;
24179
24180 case E_VDEC_EX_V2_USER_CMD_SET_TOTALRANGE_FRAMEBUFFER2:
24181 u8Idx = _VDEC_GET_IDX(pStreamId->u32Id);
24182 _VDEC_SHM_POINTER_CHECK(E_VDEC_EX_FAIL);
24183 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB2.bSetTotalBuf = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->bSetTotalBuf;
24184 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB2.phyTotalBufAddr = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->phyTotalBufAddr;
24185 pVdecExContext->_Pre_Ctrl[u8Idx].stTotalBufRgnFB2.szTotalBufSize = ((VDEC_EX_TotalBufRange*)(*((MS_VIRT*)(param[0]))))->szTotalBufSize;
24186 break;
24187
24188 default:
24189 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24190 break;
24191 }
24192 return eRet;
24193 }
24194
MApi_VDEC_EX_SystemPostSetControl(VDEC_EX_User_Cmd cmd_id,void * pParam)24195 VDEC_EX_Result MApi_VDEC_EX_SystemPostSetControl(VDEC_EX_User_Cmd cmd_id, void *pParam)
24196 {
24197 VDEC_EX_V2_IO_Param IO_arg;
24198 VDEC_EX_Result ret;
24199
24200 if (pu32VDEC_EX_Inst == NULL)
24201 {
24202 if(UtopiaOpen(MODULE_VDEC_EX | VDEC_DRIVER_BASE, &pu32VDEC_EX_Inst, 0, NULL) != UTOPIA_STATUS_SUCCESS)
24203 {
24204 VPRINTF("UtopiaOpen VDEC_EX failed\n");
24205 return E_VDEC_EX_FAIL;
24206 }
24207 }
24208
24209 IO_arg.eUserCmd = _VDEC_MapUserCmd_V2(cmd_id);
24210 IO_arg.param[0] = (pParam);
24211 IO_arg.pRet = (void*)(&ret);
24212
24213 if(UtopiaIoctl(pu32VDEC_EX_Inst,E_VDEC_EX_V2_CMD_POST_SET_CONTROL, (void*)(&IO_arg)) != UTOPIA_STATUS_SUCCESS)
24214 {
24215 VPRINTF("[Fail][%s,%d]\n",__FUNCTION__,__LINE__);
24216 return E_VDEC_EX_FAIL;
24217 }
24218 else
24219 {
24220 if(cmd_id == E_VDEC_EX_USER_CMD_SET_SECURE_MODE)
24221 {
24222 bSecureModeEnableUser = *((MS_BOOL*)pParam);
24223 }
24224 return ret;
24225 }
24226 }
24227
24228
MApi_VDEC_EX_V2_PostSetControl(VDEC_StreamId * pStreamId,VDEC_EX_V2_User_Cmd cmd_id,void ** param)24229 VDEC_EX_Result MApi_VDEC_EX_V2_PostSetControl(VDEC_StreamId* pStreamId,VDEC_EX_V2_User_Cmd cmd_id,void** param)
24230 {
24231 VDEC_EX_Result eRet = E_VDEC_EX_OK;
24232
24233 switch (cmd_id)
24234 {
24235 case E_VDEC_EX_V2_USER_CMD_SYSTEM_POSTSET_CLEAR_PROCESS_RELATED:
24236 eRet = _VDEC_EX_ClearProcessRelated(*((MS_U32*)(param[0])));
24237 break;
24238
24239 default:
24240 eRet = E_VDEC_EX_RET_ILLEGAL_ACCESS;
24241 break;
24242 }
24243
24244 return eRet;
24245 }
24246
_VDEC_EX_Create_BBU_Task(MS_U32 u32streamIdx)24247 MS_BOOL _VDEC_EX_Create_BBU_Task(MS_U32 u32streamIdx)
24248 {
24249 MDrv_HVD_EX_BBU_Proc(u32streamIdx);
24250 return TRUE;
24251 }
24252
_VDEC_EX_Delete_BBU_Task(MS_U32 u32streamIdx)24253 void _VDEC_EX_Delete_BBU_Task(MS_U32 u32streamIdx)
24254 {
24255 MDrv_HVD_EX_BBU_StopProc(u32streamIdx);
24256 }
24257
24258
24259 #else
24260 // TEE side
24261 #if defined(MSOS_TYPE_NUTTX)
24262 extern int lib_lowVDEC_PRINT(const char *fmt, ...);
24263 #define PRINTF lib_lowVDEC_PRINT
24264 #elif defined(MSOS_TYPE_OPTEE)
24265 #include "drvSEAL.h"
24266 #define PRINTF VDEC_PRINT
24267 #endif
24268
24269 typedef enum
24270 {
24271 E_VDEC_EX_REE_TO_TEE_MBX_MSG_NULL,
24272 E_VDEC_EX_REE_TO_TEE_MBX_MSG_FW_LoadCode,
24273 E_VDEC_EX_REE_TO_TEE_MBX_MSG_GETSHMBASEADDR,
24274 } VDEC_REE_TO_TEE_MBX_MSG_TYPE;
24275
24276 typedef enum
24277 {
24278 E_VDEC_EX_CODEC_TYPE_NONE = 0,
24279 E_VDEC_EX_CODEC_TYPE_MPEG2,
24280 E_VDEC_EX_CODEC_TYPE_H263,
24281 E_VDEC_EX_CODEC_TYPE_MPEG4,
24282 E_VDEC_EX_CODEC_TYPE_DIVX311,
24283 E_VDEC_EX_CODEC_TYPE_DIVX412,
24284 E_VDEC_EX_CODEC_TYPE_FLV,
24285 E_VDEC_EX_CODEC_TYPE_VC1_ADV,
24286 E_VDEC_EX_CODEC_TYPE_VC1_MAIN,
24287 E_VDEC_EX_CODEC_TYPE_RV8,
24288 E_VDEC_EX_CODEC_TYPE_RV9,
24289 E_VDEC_EX_CODEC_TYPE_H264,
24290 E_VDEC_EX_CODEC_TYPE_AVS,
24291 E_VDEC_EX_CODEC_TYPE_MJPEG,
24292 E_VDEC_EX_CODEC_TYPE_MVC,
24293 E_VDEC_EX_CODEC_TYPE_VP8,
24294 E_VDEC_EX_CODEC_TYPE_HEVC,
24295 E_VDEC_EX_CODEC_TYPE_VP9,
24296 E_VDEC_EX_CODEC_TYPE_HEVC_DV,
24297 E_VDEC_EX_CODEC_TYPE_H264_DV,
24298 E_VDEC_EX_CODEC_TYPE_NUM
24299 } VDEC_EX_CodecType;
24300
24301 typedef enum
24302 {
24303 E_Decode_NONE,
24304 E_Decode_HVD,
24305 E_Decode_EVD,
24306 E_Decode_MVD,
24307 E_Decode_VP8 //because special ES buffer
24308 } VDEC_EX_DecodeType;
24309 typedef struct
24310 {
24311 MS_PHY Bitstream_Addr_Main;
24312 MS_U32 Bitstream_Len_Main;
24313 MS_PHY Bitstream_Addr_Sub;
24314 MS_U32 Bitstream_Len_Sub;
24315 MS_PHY MIU1_BaseAddr;
24316 } VPU_EX_LOCK_DOWN_REGISTER;
24317
24318 typedef struct
24319 {
24320 MS_PHY VPUBufAddr;
24321 MS_SIZE VPUBufSize;
24322 MS_PHY BSBufAddr;
24323 MS_SIZE BSBufSize;
24324 MS_PHY FBufAddr;
24325 MS_SIZE FBufSize;
24326 MS_U32 u32streamID;
24327 VDEC_EX_CodecType eCodecType;
24328 } VDEC_EX_OPTEE_SecureBuffer;
24329
24330 typedef struct
24331 {
24332 MS_PHY FBuf2Addr;
24333 MS_SIZE FBuf2Size;
24334 MS_U32 u32streamID;
24335 } VDEC_EX_OPTEE_SecureFB2;
24336
24337 typedef struct
24338 {
24339 MS_PHY BSBufAddr;
24340 MS_SIZE BSBufSize;
24341 MS_U8 stream_ID;
24342 VDEC_EX_DecodeType Decoder;
24343 } Lock_Register_Info;
24344
24345 #define VDEC_DRIVER_PROC_BUFFER_SIZE 0xA000
24346 MS_PHY VPU_CodeAddr = 0;
24347 MS_U32 VPU_CodeSize = 0;
24348 MS_PHY Bitstream_StartAddr_Main = 0;
24349 MS_U32 Bitstream_Size_Main = 0;
24350 MS_PHY Bitstream_StartAddr_Sub = 0;
24351 MS_U32 Bitstream_Size_Sub = 0;
24352 MS_PHY Framebuffer_StartAddr_Main = 0;
24353 MS_U32 Framebuffer_Size_Main = 0;
24354 MS_PHY Framebuffer_StartAddr_Sub = 0;
24355 MS_U32 Framebuffer_Size_Sub = 0;
24356 MS_PHY VPU_SHMAddr = 0;
24357 MS_U32 VPU_SHMSize = 0; // need at least 256k bytes
24358 MS_PHY MIU1_StartAddr = 0;
24359 MS_PHY Framebuffer2_StartAddr_Main = 0;
24360 MS_U32 Framebuffer2_Size_Main = 0;
24361 MS_PHY Framebuffer2_StartAddr_Sub = 0;
24362 MS_U32 Framebuffer2_Size_Sub = 0;
24363 MS_U8 Secure_Status_Main= 0;
24364 MS_U8 Secure_Status_Sub= 0;
24365 MS_U32 VCodecType_Main= 0;
24366 MS_U32 VCodecType_Sub= 0;
24367
_VDEC_TEE_Load_FwCode(MS_U32 u32DestAddr)24368 MS_BOOL _VDEC_TEE_Load_FwCode(MS_U32 u32DestAddr)
24369 {
24370 return MDrv_HVD_EX_LoadCodeInSecure(u32DestAddr);
24371 }
24372
_VDEC_TEE_Lock_Down_Register(VPU_EX_LOCK_DOWN_REGISTER * param,MS_U8 u8IsHVD)24373 MS_BOOL _VDEC_TEE_Lock_Down_Register(VPU_EX_LOCK_DOWN_REGISTER* param,MS_U8 u8IsHVD)
24374 {
24375 return MDrv_HVD_EX_SetLockDownRegister((void*)param,u8IsHVD);
24376 }
24377
24378 #if defined(MSOS_TYPE_NUTTX)
24379
24380 typedef enum
24381 {
24382 E_VDEC_EX_TEE_TO_REE_MBX_MSG_NULL,
24383 E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_INVALID,
24384 E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_NO_TEE,
24385 E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS,
24386 E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL
24387 } VDEC_TEE_TO_REE_MBX_ACK_TYPE;
24388
24389 #define VDEC_EX_STACK_SIZE 4096
24390
24391
24392 MS_S32 _s32VDEC_TEE_EventId = -1;
24393 MS_S32 _s32VDEC_TEE_TaskId = -1;
24394 MS_U8 u8VdecExTeeStack[4096];
24395 MBX_Msg VDEC_TEE_msg;
24396 MS_U8 u8VDECMbxMsgClass = 0;
24397 MBX_Msg VDECTeeToReeMbxMsg;
24398
_VDEC_TEE_Proc(void)24399 void _VDEC_TEE_Proc(void)
24400 {
24401 MS_U32 u32Events;
24402 MS_U8 u8Index = 0;
24403 MBX_Result result;
24404 MS_U8 u8IsHVD = 0;
24405
24406 PRINTF("VDEC TEE_Proc\n");
24407
24408 while (1)
24409 {
24410 MsOS_WaitEvent(_s32VDEC_TEE_EventId, 1, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
24411
24412 u8Index = VDEC_TEE_msg.u8Index;
24413 u8IsHVD = VDEC_TEE_msg.u8Parameters[0];
24414
24415 memset(&VDECTeeToReeMbxMsg,0,sizeof(MBX_Msg));
24416 VDECTeeToReeMbxMsg.eRoleID = E_MBX_CPU_MIPS;
24417 VDECTeeToReeMbxMsg.u8Ctrl = 0;
24418 VDECTeeToReeMbxMsg.eMsgType = E_MBX_MSG_TYPE_INSTANT;
24419 VDECTeeToReeMbxMsg.u8MsgClass = VDEC_TEE_msg.u8MsgClass;
24420 VDECTeeToReeMbxMsg.u8Index = E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS;
24421
24422 switch(u8Index)
24423 {
24424 case E_VDEC_EX_REE_TO_TEE_MBX_MSG_FW_LoadCode:
24425 PRINTF("VDEC receive load f/w code in R2\n");
24426
24427 if(VPU_CodeAddr == 0)
24428 {
24429 VDECTeeToReeMbxMsg.u8Index = E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
24430 }
24431 else
24432 {
24433 if (_VDEC_TEE_Load_FwCode(MsOS_PA2KSEG1(VPU_CodeAddr)) == FALSE)
24434 {
24435 VDECTeeToReeMbxMsg.u8Index = E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
24436 }
24437 else
24438 {
24439 VPU_EX_LOCK_DOWN_REGISTER register_lockdown;
24440 register_lockdown.Bitstream_Addr_Main = Bitstream_StartAddr_Main;
24441 register_lockdown.Bitstream_Len_Main = Bitstream_Size_Main;
24442
24443 register_lockdown.Bitstream_Addr_Sub = Bitstream_StartAddr_Sub;
24444 register_lockdown.Bitstream_Len_Sub = Bitstream_Size_Sub;
24445 register_lockdown.MIU1_BaseAddr = MIU1_StartAddr;
24446
24447 if(_VDEC_TEE_Lock_Down_Register(®ister_lockdown,u8IsHVD) == TRUE)
24448 {
24449 PRINTF("VDEC receive load f/w code success in R2\n");
24450 }
24451 }
24452 }
24453 break;
24454 case E_VDEC_EX_REE_TO_TEE_MBX_MSG_GETSHMBASEADDR:
24455 PRINTF("VDEC receive get shm address in R2\n");
24456 if((VPU_SHMAddr == 0) || (VPU_SHMAddr <= VPU_CodeAddr) || (VPU_SHMSize < 0x40000))
24457 {
24458 PRINTF("[VDEC]%s,share memory base (%x,%x) is not ready\n",__FUNCTION__,(unsigned int)VPU_SHMAddr,(unsigned int)VPU_CodeAddr);
24459 VDECTeeToReeMbxMsg.u8Index = E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
24460 }
24461 else
24462 {
24463 MS_U32 SHM_offset;
24464 if(VPU_SHMAddr >= MIU1_StartAddr)
24465 {
24466 SHM_offset = VPU_SHMAddr-MIU1_StartAddr;
24467 VDECTeeToReeMbxMsg.u8Parameters[8] = 1; // miu1
24468 }
24469 else
24470 {
24471 SHM_offset = VPU_SHMAddr;
24472 VDECTeeToReeMbxMsg.u8Parameters[8] = 0; // miu0
24473 }
24474
24475 VDECTeeToReeMbxMsg.u8Index = E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_SUCCESS;
24476 VDECTeeToReeMbxMsg.u8Parameters[0] = SHM_offset&0xff;
24477 VDECTeeToReeMbxMsg.u8Parameters[1] = (SHM_offset>>8)&0xff;
24478 VDECTeeToReeMbxMsg.u8Parameters[2] = (SHM_offset>>16)&0xff;
24479 VDECTeeToReeMbxMsg.u8Parameters[3] = (SHM_offset>>24)&0xff;
24480 VDECTeeToReeMbxMsg.u8Parameters[4] = VPU_SHMSize&0xff;
24481 VDECTeeToReeMbxMsg.u8Parameters[5] = (VPU_SHMSize>>8)&0xff;
24482 VDECTeeToReeMbxMsg.u8Parameters[6] = (VPU_SHMSize>>16)&0xff;
24483 VDECTeeToReeMbxMsg.u8Parameters[7] = (VPU_SHMSize>>24)&0xff;
24484 VDECTeeToReeMbxMsg.u8ParameterCount = 9;
24485
24486 PRINTF("VDEC receive get shm address success in R2\n");
24487 }
24488 break;
24489 default:
24490 VDECTeeToReeMbxMsg.u8Index = E_VDEC_EX_TEE_TO_REE_MBX_ACK_MSG_ACTION_FAIL;
24491 PRINTF("[VDEC]%s,wrong command %d sent from HK\n",__FUNCTION__,(unsigned int)u8Index);
24492 break;
24493 }
24494
24495 result = MApi_MBX_SendMsg(&VDECTeeToReeMbxMsg);
24496
24497 #if 0
24498 if (E_MBX_SUCCESS != result)
24499 {
24500 PRINTF("[VDEC]Ack fail,classid:%x,cmd:%x\n",VDEC_TEE_msg.u8MsgClass, VDECTeeToReeMbxMsg.u8Index);
24501 }
24502 else
24503 {
24504 PRINTF("[VDEC]Ack ok,classid:%x\n",VDEC_TEE_msg.u8MsgClass);
24505 }
24506 #endif
24507 }
24508 }
24509
24510
_VDEC_TEE_HandleDynamicMBX(MBX_Msg * pMsg,MS_BOOL * pbAddToQueue)24511 void _VDEC_TEE_HandleDynamicMBX(MBX_Msg *pMsg, MS_BOOL *pbAddToQueue)
24512 {
24513 if(pMsg==NULL)
24514 {
24515 PRINTF("[VDEC]%s,pMsg is a null pointer\n",__FUNCTION__);
24516 return;
24517 }
24518
24519 if (_s32VDEC_TEE_EventId < 0)
24520 {
24521 PRINTF("[VDEC]%s,VDEC TEE event group is not created\n",__FUNCTION__);
24522 return;
24523 }
24524 memcpy(&VDEC_TEE_msg, pMsg, sizeof(MBX_Msg));
24525 MsOS_SetEvent(_s32VDEC_TEE_EventId, 1);
24526 *pbAddToQueue = FALSE;
24527 return;
24528 }
24529
24530 //------------------------------------------------------------------------------
24531 /// @brief Create task for TEE, protect VDEC from hacking
24532 /// @retval TRUE/FALSE
24533 //------------------------------------------------------------------------------
MApi_VDEC_EX_Create_Tee_System(void)24534 MS_BOOL MApi_VDEC_EX_Create_Tee_System(void)
24535 {
24536 if(u8VDECMbxMsgClass == 0)
24537 {
24538 if(MApi_MBX_GenerateDynamicClass(E_MBX_CPU_MIPS, "VDEC_TEE",&u8VDECMbxMsgClass) != E_MBX_SUCCESS)
24539 {
24540 PRINTF("[VDEC]TEE GenerateDynamicClass error\n");
24541 u8VDECMbxMsgClass = 0;
24542 return FALSE;
24543 }
24544
24545 if ( E_MBX_SUCCESS != MApi_MBX_RegisterMSGWithCallBack(u8VDECMbxMsgClass,10,_VDEC_TEE_HandleDynamicMBX))
24546 {
24547 PRINTF("[VDEC]TEE Register MBX MSG error\n");
24548 u8VDECMbxMsgClass = 0;
24549 return FALSE;
24550 }
24551 }
24552
24553 if(_s32VDEC_TEE_EventId == -1)
24554 {
24555 _s32VDEC_TEE_EventId = MsOS_CreateEventGroup("VDEC_TEE_Event");
24556 if (_s32VDEC_TEE_EventId < 0)
24557 {
24558 PRINTF("[VDEC]TEE CreateEventGroup error....\n");
24559 return FALSE;
24560 }
24561 }
24562
24563 if(_s32VDEC_TEE_TaskId == -1)
24564 {
24565 _s32VDEC_TEE_TaskId = MsOS_CreateTask((TaskEntry)_VDEC_TEE_Proc,
24566 NULL,
24567 E_TASK_PRI_MEDIUM,
24568 TRUE,
24569 (void*)u8VdecExTeeStack,
24570 VDEC_EX_STACK_SIZE,
24571 "VDEC_TEE_Task");
24572 if (_s32VDEC_TEE_TaskId < 0)
24573 {
24574 MsOS_DeleteEventGroup(_s32VDEC_TEE_EventId);
24575 PRINTF("[VDEC]TEE CreateTask error....\n");
24576 return FALSE;
24577 }
24578 }
24579 return TRUE;
24580 }
24581 #endif
24582
24583 #if defined(MSOS_TYPE_OPTEE)
_VDEC_EX_OPTEE_ResetBuffer(MS_U8 stream_ID)24584 void _VDEC_EX_OPTEE_ResetBuffer(MS_U8 stream_ID)
24585 {
24586 if(stream_ID ==0)
24587 {
24588 Bitstream_StartAddr_Main=0;
24589 Bitstream_Size_Main=0;
24590 Framebuffer_StartAddr_Main=0;
24591 Framebuffer_Size_Main=0;
24592 Framebuffer2_StartAddr_Main=0;
24593 Framebuffer2_Size_Main=0;
24594 }
24595 else if(stream_ID == 1)
24596 {
24597 Bitstream_StartAddr_Sub=0;
24598 Bitstream_Size_Sub=0;
24599 Framebuffer_StartAddr_Sub=0;
24600 Framebuffer_Size_Sub=0;
24601 Framebuffer2_StartAddr_Sub=0;
24602 Framebuffer2_Size_Sub=0;
24603 }
24604 }
24605
_VDEC_EX_OPTEE_SET_SecureBuffer(VDEC_EX_OPTEE_SecureBuffer * buffer)24606 MS_BOOL _VDEC_EX_OPTEE_SET_SecureBuffer(VDEC_EX_OPTEE_SecureBuffer *buffer)
24607 {
24608 MS_U8 stream_ID = (MS_U8)(buffer->u32streamID >> 24)&0xff;
24609 VDEC_PRINT("[VDEC][OPTEE]%s,stream_id=%d\n",__FUNCTION__,stream_ID);
24610
24611 VPU_CodeAddr = buffer->VPUBufAddr;
24612 VPU_CodeSize = buffer->VPUBufSize;
24613
24614 if(stream_ID ==0)
24615 {
24616 Bitstream_StartAddr_Main = buffer->BSBufAddr;
24617 Bitstream_Size_Main = buffer->BSBufSize;
24618 Framebuffer_StartAddr_Main= buffer->FBufAddr;
24619 Framebuffer_Size_Main= buffer->FBufSize;
24620 VCodecType_Main= buffer->eCodecType;
24621 }
24622 else if(stream_ID ==1)
24623 {
24624 Bitstream_StartAddr_Sub = buffer->BSBufAddr;
24625 Bitstream_Size_Sub = buffer->BSBufSize;
24626 Framebuffer_StartAddr_Sub = buffer->FBufAddr;
24627 Framebuffer_Size_Sub = buffer->FBufSize;
24628 VCodecType_Sub= buffer->eCodecType;
24629 }
24630 return TRUE;
24631 }
24632
_VDEC_EX_OPTEE_SET_SecureFB2(VDEC_EX_OPTEE_SecureFB2 * buffer)24633 MS_BOOL _VDEC_EX_OPTEE_SET_SecureFB2(VDEC_EX_OPTEE_SecureFB2 *buffer)
24634 {
24635 MS_U8 stream_ID = (MS_U8)(buffer->u32streamID >> 24)&0xff;
24636 VDEC_PRINT("[VDEC][OPTEE]%s,stream_id=%d\n",__FUNCTION__,stream_ID);
24637
24638 if(stream_ID ==0)
24639 {
24640 Framebuffer2_StartAddr_Main = buffer->FBuf2Addr;
24641 Framebuffer2_Size_Main = buffer->FBuf2Size;
24642 }
24643 else if(stream_ID ==1)
24644 {
24645 Framebuffer2_StartAddr_Sub = buffer->FBuf2Addr;
24646 Framebuffer2_Size_Sub= buffer->FBuf2Size;
24647 }
24648 return TRUE;
24649 }
24650
MDrv_VDEC_GetResourceByPipeNNum(MS_U64 u64PipeID,VDEC_EX_OPTEE_Buffer ResEnum,VDEC_EX_RESOURCE * pResouce)24651 MS_U32 MDrv_VDEC_GetResourceByPipeNNum(MS_U64 u64PipeID, VDEC_EX_OPTEE_Buffer ResEnum, VDEC_EX_RESOURCE* pResouce)
24652 {
24653 MS_U8 stream_ID = (MS_U8)((u64PipeID >> 24)&0xff);
24654
24655 if(ResEnum == E_VDEC_VPU)
24656 {
24657 pResouce->ID[0]= VPU_CodeSize;
24658 pResouce->ID[1]= (VPU_CodeAddr& 0xFFFFFFFF);
24659 pResouce->ID[2]= ((VPU_CodeAddr>>32)& 0xFFFFFFFF);
24660 pResouce->ID[3]= 0;
24661
24662 return UTOPIA_STATUS_SUCCESS;
24663 }
24664 if(stream_ID == 0)
24665 {
24666 if(ResEnum == E_VDEC_BS)
24667 {
24668 pResouce->ID[0]= Bitstream_Size_Main;
24669 pResouce->ID[1]= (Bitstream_StartAddr_Main& 0xFFFFFFFF);
24670 pResouce->ID[2]= ((Bitstream_StartAddr_Main>>32) & 0xFFFFFFFF);
24671 pResouce->ID[3]= 0;
24672
24673 return UTOPIA_STATUS_SUCCESS;
24674 }
24675 else if(ResEnum == E_VDEC_FB)
24676 {
24677 pResouce->ID[0]= Framebuffer_Size_Main;
24678 pResouce->ID[1]= (Framebuffer_StartAddr_Main & 0xFFFFFFFF);
24679 pResouce->ID[2]= ((Framebuffer_StartAddr_Main>>32) & 0xFFFFFFFF);
24680 pResouce->ID[3]= 0;
24681
24682 return UTOPIA_STATUS_SUCCESS;
24683 }
24684 else if(ResEnum == E_VDEC_FB2)
24685 {
24686 pResouce->ID[0]= Framebuffer2_Size_Main;
24687 pResouce->ID[1]= (Framebuffer2_StartAddr_Main& 0xFFFFFFFF);
24688 pResouce->ID[2]= ((Framebuffer2_StartAddr_Main>>32)& 0xFFFFFFFF);
24689 pResouce->ID[3]= 0;
24690
24691 return UTOPIA_STATUS_SUCCESS;
24692 }
24693 }
24694 else if(stream_ID == 1)
24695 {
24696 if(ResEnum == E_VDEC_BS)
24697 {
24698 pResouce->ID[0]= Bitstream_Size_Sub;
24699 pResouce->ID[1]= (Bitstream_StartAddr_Sub& 0xFFFFFFFF);
24700 pResouce->ID[2]= ((Bitstream_StartAddr_Sub>>32) & 0xFFFFFFFF);
24701 pResouce->ID[3]= 0;
24702
24703 return UTOPIA_STATUS_SUCCESS;
24704 }
24705 else if(ResEnum == E_VDEC_FB)
24706 {
24707 pResouce->ID[0]= Framebuffer_Size_Sub;
24708 pResouce->ID[1]= (Framebuffer_StartAddr_Sub & 0xFFFFFFFF);
24709 pResouce->ID[2]= ((Framebuffer_StartAddr_Sub>>32) & 0xFFFFFFFF);
24710 pResouce->ID[3]= 0;
24711
24712 return UTOPIA_STATUS_SUCCESS;
24713 }
24714 else if(ResEnum == E_VDEC_FB2)
24715 {
24716 pResouce->ID[0]= Framebuffer2_Size_Sub;
24717 pResouce->ID[1]= (Framebuffer2_StartAddr_Sub& 0xFFFFFFFF);
24718 pResouce->ID[2]= ((Framebuffer2_StartAddr_Sub>>32)& 0xFFFFFFFF);
24719 pResouce->ID[3]= 0;
24720
24721 return UTOPIA_STATUS_SUCCESS;
24722 }
24723 }
24724 return UTOPIA_STATUS_FAIL;
24725 }
24726
MDrv_VDEC_GetResourceByPipeID(MS_U64 u64PipeID,MS_U32 * U32MaxNRetResNum,VDEC_EX_RESOURCE * pResouce)24727 MS_U32 MDrv_VDEC_GetResourceByPipeID(MS_U64 u64PipeID, MS_U32* U32MaxNRetResNum, VDEC_EX_RESOURCE* pResouce)
24728 {
24729 MS_U8 stream_ID = (MS_U8)((u64PipeID >> 24)&0xff);
24730 //VDEC_PRINT("[VDEC][OPTEE]%s,stream_id=%d\n",__FUNCTION__,stream_ID);
24731
24732 if(*U32MaxNRetResNum < 4)
24733 {
24734 VDEC_PRINT("[VDEC][OPTEE]Resource Number too less=%d\n",(int)*U32MaxNRetResNum);
24735 return UTOPIA_STATUS_FAIL;
24736 }
24737
24738 if(pResouce == NULL)
24739 {
24740 VDEC_PRINT("[VDEC][OPTEE]Resource NULL\n"); //hsiaochi
24741 return UTOPIA_STATUS_FAIL;
24742 }
24743
24744 if(stream_ID == 0)
24745 {
24746 pResouce[0].ID[0]= Bitstream_Size_Main;
24747 pResouce[0].ID[1]= (Bitstream_StartAddr_Main& 0xFFFFFFFF);
24748 pResouce[0].ID[2]= ((Bitstream_StartAddr_Main>>32) & 0xFFFFFFFF);
24749 pResouce[0].ID[3]= 0;
24750 pResouce[1].ID[0]= Framebuffer_Size_Main;
24751 pResouce[1].ID[1]= (Framebuffer_StartAddr_Main & 0xFFFFFFFF);
24752 pResouce[1].ID[2]= ((Framebuffer_StartAddr_Main>>32) & 0xFFFFFFFF);
24753 pResouce[1].ID[3]= 0;
24754
24755 *U32MaxNRetResNum = 2;
24756
24757 if(Framebuffer2_Size_Main>0)
24758 {
24759 pResouce[2].ID[0]= Framebuffer2_Size_Main;
24760 pResouce[2].ID[1]= (Framebuffer2_StartAddr_Main& 0xFFFFFFFF);
24761 pResouce[2].ID[2]= ((Framebuffer2_StartAddr_Main>>32)& 0xFFFFFFFF);
24762 pResouce[2].ID[3]= 0;
24763
24764 *U32MaxNRetResNum = 3;
24765 }
24766 }
24767 else if(stream_ID == 1)
24768 {
24769 pResouce[0].ID[0]= Bitstream_Size_Sub;
24770 pResouce[0].ID[1]= (Bitstream_StartAddr_Sub& 0xFFFFFFFF);
24771 pResouce[0].ID[2]= ((Bitstream_StartAddr_Sub>>32) & 0xFFFFFFFF);
24772 pResouce[0].ID[3]= 0;
24773 pResouce[1].ID[0]= (Framebuffer_Size_Sub& 0xFFFFFFFF);
24774 pResouce[1].ID[1]= (Framebuffer_StartAddr_Sub & 0xFFFFFFFF) ;
24775 pResouce[1].ID[2]= ((Framebuffer_StartAddr_Sub>>32) & 0xFFFFFFFF);
24776 pResouce[1].ID[3]= 0;
24777
24778 *U32MaxNRetResNum = 2;
24779
24780 if(Framebuffer2_Size_Sub>0)
24781 {
24782 pResouce[2].ID[0]= Framebuffer2_Size_Sub;
24783 pResouce[2].ID[1]= (Framebuffer2_StartAddr_Sub& 0xFFFFFFFF);
24784 pResouce[2].ID[2]= ((Framebuffer2_StartAddr_Sub>>32) & 0xFFFFFFFF);
24785 pResouce[2].ID[3]= 0;
24786
24787 *U32MaxNRetResNum = 3;
24788 }
24789 }
24790
24791 return UTOPIA_STATUS_SUCCESS;
24792 }
24793
_VDEC_EX_OPTEE_LockRegister(Lock_Register_Info * Lock_info,MS_U32 u32OperationMode)24794 MS_U32 _VDEC_EX_OPTEE_LockRegister(Lock_Register_Info *Lock_info, MS_U32 u32OperationMode)
24795 {
24796 switch(Lock_info->Decoder)
24797 {
24798 case E_Decode_HVD:
24799 if(u32OperationMode==1)
24800 {
24801 MDrv_HVD_EX_OPTEE_SetRegister(Lock_info);
24802 }
24803 if(Lock_info->stream_ID ==0)
24804 {
24805 MDrv_Seal_BufferLock(E_SEAL_HVD_ES0_BUF, u32OperationMode); //lock register
24806 VDEC_PRINT("[VDEC][OPTEE]%d:lock HVD register\n",Lock_info->stream_ID);
24807 }
24808 else if(Lock_info->stream_ID ==1)
24809 {
24810 MDrv_Seal_BufferLock(E_SEAL_HVD_ES1_BUF, u32OperationMode); //lock register
24811 VDEC_PRINT("[VDEC][OPTEE]%d:lock HVD register\n",Lock_info->stream_ID);
24812 }
24813 break;
24814 case E_Decode_VP8:
24815 if(u32OperationMode==1)
24816 {
24817 MDrv_HVD_EX_OPTEE_SetRegister(Lock_info);
24818 }
24819 MDrv_Seal_BufferLock(E_SEAL_HVD_ES2_BUF, u32OperationMode); //lock register
24820 VDEC_PRINT("[VDEC][OPTEE]%d:lock VP8 register\n",Lock_info->stream_ID);
24821 break;
24822 case E_Decode_EVD:
24823 if(u32OperationMode==1)
24824 {
24825 MDrv_HVD_EX_OPTEE_SetRegister(Lock_info);
24826 }
24827 if(Lock_info->stream_ID ==0)
24828 {
24829 MDrv_Seal_BufferLock(E_SEAL_EVD_0_WR_PROTN_0, u32OperationMode); //lock register
24830 VDEC_PRINT("[VDEC][OPTEE]%d:lock EVD register\n",Lock_info->stream_ID);
24831 }
24832 else if(Lock_info->stream_ID ==1)
24833 {
24834 MDrv_Seal_BufferLock(E_SEAL_EVD_0_WR_PROTN_1, u32OperationMode); //lock register
24835 VDEC_PRINT("[VDEC][OPTEE]%d:lock EVD register\n",Lock_info->stream_ID);
24836 }
24837 break;
24838 default:
24839 break;
24840 }
24841 return TRUE;
24842 }
24843
_VDEC_EX_OPTEE_GetDecoderByCodecType(VDEC_EX_CodecType codetype)24844 MS_U32 _VDEC_EX_OPTEE_GetDecoderByCodecType(VDEC_EX_CodecType codetype)
24845 {
24846 MS_U32 Decode_type;
24847
24848 switch(codetype)
24849 {
24850 case E_VDEC_EX_CODEC_TYPE_H264:
24851 case E_VDEC_EX_CODEC_TYPE_RV8:
24852 case E_VDEC_EX_CODEC_TYPE_RV9:
24853 case E_VDEC_EX_CODEC_TYPE_AVS:
24854 Decode_type = E_Decode_HVD;
24855 break;
24856 case E_VDEC_EX_CODEC_TYPE_VP8:
24857 Decode_type = E_Decode_VP8;
24858 break;
24859 case E_VDEC_EX_CODEC_TYPE_HEVC:
24860 case E_VDEC_EX_CODEC_TYPE_VP9:
24861 case E_VDEC_EX_CODEC_TYPE_HEVC_DV:
24862 Decode_type = E_Decode_EVD;
24863 break;
24864 case E_VDEC_EX_CODEC_TYPE_MPEG2:
24865 case E_VDEC_EX_CODEC_TYPE_H263:
24866 case E_VDEC_EX_CODEC_TYPE_MPEG4:
24867 case E_VDEC_EX_CODEC_TYPE_DIVX311:
24868 case E_VDEC_EX_CODEC_TYPE_DIVX412:
24869 case E_VDEC_EX_CODEC_TYPE_FLV:
24870 case E_VDEC_EX_CODEC_TYPE_VC1_ADV:
24871 case E_VDEC_EX_CODEC_TYPE_VC1_MAIN:
24872 Decode_type = E_Decode_MVD;
24873 break;
24874 default:
24875 Decode_type = E_Decode_NONE;
24876 break;
24877 }
24878
24879 return Decode_type;
24880 }
24881
MDrv_VDEC_ConfigPipe(MS_U64 u64PipeID,MS_U32 u32SecureDMA,MS_U32 u32OperationMode)24882 MS_U32 MDrv_VDEC_ConfigPipe(MS_U64 u64PipeID, MS_U32 u32SecureDMA, MS_U32 u32OperationMode)
24883 {
24884 MS_U8 stream_ID = (MS_U8)((u64PipeID >> 24)&0xff);
24885 Lock_Register_Info Lock_info;
24886 Secure_Status_Main=0;
24887 Secure_Status_Sub=0;
24888 VDEC_PRINT("[VDEC][OPTEE]%s,stream_id=%d\n",__FUNCTION__,stream_ID);
24889 VDEC_PRINT("[VDEC][OPTEE]secureDMA=%d,opeation=%d\n",u32SecureDMA,u32OperationMode);
24890
24891 if(u32SecureDMA)
24892 {
24893 MDrv_Seal_ChangeIPSecureDMAAbillity(MODULE_VDEC_EX, E_SEAL_IPGROUP_VDEC_DECODER , u32SecureDMA); //VDEC
24894 MDrv_Seal_ChangeIPSecureDMAAbillity(MODULE_VDEC_EX, E_SEAL_IPGROUP_VDEC_R2 , u32SecureDMA); //VDEC R2
24895 MDrv_Seal_ChangeIPSecureDMAAbillity(MODULE_MVOP, 0 , u32SecureDMA); //MVOP
24896 }
24897
24898 //if(MDrv_Seal_SetSecureRange((VPU_CodeAddr+0x1000), (VPU_CodeSize-0x1000), u32OperationMode) == FALSE)
24899 // return UTOPIA_STATUS_FAIL ;
24900
24901 if(stream_ID == 0)
24902 {
24903 if(MDrv_Seal_SetSecureRange(Bitstream_StartAddr_Main, Bitstream_Size_Main, u32OperationMode) == FALSE)
24904 return UTOPIA_STATUS_FAIL;
24905 if(MDrv_Seal_SetSecureRange(Framebuffer_StartAddr_Main, Framebuffer_Size_Main, u32OperationMode) == FALSE)
24906 return UTOPIA_STATUS_FAIL;
24907
24908 if( Framebuffer2_Size_Main>0)
24909 {
24910 if(MDrv_Seal_SetSecureRange(Framebuffer2_StartAddr_Main, Framebuffer2_Size_Main, u32OperationMode) == FALSE)
24911 return UTOPIA_STATUS_FAIL;
24912 }
24913
24914 //lock register start
24915 VDEC_PRINT("[VDEC][OPTEE]%d:lock register start\n",stream_ID);
24916 Lock_info.BSBufAddr = Bitstream_StartAddr_Main;
24917 Lock_info.BSBufSize = Bitstream_Size_Main;
24918 Lock_info.stream_ID = stream_ID;
24919 Lock_info.Decoder = _VDEC_EX_OPTEE_GetDecoderByCodecType(VCodecType_Main);
24920 VDEC_PRINT("[VDEC][OPTEE]%d:Decoder_type=%x\n",stream_ID,Lock_info.Decoder);
24921 _VDEC_EX_OPTEE_LockRegister(&Lock_info,u32OperationMode);
24922 VDEC_PRINT("[VDEC][OPTEE]%d:lock register end\n",stream_ID);
24923 //lock register end
24924
24925 Secure_Status_Main=1;
24926 }
24927 else if(stream_ID == 1)
24928 {
24929 if(MDrv_Seal_SetSecureRange(Bitstream_StartAddr_Sub, Bitstream_Size_Sub, u32OperationMode) == FALSE)
24930 return UTOPIA_STATUS_FAIL;
24931 if(MDrv_Seal_SetSecureRange(Framebuffer_StartAddr_Sub, Framebuffer_Size_Sub, u32OperationMode) == FALSE)
24932 return UTOPIA_STATUS_FAIL;
24933
24934 if( Framebuffer2_Size_Sub>0)
24935 {
24936 if(MDrv_Seal_SetSecureRange(Framebuffer2_StartAddr_Sub, Framebuffer2_Size_Sub, u32OperationMode) == FALSE)
24937 return UTOPIA_STATUS_FAIL;
24938 }
24939
24940 //lock register start
24941 VDEC_PRINT("[VDEC][OPTEE]%d:lock register start\n",stream_ID);
24942 Lock_info.BSBufAddr = Bitstream_StartAddr_Sub;
24943 Lock_info.BSBufSize = Bitstream_Size_Sub;
24944 Lock_info.stream_ID = stream_ID;
24945 Lock_info.Decoder = _VDEC_EX_OPTEE_GetDecoderByCodecType(VCodecType_Sub);
24946 VDEC_PRINT("[VDEC][OPTEE]%d:Decoder_type=%x\n",stream_ID,Lock_info.Decoder);
24947 _VDEC_EX_OPTEE_LockRegister(&Lock_info,u32OperationMode);
24948 VDEC_PRINT("[VDEC][OPTEE]%d:lock register end\n",stream_ID);
24949 //lock register end
24950
24951 Secure_Status_Sub=1;
24952 }
24953
24954 if(!u32SecureDMA)
24955 {
24956 MDrv_Seal_ChangeIPSecureDMAAbillity(MODULE_VDEC_EX, E_SEAL_IPGROUP_VDEC_DECODER , u32SecureDMA); //VDEC
24957 MDrv_Seal_ChangeIPSecureDMAAbillity(MODULE_VDEC_EX, E_SEAL_IPGROUP_VDEC_R2 , u32SecureDMA); //VDEC R2
24958 MDrv_Seal_ChangeIPSecureDMAAbillity(MODULE_MVOP, 0 , u32SecureDMA); //MVOP
24959 }
24960
24961 return UTOPIA_STATUS_SUCCESS;
24962 }
24963
MDrv_VDEC_CheckPipe(MS_U64 u64PipeID,MS_U32 u32SecureDMA,MS_U32 u32OperationMode)24964 MS_U32 MDrv_VDEC_CheckPipe(MS_U64 u64PipeID, MS_U32 u32SecureDMA, MS_U32 u32OperationMode)
24965 {
24966 MS_U8 stream_ID = (MS_U8)((u64PipeID >> 24)&0xff);
24967 //VDEC_PRINT("[VDEC][OPTEE]%s,stream_id=%d\n",__FUNCTION__,stream_ID);
24968
24969 if(stream_ID==0 && (!Secure_Status_Main))
24970 {
24971 VDEC_PRINT("[VDEC][OPTEE]stream0 check pipe fail\n");
24972 return UTOPIA_STATUS_FAIL;
24973 }
24974 else if(stream_ID==1 && (!Secure_Status_Sub))
24975 {
24976 VDEC_PRINT("[VDEC][OPTEE]stream1 check pipe fail\n");
24977 return UTOPIA_STATUS_FAIL;
24978 }
24979
24980 return UTOPIA_STATUS_SUCCESS;
24981 }
24982 #endif
24983
_VDEC_EX_TEE_VPU_SETTING(VDEC_EX_TEE_VPU_Param * param)24984 MS_BOOL _VDEC_EX_TEE_VPU_SETTING(VDEC_EX_TEE_VPU_Param* param)
24985 {
24986 if(param == NULL)
24987 {
24988 return FALSE;
24989 }
24990 else
24991 {
24992 VPU_CodeAddr = param->u32VPUStartAddr;
24993 VPU_CodeSize = param->u32VPUCodeSize;
24994 Framebuffer_StartAddr_Main = param->u32FrameBuffertartAddrMain;
24995 Framebuffer_Size_Main = param->u32FrameBufferSizeMain;
24996 Bitstream_StartAddr_Main = param->u32BitstreamStartAddrMain;
24997 Bitstream_Size_Main = param->u32BitstreamSizeMain;
24998 Framebuffer_StartAddr_Sub = param->u32FrameBuffertartAddrSub;
24999 Framebuffer_Size_Sub = param->u32FrameBufferSizeSub;
25000 Bitstream_StartAddr_Sub = param->u32BitstreamStartAddrSub;
25001 Bitstream_Size_Sub = param->u32BitstreamSizeSub;
25002 VPU_SHMAddr = param->u32VPUSHMAddr;
25003 VPU_SHMSize = param->u32VPUSHMSize;
25004 MIU1_StartAddr = param->u32MIU1StartAddr;
25005
25006 #if 1
25007 PRINTF("VDEC VPU_CodeAddr %x\n",(unsigned int)VPU_CodeAddr);
25008 PRINTF("VDEC VPU_CodeSize %x\n",(unsigned int)VPU_CodeSize);
25009 PRINTF("VDEC Framebuffer_StartAddr_Main %x\n",(unsigned int)Framebuffer_StartAddr_Main);
25010 PRINTF("VDEC Framebuffer_Size_Main %x\n",(unsigned int)Framebuffer_Size_Main);
25011 PRINTF("VDEC Bitstream_StartAddr_Main %x\n",(unsigned int)Bitstream_StartAddr_Main);
25012 PRINTF("VDEC Bitstream_Size_Main %x\n",(unsigned int)Bitstream_Size_Main);
25013 PRINTF("VDEC Framebuffer_StartAddr_Sub %x\n",(unsigned int)Framebuffer_StartAddr_Sub);
25014 PRINTF("VDEC Framebuffer_Size_Sub %x\n",(unsigned int)Framebuffer_Size_Sub);
25015 PRINTF("VDEC Bitstream_StartAddr_Sub %x\n",(unsigned int)Bitstream_StartAddr_Sub);
25016 PRINTF("VDEC Bitstream_Size_Sub %x\n",(unsigned int)Bitstream_Size_Sub);
25017 PRINTF("VDEC VPU_SHMAddr %x\n",(unsigned int)VPU_SHMAddr);
25018 PRINTF("VDEC VPU_SHMSize %x\n",(unsigned int)VPU_SHMSize);
25019 PRINTF("VDEC MIU1_StartAddr %x\n",(unsigned int)MIU1_StartAddr);
25020 #endif
25021 return TRUE;
25022 }
25023 }
25024
25025
_VDEC_EX_TEE_GetVPUProtect(VDEC_EX_TEE_VPU_Param * param)25026 MS_BOOL _VDEC_EX_TEE_GetVPUProtect(VDEC_EX_TEE_VPU_Param* param)
25027 {
25028 if(param == NULL)
25029 {
25030 return FALSE;
25031 }
25032 else
25033 {
25034 param->u32VPUStartAddr = VPU_CodeAddr;
25035 param->u32VPUSHMAddr = VPU_SHMAddr;
25036 param->u32VPUSHMSize = VPU_SHMSize;
25037 param->u32MIU1StartAddr = MIU1_StartAddr;
25038 if(Bitstream_StartAddr_Main != 0 && Bitstream_StartAddr_Sub != 0)
25039 {
25040 param->u32ProtectNum = 3;
25041
25042 param->ProtectInfo[0].u32Addr = VPU_CodeAddr + 0x1000; // buffer protect is 4k alignment;
25043 param->ProtectInfo[0].u32Size = VPU_CodeSize-0x1000;
25044
25045 param->ProtectInfo[1].u32Addr = Bitstream_StartAddr_Main + VDEC_DRIVER_PROC_BUFFER_SIZE;
25046 param->ProtectInfo[1].u32Size = Bitstream_Size_Main-VDEC_DRIVER_PROC_BUFFER_SIZE;
25047
25048 param->ProtectInfo[2].u32Addr = Bitstream_StartAddr_Sub + VDEC_DRIVER_PROC_BUFFER_SIZE; // buffer protect is 4k alignment;
25049 param->ProtectInfo[2].u32Size = Bitstream_Size_Sub-VDEC_DRIVER_PROC_BUFFER_SIZE;
25050 #if 0
25051 PRINTF("ProtectInfo[0].u32Addr %x\n",(unsigned int)param->ProtectInfo[0].u32Addr);
25052 PRINTF("ProtectInfo[0].u32Size %x\n",(unsigned int)param->ProtectInfo[0].u32Size);
25053 PRINTF("ProtectInfo[1].u32Addr %x\n",(unsigned int)param->ProtectInfo[1].u32Addr);
25054 PRINTF("ProtectInfo[1].u32Size %x\n",(unsigned int)param->ProtectInfo[1].u32Size);
25055 PRINTF("ProtectInfo[2].u32Addr %x\n",(unsigned int)param->ProtectInfo[2].u32Addr);
25056 PRINTF("ProtectInfo[2].u32Size %x\n",(unsigned int)param->ProtectInfo[2].u32Size);
25057 #endif
25058 }
25059 else if(Bitstream_StartAddr_Main != 0)
25060 {
25061 param->u32ProtectNum = 2;
25062
25063 param->ProtectInfo[0].u32Addr = VPU_CodeAddr + 0x1000; // buffer protect is 4k alignment;
25064 param->ProtectInfo[0].u32Size = VPU_CodeSize-0x1000;
25065
25066 param->ProtectInfo[1].u32Addr = Bitstream_StartAddr_Main + VDEC_DRIVER_PROC_BUFFER_SIZE;
25067 param->ProtectInfo[1].u32Size = Bitstream_Size_Main-VDEC_DRIVER_PROC_BUFFER_SIZE;
25068
25069 #if 0
25070 PRINTF("ProtectInfo[0].u32Addr %x\n",(unsigned int)param->ProtectInfo[0].u32Addr);
25071 PRINTF("ProtectInfo[0].u32Size %x\n",(unsigned int)param->ProtectInfo[0].u32Size);
25072 PRINTF("ProtectInfo[1].u32Addr %x\n",(unsigned int)param->ProtectInfo[1].u32Addr);
25073 PRINTF("ProtectInfo[1].u32Size %x\n",(unsigned int)param->ProtectInfo[1].u32Size);
25074 #endif
25075 }
25076 else
25077 {
25078 PRINTF("VDEC MMAP is wrong\n");
25079 return FALSE;
25080 }
25081
25082 return TRUE;
25083 }
25084 }
25085
25086 //------------------------------------------------------------------------------
25087 /// @brief Set parameter for TEE
25088 /// @param cmd E_VDEC_EX_SET_VPU_SETTING
25089 /// @param cmd E_VDEC_EX_GET_VPU_PROTECT_START_ADDR
25090 /// @param param buffer address and size
25091 /// @retval TRUE/FALSE : success/fail
25092 //------------------------------------------------------------------------------
MApi_VDEC_EX_TEE_SetControl(VDEC_EX_TEE_USER_CMD cmd,void * param)25093 MS_BOOL MApi_VDEC_EX_TEE_SetControl(VDEC_EX_TEE_USER_CMD cmd,void* param)
25094 {
25095 MS_BOOL ret = FALSE;
25096
25097 if(param == NULL)
25098 {
25099 PRINTF("[VDEC]%s,Invalid param\n",__FUNCTION__);
25100 }
25101
25102 switch(cmd)
25103 {
25104 case E_VDEC_EX_SET_VPU_SETTING:
25105 ret = _VDEC_EX_TEE_VPU_SETTING((VDEC_EX_TEE_VPU_Param*)param);
25106 break;
25107 case E_VDEC_EX_SET_VPU_LOADCODE:
25108 if(VPU_CodeAddr != 0)
25109 {
25110 PRINTF("%s,%d,PA:%x VA:%x\n",__FUNCTION__,__LINE__,(MS_U32)VPU_CodeAddr,(MS_U32)MsOS_PA2KSEG1(VPU_CodeAddr));
25111 if (_VDEC_TEE_Load_FwCode(MsOS_PA2KSEG1(VPU_CodeAddr)) == TRUE)
25112 {
25113 PRINTF("VDEC receive load f/w code success in optee\n");
25114 ret = TRUE;
25115 }
25116 else
25117 {
25118 PRINTF("VDEC receive load f/w code fail in optee\n");
25119 }
25120 }
25121 else
25122 {
25123 PRINTF("VDEC receive load f/w code fail in optee due to code address is zero\n");
25124 }
25125 break;
25126 #if defined(MSOS_TYPE_OPTEE)
25127 case E_VDEC_EX_SET_SECURE_BUFFER:
25128 {
25129 ret = _VDEC_EX_OPTEE_SET_SecureBuffer((VDEC_EX_OPTEE_SecureBuffer*)param);
25130 }
25131 break;
25132 case E_VDEC_EX_SET_SECURE_FB2:
25133 {
25134 ret = _VDEC_EX_OPTEE_SET_SecureFB2((VDEC_EX_OPTEE_SecureFB2*)param);
25135 }
25136 break;
25137 #endif
25138 default:
25139 PRINTF("[VDEC]Invalid user cmd,%d\n",(unsigned int)cmd);
25140 break;
25141 }
25142
25143 return ret;
25144 }
25145
25146 //------------------------------------------------------------------------------
25147 /// @brief Get parameter for TEE
25148 /// @param cmd E_VDEC_EX_SET_VPU_SETTING
25149 /// @param cmd E_VDEC_EX_GET_VPU_PROTECT_START_ADDR
25150 /// @param param buffer address and size
25151 /// @retval TRUE/FALSE : success/fail
25152 //------------------------------------------------------------------------------
MApi_VDEC_EX_TEE_GetControl(VDEC_EX_TEE_USER_CMD cmd,void * param)25153 MS_BOOL MApi_VDEC_EX_TEE_GetControl(VDEC_EX_TEE_USER_CMD cmd,void* param)
25154 {
25155 MS_BOOL ret = FALSE;
25156
25157 switch(cmd)
25158 {
25159 case E_VDEC_EX_GET_VPU_PROTECT_START_ADDR:
25160 ret = _VDEC_EX_TEE_GetVPUProtect((VDEC_EX_TEE_VPU_Param*)param);
25161 break;
25162 default:
25163 PRINTF("[VDEC]%s,Invalid user cmd,%d\n",__FUNCTION__,(unsigned int)cmd);
25164 break;
25165 }
25166
25167 return ret;
25168 }
25169
25170 #endif
25171
25172
25173