1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 ///////////////////////////////////////////////////////////////////////////////////////////////////
96 ///
97 /// file apiMJPEG.c
98 /// @brief MJPEG API
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 //-------------------------------------------------------------------------------------------------
103 // Include Files
104 //-------------------------------------------------------------------------------------------------
105 #if (!defined(MSOS_TYPE_NUTTX) && !defined(MSOS_TYPE_OPTEE)) || defined(SUPPORT_X_MODEL_FEATURE)
106 #include "MsCommon.h"
107 // JPEG
108 #include "drvMJPEG.h"
109 #include "VirtualhalMJPEG.h"
110 #include "apiJPEG.h"
111 #include "../../../njpd/api/njpeg_ex/apiJPEG_priv.h"
112 #include "apiMJPEG_EX.h"
113 // RIU Base
114 #include "drvMMIO.h"
115 #include "halCHIP.h"
116
117
118 #if (defined CONFIG_MLOG)
119 #include "ULog.h"
120 #endif
121
122 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
123 #include "drvCMAPool.h"
124 #include "msos/linux/ion_uapi.h"
125 #include "msos/linux/mdrv_cma_pool_st.h"
126 #endif
127
128 #ifdef MSOS_TYPE_LINUX_KERNEL
129 #include <linux/string.h>
130 #else
131 #include <string.h>
132 #endif
133
134 #ifndef CONFIG_MLOG
135 #ifdef MSOS_TYPE_LINUX_KERNEL
136 #undef printf
137 #define printf(format, args...) printk(format, ##args);
138 #endif
139 #endif
140
141 //-------------------------------------------------------------------------------------------------
142 // Local Compiler Options
143 //-------------------------------------------------------------------------------------------------
144
145 #define ENABLE_MJPEG_FIRMWARE 1
146
147 #define ENABLE_AVSYNC_ID_CHECK 0
148
149 //-------------------------------------------------------------------------------------------------
150 // Local Defines
151 //-------------------------------------------------------------------------------------------------
152 #define JPEGBASEWIDTHMAX 1920UL//1600
153 #define JPEGBASEHEIGHTMAX 1080UL//1200
154 #define JPEGPROWIDTHMAX 1024UL
155 #define JPEGPROHEIGHTMAX 768UL
156
157 #define MJPEG_SD_WIDTH 640UL
158 #define MJPEG_SD_HEIGHT 480UL
159
160 #define MJPEG_HD_800x600_WIDTH 800UL
161 #define MJPEG_HD_800x600_HEIGHT 600UL
162
163 #define MJPEG_HD_1280x720_WIDTH 1280UL
164 #define MJPEG_HD_1280x720_HEIGHT 720UL
165
166 #define MJPEG_MAX_SUPPORT_WIDTH 1920UL
167 #define MJPEG_MAX_SUPPORT_HEIGHT 1088UL
168
169 #define MAX_SUPPORTED_FRAME_RATE_1080P 30000UL
170
171 #define DISPLAY_QUEUE_NUM 8UL
172 #define MJPEG_INTERNAL_SIZE 0x20000UL
173
174 #define SUPPORT_ASF_MJPEG_MODE TRUE
175 #define MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE (0x400000UL*2)
176 #define VDEC_EX_MVD_PIC_START_FLAG 0x40000000UL
177
178 #define SUPPORT_SKIP_ERROR_FRAME TRUE
179 #define SKIP_ERROR_FRAME_THRESHOLD 1000UL //60UL
180 #define printf_red(args...) do{ printf("\033[1;31m"); printf(args); printf("\033[m"); }while(0)
181 //-------------------------------------------------------------------------------------------------
182 // Local Structures
183 //-------------------------------------------------------------------------------------------------
184 #define JPEG_memcpy(pDstAddr, pSrcAddr, u32Size) memcpy((pDstAddr), (pSrcAddr), (u32Size))
185 #define JPEG_memset(pDstAddr, u8value, u32Size) memset((pDstAddr), (u8value), (u32Size))
186
187 #ifndef UNUSED
188 #define UNUSED(x) ((x)=(x))
189 #endif
190
191 #define _MJPEG_Memcpy(pDstAddr, pSrcAddr, u32Size) \
192 do { \
193 MS_U32 i = 0; \
194 volatile MS_U8 *dst = (volatile MS_U8 *)(pDstAddr); \
195 volatile MS_U8 *src = (volatile MS_U8 *)(pSrcAddr); \
196 for (i = 0; i < (u32Size); i++) \
197 { \
198 dst[i] = src[i]; \
199 } \
200 } while (0)
201
202
203 typedef enum
204 {
205 E_MJPEG_MAX_SUPPORTED_NONE,
206 E_MJPEG_MAX_SUPPORTED_FHD,
207 E_MJPEG_MAX_SUPPORTED_720P,
208 E_MJPEG_MAX_SUPPORTED_480P,
209 E_MJPEG_MAX_SUPPORTED_4K2K,
210 }MJPEG_MAX_SUPPORTED_RESOLUTION;
211
212
213 #if SUPPORT_ASF_MJPEG_MODE
214 typedef enum
215 {
216 E_MJPEG_BUF_AVAILABLE = 0
217 , E_MJPEG_BUF_USING = 1
218 , E_MJPEG_BUF_BUSY = 2
219 } MJPEG_COLLECT_BUF_STATUS;
220 #endif
221
222
223 //-------------------------------------------------------------------------------------------------
224 // Global Variables
225 //-------------------------------------------------------------------------------------------------
226
227
228 //-------------------------------------------------------------------------------------------------
229 // Local Variables
230 //-------------------------------------------------------------------------------------------------
231 static MS_BOOL bEnableDispCmdQ[E_MJPEG_MJPEG_TOTAL];
232
233 //static MS_U32 __u32FwAddr = 0xFFFFFFFF; // Address to load firmware
234 static MS_PHY __u32MRCBufAddr[E_MJPEG_MJPEG_TOTAL];
235 static MS_U32 __u32MRCBufSize[E_MJPEG_MJPEG_TOTAL];
236 static MS_PHY __u32MWCBufAddr[E_MJPEG_MJPEG_TOTAL];
237 #if SUPPORT_ASF_MJPEG_MODE
238 static MS_PHY __u32CollectBufAddr[E_MJPEG_MJPEG_TOTAL];
239 static MS_BOOL __bAsfMjpegMode[E_MJPEG_MJPEG_TOTAL];
240 static MS_BOOL __bAsfFirstFrame[E_MJPEG_MJPEG_TOTAL];
241 static MS_BOOL __bAsfFirstPacketInFrame[E_MJPEG_MJPEG_TOTAL];
242 static MS_PHY __u32CollectBufWptr[E_MJPEG_MJPEG_TOTAL];
243 static MS_PHY __u32PrevBufAddr[E_MJPEG_MJPEG_TOTAL];
244 static MJPEG_COLLECT_BUF_STATUS __eColBufStatus[E_MJPEG_MJPEG_TOTAL][2];
245 #endif
246
247 static MS_PHY __u32InternalBufAddr[E_MJPEG_MJPEG_TOTAL];
248 static MS_U32 __u32InternalBufSize[E_MJPEG_MJPEG_TOTAL];
249
250 static MS_PHY __u32ReadPtr[E_MJPEG_MJPEG_TOTAL];
251 static MS_PHY __u32WritePtr[E_MJPEG_MJPEG_TOTAL];
252
253
254 static MS_BOOL __bIsFirstFrameRdy[E_MJPEG_MJPEG_TOTAL];
255
256 static MS_U16 PreVIdx[E_MJPEG_MJPEG_TOTAL];
257 static MS_U16 ReCheckTime[E_MJPEG_MJPEG_TOTAL];
258
259 static MS_BOOL __bIsDecodeDone[E_MJPEG_MJPEG_TOTAL];
260 static MS_U32 __u32DropFrameCnt[E_MJPEG_MJPEG_TOTAL];
261 static MS_U32 u32NextFrameBuffIdx[E_MJPEG_MJPEG_TOTAL];
262 static MS_PHY u32EndAddr[E_MJPEG_MJPEG_TOTAL];
263
264 // Speed Control
265 static MJPEG_SpeedType eCurSpeedType[E_MJPEG_MJPEG_TOTAL];
266 static MJPEG_DispSpeed eCurDispSpeed[E_MJPEG_MJPEG_TOTAL];
267 static MS_U32 __u32SpeedCtrlFrameCntBase[E_MJPEG_MJPEG_TOTAL];
268
269 static MS_U8 _u8MJPEG_ApiDbgLevel = E_JPEG_DEBUG_NONE;
270
271
272 MJPEG_FrameInfo infoDecFrame[E_MJPEG_MJPEG_TOTAL];
273 static MS_BOOL isDecFrameInfoValid[E_MJPEG_MJPEG_TOTAL];
274 static MS_BOOL bStepDec[E_MJPEG_MJPEG_TOTAL];
275 static MS_BOOL bLstFrame[E_MJPEG_MJPEG_TOTAL];
276
277 static MS_BOOL __bSkipToPts[E_MJPEG_MJPEG_TOTAL];
278 static MS_BOOL __bSeekToPts[E_MJPEG_MJPEG_TOTAL];
279 static MS_U32 __u32TargetPts[E_MJPEG_MJPEG_TOTAL];
280 static MS_U32 __u32Skip2PtsBase[E_MJPEG_MJPEG_TOTAL];
281
282 static MJPEG_ErrorCode eMJPEGErrCode[E_MJPEG_MJPEG_TOTAL];
283
284 static MS_U16 u16NullCnt[E_MJPEG_MJPEG_TOTAL];
285 static MJPEG_MAX_SUPPORTED_RESOLUTION eMaxSupport[E_MJPEG_MJPEG_TOTAL];
286
287 #if SUPPORT_SKIP_ERROR_FRAME
288 static MS_U32 _u32SkipCnt[E_MJPEG_MJPEG_TOTAL];
289 static MS_U32 _u32ErrCnt[E_MJPEG_MJPEG_TOTAL];
290 static MS_U32 _u32StartDecodeTime[2];
291 #endif
292
293 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
294 static MS_BOOL bCMAUsed;
295 static MS_BOOL bCMAAllocDone;
296 static struct CMA_Pool_Init_Param cmaInitParam;
297 static struct CMA_Pool_Free_Param cmaFreeParam[E_MJPEG_MJPEG_TOTAL];
298 //static MS_BOOL bCMATwoMIU[E_MJPEG_MJPEG_TOTAL];
299 #endif
300
301 #ifdef VDEC3
302 static MS_BOOL __bFWdecideFB[E_MJPEG_MJPEG_TOTAL];
303 #endif
304
305 static MS_BOOL bNJPDNum = 0;
306 static MS_U8 u8MJPEGCnt = 0;
307 //-------------------------------------------------------------------------------------------------
308 // Debug Functions
309 //-------------------------------------------------------------------------------------------------
310 #if (defined CONFIG_MLOG)
311 #define MJPEG_DEBUG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_MJPEG) ULOGI("MJPEG", format, ##args);}while(0)
312 #define MJPEG_DEBUG_API_MSG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_API) ULOGI("MJPEG", format, ##args);}while(0)
313 #define MJPEG_DEBUG_API_ERR(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_ERR) ULOGE("MJPEG", format, ##args);}while(0)
314
315 #else
316 #ifndef ANDROID
317 #define MJPEG_DEBUG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_MJPEG) printf(format, ##args);}while(0)
318 #define MJPEG_DEBUG_API_MSG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_API) printf(format, ##args);}while(0)
319 #define MJPEG_DEBUG_API_ERR(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_ERR) printf(format, ##args);}while(0)
320 #else
321 #define LOG_TAG "API_JPEG"
322 #include <cutils/log.h>
323 #ifndef LOGD
324 #define MJPEG_DEBUG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_MJPEG) ALOGI(format, ##args);}while(0)
325 #define MJPEG_DEBUG_API_MSG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_API) ALOGI(format, ##args);}while(0)
326 #define MJPEG_DEBUG_API_ERR(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_ERR) ALOGE(format, ##args);}while(0)
327 #else
328 #define MJPEG_DEBUG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_MJPEG) LOGI(format, ##args);}while(0)
329 #define MJPEG_DEBUG_API_MSG(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_API) LOGI(format, ##args);}while(0)
330 #define MJPEG_DEBUG_API_ERR(format, args...) do{if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_ERR) LOGE(format, ##args);}while(0)
331 #endif
332
333 #endif
334 #endif
335
336
337
338 //-------------------------------------------------------------------------------------------------
339 // Local Functions
340 //-------------------------------------------------------------------------------------------------
341
_MApi_MJPEG_InitPara(MS_U32 u32Id)342 void _MApi_MJPEG_InitPara(MS_U32 u32Id)
343 {
344 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
345 MJPEG_DEBUG("[MJPEG]_MApi_MJPEG_InitPara()!!!\n");
346
347 bEnableDispCmdQ[u8DrvId] = TRUE;
348
349 __u32MRCBufAddr[u8DrvId] = 0;
350 __u32MWCBufAddr[u8DrvId] = 0;
351 #if SUPPORT_ASF_MJPEG_MODE
352 __u32CollectBufAddr[u8DrvId] = 0;
353 __u32CollectBufWptr[u8DrvId] = 0;
354 __u32PrevBufAddr[u8DrvId] = 0;
355 __bAsfMjpegMode[u8DrvId] = 0;
356 __bAsfFirstFrame[u8DrvId] = 0;
357 __bAsfFirstPacketInFrame[u8DrvId] = 0;
358 __eColBufStatus[u8DrvId][0] = E_MJPEG_BUF_AVAILABLE;
359 __eColBufStatus[u8DrvId][1] = E_MJPEG_BUF_AVAILABLE;
360 #endif
361
362 __u32InternalBufAddr[u8DrvId] = 0;
363 __u32InternalBufSize[u8DrvId] = 0;
364
365 __u32ReadPtr[u8DrvId] = 0;
366 __u32WritePtr[u8DrvId] = 0;
367
368 MDrv_MJPEG_SetFrameCnt(u8DrvId, 0);
369 MDrv_MJPEG_SetFrameTime(u8DrvId, 0);
370 MDrv_MJPEG_SetFrameRate(u8DrvId, 600UL);
371 MDrv_MJPEG_SetFrameRateBase(u8DrvId, 20UL);
372
373 MDrv_MJPEG_SetWidth(u8DrvId, 0);
374 MDrv_MJPEG_SetHeight(u8DrvId, 0);
375 MDrv_MJPEG_SetPitch(u8DrvId, 0);
376
377 MDrv_MJPEG_SetFrameBuffTotalNum(u8DrvId, 0);
378 MDrv_MJPEG_SetFrameBuffUnitSize(u8DrvId, 0);
379
380 __bIsFirstFrameRdy[u8DrvId] = FALSE;
381
382 PreVIdx[u8DrvId] = 0;
383 ReCheckTime[u8DrvId] = 0;
384
385 __bIsDecodeDone[u8DrvId] = FALSE;
386 __u32DropFrameCnt[u8DrvId] = 0;
387 u32NextFrameBuffIdx[u8DrvId] = 0;
388 u32EndAddr[u8DrvId] = 0;
389
390 // Speed Control
391 eCurSpeedType[u8DrvId] = E_MJPEG_SPEED_DEFAULT;
392 eCurDispSpeed[u8DrvId] = E_MJPEG_DISP_SPEED_1X;
393 __u32SpeedCtrlFrameCntBase[u8DrvId] = 0;
394
395
396 isDecFrameInfoValid[u8DrvId] = FALSE;
397 bStepDec[u8DrvId] = FALSE;
398 bLstFrame[u8DrvId] = FALSE;
399
400 __bSkipToPts[u8DrvId] = FALSE;
401 __bSeekToPts[u8DrvId] = FALSE;
402 __u32TargetPts[u8DrvId] = 0;
403 __u32Skip2PtsBase[u8DrvId] = 0;
404
405 u16NullCnt[u8DrvId] = 0;
406 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_NONE;
407
408 #if SUPPORT_SKIP_ERROR_FRAME
409 _u32SkipCnt[u8DrvId] = 0;
410 _u32ErrCnt[u8DrvId] = 0;
411 _u32StartDecodeTime[bNJPDNum] = 0;
412 #endif
413
414
415 }
416
_MApi_MJPEG_SetErrCode(MS_U32 u32Id,MJPEG_ErrorCode eErrorCode)417 void _MApi_MJPEG_SetErrCode(MS_U32 u32Id, MJPEG_ErrorCode eErrorCode)
418 {
419 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
420 MJPEG_DEBUG_API_MSG("_MApi_MJPEG_SetErrCode() with eMJPEGErrCode=0x%x\n", eErrorCode);
421 eMJPEGErrCode[u8DrvId] = eErrorCode;
422 }
423
424 /******************************************************************************/
425 ///Check if JPEG decode done
426 ///@return status
427 /******************************************************************************/
__MApi_MJPEG_CheckDecodeDone(MS_U32 u32Id)428 static MJPEG_Result __MApi_MJPEG_CheckDecodeDone(MS_U32 u32Id)
429 {
430 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
431
432 if(MApi_JPEG_IsNJPD()==TRUE)
433 {
434 _MApi_JPEG_SetNJPDInstance(bNJPDNum);
435 }
436
437 if (__bIsFirstFrameRdy[u8DrvId])
438 {
439 JPEG_Event reg_val = _MApi_JPEG_GetJPDEventFlag();
440 MJPEG_DEBUG_API_MSG(" EventFlag = %d\n", reg_val);
441
442 if(MApi_JPEG_IsNJPD()==FALSE)
443 {
444 MS_U16 cur_vidx = 0;
445 //For H/W bug, some cases can not exit after decode done. Check Vidx to exit.
446 if(PreVIdx[u8DrvId] != (cur_vidx = _MApi_JPEG_GetCurVidx()))
447 {
448 PreVIdx[u8DrvId] = cur_vidx;
449 ReCheckTime[u8DrvId] = 0;
450 }
451 else
452 {
453 ReCheckTime[u8DrvId]++;
454 if(ReCheckTime[u8DrvId] >= 1000)
455 {
456 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID, u32NextFrameBuffIdx[u8DrvId]);
457 MJPEG_DEBUG_API_MSG("Set frame buffer index %td as Valid", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
458 __bIsDecodeDone[u8DrvId] = TRUE;
459 __u32DropFrameCnt[u8DrvId]++;
460
461 MJPEG_DEBUG_API_ERR("Decode timeout!!!!\n");
462 reg_val = E_JPEG_EVENT_DEC_ERROR_MASK;
463 return E_MJPEG_RET_FAIL;
464 }
465 }
466 }
467
468 if((E_JPEG_EVENT_DEC_DONE | E_JPEG_EVENT_DEC_ERROR_MASK) ==reg_val)
469 {
470 return E_MJPEG_RET_FAIL;
471 }
472 else if(E_JPEG_EVENT_DEC_DONE & reg_val)
473 {
474 ReCheckTime[u8DrvId] = 0;
475
476 MJPEG_DEBUG_API_MSG(" Decode Done -- ");
477 #if ENABLE_MJPEG_FIRMWARE
478 if (__bIsDecodeDone[u8DrvId] == FALSE)
479 {
480 if (__u32DropFrameCnt[u8DrvId] != 0)
481 {
482 // Ask firmware to compensate PTS
483 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_COMPENSATE_PTS, __u32DropFrameCnt[u8DrvId]);
484 MJPEG_DEBUG_API_MSG("Compensate PTS for %td dropped frames", (ptrdiff_t)__u32DropFrameCnt[u8DrvId]);
485 }
486 __u32DropFrameCnt[u8DrvId] = 0;
487
488 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_IDX_READY, u32NextFrameBuffIdx[u8DrvId]);
489 MJPEG_DEBUG("[MJPEG]Decode done...Frame Buffer Index %td ready\n", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
490 __bIsDecodeDone[u8DrvId] = TRUE;
491 }
492 #endif
493 MJPEG_DEBUG_API_MSG("\n");
494 //__u32ReadPtr = u32EndAddr;
495 MJPEG_DEBUG_API_MSG("Count %td\n", (ptrdiff_t)MDrv_MJPEG_GetFrameCnt(u8DrvId));
496 }
497 else
498 if(E_JPEG_EVENT_DEC_ERROR_MASK & reg_val)
499 {
500 MJPEG_DEBUG_API_ERR(" JPD Decode Error\n");
501 //MApi_MJPEG_Debug();
502
503 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID, u32NextFrameBuffIdx[u8DrvId]);
504 MJPEG_DEBUG_API_MSG("Set frame buffer index %td as Valid", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
505 __bIsDecodeDone[u8DrvId] = TRUE;
506 __u32DropFrameCnt[u8DrvId]++;
507 _u32ErrCnt[u8DrvId]++;
508 _MApi_JPEG_Rst();
509 _MApi_JPEG_Exit();
510 return E_MJPEG_RET_DECODE_ERROR;
511 }
512 else
513 {
514 MJPEG_DEBUG_API_MSG(" Still decoding previous JPEG ......\n");
515 #if SUPPORT_SKIP_ERROR_FRAME
516 if(MsOS_GetSystemTime() - _u32StartDecodeTime[bNJPDNum] > SKIP_ERROR_FRAME_THRESHOLD)
517 {
518 MJPEG_DEBUG_API_ERR("%s[%d]: JPEG decode frame timeout!!!!!!!!!!\n", __FUNCTION__, u8DrvId);
519 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID, u32NextFrameBuffIdx[u8DrvId]);
520 __u32DropFrameCnt[u8DrvId]++;
521 _u32SkipCnt[u8DrvId]++;
522 _u32ErrCnt[u8DrvId]++;
523 // Repeat next frame because previous frame decode timeout
524 u16NullCnt[u8DrvId]++;
525 //MApi_MJPEG_Debug();
526 MJPEG_DEBUG_API_MSG("%s: Reset JPD!!!!!!!!!!\n", __FUNCTION__);
527 _MApi_JPEG_Rst();
528 _MApi_JPEG_Exit();
529 return E_MJPEG_RET_DECODE_ERROR;
530 }
531 #endif
532 return E_MJPEG_RET_DECODING;
533 }
534 }
535 else
536 {
537 return E_MJPEG_RET_FAIL;
538 }
539
540
541 return E_MJPEG_RET_SUCCESS;
542 }
543
544 #if SUPPORT_ASF_MJPEG_MODE
545
_MApi_MJPEG_ASFParameterSetting(MS_U32 u32Id,MJPEG_Packet_Info * pInfo)546 static void _MApi_MJPEG_ASFParameterSetting(MS_U32 u32Id, MJPEG_Packet_Info *pInfo)
547 {
548 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
549 if(__bAsfMjpegMode[u8DrvId]==FALSE)
550 {
551 if(pInfo->u32StAddr & VDEC_EX_MVD_PIC_START_FLAG)
552 {
553 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]Set to ASF-MJPEG mode!!!!!!!!!!!!!!!!\n");
554 __bAsfMjpegMode[u8DrvId] = TRUE;
555 __bAsfFirstFrame[u8DrvId] = TRUE;
556 __bAsfFirstPacketInFrame[u8DrvId] = TRUE;
557 }
558 }
559 else
560 {
561 __bAsfFirstFrame[u8DrvId] = FALSE;
562
563 if(pInfo->u32StAddr & VDEC_EX_MVD_PIC_START_FLAG)
564 {
565 __bAsfFirstPacketInFrame[u8DrvId] = TRUE;
566 }
567 else
568 {
569 __bAsfFirstPacketInFrame[u8DrvId] = FALSE;
570 }
571 }
572 }
573
_MApi_MJPEG_IsColWPtrInLow(MS_U8 u8DrvId)574 static MS_BOOL _MApi_MJPEG_IsColWPtrInLow(MS_U8 u8DrvId)
575 {
576 if(__u32CollectBufWptr[u8DrvId] >= __u32CollectBufAddr[u8DrvId] + MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE/2)
577 return FALSE;
578 else
579 return TRUE;
580 }
581
_MApi_MJPEG_IsAbleToPushNextFrame(MS_U8 u32Id)582 static MS_BOOL _MApi_MJPEG_IsAbleToPushNextFrame(MS_U8 u32Id)
583 {
584 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
585 MJPEG_DEBUG_API_MSG("is able to push?.....%tx, %tx, %tx, %tx, %tx\n", (ptrdiff_t)__eColBufStatus[u8DrvId][0], (ptrdiff_t)__eColBufStatus[u8DrvId][1],
586 (ptrdiff_t)__u32CollectBufWptr[u8DrvId], (ptrdiff_t)__u32CollectBufAddr[u8DrvId],
587 (ptrdiff_t)(__u32CollectBufAddr[u8DrvId] + MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE/2));
588 if(__MApi_MJPEG_CheckDecodeDone(u32Id) != E_MJPEG_RET_DECODING)
589 {
590 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId) ==TRUE
591 && __eColBufStatus[u8DrvId][1]==E_MJPEG_BUF_BUSY)
592 {
593 __eColBufStatus[u8DrvId][1] = E_MJPEG_BUF_AVAILABLE;
594 }
595 else if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)==FALSE
596 && __eColBufStatus[u8DrvId][0]==E_MJPEG_BUF_BUSY)
597 {
598 __eColBufStatus[u8DrvId][0] = E_MJPEG_BUF_AVAILABLE;
599 }
600 }
601 MJPEG_DEBUG_API_MSG("is able to push?.....[%x, %x]\n", __eColBufStatus[u8DrvId][0], __eColBufStatus[u8DrvId][1]);
602
603 if(__eColBufStatus[u8DrvId][0] != E_MJPEG_BUF_AVAILABLE
604 && __eColBufStatus[u8DrvId][1] != E_MJPEG_BUF_AVAILABLE)
605 return FALSE;
606 else
607 return TRUE;
608 }
609
_MApi_MJPEG_PushToLowBuffer(MS_U8 u32Id,MS_VIRT u32SrcAddrVA,MS_U32 u32Size)610 static void _MApi_MJPEG_PushToLowBuffer(MS_U8 u32Id, MS_VIRT u32SrcAddrVA, MS_U32 u32Size)
611 {
612 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
613 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId) == FALSE)
614 {
615 __u32PrevBufAddr[u8DrvId] = __u32CollectBufWptr[u8DrvId];
616 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]_MApi_MJPEG_PushToLowBuffer...............start\n");
617 // Step 1: reset write ptr to start of low buffer
618 __u32CollectBufWptr[u8DrvId] = __u32CollectBufAddr[u8DrvId];
619 // Step 2: memcpy
620 JPEG_memcpy((void *)MsOS_PA2KSEG1(__u32CollectBufWptr[u8DrvId]), (void *)u32SrcAddrVA, u32Size);
621 // Step 3: update write ptr address
622 __u32CollectBufWptr[u8DrvId] = __u32CollectBufWptr[u8DrvId] + u32Size;
623 }
624 else
625 {
626 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]_MApi_MJPEG_PushToLowBuffer...............middle\n");
627 JPEG_memcpy((void *)MsOS_PA2KSEG1(__u32CollectBufWptr[u8DrvId]), (void *)u32SrcAddrVA, u32Size);
628 __u32CollectBufWptr[u8DrvId] = __u32CollectBufWptr[u8DrvId] + u32Size;
629 }
630 }
631
_MApi_MJPEG_PushToHighBuffer(MS_U8 u32Id,MS_VIRT u32SrcAddrVA,MS_U32 u32Size)632 static void _MApi_MJPEG_PushToHighBuffer(MS_U8 u32Id, MS_VIRT u32SrcAddrVA, MS_U32 u32Size)
633 {
634 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
635 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId) == TRUE)
636 {
637 __u32PrevBufAddr[u8DrvId] = __u32CollectBufWptr[u8DrvId];
638 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]_MApi_MJPEG_PushToHighBuffer...............start\n");
639 // Step 1: reset write ptr to start of low buffer
640 __u32CollectBufWptr[u8DrvId] = __u32CollectBufAddr[u8DrvId]+MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE/2;
641 // Step 2: memcpy
642 JPEG_memcpy((void *)MsOS_PA2KSEG1(__u32CollectBufWptr[u8DrvId]), (void *)u32SrcAddrVA, u32Size);
643 // Step 3: update write ptr address
644 __u32CollectBufWptr[u8DrvId] = __u32CollectBufWptr[u8DrvId] + u32Size;
645 }
646 else
647 {
648 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]_MApi_MJPEG_PushToHighBuffer...............middle\n");
649 JPEG_memcpy((void *)MsOS_PA2KSEG1(__u32CollectBufWptr[u8DrvId]), (void *)u32SrcAddrVA, u32Size);
650 __u32CollectBufWptr[u8DrvId] = __u32CollectBufWptr[u8DrvId] + u32Size;
651 }
652
653 }
654
_MApi_MJPEG_ASFBufferManagement(MS_U32 u32Id,MJPEG_Packet_Info * pInfo)655 static MS_BOOL _MApi_MJPEG_ASFBufferManagement(MS_U32 u32Id, MJPEG_Packet_Info *pInfo)
656 {
657 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
658 MS_BOOL _bDecodeInThisPush = FALSE;
659 MS_VIRT u32SrcAddrVA = MsOS_PA2KSEG1(pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]);
660
661 if(__bAsfFirstPacketInFrame[u8DrvId])
662 {
663 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]detected first packet in frame!!!!!!!!!!!!!!!!\n");
664 if(__bAsfFirstFrame[u8DrvId]==FALSE)
665 {
666 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)
667 && __eColBufStatus[u8DrvId][0]==E_MJPEG_BUF_USING)
668 {
669 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]Push previous frame(L) to JPD!!!!!!!!!!!!!!!!\n");
670 __eColBufStatus[u8DrvId][0] = E_MJPEG_BUF_BUSY;
671 MsOS_FlushMemory();
672 _bDecodeInThisPush = TRUE;
673 }
674 else if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)==FALSE
675 && __eColBufStatus[u8DrvId][1]==E_MJPEG_BUF_USING)
676 {
677 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]Push previous frame(H) to JPD!!!!!!!!!!!!!!!!\n");
678 __eColBufStatus[u8DrvId][1] = E_MJPEG_BUF_BUSY;
679 MsOS_FlushMemory();
680 _bDecodeInThisPush = TRUE;
681 }
682 }
683
684 if(_MApi_MJPEG_IsAbleToPushNextFrame(u32Id))
685 {
686 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)
687 && __eColBufStatus[u8DrvId][1] == E_MJPEG_BUF_AVAILABLE)
688 {
689 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]First packet in frame(H)!!!!!!!!!!!!!!!!\n");
690 _MApi_MJPEG_PushToHighBuffer(u32Id, u32SrcAddrVA, pInfo->u32Size);
691 __eColBufStatus[u8DrvId][1] = E_MJPEG_BUF_USING;
692 }
693 else if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)==FALSE
694 && __eColBufStatus[u8DrvId][0]==E_MJPEG_BUF_AVAILABLE)
695 {
696 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]First packet in frame(L)!!!!!!!!!!!!!!!!\n");
697 _MApi_MJPEG_PushToLowBuffer(u32Id, u32SrcAddrVA, pInfo->u32Size);
698 __eColBufStatus[u8DrvId][0] = E_MJPEG_BUF_USING;
699 }
700 }
701 }
702 else
703 {
704 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)
705 && __eColBufStatus[u8DrvId][0] == E_MJPEG_BUF_USING)
706 {
707 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]middle packet in frame(L)!!!!!!!!!!!!!!!!\n");
708 _MApi_MJPEG_PushToLowBuffer(u32Id, u32SrcAddrVA, pInfo->u32Size);
709 }
710 else if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)==FALSE
711 && __eColBufStatus[u8DrvId][1] == E_MJPEG_BUF_USING)
712 {
713 MJPEG_DEBUG_API_MSG("[ASF_MJPEG]middle packet in frame(H)!!!!!!!!!!!!!!!!\n");
714 _MApi_MJPEG_PushToHighBuffer(u32Id, u32SrcAddrVA, pInfo->u32Size);
715 }
716 }
717 return _bDecodeInThisPush;
718 }
719 #endif
720
721
722 #if 0//SUPPORT_SKIP_ERROR_FRAME
723 static MS_BOOL _MApi_MJPEG_IsDecodeTimeout(MS_U32 u32Id)
724 {
725 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
726 if(_u32StartDecodeTime[u8DrvId] ==0)
727 {
728 return FALSE;
729 }
730 if(MsOS_GetSystemTime() - _u32StartDecodeTime[u8DrvId] > SKIP_ERROR_FRAME_THRESHOLD)
731 {
732 if(E_MJPEG_RET_DECODING == __MApi_MJPEG_CheckDecodeDone(u32Id))
733 {
734 return TRUE;
735 }
736 else
737 {
738 return FALSE;
739 }
740 }
741 return FALSE;
742 }
743 #endif
744
_MApi_MJPEG_DropFrameWhenFF(MS_U8 u32Id)745 MS_BOOL _MApi_MJPEG_DropFrameWhenFF(MS_U8 u32Id)
746 {
747 #if 0 // do not drop frame in all case (handled by vdplayer)
748 if(MApi_JPEG_IsNJPD()==TRUE)
749 {
750 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
751
752 if(_MApi_JPEG_GetWidth()<=MJPEG_SD_WIDTH && _MApi_JPEG_GetHeight()<=MJPEG_SD_HEIGHT)
753 {
754 return FALSE;
755 }
756 else if(_MApi_JPEG_GetWidth()<=MJPEG_MAX_SUPPORT_WIDTH && _MApi_JPEG_GetHeight()<=MJPEG_MAX_SUPPORT_HEIGHT
757 && MDrv_MJPEG_GetFrameRate(u8DrvId) <= (MAX_SUPPORTED_FRAME_RATE_1080P))
758 {
759 return FALSE;
760 }
761 return TRUE;
762 }
763 else
764 #endif
765 {
766 return FALSE;
767 }
768 }
769
770 //-------------------------------------------------------------------------------------------------
771 // Global Functions
772 //-------------------------------------------------------------------------------------------------
773
774 /******************************************************************************/
775 ///Called only when video start
776 ///@param pInitParam \b IN initial paramters
777 ///@param pStream \b IN file system realted function pointers
778 ///@return TRUE or FALSE
779 /******************************************************************************/
780 #ifdef VDEC3
MApi_MJPEG_Init(MS_U32 u32Id,MJPEG_INIT_PARAM * pInitParam,MS_BOOL bFWdecideFB)781 MJPEG_Result MApi_MJPEG_Init(MS_U32 u32Id, MJPEG_INIT_PARAM *pInitParam, MS_BOOL bFWdecideFB)//, PJPEG_FILE_FileSystem_t pStream)
782 #else
783 MJPEG_Result MApi_MJPEG_Init(MS_U32 u32Id, MJPEG_INIT_PARAM *pInitParam)//, PJPEG_FILE_FileSystem_t pStream)
784 #endif
785 {
786 JPEG_InitParam jpegInitParam;
787 memset(&jpegInitParam,0x00,sizeof(JPEG_InitParam)); //CID 51825
788
789 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
790
791 _MApi_MJPEG_InitPara(u32Id);
792 #if 0
793 // For register read/write
794 extern MS_U32 u32MJPEGRiuBaseAdd;
795 MS_U32 u32NonPMBankSize = 0;
796 if(FALSE == MDrv_MMIO_GetBASE( &u32MJPEGRiuBaseAdd, &u32NonPMBankSize, MS_MODULE_JPD))
797 {
798 MJPEG_DEBUG_API_ERR("MDrv_MMIO_GetBASE FAILED !! \n");
799 return E_MJPEG_RET_FAIL;
800 }
801 else
802 {
803 MJPEG_DEBUG_API_MSG("DRVreg base = 0x%lX, length = %lu\n", u32MJPEGRiuBaseAdd, u32NonPMBankSize);
804 MDrv_MJPEG_InitRegBase(u32MJPEGRiuBaseAdd);
805 }
806 #endif
807
808 #if ENABLE_MJPEG_FIRMWARE
809 // Init Firmware
810 MJPEG_FW_Info FWInfo;
811
812 FWInfo.u32Size = pInitParam->u32FwSize;
813 FWInfo.u32Addr = pInitParam->u32FwAddr;
814 FWInfo.u32BinSize = pInitParam->u32FwBinSize;
815 FWInfo.u32BinAddr = pInitParam->u32FwBinAddr;
816 FWInfo.u8FwSrcType = pInitParam->eFwSrcType;
817 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
818 if(bCMAUsed && u8DrvId == 0)
819 {
820 FWInfo.u32MWCAddr = cmaInitParam.heap_miu_start_offset;
821 FWInfo.u32MWCSize = cmaInitParam.heap_length;
822 MJPEG_DEBUG("CMA used, reset address/size to [0x%tx, 0x%tx]\n", (ptrdiff_t)FWInfo.u32MWCAddr, (ptrdiff_t)FWInfo.u32MWCSize);
823 #ifdef VDEC3
824 bFWdecideFB = TRUE;
825 #endif
826 }
827 else
828 #endif
829 {
830 FWInfo.u32MWCAddr = pInitParam->u32MWCBufAddr;
831 FWInfo.u32MWCSize = pInitParam->u32MWCBufSize;
832 }
833 #ifdef VDEC3
834 FWInfo.bFWdecideFB = bFWdecideFB;
835 #endif
836 if(E_MJPEG_OK != MDrv_MJPEG_InitFw(u32Id, FWInfo))
837 {
838 MJPEG_DEBUG_API_ERR("MDrv_MJPEG_InitFw Failed~~~~\n");
839 }
840 //__u32FwAddr = pInitParam->u32FwAddr;
841 isDecFrameInfoValid[u8DrvId] = FALSE;
842 bStepDec[u8DrvId] = FALSE;
843
844 MJPEG_DEBUG_API_MSG("clear error code due to call MApi_MJPEG_Init()\n");
845 _MApi_MJPEG_SetErrCode(u32Id, E_MJPEG_ERROR_CODE_NONE);
846 // Check if firmware is ready or not
847 if (MDrv_MJPEG_IsFirmwareReady() == FALSE)
848 {
849 MDrv_MJPEG_DeInit(u32Id);
850 return E_MJPEG_RET_FAIL;
851 }
852
853 #ifdef VDEC3
854 __bFWdecideFB[u8DrvId] = bFWdecideFB;
855 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
856 if(bFWdecideFB || (bCMAUsed && u8DrvId == 0))
857 #else
858 if(bFWdecideFB)
859 #endif
860 {
861 MJPEG_DEBUG("%s...FW decide FB!!! [%tdx%td]\n", __FUNCTION__, (ptrdiff_t)pInitParam->u32Width, (ptrdiff_t)pInitParam->u32Height);
862 if(pInitParam->u32Width*pInitParam->u32Height ==0)
863 {
864 pInitParam->u32Width = MJPEG_MAX_SUPPORT_WIDTH;
865 pInitParam->u32Height = MJPEG_MAX_SUPPORT_HEIGHT;
866 }
867 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_WIDTH, pInitParam->u32Width);
868 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_HEIGHT, pInitParam->u32Height);
869 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_FHD;
870
871 if(MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_GET_FRAME_BUFFER, 0))
872 {
873 pInitParam->u32MWCBufAddr = MDrv_MJPEG_GetFrameBuffStAddr(u8DrvId);
874 pInitParam->u32MWCBufSize= MDrv_MJPEG_GetFrameBuffTotalSize(u8DrvId);
875 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
876 if(bCMAUsed && u8DrvId == 0)
877 {
878 if(cmaInitParam.miu==1)
879 {
880 MJPEG_DEBUG("[MJPEG]CMA in MIU1!!!\n");
881 pInitParam->u32MWCBufAddr += HAL_MIU1_BASE;
882 }
883 #ifdef HAL_MIU2_BASE
884 else if(cmaInitParam.miu==2)
885 {
886 MJPEG_DEBUG("[MJPEG]CMA in MIU2!!!\n");
887 pInitParam->u32MWCBufAddr += HAL_MIU2_BASE;
888 }
889 #endif
890 }
891 #endif
892 }
893 else
894 {
895 MJPEG_DEBUG_API_ERR("MDrv_MJPEG_GetFrameBuffer Failed~~~~\n");
896 return E_MJPEG_RET_FAIL;
897 }
898 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
899 if(bCMAUsed && u8DrvId == 0)
900 {
901 MS_PHY u32Addr;
902 MS_U32 u32Size;
903 MS_BOOL bAllocateDone;
904 struct CMA_Pool_Alloc_Param alloc_param;
905 MDrv_MJPEG_GetCMAInformation(u32Id,&u32Addr,&u32Size,&bAllocateDone);
906 MJPEG_DEBUG("MDrv_MJPEG_GetCMAInformation() u32Addr=0x%tx, u32Size=0x%tx, bAllocateDone=%d!!!\n", (ptrdiff_t)u32Addr, (ptrdiff_t)u32Size, bAllocateDone);
907
908 if(u32Addr == 0 || u32Size == 0)
909 {
910 return FALSE;
911 }
912 else
913 {
914 alloc_param.pool_handle_id = cmaInitParam.pool_handle_id;
915 alloc_param.offset_in_pool = u32Addr - cmaInitParam.heap_miu_start_offset;
916 alloc_param.length = u32Size;
917 alloc_param.flags = CMA_FLAG_VIRT_ADDR;
918
919 if (MApi_CMA_Pool_GetMem(&alloc_param) == FALSE)
920 {
921 MJPEG_DEBUG("MApi_CMA_Pool_GetMem() fail!!!\n");
922 return FALSE;
923 }
924
925 MJPEG_DEBUG("[VDEC][%d]MApi_CMA_Pool_GetMem in mjpeg: alloc_param.pool_handle_id=%x, alloc_param.flags=%x, alloc_param.offset_in_pool=%llx, alloc_param.length=%x\n",
926 (unsigned int)u8DrvId,
927 (unsigned int)alloc_param.pool_handle_id,
928 (unsigned int)alloc_param.flags,
929 (unsigned long long int)alloc_param.offset_in_pool,
930 (unsigned int)alloc_param.length);
931
932 cmaFreeParam[u8DrvId].pool_handle_id = alloc_param.pool_handle_id;
933 cmaFreeParam[u8DrvId].offset_in_pool = alloc_param.offset_in_pool;
934 cmaFreeParam[u8DrvId].length = alloc_param.length;
935
936 bCMAAllocDone = TRUE;
937 }
938 }
939 #endif
940 }
941 #endif
942
943 if((pInitParam->u32MWCBufAddr)%8)
944 {
945 MJPEG_DEBUG_API_MSG("u32MWCBufAddr need 8 byte alignment~~~~0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufAddr);
946 }
947 else
948 {
949 MJPEG_DEBUG_API_MSG("u32MWCBufAddr don't need 8 byte alignment~~~~0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufAddr);
950 }
951
952 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_START_ADDR, pInitParam->u32MWCBufAddr);
953
954 #if SUPPORT_ASF_MJPEG_MODE
955 if(MApi_JPEG_IsNJPD()==TRUE)
956 {
957 if((pInitParam->u32MWCBufSize-MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE)
958 >= MJPEG_MAX_SUPPORT_WIDTH*MJPEG_MAX_SUPPORT_HEIGHT*2*DISPLAY_QUEUE_NUM)
959 {
960 MDrv_MJPEG_SetFrameBuffTotalNum(u8DrvId, DISPLAY_QUEUE_NUM);
961 MJPEG_DEBUG("Max Support: MJPEG_FHD with pInitParam->u32MWCBufSize=0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufSize);
962 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_FHD;
963 }
964 else if((pInitParam->u32MWCBufSize-MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE)
965 >= MJPEG_HD_1280x720_WIDTH*MJPEG_HD_1280x720_HEIGHT*2*DISPLAY_QUEUE_NUM)
966 {
967 MDrv_MJPEG_SetFrameBuffTotalNum(u8DrvId, DISPLAY_QUEUE_NUM);
968 MJPEG_DEBUG("Max Support: MJPEG_720P with pInitParam->u32MWCBufSize=0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufSize);
969 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_720P;
970 }
971 else if((pInitParam->u32MWCBufSize-MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE)
972 >= MJPEG_SD_WIDTH*MJPEG_SD_HEIGHT*2*DISPLAY_QUEUE_NUM)
973 {
974 MDrv_MJPEG_SetFrameBuffTotalNum(u8DrvId, DISPLAY_QUEUE_NUM);
975 MJPEG_DEBUG("Max Support: MJPEG_480P with pInitParam->u32MWCBufSize=0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufSize);
976 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_480P;
977 }
978 else
979 {
980 MJPEG_DEBUG_API_ERR("Not enough framebuffer for 480p asf-mjpeg mode support!!\n");
981 return E_MJPEG_RET_FAIL;
982 }
983 }
984 else
985 {
986 if((pInitParam->u32MWCBufSize-MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE)
987 >= MJPEG_SD_WIDTH*MJPEG_SD_HEIGHT*2*DISPLAY_QUEUE_NUM)
988 {
989 MDrv_MJPEG_SetFrameBuffTotalNum(u8DrvId, DISPLAY_QUEUE_NUM);
990 MJPEG_DEBUG("Max Support: MJPEG_480P with pInitParam->u32MWCBufSize=0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufSize);
991 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_480P;
992 }
993 else
994 {
995 MJPEG_DEBUG_API_ERR("Not enough framebuffer for asf-mjpeg mode support!!\n");
996 return E_MJPEG_RET_FAIL;
997 }
998 }
999 MDrv_MJPEG_SetFrameBuffUnitSize(u8DrvId, (pInitParam->u32MWCBufSize-MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE)/MDrv_MJPEG_GetFrameBuffTotalNum(u8DrvId));
1000 #else
1001 if(MApi_JPEG_IsNJPD()==TRUE)
1002 {
1003 if(pInitParam->u32MWCBufSize >= MJPEG_MAX_SUPPORT_WIDTH*MJPEG_MAX_SUPPORT_HEIGHT*2*DISPLAY_QUEUE_NUM)
1004 {
1005 MDrv_MJPEG_SetFrameBuffTotalNum(u8DrvId, DISPLAY_QUEUE_NUM);
1006 MJPEG_DEBUG("Max Support: MJPEG_FHD with pInitParam->u32MWCBufSize=0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufSize);
1007 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_FHD;
1008 }
1009 else
1010 {
1011 MJPEG_DEBUG_API_ERR("Not enough framebuffer for FHD mjpeg!!\n");
1012 return E_MJPEG_RET_FAIL;
1013 }
1014 }
1015 else
1016 {
1017 if(pInitParam->u32MWCBufSize >= MJPEG_SD_WIDTH*MJPEG_SD_HEIGHT*2*DISPLAY_QUEUE_NUM)
1018 {
1019 MDrv_MJPEG_SetFrameBuffTotalNum(u8DrvId, DISPLAY_QUEUE_NUM);
1020 MJPEG_DEBUG("Max Support: MJPEG_480P with pInitParam->u32MWCBufSize=0x%tx\n", (ptrdiff_t)pInitParam->u32MWCBufSize);
1021 eMaxSupport[u8DrvId] = E_MJPEG_MAX_SUPPORTED_480P;
1022 }
1023 else
1024 {
1025 MJPEG_DEBUG_API_ERR("Not enough framebuffer for mjpeg!!\n");
1026 return E_MJPEG_RET_FAIL;
1027 }
1028 }
1029 MDrv_MJPEG_SetFrameBuffUnitSize(u8DrvId, pInitParam->u32MWCBufSize/MDrv_MJPEG_GetFrameBuffTotalNum(u8DrvId));
1030 #endif
1031 MDrv_MJPEG_SetFrameBuffUnitSize(u8DrvId, (MDrv_MJPEG_GetFrameBuffUnitSize(u8DrvId) >> 3) << 3);//8 byte alignment
1032
1033 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_UNIT_SIZE, MDrv_MJPEG_GetFrameBuffUnitSize(u8DrvId));
1034 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_TOTAL_NUM, MDrv_MJPEG_GetFrameBuffTotalNum(u8DrvId));
1035 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAMERATE, pInitParam->u32FrameRate);
1036 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAMERATE_BASE, pInitParam->u32FrameRateBase);
1037 // MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_CHIP_ID, MDrv_MJPEG_Get_Chip_ID());
1038
1039 if(pInitParam->u32FrameRate ==0)
1040 {
1041 MJPEG_DEBUG_API_ERR("Error!!! MJPEG Frame rate is 0\n");
1042 pInitParam->u32FrameRate =30000;
1043 }
1044 MDrv_MJPEG_SetFrameRate(u8DrvId, pInitParam->u32FrameRate);
1045 MDrv_MJPEG_SetFrameRateBase(u8DrvId, pInitParam->u32FrameRateBase);
1046
1047 MDrv_MJPEG_SetFrameTime(u8DrvId, MDrv_MJPEG_GetFrameRateBase(u8DrvId) * 1000 / MDrv_MJPEG_GetFrameRate(u8DrvId));
1048 #endif // ENABLE_MJPEG_FIRMWARE
1049
1050 MDrv_MJPEG_SetFrameCnt(u8DrvId, 0);
1051 __u32DropFrameCnt[u8DrvId] = 0;
1052
1053 __u32MRCBufAddr[u8DrvId] = pInitParam->u32MRCBufAddr;
1054 __u32MRCBufSize[u8DrvId] = pInitParam->u32MRCBufSize;
1055 __u32MWCBufAddr[u8DrvId] = pInitParam->u32MWCBufAddr;
1056 #if SUPPORT_ASF_MJPEG_MODE
1057 __u32CollectBufAddr[u8DrvId] = pInitParam->u32MWCBufAddr+pInitParam->u32MWCBufSize - MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE;
1058 __u32CollectBufWptr[u8DrvId] = __u32CollectBufAddr[u8DrvId];
1059 #endif
1060
1061 __u32InternalBufAddr[u8DrvId] = pInitParam->u32MRCBufAddr;
1062 __u32InternalBufSize[u8DrvId] = pInitParam->u32MRCBufSize;
1063
1064
1065 if(MApi_JPEG_IsNJPD()==TRUE)
1066 {
1067 if(u8MJPEGCnt==0)
1068 {
1069 _MApi_JPEG_SetNJPDInstance(0xCC);
1070 }
1071 }
1072 else
1073 {
1074 jpegInitParam.u32MRCBufAddr = pInitParam->u32MRCBufAddr;
1075 jpegInitParam.u32MRCBufSize = pInitParam->u32MRCBufSize;
1076 jpegInitParam.u32MWCBufAddr = pInitParam->u32MWCBufAddr;
1077 #if SUPPORT_ASF_MJPEG_MODE
1078 jpegInitParam.u32MWCBufSize = pInitParam->u32MWCBufSize - MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE;
1079 #else
1080 jpegInitParam.u32MWCBufSize = pInitParam->u32MWCBufSize;
1081 #endif
1082
1083 jpegInitParam.u32InternalBufAddr = pInitParam->u32InternalBufAddr;
1084 jpegInitParam.u32InternalBufSize = pInitParam->u32InternalBufSize;
1085 jpegInitParam.u32DecByteRead = 0;
1086 jpegInitParam.bEOF = TRUE;
1087 jpegInitParam.u8DecodeType = E_JPEG_TYPE_MJPEG;
1088 jpegInitParam.bInitMem = TRUE;
1089 jpegInitParam.pFillHdrFunc = NULL;
1090 // This is used to init memory
1091 if (_MApi_JPEG_Init(&jpegInitParam) == E_JPEG_FAILED)
1092 {
1093 #if ENABLE_MJPEG_FIRMWARE
1094 MDrv_MJPEG_DeInit(u32Id);
1095 #endif
1096 return E_MJPEG_RET_FAIL;
1097 }
1098
1099 // Make sure it's exited correctly
1100 _MApi_JPEG_Exit();
1101 }
1102
1103 MJPEG_DEBUG("MJPEG init================================\n");
1104 MJPEG_DEBUG("[MRC]addr=0x%tx, size=0x%tx\n", (ptrdiff_t)__u32MRCBufAddr[u8DrvId], (ptrdiff_t)pInitParam->u32MRCBufSize);
1105 MJPEG_DEBUG("[MWC]addr=0x%tx, size=0x%tx\n", (ptrdiff_t)__u32MWCBufAddr[u8DrvId], (ptrdiff_t)pInitParam->u32MWCBufSize);
1106 MJPEG_DEBUG("[INTER]addr=0x%tx, size=0x%tx\n", (ptrdiff_t)__u32InternalBufAddr[u8DrvId], (ptrdiff_t)__u32InternalBufSize[u8DrvId]);
1107 MJPEG_DEBUG("[MRC VA]addr=0x%tx, size=0x%tx\n", (ptrdiff_t)MS_PA2KSEG1(__u32MRCBufAddr[u8DrvId]), (ptrdiff_t)pInitParam->u32MRCBufSize);
1108 MJPEG_DEBUG("[MWC VA]addr=0x%tx, size=0x%tx\n", (ptrdiff_t)MS_PA2KSEG1(__u32MWCBufAddr[u8DrvId]), (ptrdiff_t)pInitParam->u32MWCBufSize);
1109 MJPEG_DEBUG("[INTER VA]addr=0x%tx, size=0x%tx\n", (ptrdiff_t)MS_PA2KSEG1(__u32InternalBufAddr[u8DrvId]), (ptrdiff_t)__u32InternalBufSize[u8DrvId]);
1110 MJPEG_DEBUG("===========================================\n");
1111
1112 // Init Local Variables
1113 PreVIdx[u8DrvId] = 0;
1114 ReCheckTime[u8DrvId] = 0;
1115 bLstFrame[u8DrvId] = FALSE;
1116
1117 u8MJPEGCnt++;
1118 return E_MJPEG_RET_SUCCESS;
1119 }
1120
1121 /******************************************************************************/
1122 ///Reset JPD
1123 /******************************************************************************/
MApi_MJPEG_Rst(MS_U32 u32Id)1124 MJPEG_Result MApi_MJPEG_Rst(MS_U32 u32Id)
1125 {
1126 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1127 __bIsFirstFrameRdy[u8DrvId] = FALSE;
1128
1129 #if 0
1130 if(MApi_JPEG_IsNJPD()==TRUE)
1131 {
1132 _MApi_JPEG_SetNJPDInstance(0);
1133 }
1134 _MApi_JPEG_Rst();
1135 if(MApi_JPEG_IsNJPD()==TRUE)
1136 {
1137 _MApi_JPEG_SetNJPDInstance(1);
1138 }
1139 _MApi_JPEG_Rst();
1140 #endif
1141 MJPEG_DEBUG_API_MSG("clear error code due to call MApi_MJPEG_Rst()\n");
1142 _MApi_MJPEG_SetErrCode(u32Id, E_MJPEG_ERROR_CODE_NONE);
1143
1144 // CHECK : reset firmware???
1145
1146 return E_MJPEG_RET_SUCCESS;
1147 }
1148
1149 /******************************************************************************/
1150 ///Turn off JPD clock
1151 /******************************************************************************/
1152 //extern void _MApi_JPEG_DisableAddressConvert(void); // defined in apiJPEG.c
MApi_MJPEG_Stop(MS_U32 u32Id)1153 MJPEG_Result MApi_MJPEG_Stop(MS_U32 u32Id)
1154 {
1155 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1156
1157 __bIsFirstFrameRdy[u8DrvId] = FALSE;
1158 isDecFrameInfoValid[u8DrvId] = FALSE;
1159 bStepDec[u8DrvId] = FALSE;
1160
1161 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
1162 if (bCMAUsed && u8DrvId == 0)
1163 {
1164 if (MApi_CMA_Pool_PutMem(&cmaFreeParam[u8DrvId]) == FALSE)
1165 {
1166 return E_MJPEG_RET_FAIL;
1167 }
1168
1169 MJPEG_DEBUG("[VDEC][%d]MApi_CMA_Pool_PutMem in mjpeg: cmaFreeParam.pool_handle_id=%x, cmaFreeParam.offset_in_pool=%llx, cmaFreeParam.length=%x\n",
1170 (unsigned int)u8DrvId,
1171 (unsigned int)cmaFreeParam[u8DrvId].pool_handle_id,
1172 (unsigned long long int)cmaFreeParam[u8DrvId].offset_in_pool,
1173 (unsigned int)cmaFreeParam[u8DrvId].length);
1174 MJPEG_DEBUG("[MJPEG][0x%tx]MApi_CMA_Pool_PutMem: offset=0x%tx, len=0x%tx\n", (ptrdiff_t)u32Id, (ptrdiff_t)cmaFreeParam[u8DrvId].offset_in_pool, (ptrdiff_t)cmaFreeParam[u8DrvId].length);
1175 }
1176 #endif
1177
1178 #ifdef VDEC3
1179 if(__bFWdecideFB[u8DrvId])
1180 {
1181 MJPEG_DEBUG("%s...release FB by FW!!!\n", __FUNCTION__);
1182 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_FREE_FRAME_BUFFER, 0);
1183 }
1184 #endif
1185 MDrv_MJPEG_StopVPU();
1186
1187 MDrv_MJPEG_DeInit(u32Id);
1188
1189 #if 0
1190 if(MApi_JPEG_IsNJPD()==TRUE)
1191 {
1192 _MApi_JPEG_SetNJPDInstance(0);
1193 }
1194
1195 _MApi_JPEG_DisableAddressConvert();
1196
1197 //_MApi_JPEG_PowerOff() is called in _MApi_JPEG_Exit()
1198 _MApi_JPEG_Exit();
1199
1200 if(MApi_JPEG_IsNJPD()==TRUE)
1201 {
1202 _MApi_JPEG_SetNJPDInstance(1);
1203 }
1204
1205 _MApi_JPEG_DisableAddressConvert();
1206
1207 //_MApi_JPEG_PowerOff() is called in _MApi_JPEG_Exit()
1208 _MApi_JPEG_Exit();
1209 #endif
1210
1211 if(u8MJPEGCnt)
1212 {
1213 u8MJPEGCnt--;
1214 }
1215 else
1216 {
1217 MJPEG_DEBUG_API_ERR("Warning!!! u8MJPEGCnt is 0 and cannot be decreased!!\n");
1218 }
1219 if(MApi_JPEG_IsNJPD()==TRUE && u8MJPEGCnt==0)
1220 {
1221 MJPEG_DEBUG("MJPEG all close!!!!!!!!!!!!!!!!!!\n");
1222 _MApi_JPEG_SetNJPDInstance(0xdd);
1223 _MApi_JPEG_Exit();
1224 }
1225 else if(MApi_JPEG_IsNJPD()==FALSE)
1226 {
1227 MJPEG_DEBUG("[OJPD]_MApi_JPEG_Exit()\n");
1228 _MApi_JPEG_Exit();
1229 }
1230 // CHECK : stop firmware???
1231 MJPEG_DEBUG("MApi_MJPEG_Stop()...done\n");
1232
1233 return E_MJPEG_RET_SUCCESS;
1234 }
1235
1236 /******************************************************************************/
1237 ///Check if first frame has been decoded
1238 ///@return TRUE if first picture is decoded, else return FALSE
1239 /******************************************************************************/
MApi_MJPEG_CheckDispInfoRdy(MS_U32 u32Id)1240 MJPEG_Result MApi_MJPEG_CheckDispInfoRdy(MS_U32 u32Id)
1241 {
1242 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1243 if ((TRUE == __bIsFirstFrameRdy[u8DrvId])
1244 && (E_JPEG_EVENT_DEC_DONE & _MApi_JPEG_GetJPDEventFlag()))
1245 {
1246 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_CheckDispInfoRdy : E_MJPEG_RET_SUCCESS\n");
1247 return E_MJPEG_RET_SUCCESS;
1248 }
1249
1250 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_CheckDispInfoRdy : E_MJPEG_RET_FAIL\n");
1251 return E_MJPEG_RET_FAIL;
1252 }
1253
1254 /******************************************************************************/
1255 ///Play
1256 ///@param in \b IN in parameter
1257 ///@param out \b OUT out parameter
1258 ///@return status
1259 /******************************************************************************/
MApi_MJPEG_Play(MS_U32 u32Id)1260 MJPEG_Result MApi_MJPEG_Play(MS_U32 u32Id)
1261 {
1262 if (MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_PLAY, 0xFFFFFFFFUL) == 0)
1263 {
1264 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_Play : E_MJPEG_RET_FAIL\n");
1265 return E_MJPEG_RET_FAIL;
1266 }
1267
1268 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_Play : E_MJPEG_RET_SUCCESS\n");
1269 return E_MJPEG_RET_SUCCESS;
1270 }
1271
1272 /******************************************************************************/
1273 ///Pause
1274 ///@param in \b IN in parameter
1275 ///@param out \b OUT out parameter
1276 ///@return status
1277 /******************************************************************************/
MApi_MJPEG_Pause(MS_U32 u32Id)1278 MJPEG_Result MApi_MJPEG_Pause(MS_U32 u32Id)
1279 {
1280 if (MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_PAUSE, 0xFFFFFFFFUL) == 0)
1281 {
1282 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_Pause : E_MJPEG_RET_FAIL\n");
1283 return E_MJPEG_RET_FAIL;
1284 }
1285
1286 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_Pause : E_MJPEG_RET_SUCCESS\n");
1287 return E_MJPEG_RET_SUCCESS;
1288 }
1289
1290 /******************************************************************************/
1291 ///Resume
1292 ///@param in \b IN in parameter
1293 ///@param out \b OUT out parameter
1294 ///@return status
1295 /******************************************************************************/
MApi_MJPEG_Resume(MS_U32 u32Id)1296 MJPEG_Result MApi_MJPEG_Resume(MS_U32 u32Id)
1297 {
1298 if (MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_RESUME, 0xFFFFFFFFUL) == 0)
1299 {
1300 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_Resume : E_MJPEG_RET_FAIL\n");
1301 return E_MJPEG_RET_FAIL;
1302 }
1303
1304 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_Resume : E_MJPEG_RET_SUCCESS\n");
1305 return E_MJPEG_RET_SUCCESS;
1306 }
1307
1308 /******************************************************************************/
1309 ///Step Play
1310 ///@param in \b IN in parameter
1311 ///@param out \b OUT out parameter
1312 ///@return status
1313 /******************************************************************************/
MApi_MJPEG_StepPlay(MS_U32 u32Id)1314 MJPEG_Result MApi_MJPEG_StepPlay(MS_U32 u32Id)
1315 {
1316 MDrv_MJPEG_SetStepDispPara(u32Id);
1317 if (MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_STEP_PLAY, 0xFFFFFFFFUL) == 0)
1318 {
1319 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_StepPlay : E_MJPEG_RET_FAIL\n");
1320 return E_MJPEG_RET_FAIL;
1321 }
1322
1323 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_StepPlay : E_MJPEG_RET_SUCCESS\n");
1324 return E_MJPEG_RET_SUCCESS;
1325 }
1326
1327 /******************************************************************************/
1328 ///Check if step play is done or not
1329 ///@return TRUE or FALSE
1330 /******************************************************************************/
MApi_MJPEG_IsStepPlayDone(MS_U32 u32Id)1331 MS_BOOL MApi_MJPEG_IsStepPlayDone(MS_U32 u32Id)
1332 {
1333 return (!MDrv_MJPEG_IsStepPlayDone(u32Id));
1334 }
1335
1336 /******************************************************************************/
1337 ///Description
1338 ///@param in \b IN in parameter
1339 ///@param out \b OUT out parameter
1340 ///@return status
1341 /******************************************************************************/
MApi_MJPEG_StepDecode(MS_U32 u32Id)1342 MJPEG_Result MApi_MJPEG_StepDecode(MS_U32 u32Id)
1343 {
1344 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1345 bStepDec[u8DrvId] = FALSE;
1346 return E_MJPEG_RET_SUCCESS;
1347 }
1348
1349 /******************************************************************************/
1350 ///Description
1351 ///@param in \b IN in parameter
1352 ///@param out \b OUT out parameter
1353 ///@return status
1354 /******************************************************************************/
MApi_MJPEG_IsStepDecodeDone(MS_U32 u32Id)1355 MS_BOOL MApi_MJPEG_IsStepDecodeDone(MS_U32 u32Id)
1356 {
1357 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1358 if(FALSE == bStepDec[u8DrvId])
1359 return FALSE;
1360
1361 if (E_MJPEG_RET_SUCCESS == __MApi_MJPEG_CheckDecodeDone(u32Id))
1362 return TRUE;
1363
1364 return FALSE;
1365 }
1366
1367 /******************************************************************************/
1368 ///Issue full JPEG decode process
1369 ///@param in \b IN in parameter
1370 ///@param out \b OUT out parameter
1371 ///@return status
1372 /******************************************************************************/
1373 //MJPEG_Result MApi_MJPEG_PushQueue(MS_PHY u32StAddr, MS_U32 u32Size, MS_U32 u32TimeStamp)
MApi_MJPEG_PushQueue(MS_U32 u32Id,MJPEG_Packet_Info * pInfo)1374 MJPEG_Result MApi_MJPEG_PushQueue(MS_U32 u32Id, MJPEG_Packet_Info *pInfo)
1375 {
1376 //
1377 // There's no queue
1378 //
1379 JPEG_InitParam jpegInitParam;
1380 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1381 if(MApi_JPEG_IsNJPD()==TRUE)
1382 {
1383 _MApi_JPEG_SetNJPDInstance(bNJPDNum);
1384 }
1385
1386 MJPEG_DEBUG("[MJPEG]MApi_MJPEG_PushQueue() pts=%td\n", (ptrdiff_t)pInfo->u32TimeStamp);
1387 #if 0 // force to asf mjpeg mode (move to another internal buffer)
1388 pInfo->u32StAddr |= VDEC_EX_MVD_PIC_START_FLAG;
1389 #endif
1390
1391 if(pInfo->u32Size == 0)
1392 {
1393 u16NullCnt[u8DrvId]++;
1394 MJPEG_DEBUG_API_MSG("%s: MJPEG NULL PACKET!!!!!!!!!!\n", __FUNCTION__);
1395 return E_MJPEG_RET_SUCCESS;
1396 }
1397 #if 0//SUPPORT_SKIP_ERROR_FRAME
1398 if(_MApi_MJPEG_IsDecodeTimeout(u32Id))
1399 {
1400 MJPEG_DEBUG_API_ERR("%s: JPEG decode frame timeout!!!!!!!!!!\n", __FUNCTION__);
1401 _u32SkipCnt[u8DrvId]++;
1402 _u32ErrCnt[u8DrvId]++;
1403 // Repeat next frame because previous frame decode timeout
1404 u16NullCnt[u8DrvId]++;
1405 MJPEG_DEBUG_API_ERR("%s: Reset JPD!!!!!!!!!!\n", __FUNCTION__);
1406 _MApi_JPEG_Rst();
1407 _MApi_JPEG_Exit();
1408 }
1409 #endif
1410
1411 #if SUPPORT_ASF_MJPEG_MODE
1412 if(__bAsfMjpegMode[u8DrvId]==TRUE)
1413 {
1414 if(_MApi_MJPEG_IsAbleToPushNextFrame(u32Id) ==FALSE
1415 && pInfo->u32StAddr & VDEC_EX_MVD_PIC_START_FLAG)
1416 {
1417 // At least one packet is available for pushing next frame
1418 return E_MJPEG_RET_DECODING;
1419 }
1420 }
1421
1422 _MApi_MJPEG_ASFParameterSetting(u32Id, pInfo);
1423 pInfo->u32StAddr &= ~VDEC_EX_MVD_PIC_START_FLAG;
1424
1425 if(__bAsfMjpegMode[u8DrvId]==TRUE)
1426 {
1427 if(_MApi_MJPEG_ASFBufferManagement(u32Id, pInfo)==FALSE)
1428 {
1429 return E_MJPEG_RET_SUCCESS;
1430 }
1431 }
1432 #endif
1433
1434 MS_U16 u16DecodeCnt;
1435 for(u16DecodeCnt=0; u16DecodeCnt<=u16NullCnt[u8DrvId]; u16DecodeCnt++)
1436 {
1437 if (E_MJPEG_RET_DECODING == __MApi_MJPEG_CheckDecodeDone(u32Id))
1438 {
1439 u16NullCnt[u8DrvId] -=u16DecodeCnt;
1440 MJPEG_DEBUG_API_MSG("%s: E_MJPEG_RET_DECODING with u16DecodeCnt=%d\n", __FUNCTION__, u16DecodeCnt);
1441 return E_MJPEG_RET_DECODING;
1442 }
1443 #if SUPPORT_ASF_MJPEG_MODE
1444 if(__bAsfMjpegMode[u8DrvId]==TRUE)
1445 {
1446 if(u16DecodeCnt == u16NullCnt[u8DrvId])
1447 {
1448 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId) ==TRUE
1449 && __eColBufStatus[u8DrvId][1]==E_MJPEG_BUF_BUSY)
1450 {
1451 __eColBufStatus[u8DrvId][1] = E_MJPEG_BUF_AVAILABLE;
1452 }
1453 else if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId)==FALSE
1454 && __eColBufStatus[u8DrvId][0]==E_MJPEG_BUF_BUSY)
1455 {
1456 __eColBufStatus[u8DrvId][0] = E_MJPEG_BUF_AVAILABLE;
1457 }
1458 }
1459 }
1460 #endif
1461
1462 #if 1
1463 if(__u32ReadPtr[u8DrvId] > __u32WritePtr[u8DrvId])
1464 {
1465 MJPEG_DEBUG("\033[1;31m[MWC][%dx%d.yuyv]addr=0x%tx, size=0x%tx, [r:0x%tx, w:0x%tx]\033[m\n",
1466 _MApi_JPEG_GetWidth(), _MApi_JPEG_GetHeight(), (ptrdiff_t)infoDecFrame[u8DrvId].u32LumaAddr,
1467 (ptrdiff_t)(_MApi_JPEG_GetWidth()*_MApi_JPEG_GetHeight()*2),
1468 (ptrdiff_t)__u32ReadPtr[u8DrvId], (ptrdiff_t)__u32WritePtr[u8DrvId]);
1469 }
1470 else
1471 {
1472 MJPEG_DEBUG("[MWC][%dx%d.yuyv]addr=0x%tx, size=0x%tx, [r:0x%tx, w:0x%tx]\n",
1473 _MApi_JPEG_GetWidth(), _MApi_JPEG_GetHeight(), (ptrdiff_t)infoDecFrame[u8DrvId].u32LumaAddr,
1474 (ptrdiff_t)(_MApi_JPEG_GetWidth()*_MApi_JPEG_GetHeight()*2),
1475 (ptrdiff_t)__u32ReadPtr[u8DrvId], (ptrdiff_t)__u32WritePtr[u8DrvId]);
1476 }
1477 if(_u8MJPEG_ApiDbgLevel & E_JPEG_DEBUG_MJPEG)
1478 {
1479 MDrv_MJPEG_PrintShareInfo(u32Id);
1480 }
1481 #endif
1482
1483 __u32ReadPtr[u8DrvId] = u32EndAddr[u8DrvId];
1484 MJPEG_DEBUG_API_MSG("%s: Count %td, __bSkipToPts=%td, __bSeekToPts=%td, __u32Skip2PtsBase=%td, __u32TargetPts=%td\n",
1485 __FUNCTION__, (ptrdiff_t)MDrv_MJPEG_GetFrameCnt(u8DrvId), (ptrdiff_t)__bSkipToPts[u8DrvId], (ptrdiff_t)__bSeekToPts[u8DrvId], (ptrdiff_t)__u32Skip2PtsBase[u8DrvId], (ptrdiff_t)__u32TargetPts[u8DrvId]);
1486
1487
1488 __u32WritePtr[u8DrvId] = pInfo->u32StAddr + pInfo->u32Size - 1;
1489
1490
1491 MJPEG_DEBUG("[MJPEG]Pushed done, [r:0x%tx, w:0x%tx, u8DrvId=%td]\n", (ptrdiff_t)__u32ReadPtr[u8DrvId], (ptrdiff_t)__u32WritePtr[u8DrvId], (ptrdiff_t)u8DrvId);
1492
1493 // Skip/Seek to PTS
1494 if (__bSkipToPts[u8DrvId] || __bSeekToPts[u8DrvId])
1495 {
1496 if (__u32Skip2PtsBase[u8DrvId] >= __u32TargetPts[u8DrvId])
1497 {
1498 MJPEG_DEBUG_API_MSG("Skip/Seek to PTS done -- current PTS %td\n", (ptrdiff_t)__u32Skip2PtsBase[u8DrvId]);
1499 __bSkipToPts[u8DrvId] = FALSE;
1500 __bSeekToPts[u8DrvId] = FALSE;
1501 // Need to update firmware PTS base
1502 MDrv_MJPEG_ResetPTS(u32Id, __u32Skip2PtsBase[u8DrvId]);
1503 }
1504 else
1505 {
1506 MJPEG_DEBUG_API_MSG("Skip Frame -- PTS %td\n", (ptrdiff_t)__u32Skip2PtsBase[u8DrvId]);
1507 __u32Skip2PtsBase[u8DrvId] += MDrv_MJPEG_GetFrameTime(u8DrvId);
1508 __bIsDecodeDone[u8DrvId] = TRUE;
1509 u32EndAddr[u8DrvId] = pInfo->u32StAddr + pInfo->u32Size - 1;
1510 return E_MJPEG_RET_SUCCESS;
1511 }
1512 }
1513
1514 // Speed Control
1515 if (__bIsFirstFrameRdy[u8DrvId])
1516 {
1517 if (eCurSpeedType[u8DrvId] == E_MJPEG_SPEED_FAST)
1518 {
1519 if ((MDrv_MJPEG_GetFrameCnt(u8DrvId) - __u32SpeedCtrlFrameCntBase[u8DrvId]) % eCurDispSpeed[u8DrvId])
1520 {
1521 MJPEG_DEBUG_API_MSG(" Skip frame %td\n", (ptrdiff_t)(MDrv_MJPEG_GetFrameCnt(u8DrvId) - __u32SpeedCtrlFrameCntBase[u8DrvId]));
1522 u16NullCnt[u8DrvId]=0;
1523 if(_MApi_MJPEG_DropFrameWhenFF(u32Id)==TRUE)
1524 {
1525 __bIsDecodeDone[u8DrvId] = TRUE;
1526 return E_MJPEG_RET_SUCCESS;
1527 }
1528 }
1529 }
1530 else if (eCurSpeedType[u8DrvId] == E_MJPEG_SPEED_SLOW)
1531 {
1532 }
1533 else // if (eCurSpeedType == E_MJPEG_SPEED_DEFAULT)
1534 {
1535 __u32SpeedCtrlFrameCntBase[u8DrvId] = MDrv_MJPEG_GetFrameCnt(u8DrvId);
1536 MJPEG_DEBUG_API_MSG(" Update Frame Count Base %td\n", (ptrdiff_t)__u32SpeedCtrlFrameCntBase[u8DrvId]);
1537 }
1538 }
1539
1540
1541 _MApi_JPEG_SetMaxDecodeResolution(JPEGBASEWIDTHMAX, JPEGBASEHEIGHTMAX);
1542
1543
1544 MJPEG_DEBUG_API_MSG("pInfo->u32StAddr=0x%tx, __u32MRCBufAddr=0x%tx\n", (ptrdiff_t)pInfo->u32StAddr, (ptrdiff_t)__u32MRCBufAddr[u8DrvId]);
1545 MJPEG_DEBUG_API_MSG("pInfo->u32Size=0x%tx\n", (ptrdiff_t)pInfo->u32Size);
1546 // Init
1547 #if SUPPORT_ASF_MJPEG_MODE
1548 if(__bAsfMjpegMode[u8DrvId]==TRUE)
1549 {
1550 if(_MApi_MJPEG_IsColWPtrInLow(u8DrvId))
1551 {
1552 jpegInitParam.u32MRCBufAddr = __u32CollectBufAddr[u8DrvId]+MJPEG_RESERVED_MJPEG_COLLECT_BUF_SIZE/2;
1553 }
1554 else
1555 {
1556 jpegInitParam.u32MRCBufAddr = __u32CollectBufAddr[u8DrvId];
1557 }
1558 jpegInitParam.u32MRCBufSize = 2*(__u32PrevBufAddr[u8DrvId] - jpegInitParam.u32MRCBufAddr);
1559 //printf("[addr=0x%lx, size=0x%lx]\n", jpegInitParam.u32MRCBufAddr, jpegInitParam.u32MRCBufSize);
1560 }
1561 else
1562 {
1563 jpegInitParam.u32MRCBufAddr = (pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]) & ~0x0f;
1564 // Tricky code: let JPD decode only L buffer, then decode dne
1565 MS_U8 u8Cnt;
1566 for(u8Cnt=0; u8Cnt<(pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]-jpegInitParam.u32MRCBufAddr); u8Cnt++)
1567 {
1568 if((*((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt))==0xff && *((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt+1))==0xd9) ||
1569 (*((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt))==0xff && *((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt+1))==0xd8))
1570 {
1571 *((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt+1)) = 0xff;
1572 }
1573 }
1574 // memset((void *)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr), 0, (pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]-jpegInitParam.u32MRCBufAddr));
1575 jpegInitParam.u32MRCBufSize = ((pInfo->u32Size+(pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]-jpegInitParam.u32MRCBufAddr)+0xf) & ~0x0f)*2;
1576 }
1577 #else
1578 jpegInitParam.u32MRCBufAddr = (pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]) & ~0x0f;
1579 // Tricky code: let JPD decode only L buffer, then decode dne
1580 MS_U8 u8Cnt;
1581 for(u8Cnt=0; u8Cnt<(pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]-jpegInitParam.u32MRCBufAddr); u8Cnt++)
1582 {
1583 if((*((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt))==0xff && *((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt+1))==0xd9) ||
1584 (*((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt))==0xff && *((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt+1))==0xd8))
1585 {
1586 *((MS_U8*)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr+u8Cnt+1)) = 0xff;
1587 }
1588 }
1589 // memset((void *)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr), 0, (pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]-jpegInitParam.u32MRCBufAddr));
1590 jpegInitParam.u32MRCBufSize = ((pInfo->u32Size+(pInfo->u32StAddr + __u32MRCBufAddr[u8DrvId]-jpegInitParam.u32MRCBufAddr)+0xf) & ~0x0f)*2;
1591 #endif
1592 if (jpegInitParam.u32MRCBufSize < JPEG_DEFAULT_EXIF_SIZE)
1593 { // Meet size check in _MApi_JPEG_Init()
1594 jpegInitParam.u32MRCBufSize = JPEG_DEFAULT_EXIF_SIZE;
1595 }
1596
1597 // Ask firmware if there is any frame buffer available
1598 u32NextFrameBuffIdx[u8DrvId] = MDrv_MJPEG_GetNextFrameBufferIdx(u32Id);
1599
1600 MJPEG_DEBUG("[MJPEG] E_MJPEG_CMD_GET_NEXT_FREE_FRAME_BUFF_IDX %td\n", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
1601 if (u32NextFrameBuffIdx[u8DrvId] >= 0xFFUL)// It may be 0xFF, 0xFFFF, 0xFFFFFF, or 0xFFFFFFFF
1602 {
1603 MJPEG_DEBUG_API_ERR(" !!! No frame buffer available !!!, u32NextFrameBuffIdx=0x%tx\n", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
1604 __bIsDecodeDone[u8DrvId] = TRUE;
1605 __u32DropFrameCnt[u8DrvId]++;
1606 u16NullCnt[u8DrvId]=0;
1607 return E_MJPEG_RET_FAIL;
1608 }
1609
1610 if (__bIsFirstFrameRdy[u8DrvId] == FALSE)
1611 {
1612 u32NextFrameBuffIdx[u8DrvId] = 0;
1613 }
1614 __bIsDecodeDone[u8DrvId] = FALSE;
1615 MDrv_MJPEG_SetPushQPara(u32Id, pInfo->u32TimeStamp, pInfo->u32ID_L, pInfo->u32ID_H, u32NextFrameBuffIdx[u8DrvId]);
1616 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_PUSH_QUEUE_PARA_SETTING, (MS_VIRT)NULL);
1617
1618 jpegInitParam.u32MWCBufAddr = __u32MWCBufAddr[u8DrvId] + MDrv_MJPEG_GetFrameBuffUnitSize(u8DrvId)*u32NextFrameBuffIdx[u8DrvId];
1619 MJPEG_DEBUG_API_MSG(" Set Frame buffer addr 0x%tx\n", (ptrdiff_t)jpegInitParam.u32MWCBufAddr);
1620 jpegInitParam.u32MWCBufSize = MDrv_MJPEG_GetFrameBuffUnitSize(u8DrvId);
1621 jpegInitParam.u32InternalBufAddr = __u32InternalBufAddr[u8DrvId];
1622 jpegInitParam.u32InternalBufSize = __u32InternalBufSize[u8DrvId];
1623
1624 #if SUPPORT_ASF_MJPEG_MODE
1625 if(__bAsfMjpegMode[u8DrvId]==TRUE)
1626 {
1627 jpegInitParam.u32DecByteRead = jpegInitParam.u32MRCBufSize;
1628 }
1629 else
1630 {
1631 jpegInitParam.u32DecByteRead = pInfo->u32Size;
1632 }
1633 #else
1634 jpegInitParam.u32DecByteRead = pInfo->u32Size;
1635 #endif
1636 jpegInitParam.bEOF = TRUE; // Set to TRUE to disable read function
1637 jpegInitParam.u8DecodeType = E_JPEG_TYPE_MAIN; // only set to E_JPEG_TYPE_MJPEG when 1st time
1638 jpegInitParam.bInitMem = TRUE;
1639 jpegInitParam.pFillHdrFunc = NULL;
1640
1641 #if ENABLE_AVSYNC_ID_CHECK
1642 MJPEG_DEBUG ("ID 0x%08lx%08lx PTS %d\n", pInfo->u32ID_H, pInfo->u32ID_L, pInfo->u32TimeStamp);
1643 #endif
1644
1645 // Make sure it's exited correctly
1646 _MApi_JPEG_Exit();
1647
1648
1649 u32EndAddr[u8DrvId] = pInfo->u32StAddr + pInfo->u32Size - 1;
1650 MJPEG_DEBUG("[MWC]: PA=0x%tx, size=0x%tx, VA=0x%tx\n", (ptrdiff_t)jpegInitParam.u32MWCBufAddr, (ptrdiff_t)jpegInitParam.u32MWCBufSize, (ptrdiff_t)MS_PA2KSEG1(jpegInitParam.u32MWCBufAddr));
1651 MJPEG_DEBUG("[MRC]: PA=0x%tx, size=0x%tx, VA=0x%tx\n", (ptrdiff_t)jpegInitParam.u32MRCBufAddr, (ptrdiff_t)jpegInitParam.u32MRCBufSize, (ptrdiff_t)MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr));
1652 MJPEG_DEBUG("[INTER]: PA=0x%tx, size=0x%tx, VA=0x%tx\n", (ptrdiff_t)jpegInitParam.u32InternalBufAddr, (ptrdiff_t)jpegInitParam.u32InternalBufSize, (ptrdiff_t)MS_PA2KSEG1(jpegInitParam.u32InternalBufAddr));
1653 #if 0
1654 printf("bitstream addr[PA]: 0x%llx, size=0x%x\n", jpegInitParam.u32MRCBufAddr, pInfo->u32Size);
1655 MS_U32 u32VA = MS_PA2KSEG1(jpegInitParam.u32MRCBufAddr);
1656 MS_U16 u8i;
1657 for(u8i=0; u8i<0x100; u8i++)
1658 {
1659 printf("%02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x \n",
1660 *((MS_U8*)(u32VA+u8i*16)), *((MS_U8*)(u32VA+u8i*16+1)), *((MS_U8*)(u32VA+u8i*16+2)), *((MS_U8*)(u32VA+u8i*16+3)),
1661 *((MS_U8*)(u32VA+u8i*16+4)), *((MS_U8*)(u32VA+u8i*16+5)), *((MS_U8*)(u32VA+u8i*16+6)), *((MS_U8*)(u32VA+u8i*16+7)),
1662 *((MS_U8*)(u32VA+u8i*16+8)), *((MS_U8*)(u32VA+u8i*16+9)), *((MS_U8*)(u32VA+u8i*16+10)), *((MS_U8*)(u32VA+u8i*16+11)),
1663 *((MS_U8*)(u32VA+u8i*16+12)), *((MS_U8*)(u32VA+u8i*16+13)), *((MS_U8*)(u32VA+u8i*16+14)), *((MS_U8*)(u32VA+u8i*16+15))
1664 );
1665 }
1666 #endif
1667
1668 if (_MApi_JPEG_Init(&jpegInitParam) == E_JPEG_FAILED)
1669 {
1670 MJPEG_DEBUG_API_ERR("_MApi_JPEG_Init() FAIL\n");
1671 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID, u32NextFrameBuffIdx[u8DrvId]);
1672 MJPEG_DEBUG_API_MSG("Set frame buffer index %td as Valid", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
1673 __bIsDecodeDone[u8DrvId] = TRUE;
1674 __u32DropFrameCnt[u8DrvId]++;
1675 _u32ErrCnt[u8DrvId]++;
1676 u16NullCnt[u8DrvId]=0;
1677 _MApi_JPEG_Rst();
1678 _MApi_JPEG_Exit();
1679 return E_MJPEG_RET_FAIL;
1680 }
1681
1682 // Get width, height, & pitch of 1st frame
1683 if (__bIsFirstFrameRdy[u8DrvId] == FALSE)
1684 {
1685 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_WIDTH, _MApi_JPEG_GetWidth());
1686 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_HEIGHT, _MApi_JPEG_GetHeight());
1687 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_PITCH, _MApi_JPEG_GetAlignedPitch());
1688 MJPEG_DEBUG_API_MSG(" width %d, height %d, pitch %d\n", MDrv_MJPEG_GetWidth(u8DrvId),
1689 MDrv_MJPEG_GetHeight(u8DrvId), MDrv_MJPEG_GetPitch(u8DrvId));
1690
1691 if(MApi_JPEG_IsNJPD()==TRUE)
1692 {
1693 if(((MDrv_MJPEG_GetWidth(u8DrvId) > MJPEG_MAX_SUPPORT_WIDTH) ||
1694 (MDrv_MJPEG_GetHeight(u8DrvId)>MJPEG_MAX_SUPPORT_HEIGHT))
1695 && (eMaxSupport[u8DrvId] == E_MJPEG_MAX_SUPPORTED_FHD))
1696 {
1697 MJPEG_DEBUG_API_ERR("Set MJPEG error code=E_MJPEG_ERR_CODE_RES > FHD\n");
1698 _MApi_MJPEG_SetErrCode(u32Id, E_MJPEG_ERR_CODE_RES);
1699 }
1700 else if(((MDrv_MJPEG_GetWidth(u8DrvId) > MJPEG_HD_1280x720_WIDTH) ||
1701 (MDrv_MJPEG_GetHeight(u8DrvId)>MJPEG_HD_1280x720_HEIGHT))
1702 && (eMaxSupport[u8DrvId] == E_MJPEG_MAX_SUPPORTED_720P))
1703 {
1704 MJPEG_DEBUG_API_ERR("Set MJPEG error code=E_MJPEG_ERR_CODE_RES > 720P\n");
1705 _MApi_MJPEG_SetErrCode(u32Id, E_MJPEG_ERR_CODE_RES);
1706 }
1707 else if(((MDrv_MJPEG_GetWidth(u8DrvId) > MJPEG_SD_WIDTH) ||
1708 (MDrv_MJPEG_GetHeight(u8DrvId)>MJPEG_SD_HEIGHT))
1709 && (eMaxSupport[u8DrvId] == E_MJPEG_MAX_SUPPORTED_480P))
1710 {
1711 MJPEG_DEBUG_API_ERR("Set MJPEG error code=E_MJPEG_ERR_CODE_RES > 480P\n");
1712 _MApi_MJPEG_SetErrCode(u32Id, E_MJPEG_ERR_CODE_RES);
1713 }
1714 }
1715 else
1716 {
1717 if(((MDrv_MJPEG_GetWidth(u8DrvId) > MJPEG_SD_WIDTH) ||
1718 (MDrv_MJPEG_GetHeight(u8DrvId)>MJPEG_SD_HEIGHT))
1719 && (eMaxSupport[u8DrvId] == E_MJPEG_MAX_SUPPORTED_480P))
1720 {
1721 MJPEG_DEBUG_API_ERR("Set MJPEG error code=E_MJPEG_ERR_CODE_RES > 480P\n");
1722 _MApi_MJPEG_SetErrCode(u32Id, E_MJPEG_ERR_CODE_RES);
1723 }
1724
1725 }
1726 }
1727
1728 // Fill decode frame info
1729 infoDecFrame[u8DrvId].u32LumaAddr = jpegInitParam.u32MWCBufAddr;
1730 infoDecFrame[u8DrvId].u32ChromaAddr = infoDecFrame[u8DrvId].u32LumaAddr;
1731 infoDecFrame[u8DrvId].u32TimeStamp = pInfo->u32TimeStamp;
1732 infoDecFrame[u8DrvId].u32ID_L = pInfo->u32ID_L;
1733 infoDecFrame[u8DrvId].u32ID_H = pInfo->u32ID_H;
1734 infoDecFrame[u8DrvId].u16Pitch = MDrv_MJPEG_GetPitch(u8DrvId);
1735 infoDecFrame[u8DrvId].u16Width = MDrv_MJPEG_GetWidth(u8DrvId);
1736 infoDecFrame[u8DrvId].u16Height = MDrv_MJPEG_GetHeight(u8DrvId);
1737 isDecFrameInfoValid[u8DrvId] = TRUE;
1738
1739 // Decode header
1740 if (_MApi_JPEG_DecodeHdr() == E_JPEG_FAILED)
1741 {
1742 MJPEG_DEBUG_API_ERR("_MApi_JPEG_DecodeHdr() FAIL\n");
1743 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID, u32NextFrameBuffIdx[u8DrvId]);
1744 MJPEG_DEBUG_API_MSG("Set frame buffer index %td as Valid", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
1745 __bIsDecodeDone[u8DrvId] = TRUE;
1746 __u32DropFrameCnt[u8DrvId]++;
1747 _u32ErrCnt[u8DrvId]++;
1748 u16NullCnt[u8DrvId]=0;
1749
1750 JPEG_ErrCode jpeg_errcode = _MApi_JPEG_GetErrorCode();
1751 if((E_JPEG_UNSUPPORTED_COLORSPACE == jpeg_errcode)
1752 || (E_JPEG_UNSUPPORTED_SAMP_FACTORS == jpeg_errcode)
1753 || (E_JPEG_UNSUPPORTED_HUFF_DECODE == jpeg_errcode))
1754 {
1755 MJPEG_DEBUG_API_ERR("Set MJPEG error code=E_MJPEG_ERR_CODE_RES for unsupport!!\n");
1756 _MApi_MJPEG_SetErrCode(u32Id, E_MJPEG_ERR_CODE_RES);
1757 }
1758 _MApi_JPEG_Rst();
1759 _MApi_JPEG_Exit();
1760
1761 return E_MJPEG_RET_DECODE_HDR_ERROR;
1762 }
1763
1764 bStepDec[u8DrvId] = TRUE;
1765
1766 // Decode
1767 if (_MApi_JPEG_Decode() == E_JPEG_FAILED)
1768 {
1769 MJPEG_DEBUG_API_ERR("_MApi_JPEG_Decode() FAIL\n");
1770 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_FRAME_BUFF_IDX_VALID, u32NextFrameBuffIdx[u8DrvId]);
1771 MJPEG_DEBUG_API_MSG("Set frame buffer index %td as Valid", (ptrdiff_t)u32NextFrameBuffIdx[u8DrvId]);
1772 __bIsDecodeDone[u8DrvId] = TRUE;
1773 __u32DropFrameCnt[u8DrvId]++;
1774 u16NullCnt[u8DrvId]=0;
1775 return E_MJPEG_RET_DECODE_ERROR;
1776 }
1777
1778 if(_MApi_NJPD_JPDCount()==2)
1779 {
1780 bNJPDNum = !bNJPDNum ;
1781 MJPEG_DEBUG("bNJPDNum=%d\n", bNJPDNum);
1782 }
1783
1784 if(MApi_JPEG_IsNJPD()==TRUE)
1785 {
1786 _MApi_JPEG_SetNJPDInstance(bNJPDNum);
1787 }
1788
1789 #if SUPPORT_SKIP_ERROR_FRAME
1790 _u32StartDecodeTime[bNJPDNum] = MsOS_GetSystemTime();
1791 #endif
1792
1793
1794 // Moved Up
1795 //u32EndAddr = pInfo->u32StAddr + pInfo->u32Size - 1;
1796 __bIsFirstFrameRdy[u8DrvId] = TRUE;
1797
1798 // All done, wait for decoding finish
1799 if(u16NullCnt[u8DrvId] ==u16DecodeCnt)
1800 {
1801 if(u16NullCnt[u8DrvId]!=0)
1802 {
1803 MJPEG_DEBUG_API_MSG("%s: Handle MJPEG NULL PACKET with u16DecodeCnt=%d\n", __FUNCTION__, u16DecodeCnt);
1804 }
1805 u16NullCnt[u8DrvId]=0;
1806 MJPEG_DEBUG_API_MSG("Wait for Fill decode frame info u32LumaAddr=0x%tx, u32ChromaAddr=0x%tx\n",
1807 (ptrdiff_t)infoDecFrame[u8DrvId].u32LumaAddr, (ptrdiff_t)infoDecFrame[u8DrvId].u32ChromaAddr);
1808 return E_MJPEG_RET_SUCCESS;
1809 }
1810 else
1811 {
1812 MJPEG_DEBUG_API_MSG("%s: Duplicate PACKET with u16DecodeCnt=%d\n", __FUNCTION__, u16DecodeCnt);
1813 }
1814 }
1815
1816 // Only for compile ok, the code should not run to this place.
1817 MJPEG_DEBUG_API_MSG("%s: Handle MJPEG NULL PACKET with u16DecodeCnt=%d\n", __FUNCTION__, u16DecodeCnt);
1818 u16NullCnt[u8DrvId]=0;
1819 return E_MJPEG_RET_SUCCESS;
1820 }
1821
1822 /******************************************************************************/
1823 ///Description
1824 ///@param in \b IN in parameter
1825 ///@param out \b OUT out parameter
1826 ///@return status
1827 /******************************************************************************/
MApi_MJPEG_GetQueueVacancy(MS_U32 u32Id)1828 MS_U32 MApi_MJPEG_GetQueueVacancy(MS_U32 u32Id)
1829 {
1830 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1831 #if ENABLE_AVSYNC_ID_CHECK
1832 MJPEG_FrameInfo info;
1833 MApi_MJPEG_GetDispFrameInfo(u32Id, &info);
1834 #endif
1835
1836
1837 if (__bIsFirstFrameRdy[u8DrvId] == FALSE)
1838 {
1839 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_GetQueueVacancy : 1\n");
1840 return 1;
1841 }
1842 else
1843 {
1844 if (__MApi_MJPEG_CheckDecodeDone(u32Id) != E_MJPEG_RET_DECODING)
1845 {
1846 if (MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_IS_DISPLAY_QUEUE_FULL, 0xFFFFFFFFUL) == 1)
1847 {
1848 MJPEG_DEBUG_API_MSG("[MJPEG] Display queue is full\n");
1849 MJPEG_DEBUG_API_MSG("[MJPEG] MApi_MJPEG_GetQueueVacancy : 0\n");
1850 return 0;
1851 }
1852
1853 if(MDrv_MJPEG_GetNextFrameBufferIdx(u32Id)>=0xff)
1854 {
1855 MJPEG_DEBUG_API_MSG("[MJPEG] MApi_MJPEG_GetQueueVacancy : 0\n");
1856 return 0;
1857 }
1858 else
1859 {
1860 MJPEG_DEBUG_API_MSG("[MJPEG] MApi_MJPEG_GetQueueVacancy : 1\n");
1861 return 1;
1862 }
1863 }
1864 }
1865
1866 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_GetQueueVacancy : 0\n");
1867 return 0;
1868 }
1869
1870 /******************************************************************************/
1871 ///Description
1872 ///@param in \b IN in parameter
1873 ///@param out \b OUT out parameter
1874 ///@return status
1875 /******************************************************************************/
MApi_MJPEG_FlushQueue(MS_U32 u32Id)1876 MJPEG_Result MApi_MJPEG_FlushQueue(MS_U32 u32Id)
1877 {
1878 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1879 MS_U32 u32Ret;
1880 // Wait current frame decode done
1881 while (E_MJPEG_RET_DECODING == __MApi_MJPEG_CheckDecodeDone(u32Id))
1882 ;
1883
1884 // Stop firmware display to avoid display queue status overwritten
1885 MApi_MJPEG_Pause(u32Id);
1886
1887 isDecFrameInfoValid[u8DrvId] = FALSE;
1888 bStepDec[u8DrvId] = FALSE;
1889
1890 MJPEG_DEBUG("MApi_MJPEG_FlushQueue()!!!!!!!!!\n");
1891 __u32WritePtr[u8DrvId] = 0;
1892 __u32ReadPtr[u8DrvId] = 0;
1893 u32EndAddr[u8DrvId] = 0;
1894
1895 MDrv_MJPEG_InitFlush(u32Id);
1896 u32Ret = MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_FLUSH_DISP_QUEUE, 0xFFFFFFFFUL);
1897 if (u32Ret == 0)
1898 {
1899 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_FlushQueue : E_MJPEG_RET_FAIL\n");
1900 return E_MJPEG_RET_FAIL;
1901 }
1902 else if(u32Ret == 2)
1903 {
1904 MJPEG_DEBUG_API_MSG("MApi_MJPEG_FlushQueue return SUCCESS\n");
1905 return E_MJPEG_RET_SUCCESS;
1906 }
1907
1908 while(MDrv_MJPEG_IsFlushDone(u32Id)==0);
1909 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_FlushQueue : E_MJPEG_RET_SUCCESS\n");
1910 return E_MJPEG_RET_SUCCESS;
1911 }
1912
1913 /******************************************************************************/
1914 ///Description
1915 ///@param in \b IN in parameter
1916 ///@param out \b OUT out parameter
1917 ///@return status
1918 /******************************************************************************/
MApi_MJPEG_GetESWritePtr(MS_U32 u32Id)1919 MS_PHY MApi_MJPEG_GetESWritePtr(MS_U32 u32Id)
1920 {
1921 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1922 // return end of data
1923 return __u32WritePtr[u8DrvId];
1924 }
1925
1926 /******************************************************************************/
1927 ///Description
1928 ///@param in \b IN in parameter
1929 ///@param out \b OUT out parameter
1930 ///@return status
1931 /******************************************************************************/
MApi_MJPEG_GetESReadPtr(MS_U32 u32Id)1932 MS_PHY MApi_MJPEG_GetESReadPtr(MS_U32 u32Id)
1933 {
1934 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1935 // return end of data
1936 return __u32ReadPtr[u8DrvId];
1937 }
1938
1939 /******************************************************************************/
1940 ///Description
1941 ///@param in \b IN in parameter
1942 ///@param out \b OUT out parameter
1943 ///@return status
1944 /******************************************************************************/
MApi_MJPEG_EnableLastFrameShow(MS_U32 u32Id,MS_BOOL bEnable)1945 MJPEG_Result MApi_MJPEG_EnableLastFrameShow(MS_U32 u32Id, MS_BOOL bEnable)
1946 {
1947 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1948 bLstFrame[u8DrvId] = bEnable;
1949 // This function always returns TRUE.
1950 // Because MJPEG firmware does not reserve any frame.
1951 return E_MJPEG_RET_SUCCESS;
1952 }
1953
1954 /******************************************************************************/
1955 ///Description
1956 ///@param in \b IN in parameter
1957 ///@param out \b OUT out parameter
1958 ///@return status
1959 /******************************************************************************/
MApi_MJPEG_IsDispFinish(MS_U32 u32Id)1960 MS_BOOL MApi_MJPEG_IsDispFinish(MS_U32 u32Id)
1961 {
1962 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
1963 // Check if the last frame decode finish,
1964 // Call this function to set E_MJPEG_CMD_SET_FRAME_BUFF_IDX_READY
1965 // when decode done.
1966 // MJPEG_Result ret;
1967 if (bLstFrame[u8DrvId] == 0)
1968 {
1969 return FALSE;
1970 }
1971 // ret = __MApi_MJPEG_CheckDecodeDone(u32Id);
1972
1973 if (__bIsFirstFrameRdy[u8DrvId] ==0 && bLstFrame[u8DrvId] ==1)
1974 {
1975 MJPEG_DEBUG("MApi_MJPEG_IsDispFinish()...no input frame!!!\n");
1976 return TRUE;
1977 }
1978
1979
1980 if(E_MJPEG_RET_SUCCESS != __MApi_MJPEG_CheckDecodeDone(u32Id))
1981 {
1982 MJPEG_DEBUG_API_MSG("MApi_MJPEG_IsDispFinish: MApi_MJPEG_CheckDecodeDone Fail!!\n");
1983 return FALSE;
1984 }
1985
1986 if (MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_IS_DISP_FINISH, 0xFFFFFFFFUL) == 0)
1987 {
1988 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_IsDispFinish : FALSE\n");
1989 return FALSE;
1990 }
1991
1992 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_IsDispFinish : TRUE\n");
1993 return TRUE;
1994 }
1995
1996 /******************************************************************************/
1997 ///Description
1998 ///@param in \b IN in parameter
1999 ///@param out \b OUT out parameter
2000 ///@return status
2001 /******************************************************************************/
MApi_MJPEG_SetSpeed(MS_U32 u32Id,MJPEG_SpeedType eSpeedType,MJPEG_DispSpeed eDispSpeed)2002 MJPEG_Result MApi_MJPEG_SetSpeed(MS_U32 u32Id, MJPEG_SpeedType eSpeedType, MJPEG_DispSpeed eDispSpeed)
2003 {
2004 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2005 eCurSpeedType[u8DrvId] = eSpeedType;
2006 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_SPEED_TYPE, (MS_U32)eSpeedType);
2007
2008 eCurDispSpeed[u8DrvId] = eDispSpeed;
2009 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_SPEED, (MS_U32)eDispSpeed);
2010
2011 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_STC_BASE, 0xFFFFFFFFUL);
2012
2013 return E_MJPEG_RET_SUCCESS;
2014 }
2015
2016 /******************************************************************************/
2017 ///Description
2018 ///@param in \b IN in parameter
2019 ///@param out \b OUT out parameter
2020 ///@return status
2021 /******************************************************************************/
MApi_MJPEG_SetFreezeDisp(MS_U32 u32Id,MS_BOOL bEnable)2022 MJPEG_Result MApi_MJPEG_SetFreezeDisp(MS_U32 u32Id, MS_BOOL bEnable)
2023 {
2024 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_FREEZE_DISP, (MS_U32)bEnable);
2025
2026 return E_MJPEG_RET_SUCCESS;
2027 }
2028
2029 /******************************************************************************/
2030 ///Description
2031 ///@param in \b IN in parameter
2032 ///@param out \b OUT out parameter
2033 ///@return status
2034 /******************************************************************************/
MApi_MJPEG_SetBlueScreen(MS_U32 u32Id,MS_BOOL bOn)2035 MJPEG_Result MApi_MJPEG_SetBlueScreen(MS_U32 u32Id, MS_BOOL bOn)
2036 {
2037 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_BLUE_SCREEN, (MS_U32)bOn);
2038
2039 return E_MJPEG_RET_SUCCESS;
2040 }
2041
2042 /******************************************************************************/
2043 ///Reset PTS value
2044 ///@param u32Value \b IN new PTS value
2045 /******************************************************************************/
MApi_MJPEG_ResetPTS(MS_U32 u32Id,MS_U32 u32PtsBase)2046 MJPEG_Result MApi_MJPEG_ResetPTS(MS_U32 u32Id, MS_U32 u32PtsBase)
2047 {
2048 if (MDrv_MJPEG_ResetPTS(u32Id, u32PtsBase))
2049 return E_MJPEG_RET_SUCCESS;
2050
2051 return E_MJPEG_RET_FAIL;
2052 }
2053
2054 /******************************************************************************/
2055 ///Return PTS of current displayed frame
2056 ///@return PTS
2057 /******************************************************************************/
MApi_MJPEG_GetPTS(MS_U32 u32Id)2058 MS_U32 MApi_MJPEG_GetPTS(MS_U32 u32Id)
2059 {
2060 return MDrv_MJPEG_GetPTS(u32Id);
2061 }
2062
2063 /******************************************************************************/
2064 ///Description
2065 ///@param in \b IN in parameter
2066 ///@param out \b OUT out parameter
2067 ///@return status
2068 /******************************************************************************/
MApi_MJPEG_AVSyncOn(MS_U32 u32Id,MS_BOOL bOn,MS_U32 u32SyncDelay,MS_U16 u16SyncTolerance)2069 MJPEG_Result MApi_MJPEG_AVSyncOn(MS_U32 u32Id, MS_BOOL bOn, MS_U32 u32SyncDelay, MS_U16 u16SyncTolerance)
2070 {
2071 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_ENABLE_AVSYNC, (MS_U32)bOn);
2072 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_AVSYNC_DELAY, (MS_U32)u32SyncDelay);
2073 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_AVSYNC_TOLERENCE, (MS_U32)u16SyncTolerance);
2074
2075 return E_MJPEG_RET_SUCCESS;
2076 }
2077
2078 /******************************************************************************/
2079 ///Description
2080 ///@param in \b IN in parameter
2081 ///@param out \b OUT out parameter
2082 ///@return status
2083 /******************************************************************************/
MApi_MJPEG_IsAVSyncOn(MS_U32 u32Id)2084 MS_BOOL MApi_MJPEG_IsAVSyncOn(MS_U32 u32Id)
2085 {
2086 return MDrv_MJPEG_IsAVSyncOn(u32Id);
2087 }
2088
2089 /******************************************************************************/
2090 ///Description
2091 ///@param in \b IN in parameter
2092 ///@param out \b OUT out parameter
2093 ///@return status
2094 /******************************************************************************/
MApi_MJPEG_IsReachSync(MS_U32 u32Id)2095 MS_BOOL MApi_MJPEG_IsReachSync(MS_U32 u32Id)
2096 {
2097 return MDrv_MJPEG_IsReachAVSync(u32Id);
2098 }
2099
2100 /******************************************************************************/
2101 ///Description
2102 ///@param in \b IN in parameter
2103 ///@param out \b OUT out parameter
2104 ///@return status
2105 /******************************************************************************/
MApi_MJPEG_GetStatus(MS_U32 u32Id,MJPEG_Status * pStatus)2106 MS_BOOL MApi_MJPEG_GetStatus(MS_U32 u32Id, MJPEG_Status *pStatus)
2107 {
2108 pStatus->bIdle = MApi_MJPEG_IsIdle(u32Id);
2109 //pStatus->bInit
2110 //pStatus->eStage = E_MJPEG_STAGE_PLAY;
2111
2112 return FALSE;
2113 }
2114
2115 /******************************************************************************/
2116 ///Return JPD error code
2117 ///@return JPD error code
2118 /******************************************************************************/
MApi_MJPEG_GetErrCode(MS_U32 u32Id)2119 MS_U32 MApi_MJPEG_GetErrCode(MS_U32 u32Id)
2120 {
2121 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2122 // Per XDemux's request, this only returns critical error.
2123 // Since no error would prevent JPD from decoding next JPEG,
2124 // it always return 0 here.
2125 MJPEG_DEBUG_API_MSG("MApi_MJPEG_GetErrCode() with eMJPEGErrCode=0x%x\n", eMJPEGErrCode[u8DrvId]);
2126 return eMJPEGErrCode[u8DrvId];
2127 }
2128
2129 /******************************************************************************/
2130 ///Description
2131 ///@param in \b IN in parameter
2132 ///@param out \b OUT out parameter
2133 ///@return status
2134 /******************************************************************************/
MApi_MJPEG_GetErrCnt(MS_U32 u32Id)2135 MS_U32 MApi_MJPEG_GetErrCnt(MS_U32 u32Id)
2136 {
2137 #if SUPPORT_SKIP_ERROR_FRAME
2138 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2139 MJPEG_DEBUG_API_MSG("[MJPEG] _u32ErrCnt[u8DrvId]=%td\n", (ptrdiff_t)_u32ErrCnt[u8DrvId]);
2140
2141 return _u32ErrCnt[u8DrvId];
2142 #else
2143 return 0;
2144 #endif
2145 }
2146
2147 /******************************************************************************/
2148 ///Description
2149 ///@param in \b IN in parameter
2150 ///@param out \b OUT out parameter
2151 ///@return status
2152 /******************************************************************************/
MApi_MJPEG_GetSkipCnt(MS_U32 u32Id)2153 MS_U32 MApi_MJPEG_GetSkipCnt(MS_U32 u32Id)
2154 {
2155 #if SUPPORT_SKIP_ERROR_FRAME
2156 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2157 return _u32SkipCnt[u8DrvId];
2158 #else
2159 return 0;
2160 #endif
2161 }
2162 /******************************************************************************/
2163 ///Return count of current displayed frame
2164 ///@return frame count
2165 /******************************************************************************/
MApi_MJPEG_GetFrameCnt(MS_U32 u32Id)2166 MS_U32 MApi_MJPEG_GetFrameCnt(MS_U32 u32Id)
2167 {
2168 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2169 return MDrv_MJPEG_GetFrameCnt(u8DrvId);
2170 }
2171
2172 /******************************************************************************/
2173 ///Return video information
2174 ///@param pInfo \b OUT video information: width & height
2175 /******************************************************************************/
MApi_MJPEG_GetDispInfo(MS_U32 u32Id,MJPEG_DISP_INFO * pInfo)2176 MJPEG_Result MApi_MJPEG_GetDispInfo(MS_U32 u32Id, MJPEG_DISP_INFO *pInfo)
2177 {
2178 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2179 // APP wants pitch to setup display
2180 // This should be used with crop information
2181
2182 MJPEG_DEBUG_API_MSG("MApi_MJPEG_GetDispInfo() with u16Pitch=%d, u16Height=%d, u16Width=%d\n",
2183 MDrv_MJPEG_GetPitch(u8DrvId), MDrv_MJPEG_GetHeight(u8DrvId), MDrv_MJPEG_GetWidth(u8DrvId));
2184 pInfo->u16Width = MDrv_MJPEG_GetPitch(u8DrvId);
2185 pInfo->u16Height = MDrv_MJPEG_GetHeight(u8DrvId);
2186 pInfo->u16Pitch = MDrv_MJPEG_GetPitch(u8DrvId);
2187 if(MDrv_MJPEG_GetFrameRateBase(u8DrvId) !=0)
2188 {
2189 pInfo->u32FrameRate = MDrv_MJPEG_GetFrameRate(u8DrvId) * 1000 / MDrv_MJPEG_GetFrameRateBase(u8DrvId);
2190 }
2191 else
2192 {
2193 MJPEG_DEBUG_API_ERR("Error!!! u32FrameRateBase==0!!!!!\n");
2194 }
2195
2196 pInfo->u16CropLeft = 0;
2197 if(pInfo->u16Width >= MDrv_MJPEG_GetWidth(u8DrvId))
2198 {
2199 pInfo->u16CropRight = pInfo->u16Width - MDrv_MJPEG_GetWidth(u8DrvId) - pInfo->u16CropLeft;
2200 }
2201 else
2202 {
2203 // for the case we cannot get correct width/pitch
2204 pInfo->u16CropRight = 0;
2205 }
2206 pInfo->u16CropTop = (pInfo->u16Height - MDrv_MJPEG_GetHeight(u8DrvId))/2;
2207 pInfo->u16CropBottom = pInfo->u16Height - MDrv_MJPEG_GetHeight(u8DrvId) - pInfo->u16CropTop;
2208 MJPEG_DEBUG_API_MSG(" Crop info right %d, left %d, bottom %d, top %d\n",
2209 pInfo->u16CropRight, pInfo->u16CropLeft, pInfo->u16CropBottom, pInfo->u16CropTop);
2210
2211 return E_MJPEG_RET_SUCCESS;
2212 }
2213
2214 /******************************************************************************/
2215 ///Description
2216 ///@param in \b IN in parameter
2217 ///@param out \b OUT out parameter
2218 ///@return status
2219 /******************************************************************************/
MApi_MJPEG_IsPlaying(MS_U32 u32Id)2220 MS_BOOL MApi_MJPEG_IsPlaying(MS_U32 u32Id)
2221 {
2222 return MDrv_MJPEG_IsPlaying(u32Id);
2223 }
2224
2225 /******************************************************************************/
2226 ///Return TRUE if idle, including decode done & error
2227 ///@return idle or not
2228 /******************************************************************************/
MApi_MJPEG_IsIdle(MS_U32 u32Id)2229 MS_BOOL MApi_MJPEG_IsIdle(MS_U32 u32Id)
2230 {
2231 if(MApi_JPEG_IsNJPD()==TRUE)
2232 {
2233 _MApi_JPEG_SetNJPDInstance(bNJPDNum);
2234 }
2235 JPEG_Event u16Value = _MApi_JPEG_GetJPDEventFlag();
2236 if ((E_JPEG_EVENT_DEC_DONE & u16Value)
2237 || (E_JPEG_EVENT_DEC_ERROR_MASK & u16Value))
2238 {
2239 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_IsIdle : TRUE\n");
2240 return TRUE;
2241 }
2242
2243 MJPEG_DEBUG_API_MSG(" MApi_MJPEG_IsIdle : FALSE\n");
2244 return FALSE;
2245 }
2246
2247 /******************************************************************************/
2248 ///Description
2249 ///@param in \b IN in parameter
2250 ///@param out \b OUT out parameter
2251 ///@return status
2252 /******************************************************************************/
MApi_MJPEG_IsIFrameFound(MS_U32 u32Id)2253 MS_BOOL MApi_MJPEG_IsIFrameFound(MS_U32 u32Id)
2254 {
2255 UNUSED(u32Id);
2256 return TRUE;
2257 }
2258
2259 /******************************************************************************/
2260 ///Description
2261 ///@param in \b IN in parameter
2262 ///@param out \b OUT out parameter
2263 ///@return status
2264 /******************************************************************************/
MApi_MJPEG_IsWithLowDelay(MS_U32 u32Id)2265 MS_BOOL MApi_MJPEG_IsWithLowDelay(MS_U32 u32Id)
2266 {
2267 UNUSED(u32Id);
2268 return TRUE;
2269 }
2270
2271 /******************************************************************************/
2272 ///Description
2273 ///@param in \b IN in parameter
2274 ///@param out \b OUT out parameter
2275 ///@return status
2276 /******************************************************************************/
MApi_MJPEG_GetDecFrameInfo(MS_U32 u32Id,MJPEG_FrameInfo * pFrmInfo)2277 MJPEG_Result MApi_MJPEG_GetDecFrameInfo(MS_U32 u32Id, MJPEG_FrameInfo *pFrmInfo)
2278 {
2279 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2280 if(FALSE == isDecFrameInfoValid[u8DrvId])
2281 return E_MJPEG_RET_FAIL;
2282
2283 pFrmInfo->u32LumaAddr = infoDecFrame[u8DrvId].u32LumaAddr;
2284 pFrmInfo->u32ChromaAddr = infoDecFrame[u8DrvId].u32ChromaAddr;
2285 pFrmInfo->u32TimeStamp = infoDecFrame[u8DrvId].u32TimeStamp;
2286 pFrmInfo->u32ID_L = infoDecFrame[u8DrvId].u32ID_L;
2287 pFrmInfo->u32ID_H = infoDecFrame[u8DrvId].u32ID_H;
2288 pFrmInfo->u16Pitch = infoDecFrame[u8DrvId].u16Pitch;
2289 pFrmInfo->u16Width = infoDecFrame[u8DrvId].u16Width;
2290 pFrmInfo->u16Height = infoDecFrame[u8DrvId].u16Height;
2291 pFrmInfo->u8FrmType = (MS_U8)E_MJPEG_FRM_TYPE_I;
2292
2293 return E_MJPEG_RET_SUCCESS;
2294 }
2295
2296 /******************************************************************************/
2297 ///Description
2298 ///@param in \b IN in parameter
2299 ///@param out \b OUT out parameter
2300 ///@return status
2301 /******************************************************************************/
MApi_MJPEG_GetDispFrameInfo(MS_U32 u32Id,MJPEG_FrameInfo * pFrmInfo)2302 MJPEG_Result MApi_MJPEG_GetDispFrameInfo(MS_U32 u32Id, MJPEG_FrameInfo *pFrmInfo)
2303 {
2304 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2305 #if ENABLE_AVSYNC_ID_CHECK
2306 static MS_U32 u32OldID_L = 0, u32OldID_H = 0, u32OldTimeStamp = 0;
2307 #endif
2308 MJPEG_FrameInfo info;
2309 MDrv_MJPEG_GetDispFrameInfo(u32Id, (void *)&info);
2310
2311 pFrmInfo->u32LumaAddr = info.u32LumaAddr;
2312 pFrmInfo->u32ChromaAddr = info.u32ChromaAddr;
2313 pFrmInfo->u32TimeStamp = info.u32TimeStamp;
2314 pFrmInfo->u32ID_L = info.u32ID_L;
2315 pFrmInfo->u32ID_H = info.u32ID_H;
2316 pFrmInfo->u16Pitch = MDrv_MJPEG_GetPitch(u8DrvId);
2317 pFrmInfo->u16Width = MDrv_MJPEG_GetWidth(u8DrvId);
2318 pFrmInfo->u16Height = MDrv_MJPEG_GetHeight(u8DrvId);
2319 pFrmInfo->u8FrmType = (MS_U8)E_MJPEG_FRM_TYPE_I;
2320
2321 #if ENABLE_AVSYNC_ID_CHECK
2322 if (u32OldID_H != pFrmInfo->u32ID_H || u32OldID_L != pFrmInfo->u32ID_L
2323 || u32OldTimeStamp != pFrmInfo->u32TimeStamp)
2324 {
2325 MJPEG_DEBUG ("ID 0x%08lx%08lx PTS %d addr 0x%lx\n",
2326 pFrmInfo->u32ID_H, pFrmInfo->u32ID_L, pFrmInfo->u32TimeStamp, pFrmInfo->u32LumaAddr);
2327 u32OldID_H = pFrmInfo->u32ID_H;
2328 u32OldID_L = pFrmInfo->u32ID_L;
2329 u32OldTimeStamp = pFrmInfo->u32TimeStamp;
2330 }
2331 #endif
2332
2333 return E_MJPEG_RET_SUCCESS;
2334 }
2335
2336 /******************************************************************************/
2337 ///Description
2338 ///@param in \b IN in parameter
2339 ///@param out \b OUT out parameter
2340 ///@return status
2341 /******************************************************************************/
MApi_MJPEG_DbgSetMsgLevel(MJPEG_DbgLevel eDbgLevel)2342 void MApi_MJPEG_DbgSetMsgLevel(MJPEG_DbgLevel eDbgLevel)
2343 {
2344 MS_U8 u8Level;
2345
2346 switch (eDbgLevel)
2347 {
2348 case E_MJPEG_DBG_LEVEL_ERR:
2349 u8Level = E_JPEG_DEBUG_ERR;
2350 _u8MJPEG_ApiDbgLevel = E_JPEG_DEBUG_ERR;
2351 break;
2352 case E_MJPEG_DBG_LEVEL_INFO:
2353 u8Level = E_JPEG_DEBUG_ERR;
2354 _u8MJPEG_ApiDbgLevel = E_JPEG_DEBUG_MJPEG | E_JPEG_DEBUG_ERR;
2355 break;
2356 case E_MJPEG_DBG_LEVEL_DBG:
2357 u8Level = E_JPEG_DEBUG_ALL;
2358 _u8MJPEG_ApiDbgLevel = E_JPEG_DEBUG_MJPEG | E_JPEG_DEBUG_API | E_JPEG_DEBUG_ERR;
2359 break;
2360 case E_MJPEG_DBG_LEVEL_TRACE:
2361 u8Level = E_JPEG_DEBUG_ALL;
2362 _u8MJPEG_ApiDbgLevel = E_JPEG_DEBUG_MJPEG | E_JPEG_DEBUG_API | E_JPEG_DEBUG_ERR;
2363 break;
2364 case E_MJPEG_DBG_LEVEL_FW:
2365 u8Level = E_JPEG_DEBUG_NONE;
2366 _u8MJPEG_ApiDbgLevel = E_JPEG_DEBUG_NONE;
2367 break;
2368 case E_MJPEG_DBG_LEVEL_NONE:
2369 default:
2370 u8Level = E_JPEG_DEBUG_NONE;
2371 _u8MJPEG_ApiDbgLevel = E_JPEG_DEBUG_NONE;
2372 break;
2373 }
2374
2375 _MApi_JPEG_SetDbgLevel(u8Level);
2376 MDrv_MJPEG_SetDbgLevel(u8Level);
2377 }
2378
2379 /******************************************************************************/
2380 ///Description
2381 ///@param in \b IN in parameter
2382 ///@param out \b OUT out parameter
2383 ///@return status
2384 /******************************************************************************/
MApi_MJPEG_DbgSetData(MS_U32 u32Id,MS_PHY u32Addr,MS_U32 u32Data)2385 MJPEG_Result MApi_MJPEG_DbgSetData(MS_U32 u32Id, MS_PHY u32Addr, MS_U32 u32Data)
2386 {
2387 UNUSED(u32Id);
2388 u32Addr = u32Addr;
2389 u32Data = u32Data;
2390 return E_MJPEG_RET_SUCCESS;
2391 }
2392
2393 /******************************************************************************/
2394 ///Description
2395 ///@param in \b IN in parameter
2396 ///@param out \b OUT out parameter
2397 ///@return status
2398 /******************************************************************************/
MApi_MJPEG_DbgGetData(MS_U32 u32Id,MS_PHY u32Addr,MS_U32 * u32Data)2399 MJPEG_Result MApi_MJPEG_DbgGetData(MS_U32 u32Id, MS_PHY u32Addr, MS_U32* u32Data)
2400 {
2401 UNUSED(u32Id);
2402 u32Addr = u32Addr;
2403 *u32Data = 0;
2404
2405 return E_MJPEG_RET_SUCCESS;
2406 }
2407
2408 /******************************************************************************/
2409 ///Description
2410 ///@param in \b IN in parameter
2411 ///@param out \b OUT out parameter
2412 ///@return status
2413 /******************************************************************************/
MApi_MJPEG_DispFrame(MS_U32 u32Id,MS_U32 u32DispIdx)2414 MJPEG_Result MApi_MJPEG_DispFrame(MS_U32 u32Id, MS_U32 u32DispIdx)
2415 {
2416 MJPEG_DEBUG_API_MSG("MApi_MJPEG_DispFrame() with index=%td\n", (ptrdiff_t)u32DispIdx);
2417 MDrv_MJPEG_DispFrame(u32Id, u32DispIdx);
2418 return E_MJPEG_RET_SUCCESS;
2419 }
2420
2421 /******************************************************************************/
2422 ///Description
2423 ///@param in \b IN in parameter
2424 ///@param out \b OUT out parameter
2425 ///@return status
2426 /******************************************************************************/
MApi_MJPEG_FreeFrame(MS_U32 u32Id,MS_U32 u32DispIdx)2427 MJPEG_Result MApi_MJPEG_FreeFrame(MS_U32 u32Id, MS_U32 u32DispIdx)
2428 {
2429 MDrv_MJPEG_FreeFrame(u32Id, u32DispIdx);
2430 return E_MJPEG_RET_SUCCESS;
2431 }
2432
2433 /******************************************************************************/
2434 ///Description
2435 ///@param in \b IN in parameter
2436 ///@param out \b OUT out parameter
2437 ///@return status
2438 /******************************************************************************/
MApi_MJPEG_GetNextDispFrame(MS_U32 u32Id,MJPEG_FrameInfo * pFrmInfo)2439 MJPEG_Result MApi_MJPEG_GetNextDispFrame(MS_U32 u32Id, MJPEG_FrameInfo *pFrmInfo)
2440 {
2441 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2442 // Need to call __MApi_MJPEG_CheckDecodeDone to update decode status
2443 // When decode done, change the display queue status to E_HVD_DISPQ_STATUS_INIT,
2444 // thus we can get the updated next display frame.
2445 __MApi_MJPEG_CheckDecodeDone(u32Id);
2446 MJPEG_FrameInfo *pSrc = (MJPEG_FrameInfo*)MDrv_MJPEG_GetNextDispFrame(u32Id);
2447 if (pSrc != NULL)
2448 {
2449 _MJPEG_Memcpy(pFrmInfo, pSrc, sizeof(MJPEG_FrameInfo));
2450 pFrmInfo->u16Pitch = MDrv_MJPEG_GetPitch(u8DrvId);
2451 pFrmInfo->u16Width = MDrv_MJPEG_GetPitch(u8DrvId);
2452 pFrmInfo->u16Height = MDrv_MJPEG_GetHeight(u8DrvId);
2453 pFrmInfo->u8FrmType = (MS_U8)E_MJPEG_FRM_TYPE_I;
2454
2455 return E_MJPEG_RET_SUCCESS;
2456 }
2457 return E_MJPEG_RET_FAIL;
2458 }
2459
2460 /******************************************************************************/
2461 ///Description
2462 ///@param in \b IN in parameter
2463 ///@param out \b OUT out parameter
2464 ///@return status
2465 /******************************************************************************/
MApi_MJPEG_GetDispFrmNum(MS_U32 u32Id)2466 MS_U32 MApi_MJPEG_GetDispFrmNum(MS_U32 u32Id)
2467 {
2468 return MDrv_MJPEG_GetDispFrameNum(u32Id);
2469 }
2470
2471 /******************************************************************************/
2472 ///Description
2473 ///@param in \b IN in parameter
2474 ///@param out \b OUT out parameter
2475 ///@return status
2476 /******************************************************************************/
MApi_MJPEG_GetNextDispQPtr(MS_U32 u32Id)2477 MS_U32 MApi_MJPEG_GetNextDispQPtr(MS_U32 u32Id)
2478 {
2479 return MDrv_MJPEG_GetNextDispQPtr(u32Id);
2480 }
2481
2482 /******************************************************************************/
2483 ///Description
2484 ///@param in \b IN in parameter
2485 ///@param out \b OUT out parameter
2486 ///@return status
2487 /******************************************************************************/
MApi_MJPEG_EnableDispCmdQ(MS_U32 u32Id,MS_BOOL bEnable)2488 MJPEG_Result MApi_MJPEG_EnableDispCmdQ(MS_U32 u32Id, MS_BOOL bEnable)
2489 {
2490 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2491 bEnableDispCmdQ[u8DrvId] = bEnable;
2492
2493 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_ENABLE_DISP_CMD_QUEUE, bEnable);
2494
2495 return E_MJPEG_RET_SUCCESS;
2496 }
2497
2498 /******************************************************************************/
2499 ///Description
2500 ///@param in \b IN in parameter
2501 ///@param out \b OUT out parameter
2502 ///@return status
2503 /******************************************************************************/
MApi_MJPEG_PushDispCmdQ(MS_U32 u32Id)2504 MJPEG_Result MApi_MJPEG_PushDispCmdQ(MS_U32 u32Id)
2505 {
2506 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2507 if (bEnableDispCmdQ[u8DrvId])
2508 {
2509 }
2510
2511 return E_MJPEG_RET_FAIL;
2512 }
2513
2514 /******************************************************************************/
2515 ///Description
2516 ///@param in \b IN in parameter
2517 ///@param out \b OUT out parameter
2518 ///@return status
2519 /******************************************************************************/
MApi_MJPEG_GetDispCmdQVacancy(MS_U32 u32Id)2520 MS_U32 MApi_MJPEG_GetDispCmdQVacancy( MS_U32 u32Id)
2521 {
2522 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2523 if (bEnableDispCmdQ[u8DrvId])
2524 {
2525 }
2526
2527 return 0;
2528 }
2529
2530 /******************************************************************************/
2531 ///Description
2532 ///@param in \b IN in parameter
2533 ///@param out \b OUT out parameter
2534 ///@return status
2535 /******************************************************************************/
MApi_MJPEG_SeekToPTS(MS_U32 u32Id,MS_U32 u32PTS)2536 MJPEG_Result MApi_MJPEG_SeekToPTS(MS_U32 u32Id, MS_U32 u32PTS)
2537 {
2538 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2539 __bSeekToPts[u8DrvId] = TRUE;
2540 __u32Skip2PtsBase[u8DrvId] = MApi_MJPEG_GetPTS(u32Id);
2541 __u32TargetPts[u8DrvId] = u32PTS;
2542 MJPEG_DEBUG_API_MSG(" Seek from PTS %td to %td\n", (ptrdiff_t)__u32Skip2PtsBase[u8DrvId], (ptrdiff_t)__u32TargetPts[u8DrvId]);
2543
2544 return E_MJPEG_RET_SUCCESS;
2545 }
2546
2547 /******************************************************************************/
2548 ///Description
2549 ///@param in \b IN in parameter
2550 ///@param out \b OUT out parameter
2551 ///@return status
2552 /******************************************************************************/
MApi_MJPEG_SkipToPTS(MS_U32 u32Id,MS_U32 u32PTS)2553 MJPEG_Result MApi_MJPEG_SkipToPTS(MS_U32 u32Id, MS_U32 u32PTS)
2554 {
2555 MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2556 __bSkipToPts[u8DrvId] = TRUE;
2557 __u32Skip2PtsBase[u8DrvId] = MApi_MJPEG_GetPTS(u32Id);
2558 __u32TargetPts[u8DrvId] = u32PTS;
2559 MJPEG_DEBUG_API_MSG(" Skip from PTS %td to %td\n", (ptrdiff_t)__u32Skip2PtsBase[u8DrvId], (ptrdiff_t)__u32TargetPts[u8DrvId]);
2560
2561 return E_MJPEG_RET_SUCCESS;
2562 }
2563
2564 /******************************************************************************/
2565 ///Description : Enable/Disable FW turbo mode
2566 ///@param bEnable \b IN enable or not.
2567 ///@return NONE
2568 /******************************************************************************/
MApi_MJPEG_EnableTurboFWMode(MS_BOOL bEnable)2569 void MApi_MJPEG_EnableTurboFWMode(MS_BOOL bEnable)
2570 {
2571 MDrv_MJPEG_EnableTurboFWMode(bEnable);
2572 }
2573
_MApi_MJPEG_SetDisplayOutSideMode(MS_U32 u32Id,MS_BOOL bOn)2574 static MJPEG_Result _MApi_MJPEG_SetDisplayOutSideMode(MS_U32 u32Id, MS_BOOL bOn)
2575 {
2576 MJPEG_DEBUG_API_MSG("MJPEG _VDEC_EX_DISP_OUTSIDE_MODE!!!!!! with %d\n", bOn);
2577 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_SET_DISPLAY_OUTSIDE_MODE, (MS_U32)bOn);
2578
2579 return E_MJPEG_RET_SUCCESS;
2580 }
2581
MApi_MJPEG_SetControl(MS_U32 u32Id,MJPEG_VDEC_Cmd cmd_id,MS_U32 param)2582 MJPEG_Result MApi_MJPEG_SetControl(MS_U32 u32Id, MJPEG_VDEC_Cmd cmd_id, MS_U32 param)
2583 {
2584 MJPEG_Result eRet = E_MJPEG_RET_INVALID_PARAMETER;
2585 switch(cmd_id)
2586 {
2587 case E_MJPEG_VDEC_CMD_SET_DISPLAY_OUTSIDE_MODE:
2588 eRet = _MApi_MJPEG_SetDisplayOutSideMode(u32Id, (MS_BOOL)param);
2589 break;
2590 default:
2591 break;
2592 }
2593 return eRet;
2594 }
2595
2596 /******************************************************************************/
2597 ///Description : GetFreeStream for Dual Decode
2598 ///@param in \b IN in parameter
2599 ///@param out \b OUT out parameter
2600 ///@return status
2601 /******************************************************************************/
MApi_MJPEG_GetFreeStream(MS_U32 * pu32Id,MJPEG_API_StreamType eStreamType)2602 MJPEG_Result MApi_MJPEG_GetFreeStream(MS_U32 *pu32Id, MJPEG_API_StreamType eStreamType)
2603 {
2604 MJPEG_Result eRet = E_MJPEG_RET_INVALID_PARAMETER;
2605
2606 #ifdef VDEC3
2607 if ((eStreamType >= E_MJPEG_API_N_STREAM) && (eStreamType < E_MJPEG_API_N_STREAM + E_MJPEG_MJPEG_TOTAL))
2608 {
2609 if (E_MJPEG_OK == MDrv_MJPEG_GetFreeStream(pu32Id, E_MJPEG_DRV_N_STREAM + eStreamType-E_MJPEG_API_N_STREAM))
2610 eRet = E_MJPEG_RET_SUCCESS;
2611 else
2612 eRet = E_MJPEG_RET_FAIL;
2613 }
2614 #else
2615 switch(eStreamType)
2616 {
2617 case E_MJPEG_API_MAIN_STREAM:
2618 {
2619 if (E_MJPEG_OK == MDrv_MJPEG_GetFreeStream(pu32Id, E_MJPEG_DRV_MAIN_STREAM))
2620 eRet = E_MJPEG_RET_SUCCESS;
2621 else
2622 eRet = E_MJPEG_RET_FAIL;
2623
2624 break;
2625 }
2626 case E_MJPEG_API_SUB_STREAM:
2627 {
2628 if (E_MJPEG_OK == MDrv_MJPEG_GetFreeStream(pu32Id, E_MJPEG_DRV_SUB_STREAM))
2629 eRet = E_MJPEG_RET_SUCCESS;
2630 else
2631 eRet = E_MJPEG_RET_FAIL;
2632
2633 break;
2634 }
2635 default:
2636 break;
2637 }
2638 #endif
2639
2640
2641
2642 return eRet;
2643 }
2644
MApi_MJPEG_SetDynmcDispPath(MS_U32 u32Id,MS_BOOL bConnect,HVD_EX_DISPLAY_PATH eDispPath)2645 MJPEG_Result MApi_MJPEG_SetDynmcDispPath(MS_U32 u32Id, MS_BOOL bConnect, HVD_EX_DISPLAY_PATH eDispPath)
2646 {
2647 MJPEG_Result eRet = E_MJPEG_RET_INVALID_PARAMETER;
2648 // MS_U8 u8DrvId = MDrv_MJPEG_GetDrvId(u32Id);
2649 MS_U32 u32Arg = 0;
2650 //MS_U32 u32Times = 0;
2651 MDrv_MJPEG_SetConnectStatus(u32Id, E_HVD_EX_DISP_PATH_DYNMC_HANDLING);
2652 u32Arg = (((MS_U32)(eDispPath)) << 1) & (~0x1);
2653 u32Arg |= (bConnect & 0x1);
2654 MDrv_MJPEG_SendVPUCommand(u32Id, E_MJPEG_CMD_DYNAMIC_CONNECT_DISP_PATH, u32Arg);
2655 MS_U32 u32TimeOut = MsOS_GetSystemTime() + 500; // it can not block
2656 while (1)
2657 {
2658 if(bConnect)
2659 {
2660 if (MDrv_MJPEG_GetConnectStatus(u32Id) == E_HVD_EX_DISP_PATH_DYNMC_CONNECTTED)
2661 {
2662 eRet = E_MJPEG_RET_SUCCESS;
2663 break;
2664 }
2665 }
2666 else//disconnect
2667 {
2668 if (MDrv_MJPEG_GetConnectStatus(u32Id) == E_HVD_EX_DISP_PATH_DYNMC_DISCONNECT)
2669 {
2670 eRet = E_MJPEG_RET_SUCCESS;
2671 break;
2672 }
2673 }
2674
2675 if (MsOS_GetSystemTime() > u32TimeOut)
2676 {
2677 eRet = E_MJPEG_RET_FAIL;
2678 MJPEG_DEBUG_API_ERR("Set dynamic display path timeout!\n");
2679 break;
2680 }
2681 }
2682 return eRet;
2683 }
2684
2685 #if defined(MSOS_TYPE_LINUX) && defined(SUPPORT_CMA)
MApi_MJPEG_SetCMAInformation(void * pcmaInitParam)2686 void MApi_MJPEG_SetCMAInformation(void* pcmaInitParam)
2687 {
2688 bCMAUsed = TRUE;
2689 JPEG_memcpy((void*)(&cmaInitParam),pcmaInitParam,sizeof(struct CMA_Pool_Init_Param));
2690 MJPEG_DEBUG("[MJPEG!!] set bCMAUsed=TRUE, cmaInitParam.heap_miu_start_offset=0x%tx, cmaInitParam.heap_length=0x%tx\n", (ptrdiff_t)cmaInitParam.heap_miu_start_offset, (ptrdiff_t)cmaInitParam.heap_length);
2691 }
2692 #endif
2693
2694 #endif
2695