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