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 apiDMX_v2.c
98 /// @brief Demux 1.0 API wrapper for Demux 2.0
99 /// @author MStar Semiconductor,Inc.
100 ////////////////////////////////////////////////////////////////////////////////////////////////////
101 #include "utopia.h"
102 #include "utopia_dapi.h"
103 #include "apiDMX.h"
104 #include "apiDMX_tsio.h"
105 #include "apiDMX_private.h"
106 #include "ULog.h"
107
108 #ifdef MSOS_TYPE_LINUX_KERNEL
109 #include <linux/string.h>
110 #else
111 #include <string.h>
112 #include <sys/types.h>
113 #include <unistd.h>
114 #endif
115
116 #define DMX_V2DBGMSG(x) //x
117
118 #define DMX_TASK_STACK_SIZE 4096UL
119 #define DMX_MAX_PVR_ENG 10UL
120 #define DMX_MAX_SECFLT_NUM 512UL
121 //------------------------------------------------------------------------------
122 // Local Variable
123 //------------------------------------------------------------------------------
124 #ifdef DMX_UTOPIA_20
125 static void* _pInstantDmx = NULL;
126 static void* _pAttributeDmx = NULL;
127 #endif
128
129 //#define DMX_UTOPIA_2K
130 #ifdef DMX_UTOPIA_2K
131
132 typedef struct _DMX_SEC_CB_PARAM
133 {
134 DMX_EVENT Event; ///< DMX section event
135 DMX_NotifyCb pNotify; ///< DMX section callback
136 DMX_Type2NotifyCb pType2Notify; ///< DMX section callback
137 MS_U32 Type2NotifyParam1; ///< DMX section callback
138 DMX_Type2NotifyCb_Ex pType2Notify_Ex; ///< DMX section callback (type2_ex)
139 void* pType2NotifyParamEx;
140 }DMX_SEC_CB_PARAM;
141
142 static MS_U8 _u8DmxTspStack[DMX_TASK_STACK_SIZE];
143 static MS_S32 _s32DmxTspTaskId = -1;
144 static MS_U8 _u8TspThrState = 0;
145 static MS_S32 _Dmx2K_Mutex = -1;
146 static MS_BOOL _bKrenelMod = FALSE;
147 static MS_U32 _u32IntRefCnt = 0;
148
149 static DMX_NotifyCb _PvrEngCb[DMX_MAX_PVR_ENG] = {[0 ... (DMX_MAX_PVR_ENG-1)] = NULL}; //< DMX Pvr callback
150 static DMX_SEC_CB_PARAM _SecCbParam[DMX_MAX_SECFLT_NUM];
151
152 #define DMX2K_MUTEX_TIMEOUT 10000UL
153 #define _DMX2K_LOCK() while(!MsOS_ObtainMutex(_Dmx2K_Mutex, DMX2K_MUTEX_TIMEOUT)) \
154 { \
155 ULOGE("DMX", "[%s][%d] DMX2K mutex get error\n", __FUNCTION__, __LINE__); \
156 MsOS_DelayTask(1); \
157 }
158
159 #define _DMX2K_UNLOCK() do{ \
160 if(!MsOS_ReleaseMutex(_Dmx2K_Mutex)) \
161 { \
162 ULOGE("DMX", "[%s][%d] DMX2K mutex free error\n", __FUNCTION__, __LINE__); \
163 } \
164 }while(0);
165
166 //TSIO
167 #if defined(TSIO_ENABLE)
168 static MS_U8 _u8DmxTsioStack[DMX_TASK_STACK_SIZE];
169 static MS_S32 _s32DmxTsioTaskId = -1;
170 static MS_U8 _u8TsioThrState = 0;
171 static TSIOIntTypeCB _TsioIntCb = NULL;
172 #define TSIO_SERVICE_NUM 64
173 #define TSIO_EVENT_GET(event,type) (event & (0x1 << type))
174 #define TSIO_INT_GET(int,idx) ((int >> idx) & 0x1)
175 #define TSIO_CB(Type, Value, ext1, ext2) do{ \
176 if (_TsioIntCb != NULL) \
177 { \
178 _TsioIntCb(Type, Value, ext1, ext2); \
179 } \
180 }while(0);
181 #endif //TSIO_ENABLE
182
183 #endif //DMX_UTOPIA_2K
184
185 //------------------------------------------------------------------------------
186 // Internal implementation
187 //------------------------------------------------------------------------------
_DMX_PhyAddr_To_U32Param(MS_PHY phyaddr,MS_U32 * pu32param)188 static void _DMX_PhyAddr_To_U32Param(MS_PHY phyaddr, MS_U32* pu32param)
189 {
190 pu32param[0] = (MS_U32)phyaddr;
191 pu32param[1] = ((sizeof(MS_PHY) > sizeof(MS_U32)) ? *(((MS_U32*)&phyaddr) + 1) : 0);
192 }
193
194 #ifdef DMX_UTOPIA_20
_DMX_IOCtrlOpen(void)195 static MS_BOOL _DMX_IOCtrlOpen(void)
196 {
197 if(_pInstantDmx == NULL)
198 {
199 //DMXRegisterToUtopia(NULL);
200
201 #ifdef MSOS_TYPE_LINUX_KERNEL
202 ULOGD("DMX", "[%s]: KERNEL init\n", __FUNCTION__);
203 #else
204 ULOGD("DMX", "[%s]: USER init\n", __FUNCTION__);
205 #endif
206
207 if(UtopiaOpen(MODULE_DMX, &_pInstantDmx, 0, _pAttributeDmx) != UTOPIA_STATUS_SUCCESS)
208 {
209 ULOGE("DMX", "[MAPI DMX][%06d] Open DMX Lib fail\n", __LINE__);
210 return FALSE;
211 }
212
213 #ifdef MSOS_TYPE_LINUX_KERNEL
214 ULOGD("DMX", "[%s] _pInstantDmx %p \n", __FUNCTION__, _pInstantDmx);
215 #endif
216 }
217
218 return TRUE;
219 }
220
221 #if (defined(DMX_UTOPIA_2K) && defined(TSIO_ENABLE))
_DMX_TSIO_Proc_Task(void)222 static void _DMX_TSIO_Proc_Task(void)
223 {
224 DMX_TSIO_IOSIGNAL stTsioIoSig;
225 MS_U32 index = 0;
226
227 while(_pInstantDmx == NULL)
228 {
229 MsOS_DelayTask(1);
230 }
231
232 while((_pInstantDmx != NULL) && (_u8TsioThrState == 0))
233 {
234 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_WaitCbEvt, (void*)&stTsioIoSig) != UTOPIA_STATUS_SUCCESS)
235 {
236 continue;
237 }
238
239 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_SGDMAOUT_LASTNODE))
240 {
241 for (index = 0; index < TSIO_SERVICE_NUM; index ++)
242 {
243 if (TSIO_INT_GET(stTsioIoSig.u64DmaoutInt[0], index))
244 {
245 TSIO_CB(TSIO_INT_TYPE_SGDMAOUT_LASTNODE, index, 0, NULL);
246 }
247 }
248 }
249
250 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_SGDMAOUT_NODEINT))
251 {
252 for (index = 0; index < TSIO_SERVICE_NUM; index ++)
253 {
254 if (TSIO_INT_GET(stTsioIoSig.u64DmaoutInt[1], index))
255 {
256 TSIO_CB(TSIO_INT_TYPE_SGDMAOUT_NODEINT, index, NULL, NULL);
257 }
258 }
259 }
260
261 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_SGDMAOUT_DROP))
262 {
263 for (index = 0; index < TSIO_SERVICE_NUM; index ++)
264 {
265 if (TSIO_INT_GET(stTsioIoSig.u64DmaoutInt[2], index))
266 {
267 TSIO_CB(TSIO_INT_TYPE_SGDMAOUT_DROP, index, NULL, NULL);
268 }
269 }
270 }
271
272 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_SGDMAOUT_DMAEND))
273 {
274 for (index = 0; index < TSIO_SERVICE_NUM; index ++)
275 {
276 if (TSIO_INT_GET(stTsioIoSig.u64DmaoutInt[3], index))
277 {
278 TSIO_CB(TSIO_INT_TYPE_SGDMAOUT_DMAEND, index, 0, NULL);
279 }
280 }
281 }
282
283 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_SGDMAIN_DONE))
284 {
285 for (index = 0; index < TSIO_SERVICE_NUM; index ++)
286 {
287 if (TSIO_INT_GET(stTsioIoSig.u64DmainInt, index))
288 {
289 TSIO_CB(TSIO_INT_TYPE_SGDMAIN_DONE, index, NULL, NULL);
290 }
291 }
292 }
293
294 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_CC_TX_DONE))
295 {
296 TSIO_CB(TSIO_INT_TYPE_CC_TX_DONE, 0, NULL, NULL);
297 }
298
299 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_CC_RX_DONE))
300 {
301 TSIO_CB(TSIO_INT_TYPE_CC_RX_DONE, 0, NULL, NULL);
302 }
303
304 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_LIVE_TSO_OVERFLOW))
305 {
306 TSIO_CB(TSIO_INT_TYPE_LIVE_TSO_OVERFLOW, 0, NULL, NULL);
307 }
308
309 if (TSIO_EVENT_GET(stTsioIoSig.u32Event, TSIO_INT_TYPE_OPERATION_START))
310 {
311 TSIO_CB(TSIO_INT_TYPE_OPERATION_START, 0, NULL, NULL);
312 }
313 }
314 _s32DmxTsioTaskId = -1;
315 _u8TsioThrState = 2;
316 }
317 #endif //end of DMX_UTOPIA_2K && TSIO_ENABLE
318
319 #if defined(DMX_UTOPIA_2K)
_DMX_TSP_Proc_SecCB(MS_U32 u32FltId,DMX_EVENT NotifyEvent)320 static void _DMX_TSP_Proc_SecCB(MS_U32 u32FltId, DMX_EVENT NotifyEvent)
321 {
322 DMX_SEC_CB_PARAM stCbParam;
323
324 _DMX2K_LOCK();
325 stCbParam.Event = _SecCbParam[u32FltId].Event;
326 stCbParam.pNotify = _SecCbParam[u32FltId].pNotify;
327 stCbParam.pType2Notify = _SecCbParam[u32FltId].pType2Notify;
328 stCbParam.Type2NotifyParam1 = _SecCbParam[u32FltId].Type2NotifyParam1;
329 stCbParam.pType2Notify_Ex= _SecCbParam[u32FltId].pType2Notify_Ex;
330 stCbParam.pType2NotifyParamEx = _SecCbParam[u32FltId].pType2NotifyParamEx;
331 _DMX2K_UNLOCK();
332
333 if(stCbParam.Event & DMX_EVENT_CB_MASK)
334 {
335 if((stCbParam.Event & DMX_EVENT_CB_SELF_TYPE2) == DMX_EVENT_CB_SELF_TYPE2)
336 {
337 if((stCbParam.pType2Notify) && (stCbParam.pType2Notify_Ex))
338 {
339 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] Mixed usage of SecRdy Callback function\n", __LINE__));
340 }
341 else if((stCbParam.pType2Notify) && !(stCbParam.pType2Notify_Ex))
342 {
343 stCbParam.pType2Notify((MS_U8)u32FltId, NotifyEvent ,stCbParam.Type2NotifyParam1);
344 }
345 else if(!(stCbParam.pType2Notify) && (stCbParam.pType2Notify_Ex))
346 {
347 stCbParam.pType2Notify_Ex(u32FltId, NotifyEvent ,stCbParam.pType2NotifyParamEx);
348 }
349 else
350 {
351 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] Null function pointer\n", __LINE__));
352 }
353 }
354 else
355 {
356 if(stCbParam.pNotify)
357 {
358 stCbParam.pNotify((MS_U8)u32FltId, NotifyEvent);
359 }
360 else
361 {
362 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] Null function pointer\n", __LINE__));
363 }
364 }
365 }
366 }
367
_DMX_TSP_Proc_Task(void)368 static void _DMX_TSP_Proc_Task(void)
369 {
370 DMX_TSP_IOSIGNAL stTspIoSig;
371 MS_U32 u32ii =0, u32jj = 0, u32FltId = 0;
372 MS_U32 u32PidFltNum = 0, u32PidGroup = 0;
373 MS_U32 u32Mask = 0;
374
375 while(_pInstantDmx == NULL)
376 {
377 MsOS_DelayTask(1);
378 }
379
380 MApi_DMX_GetCap(DMX_CAP_PID_FILTER_NUM, (void*)&u32PidFltNum);
381
382 stTspIoSig.s32KerModeTspEvtId = -1; //init it first
383 while((_pInstantDmx != NULL) && (_u8TspThrState == 0))
384 {
385 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_WaitTspCbEvt, (void*)&stTspIoSig) != UTOPIA_STATUS_SUCCESS)
386 {
387 continue;
388 }
389
390 if(stTspIoSig.u32DmxEvt == 0)
391 {
392 continue;
393 }
394
395 //printf("[%s][%d] u32DmxEvt %x\n", __FUNCTION__, __LINE__, (int)stTspIoSig.u32DmxEvt);
396
397 //PVR CB process
398 if((stTspIoSig.u32DmxEvt & (DMX_EVENT_PVRBUF_FULL|DMX_EVENT_PVR1BUF_FULL)) && (_PvrEngCb[0] != NULL))
399 {
400 if(stTspIoSig.u32PvrBufFullFlag[0] == 0xFF)
401 {
402 _PvrEngCb[0](0xFF, DMX_EVENT_PVR1BUF_FULL);
403 }
404 else
405 {
406 if(stTspIoSig.u32PvrBufFullFlag[0] & 0x01)
407 {
408 _PvrEngCb[0](0, DMX_EVENT_PVRBUF_FULL);
409 }
410 else if(stTspIoSig.u32PvrBufFullFlag[0] & 0x01)
411 {
412 _PvrEngCb[u32ii](1, DMX_EVENT_PVRBUF_FULL);
413 }
414 }
415 }
416
417 //Section CB process
418 if(stTspIoSig.u32DmxEvt & (DMX_EVENT_DATA_READY|DMX_EVENT_SEC_CRCERROR|DMX_EVENT_BUF_OVERFLOW))
419 {
420 u32PidGroup = u32PidFltNum >> 5;
421 for(u32ii = 0; u32ii < u32PidGroup; u32ii++)
422 {
423 u32FltId = u32ii << 5;
424 u32Mask = 1;
425 for(u32jj = 0; u32jj < 32; u32jj++)
426 {
427 if((stTspIoSig.u32SecRdyFlag[u32ii] | stTspIoSig.u32SecCrcErrFlag[u32ii] | stTspIoSig.u32SecOvfFlag[u32ii]) == 0)
428 {
429 break;
430 }
431
432 if(stTspIoSig.u32SecRdyFlag[u32ii] & u32Mask)
433 {
434 _DMX_TSP_Proc_SecCB(u32FltId, DMX_EVENT_DATA_READY);
435 stTspIoSig.u32SecRdyFlag[u32ii] &= ~u32Mask;
436 }
437
438 if(stTspIoSig.u32SecCrcErrFlag[u32ii] & u32Mask)
439 {
440 _DMX_TSP_Proc_SecCB(u32FltId, DMX_EVENT_SEC_CRCERROR);
441 stTspIoSig.u32SecCrcErrFlag[u32ii] &= ~u32Mask;
442 }
443
444 if(stTspIoSig.u32SecOvfFlag[u32ii] & u32Mask)
445 {
446 _DMX_TSP_Proc_SecCB(u32FltId, DMX_EVENT_BUF_OVERFLOW);
447 stTspIoSig.u32SecOvfFlag[u32ii] &= ~u32Mask;
448 }
449
450 u32FltId++;
451 u32Mask <<= 1;
452 }
453
454 }
455 }
456 }
457
458 _s32DmxTspTaskId = -1;
459 _u8TspThrState = 2;
460 }
461 #endif
462
463 #endif //end of DMX_UTOPIA_2K
464
MApi_DMX_SetFW(MS_PHY pFwAddr,MS_U32 u32FwSize)465 DMX_FILTER_STATUS MApi_DMX_SetFW(MS_PHY pFwAddr, MS_U32 u32FwSize)
466 {
467
468 #ifdef DMX_UTOPIA_20
469
470 MS_U32 u32param[4] = {0, 0, 0, 0};
471
472 DMX_V2DBGMSG(ULOGD("DMX", "[%s][%d](%lx, %lx)\n", __FUNCTION__, __LINE__, pFwAddr, u32FwSize));
473
474 if(_DMX_IOCtrlOpen() == FALSE)
475 return DMX_FILTER_STATUS_ERROR;
476
477 _DMX_PhyAddr_To_U32Param(pFwAddr, u32param);
478 u32param[2] = u32FwSize;
479
480 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetFw, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
481 {
482 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Init fail\n", __LINE__));
483 return DMX_FILTER_STATUS_ERROR;
484 }
485
486 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
487 return DMX_FILTER_STATUS_ERROR;
488 else
489 return DMX_FILTER_STATUS_OK;
490
491 #else
492
493 return _MApi_DMX_SetFW(pFwAddr, u32FwSize);
494
495 #endif
496
497 }
498
499 #ifdef DMX_UTOPIA_2K
500 static char dmx_tsp_prc_task[] = "dmx2k_task";
501 static char dmx2k_mux[] = "dmx2k_mux";
502 #endif
MApi_DMX_Init(void)503 DMX_FILTER_STATUS MApi_DMX_Init(void)
504 {
505
506 #ifdef DMX_UTOPIA_20
507 MS_U32 u32param = 0;
508
509 #ifdef DMX_UTOPIA_2K
510 DMX_CMDRUN_PARAM stCmdRunParam;
511
512 _bKrenelMod = ((UtopiaModuleQueryMode(MODULE_DMX) == KERNEL_MODE) ? TRUE: FALSE);
513 #endif
514
515 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
516
517 if(_DMX_IOCtrlOpen() == FALSE)
518 {
519 return DMX_FILTER_STATUS_ERROR;
520 }
521
522 #ifdef DMX_UTOPIA_2K
523 stCmdRunParam.u32Cmd = DMX_CMD_SET_LIB_MODE; //dynamically setting lib to be kernel or use mode
524 stCmdRunParam.u32Config = (MS_U32)_bKrenelMod;
525 stCmdRunParam.u32DataNum = 0;
526 stCmdRunParam.pData = 0;
527 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_CmdRun, (void*)&stCmdRunParam) != UTOPIA_STATUS_SUCCESS)
528 {
529 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Cmd_Run API fail\n", __LINE__));
530 return DMX_FILTER_STATUS_ERROR;
531 }
532
533 //printf("[%s][%d] _bKrenelMod %d , _u32IntRefCnt %d \n", __FUNCTION__, __LINE__, (int)_bKrenelMod, (int)_u32IntRefCnt);
534
535 if(_bKrenelMod == TRUE)
536 {
537 if((++_u32IntRefCnt) > 1)
538 return DMX_FILTER_STATUS_OK;
539 }
540 #endif
541
542 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Init_1_0, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
543 {
544 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Init fail\n", __LINE__));
545 return DMX_FILTER_STATUS_ERROR;
546 }
547
548 #ifdef DMX_UTOPIA_2K
549 if((_bKrenelMod == TRUE) && (_s32DmxTspTaskId == -1))
550 {
551 MS_U32 ii = 0;
552
553 _Dmx2K_Mutex = MsOS_CreateMutex(E_MSOS_FIFO, dmx2k_mux, MSOS_PROCESS_SHARED);
554 if (-1 == _Dmx2K_Mutex)
555 {
556 ULOGE("DMX", "[%s][%06d] create DMX2K mutex fail\n", __FUNCTION__, __LINE__);
557 return DMX_FILTER_STATUS_ERROR;
558 }
559
560 for(ii = 0; ii < DMX_MAX_SECFLT_NUM; ii++)
561 {
562 _SecCbParam[ii].Event = 0;
563 _SecCbParam[ii].pNotify = NULL;
564 _SecCbParam[ii].pType2Notify = NULL;
565 _SecCbParam[ii].Type2NotifyParam1 = 0;
566 _SecCbParam[ii].pType2Notify_Ex = NULL;
567 _SecCbParam[ii].pType2NotifyParamEx = NULL;
568 }
569 //ULOGD("DMX", "[%s][%d] %lx\n", __FUNCTION__, __LINE__, (MS_U32)_s32DmxTspTaskId);
570 _s32DmxTspTaskId = MsOS_CreateTask((TaskEntry)_DMX_TSP_Proc_Task,
571 0,
572 E_TASK_PRI_MEDIUM,
573 TRUE,
574 _u8DmxTspStack,
575 DMX_TASK_STACK_SIZE,
576 dmx_tsp_prc_task);
577 //printf("[%s][%d] %x\n", __FUNCTION__, __LINE__, (int)_s32DmxTspTaskId);
578 }
579 #endif
580
581 if(u32param != (MS_U32)DMX_FILTER_STATUS_OK)
582 return DMX_FILTER_STATUS_ERROR;
583 else
584 return DMX_FILTER_STATUS_OK;
585
586 #else
587
588 return _MApi_DMX_Init();
589
590 #endif
591
592 }
593
MApi_DMX_TSPInit_GetConfig(DMX_TSPParam * pstParam)594 MS_U32 MApi_DMX_TSPInit_GetConfig(DMX_TSPParam *pstParam)
595 {
596 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
597
598 #ifdef DMX_UTOPIA_20
599
600 if(_DMX_IOCtrlOpen() == FALSE)
601 return UTOPIA_STATUS_FAIL;
602
603 if(UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSPInit_GetConfig, pstParam) != UTOPIA_STATUS_SUCCESS)
604 {
605 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Get config fail\n", __LINE__));
606 return UTOPIA_STATUS_FAIL;
607 }
608
609 return pstParam->u32Res;
610
611 #else
612 return UTOPIA_STATUS_NOT_SUPPORTED;
613 #endif
614 }
615
MApi_DMX_TSPInit(DMX_TSPParam * param)616 DMX_FILTER_STATUS MApi_DMX_TSPInit(DMX_TSPParam *param)
617 {
618 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
619
620 #ifdef DMX_UTOPIA_20
621
622 if(_DMX_IOCtrlOpen() == FALSE)
623 return DMX_FILTER_STATUS_ERROR;
624
625 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSPInit_1_0, param) != UTOPIA_STATUS_SUCCESS)
626 {
627 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Init fail\n", __LINE__));
628 return DMX_FILTER_STATUS_ERROR;
629 }
630
631 if(param->u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
632 return DMX_FILTER_STATUS_ERROR;
633 else
634 return DMX_FILTER_STATUS_OK;
635
636 #else
637
638 return _MApi_DMX_TSPInit(param);
639
640 #endif
641 }
642
MApi_DMX_Exit(void)643 DMX_FILTER_STATUS MApi_DMX_Exit(void)
644 {
645 #ifdef DMX_UTOPIA_20
646 MS_U32 u32param = 0;
647
648 #ifdef DMX_UTOPIA_2K
649 MS_U32 u32Timer;
650 #endif
651
652 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
653
654 if(_DMX_IOCtrlOpen() == FALSE)
655 return DMX_FILTER_STATUS_ERROR;
656
657 //printf("[%s][%d] _bKrenelMod %d , _u32IntRefCnt %d \n", __FUNCTION__, __LINE__, (int)_bKrenelMod, (int)_u32IntRefCnt);
658
659 #ifdef DMX_UTOPIA_2K
660 if(_bKrenelMod == TRUE)
661 {
662 if((--_u32IntRefCnt) > 0)
663 {
664 return DMX_FILTER_STATUS_OK;
665 }
666 if(_u32IntRefCnt == 0)
667 {
668 DMX_TSP_IOSIGNAL stTspIoSig;
669
670 _u8TspThrState = 1;
671
672 stTspIoSig.u32EvtWaitOpt = 0xFFFFFFFF;
673 UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_WaitTspCbEvt, (void*)&stTspIoSig);
674 if(u32param == (MS_U32)DMX_FILTER_STATUS_ERROR)
675 {
676 printf("[%s] Send free event fail\n", __FUNCTION__);
677 }
678 }
679 }
680 #endif
681
682 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Exit, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
683 {
684 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Exit fail\n", __LINE__));
685 return DMX_FILTER_STATUS_ERROR;
686 }
687
688 #ifdef DMX_UTOPIA_2K
689 if((_bKrenelMod == TRUE) && (_u32IntRefCnt == 0))
690 {
691 u32Timer = MsOS_GetSystemTime();
692 while(_s32DmxTspTaskId > 0)
693 {
694 if(_u8TspThrState == 2)
695 break;
696
697 if (MsOS_GetSystemTime()-u32Timer > 10000)
698 {
699 DMX_V2DBGMSG(ULOGD("DMX", "[%s][%d] TSP Proc task exit timeout!!!!!!\n", __FUNCTION__, __LINE__));
700 break;
701 }
702 }
703
704 /*if(_s32DmxTspTaskId != -1)
705 {
706 MsOS_DeleteTask(_s32DmxTspTaskId);
707 _s32DmxTspTaskId = -1;
708 }*/
709 _u8TspThrState = 0;
710
711 if (_Dmx2K_Mutex != -1 )
712 {
713 _DMX2K_LOCK();
714 _DMX2K_UNLOCK();
715 MsOS_DeleteMutex(_Dmx2K_Mutex);
716 _Dmx2K_Mutex = -1;
717 }
718
719 _bKrenelMod = FALSE;
720 }
721 #endif
722
723 if(u32param != (MS_U32)DMX_FILTER_STATUS_MULTIPRC_RUNNING)
724 {
725 if(UtopiaClose(_pInstantDmx) != UTOPIA_STATUS_SUCCESS)
726 {
727 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Close fail\n", __LINE__));
728 return DMX_FILTER_STATUS_ERROR;
729 }
730
731 _pInstantDmx = NULL;
732 _pAttributeDmx = NULL;
733 }
734
735 return ((DMX_FILTER_STATUS)u32param);
736
737 #else
738
739 return _MApi_DMX_Exit();
740 #endif
741 }
742
MApi_DMX_Reset(void)743 DMX_FILTER_STATUS MApi_DMX_Reset(void)
744 {
745 #ifdef DMX_UTOPIA_20
746
747 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
748 MS_U32 u32param = 0;
749
750 if(_DMX_IOCtrlOpen() == FALSE)
751 return DMX_FILTER_STATUS_ERROR;
752
753 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Reset, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
754 {
755 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Reset fail\n", __LINE__));
756 return DMX_FILTER_STATUS_ERROR;
757 }
758
759 if(u32param != (MS_U32)DMX_FILTER_STATUS_OK)
760 return DMX_FILTER_STATUS_ERROR;
761 else
762 return DMX_FILTER_STATUS_OK;
763
764 #else
765
766 return _MApi_DMX_Reset();
767
768 #endif
769 }
770
MApi_DMX_ForceExit(void)771 DMX_FILTER_STATUS MApi_DMX_ForceExit(void)
772 {
773 #ifdef DMX_UTOPIA_20
774
775 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
776 MS_U32 u32param = 0;
777
778 if(_DMX_IOCtrlOpen() == FALSE)
779 return DMX_FILTER_STATUS_ERROR;
780
781 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_ForceExit, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
782 {
783 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Reset fail\n", __LINE__));
784 return DMX_FILTER_STATUS_ERROR;
785 }
786
787 if(u32param != (MS_U32)DMX_FILTER_STATUS_OK)
788 return DMX_FILTER_STATUS_ERROR;
789 else
790 return DMX_FILTER_STATUS_OK;
791
792 #else
793
794 return _MApi_DMX_ForceExit();
795
796 #endif
797 }
798
MApi_DMX_Resume(MS_PHY phyFWAddr,MS_U32 u32FWSize)799 DMX_FILTER_STATUS MApi_DMX_Resume(MS_PHY phyFWAddr, MS_U32 u32FWSize)
800 {
801
802 #ifdef DMX_UTOPIA_20
803
804 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
805
806 DMX_TSPParam tspparam;
807
808 if(_DMX_IOCtrlOpen() == FALSE)
809 return DMX_FILTER_STATUS_ERROR;
810
811 tspparam.phyFWAddr = phyFWAddr;
812 tspparam.u32FWSize = u32FWSize;
813 tspparam.u32Res = 0;
814 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Resume, (void*)&tspparam) != UTOPIA_STATUS_SUCCESS)
815 {
816 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Resume fail\n", __LINE__));
817 return DMX_FILTER_STATUS_ERROR;
818 }
819
820 if(tspparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
821 return DMX_FILTER_STATUS_ERROR;
822 else
823 return DMX_FILTER_STATUS_OK;
824
825 #else
826
827 return _MApi_DMX_Resume(phyFWAddr, u32FWSize);
828
829 #endif
830 }
831
MApi_DMX_Suspend(void)832 DMX_FILTER_STATUS MApi_DMX_Suspend(void)
833 {
834 #ifdef DMX_UTOPIA_20
835
836 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
837 MS_U32 u32param = 0;
838
839 if(_DMX_IOCtrlOpen() == FALSE)
840 return DMX_FILTER_STATUS_ERROR;
841
842 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Suspend, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
843 {
844 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Suspend fail\n", __LINE__));
845 return DMX_FILTER_STATUS_ERROR;
846 }
847
848 if(u32param != (MS_U32)DMX_FILTER_STATUS_OK)
849 return DMX_FILTER_STATUS_ERROR;
850 else
851 return DMX_FILTER_STATUS_OK;
852
853 #else
854
855 return _MApi_DMX_Suspend();
856
857 #endif
858 }
859
MApi_DMX_ReleaseSemaphone(void)860 DMX_FILTER_STATUS MApi_DMX_ReleaseSemaphone(void)
861 {
862 #ifdef DMX_UTOPIA_20
863
864 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
865 MS_U32 u32param = 0;
866
867 if(_DMX_IOCtrlOpen() == FALSE)
868 return DMX_FILTER_STATUS_ERROR;
869
870 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_ReleseHWSemp, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
871 {
872 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%06d] DMX Release HW lock semaphore fail\n", __LINE__));
873 return DMX_FILTER_STATUS_ERROR;
874 }
875
876 if(u32param != (MS_U32)DMX_FILTER_STATUS_OK)
877 return DMX_FILTER_STATUS_ERROR;
878 else
879 return DMX_FILTER_STATUS_OK;
880
881 #else
882
883 return _MApi_DMX_ReleaseSemaphone();
884
885 #endif
886 }
887
MApi_DMX_Get_FlowInput_Status(DMX_FLOW DmxFlow,DMX_FLOW_INPUT * pDmxFlowInput,MS_BOOL * pbClkInv,MS_BOOL * pbExtSync,MS_BOOL * pbParallel)888 DMX_FILTER_STATUS MApi_DMX_Get_FlowInput_Status(DMX_FLOW DmxFlow, DMX_FLOW_INPUT *pDmxFlowInput, MS_BOOL *pbClkInv, MS_BOOL *pbExtSync, MS_BOOL *pbParallel)
889 {
890
891 #ifdef DMX_UTOPIA_20
892
893 DMX_FLOW_PARAM flowparam;
894
895 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
896
897 //initiate the parameters
898 *pDmxFlowInput = DMX_FLOW_INPUT_MEM;
899 *pbClkInv = FALSE;
900 *pbExtSync = FALSE;
901 *pbParallel = FALSE;
902
903 if(_DMX_IOCtrlOpen() == FALSE)
904 return DMX_FILTER_STATUS_ERROR;
905
906 flowparam.DmxFlow = DmxFlow;
907 flowparam.DmxFlowInput = DMX_FLOW_INPUT_DEMOD;
908 flowparam.bClkInv = FALSE;
909 flowparam.bExtSync = FALSE;
910 flowparam.bParallel = FALSE;
911 flowparam.bSet = FALSE;
912 flowparam.u32CAEngSel = 0;
913 flowparam.u32Res = 0;
914 //initiate the parameters
915 *pDmxFlowInput = DMX_FLOW_INPUT_MEM;
916 *pbClkInv = FALSE;
917 *pbExtSync = FALSE;
918 *pbParallel = FALSE;
919
920 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Flow,(void*)&flowparam) != UTOPIA_STATUS_SUCCESS)
921 {
922 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
923 return DMX_FILTER_STATUS_ERROR;
924 }
925
926 *pDmxFlowInput = flowparam.DmxFlowInput;
927 *pbClkInv = flowparam.bClkInv;
928 *pbExtSync = flowparam.bExtSync;
929 *pbParallel = flowparam.bParallel;
930
931 if(flowparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
932 return DMX_FILTER_STATUS_ERROR;
933 else
934 return DMX_FILTER_STATUS_OK;
935
936 #else
937
938 return _MApi_DMX_Get_FlowInput_Status(DmxFlow, pDmxFlowInput, pbClkInv, pbExtSync, pbParallel);
939
940 #endif
941 }
942
MApi_DMX_FlowSet(DMX_FLOW DmxFlow,DMX_FLOW_INPUT DmxFlowInput,MS_BOOL bClkInv,MS_BOOL bExtSync,MS_BOOL bParallel)943 DMX_FILTER_STATUS MApi_DMX_FlowSet(DMX_FLOW DmxFlow, DMX_FLOW_INPUT DmxFlowInput, MS_BOOL bClkInv, MS_BOOL bExtSync, MS_BOOL bParallel)
944 {
945 #ifdef DMX_UTOPIA_20
946 DMX_FLOW_PARAM flowparam;
947
948 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
949
950 if(_DMX_IOCtrlOpen() == FALSE)
951 return DMX_FILTER_STATUS_ERROR;
952
953 flowparam.bSet = TRUE;
954 flowparam.DmxFlow = DmxFlow;
955 flowparam.DmxFlowInput = DmxFlowInput;
956 flowparam.bClkInv = bClkInv;
957 flowparam.bExtSync = bExtSync;
958 flowparam.bParallel = bParallel;
959 flowparam.u32CAEngSel = 0;
960 flowparam.u32Res = 0;
961
962 if(DmxFlowInput == DMX_FLOW_INPUT_MEM_NOPASSCA)
963 {
964 flowparam.u32CAEngSel = 0xFFFFFFFF;
965 }
966 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Flow,(void*)&flowparam) != UTOPIA_STATUS_SUCCESS)
967 {
968 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
969 return DMX_FILTER_STATUS_ERROR;
970 }
971
972 if(flowparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
973 return DMX_FILTER_STATUS_ERROR;
974 else
975 return DMX_FILTER_STATUS_OK;
976 #else
977
978 return _MApi_DMX_FlowSet(DmxFlow, DmxFlowInput, bClkInv, bExtSync, bParallel);
979
980 #endif
981 }
982
MApi_DMX_PVR_FlowSet(DMX_PVR_ENG Eng,DMX_TSIF ePvrSrcTSIf,MS_BOOL bDscmbRec)983 DMX_FILTER_STATUS MApi_DMX_PVR_FlowSet(DMX_PVR_ENG Eng, DMX_TSIF ePvrSrcTSIf, MS_BOOL bDscmbRec)
984 {
985 #ifdef DMX_UTOPIA_20
986 DMX_PVRFLOWPARAM pvrflowparam;
987
988 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
989
990 if(_DMX_IOCtrlOpen() == FALSE)
991 return DMX_FILTER_STATUS_ERROR;
992
993 pvrflowparam.bSet = TRUE;
994 pvrflowparam.eEng = Eng;
995 pvrflowparam.eSrcTSIf = ePvrSrcTSIf;
996 pvrflowparam.bDscmbRec = bDscmbRec;
997 pvrflowparam.u32Res = 0;
998
999 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_PVR_Flow,(void*)&pvrflowparam) != UTOPIA_STATUS_SUCCESS)
1000 {
1001 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1002 return DMX_FILTER_STATUS_ERROR;
1003 }
1004
1005 if(pvrflowparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
1006 return DMX_FILTER_STATUS_ERROR;
1007 else
1008 return DMX_FILTER_STATUS_OK;
1009
1010 #else
1011
1012 return _MApi_DMX_PVR_FlowSet(Eng, ePvrSrcTSIf, bDscmbRec);
1013
1014 #endif
1015 }
1016
MApi_DMX_Open(DMX_FILTER_TYPE DmxFltType,MS_U8 * pu8DmxId)1017 DMX_FILTER_STATUS MApi_DMX_Open(DMX_FILTER_TYPE DmxFltType, MS_U8* pu8DmxId)
1018 {
1019 #ifdef DMX_UTOPIA_20
1020 DMX_FLT_TYPE_PARAM fltparam;
1021
1022 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1023
1024 *pu8DmxId = 0xFF;
1025
1026 if(_DMX_IOCtrlOpen() == FALSE)
1027 return DMX_FILTER_STATUS_ERROR;
1028
1029 fltparam.DmxFltType = DmxFltType;
1030 fltparam.u32DmxId = 0xFFFFFFFF;
1031 fltparam.u32Res = 0;
1032
1033 //initiate the parameters
1034 *pu8DmxId = 0xFF;
1035
1036 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Open,(void*)&fltparam) != UTOPIA_STATUS_SUCCESS)
1037 {
1038 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1039 return DMX_FILTER_STATUS_ERROR;
1040 }
1041
1042 *pu8DmxId = (MS_U8)(fltparam.u32DmxId & 0xFF);
1043
1044 if(fltparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
1045 return DMX_FILTER_STATUS_ERROR;
1046 else
1047 return DMX_FILTER_STATUS_OK;
1048
1049 #else
1050 MS_U32 u32DmxId = 0xFFFFFFFF;
1051
1052 if(_MApi_DMX_Open(DmxFltType, &u32DmxId) == DMX_FILTER_STATUS_OK)
1053 {
1054 *pu8DmxId = (MS_U8)u32DmxId;
1055 return DMX_FILTER_STATUS_OK;
1056 }
1057 else
1058 {
1059 *pu8DmxId = 0xFF;
1060 return DMX_FILTER_STATUS_ERROR;
1061 }
1062 #endif
1063 }
1064
MApi_DMX_Open_Ex(DMX_Info_EX * pDmxInfo,MS_U32 * pu32DmxId)1065 DMX_FILTER_STATUS MApi_DMX_Open_Ex(DMX_Info_EX *pDmxInfo, MS_U32* pu32DmxId)
1066 {
1067
1068 #ifdef DMX_UTOPIA_20
1069 DMX_FLT_TYPE_PARAM fltparam;
1070 *pu32DmxId = (MS_U32)-1;
1071
1072 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1073
1074 if(_DMX_IOCtrlOpen() == FALSE)
1075 return DMX_FILTER_STATUS_ERROR;
1076
1077 fltparam.DmxFltType = pDmxInfo->DmxFltType;
1078 fltparam.u32DmxId = 0xFFFFFFFF;
1079 fltparam.u32Res = 0;
1080
1081 //initiate the parameters
1082
1083 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Open_Ex,(void*)&fltparam) != UTOPIA_STATUS_SUCCESS)
1084 {
1085 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1086 return DMX_FILTER_STATUS_ERROR;
1087 }
1088 *pu32DmxId = fltparam.u32DmxId;
1089 if(fltparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
1090 return DMX_FILTER_STATUS_ERROR;
1091 else
1092 return DMX_FILTER_STATUS_OK;
1093
1094 #else
1095 return _MApi_DMX_Open_Ex((pDmxInfo->DmxFltType) , pu32DmxId);
1096
1097 #endif
1098 }
1099
1100
1101
1102
1103
MApi_DMX_Close(MS_U32 u32DmxId)1104 DMX_FILTER_STATUS MApi_DMX_Close(MS_U32 u32DmxId)
1105 {
1106 #ifdef DMX_UTOPIA_20
1107
1108 MS_U32 u32param[2] = {0, 0};
1109 u32param[0] = u32DmxId;
1110
1111 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
1112
1113 if(_DMX_IOCtrlOpen() == FALSE)
1114 return DMX_FILTER_STATUS_ERROR;
1115
1116 #ifdef DMX_UTOPIA_2K
1117 if(_bKrenelMod == TRUE)
1118 {
1119 _DMX2K_LOCK();
1120 _SecCbParam[u32param[0]].Event = 0;
1121 _SecCbParam[u32param[0]].pNotify = NULL;
1122 _SecCbParam[u32param[0]].pType2Notify = NULL;
1123 _SecCbParam[u32param[0]].pType2Notify_Ex = NULL;
1124 _SecCbParam[u32param[0]].Type2NotifyParam1 = 0;
1125 _SecCbParam[u32param[0]].pType2NotifyParamEx = NULL;
1126 _DMX2K_UNLOCK();
1127 }
1128 #endif
1129
1130 while(1)
1131 {
1132 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Close,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1133 {
1134 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1135 return DMX_FILTER_STATUS_ERROR;
1136 }
1137 if(u32param[1] == (MS_U32)DMX_FILTER_STATUS_OK)
1138 {
1139 break;
1140 }
1141 MsOS_DelayTask(4);
1142 }
1143
1144 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
1145 return DMX_FILTER_STATUS_ERROR;
1146 else
1147 return DMX_FILTER_STATUS_OK;
1148
1149 #else
1150
1151 return _MApi_DMX_Close(u32DmxId);
1152
1153 #endif
1154 }
1155
MApi_DMX_Start(MS_U32 u32DmxId)1156 DMX_FILTER_STATUS MApi_DMX_Start(MS_U32 u32DmxId)
1157 {
1158 #ifdef DMX_UTOPIA_20
1159
1160 MS_U32 u32param[2] = {0, 0};
1161
1162 u32param[0] = u32DmxId;
1163
1164 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1165
1166 if(_DMX_IOCtrlOpen() == FALSE)
1167 return DMX_FILTER_STATUS_ERROR;
1168
1169 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Start,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1170 {
1171 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1172 return DMX_FILTER_STATUS_ERROR;
1173 }
1174
1175 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
1176 return DMX_FILTER_STATUS_ERROR;
1177 else
1178 return DMX_FILTER_STATUS_OK;
1179
1180 #else
1181
1182 return _MApi_DMX_Start(u32DmxId);
1183 #endif
1184 }
1185
MApi_DMX_Stop(MS_U32 u32DmxId)1186 DMX_FILTER_STATUS MApi_DMX_Stop(MS_U32 u32DmxId)
1187 {
1188 #ifdef DMX_UTOPIA_20
1189 MS_U32 u32param[2] = {0, 0};
1190
1191 u32param[0] = u32DmxId;
1192
1193 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1194
1195 if(_DMX_IOCtrlOpen() == FALSE)
1196 return DMX_FILTER_STATUS_ERROR;
1197
1198 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Stop,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1199 {
1200 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1201 return DMX_FILTER_STATUS_ERROR;
1202 }
1203
1204 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
1205 return DMX_FILTER_STATUS_ERROR;
1206 else
1207 return DMX_FILTER_STATUS_OK;
1208
1209 #else
1210
1211 return _MApi_DMX_Stop(u32DmxId);
1212
1213 #endif
1214 }
1215
MApi_DMX_IsStart(MS_U32 u32DmxId,MS_BOOL * pbEnable)1216 DMX_FILTER_STATUS MApi_DMX_IsStart(MS_U32 u32DmxId, MS_BOOL* pbEnable)
1217 {
1218 #ifdef DMX_UTOPIA_20
1219 MS_U32 u32param[3] = {0, 0, 0};
1220
1221 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1222
1223 *pbEnable = FALSE;
1224
1225 if(_DMX_IOCtrlOpen() == FALSE)
1226 return DMX_FILTER_STATUS_ERROR;
1227
1228 u32param[0] = u32DmxId;
1229 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_IsStart,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1230 {
1231 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1232 return DMX_FILTER_STATUS_ERROR;
1233 }
1234
1235 *pbEnable = (MS_BOOL)(u32param[1] & 0xFF);
1236
1237 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
1238 return DMX_FILTER_STATUS_ERROR;
1239 else
1240 return DMX_FILTER_STATUS_OK;
1241 #else
1242
1243 return _MApi_DMX_IsStart(u32DmxId, pbEnable);
1244
1245 #endif
1246 }
1247
MApi_DMX_Get_FltScmbSts(DMX_FILTER_TYPE FltSrc,MS_U32 u32FltGroupId,MS_U32 PidFltId,MS_U32 * pu32ScmbSts)1248 DMX_FILTER_STATUS MApi_DMX_Get_FltScmbSts(DMX_FILTER_TYPE FltSrc, MS_U32 u32FltGroupId, MS_U32 PidFltId, MS_U32 *pu32ScmbSts)
1249 {
1250 #ifdef DMX_UTOPIA_20
1251
1252 MS_U32 u32param[5] = {0, 0, 0, 0, 0};
1253
1254 *pu32ScmbSts = 0;
1255
1256 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1257
1258 if(_DMX_IOCtrlOpen() == FALSE)
1259 return DMX_FILTER_STATUS_ERROR;
1260
1261 u32param[0] = (MS_U32)FltSrc;
1262 u32param[1] = u32FltGroupId;
1263 u32param[2] = PidFltId;
1264
1265 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetFltScmbSts,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1266 {
1267 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1268 return DMX_FILTER_STATUS_ERROR;
1269 }
1270
1271 *pu32ScmbSts = u32param[3];
1272
1273 if(u32param[4] != (MS_U32)DMX_FILTER_STATUS_OK)
1274 return DMX_FILTER_STATUS_ERROR;
1275 else
1276 return DMX_FILTER_STATUS_OK;
1277
1278 #else
1279
1280 return _MApi_DMX_Get_FltScmbSts(FltSrc, u32FltGroupId, PidFltId, pu32ScmbSts);
1281
1282 #endif
1283
1284 }
1285
MApi_DMX_Get_PesScmbSts(MS_U32 u32DmxId,MS_U8 * pu8scmb)1286 DMX_FILTER_STATUS MApi_DMX_Get_PesScmbSts(MS_U32 u32DmxId, MS_U8* pu8scmb)
1287 {
1288 #ifdef DMX_UTOPIA_20
1289
1290 MS_U32 u32param[3] = {0, 0, 0};
1291
1292 *pu8scmb = 0;
1293
1294 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1295
1296 if(_DMX_IOCtrlOpen() == FALSE)
1297 return DMX_FILTER_STATUS_ERROR;
1298
1299 u32param[0] = u32DmxId;
1300 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetPESScmbSts,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1301 {
1302 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1303 return DMX_FILTER_STATUS_ERROR;
1304 }
1305
1306 *pu8scmb = (MS_U8)(u32param[1] & 0xFF);
1307
1308 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
1309 return DMX_FILTER_STATUS_ERROR;
1310 else
1311 return DMX_FILTER_STATUS_OK;
1312 #else
1313
1314 return _MApi_DMX_Get_PesScmbSts(u32DmxId, pu8scmb);
1315
1316 #endif
1317
1318 }
1319
MApi_DMX_Get_TsScmbSts(MS_U32 u32DmxId,MS_U8 * pu8ScmSts)1320 DMX_FILTER_STATUS MApi_DMX_Get_TsScmbSts(MS_U32 u32DmxId, MS_U8* pu8ScmSts)
1321 {
1322 #ifdef DMX_UTOPIA_20
1323
1324 MS_U32 u32param[3] = {0, 0, 0};
1325
1326 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1327
1328 *pu8ScmSts = 0;
1329
1330 if(_DMX_IOCtrlOpen() == FALSE)
1331 return DMX_FILTER_STATUS_ERROR;
1332
1333 u32param[0] = u32DmxId;
1334 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetTsScmbSts,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1335 {
1336 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1337 return DMX_FILTER_STATUS_ERROR;
1338 }
1339
1340 *pu8ScmSts = (MS_U8)(u32param[1] & 0xFF);
1341
1342 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
1343 return DMX_FILTER_STATUS_ERROR;
1344 else
1345 return DMX_FILTER_STATUS_OK;
1346
1347 #else
1348
1349 return _MApi_DMX_Get_TsScmbSts(u32DmxId, pu8ScmSts);
1350
1351 #endif
1352
1353 }
1354
MApi_DMX_ChkAlive(void)1355 DMX_FILTER_STATUS MApi_DMX_ChkAlive(void)
1356 {
1357 #ifdef DMX_UTOPIA_20
1358 MS_U32 u32param = 0;
1359
1360 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1361
1362 if(_DMX_IOCtrlOpen() == FALSE)
1363 return DMX_FILTER_STATUS_ERROR;
1364
1365 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_ChkFwAlive, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
1366 {
1367 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1368 return DMX_FILTER_STATUS_ERROR;
1369 }
1370
1371 if(u32param != (MS_U32)DMX_FILTER_STATUS_OK)
1372 return DMX_FILTER_STATUS_ERROR;
1373 else
1374 return DMX_FILTER_STATUS_OK;
1375
1376 #else
1377
1378 return _MApi_DMX_ChkAlive();
1379
1380 #endif
1381
1382 }
1383
MApi_DMX_Info(MS_U32 u32DmxId,DMX_Flt_info * pDmxFltInfo,DMX_FILTER_TYPE * pDmxFltType,MS_BOOL bSet)1384 DMX_FILTER_STATUS MApi_DMX_Info(MS_U32 u32DmxId, DMX_Flt_info* pDmxFltInfo, DMX_FILTER_TYPE* pDmxFltType, MS_BOOL bSet)
1385 {
1386
1387 if (pDmxFltType == NULL)
1388 {
1389 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] DMX Filter Type is NULL\n", __FUNCTION__, __LINE__));
1390 return DMX_FILTER_STATUS_ERROR;
1391 }
1392
1393 #ifdef DMX_UTOPIA_20
1394
1395 DMX_FLT_INFO_PARAM infoparam;
1396
1397 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
1398
1399 if(_DMX_IOCtrlOpen() == FALSE)
1400 return DMX_FILTER_STATUS_ERROR;
1401
1402 infoparam.u32DmxId = u32DmxId;
1403 infoparam.pDmxFltInfo = pDmxFltInfo;
1404 infoparam.pDmxFltType = pDmxFltType;
1405 infoparam.bSet = bSet;
1406 infoparam.u32Res = 0;
1407
1408 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Info,(void*)&infoparam) != UTOPIA_STATUS_SUCCESS)
1409 {
1410 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1411 return DMX_FILTER_STATUS_ERROR;
1412 }
1413
1414 #ifdef DMX_UTOPIA_2K
1415 if(_bKrenelMod == TRUE)
1416 {
1417 if(bSet == TRUE)
1418 {
1419 DMX_Sect_info* pInfo = &(pDmxFltInfo->Info.SectInfo);
1420
1421 //ULOGD("DMX", "info %d: type: %lx, %lx , %p , %p , %ld\n", (int)u32DmxId, *pDmxFltType,
1422 // pInfo->Event, pInfo->pNotify, pInfo->pType2Notify, pInfo->Type2NotifyParam1);
1423 switch(*pDmxFltType & ~DMX_FILTER_FLT_MASK)
1424 {
1425 case DMX_FILTER_TYPE_SECTION:
1426 case DMX_FILTER_TYPE_PES:
1427 case DMX_FILTER_TYPE_PACKET:
1428 case DMX_FILTER_TYPE_PCR:
1429 case DMX_FILTER_TYPE_TELETEXT:
1430 case DMX_FILTER_TYPE_SCMBCHK:
1431 #if(defined(TSP_VERSION) && ((TSP_VERSION == TSP_VER_1_0)||(TSP_VERSION == TSP_VER_3_0)))
1432 case DMX_FILTER_TYPE_SECTION_VER:
1433 #endif
1434 //_DMX2K_LOCK();
1435 _SecCbParam[u32DmxId].Event = pInfo->Event;
1436 _SecCbParam[u32DmxId].pType2Notify_Ex = NULL;
1437 _SecCbParam[u32DmxId].pNotify = pInfo->pNotify;
1438 _SecCbParam[u32DmxId].pType2Notify = pInfo->pType2Notify;
1439 _SecCbParam[u32DmxId].Type2NotifyParam1 = pInfo->Type2NotifyParam1;
1440 _SecCbParam[u32DmxId].pType2NotifyParamEx = NULL;
1441 //_DMX2K_UNLOCK();
1442 break;
1443 default:
1444 break;
1445 }
1446 }
1447 }
1448 #endif
1449
1450 if(infoparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
1451 return DMX_FILTER_STATUS_ERROR;
1452 else
1453 return DMX_FILTER_STATUS_OK;
1454
1455 #else
1456
1457 return _MApi_DMX_Info(u32DmxId, pDmxFltInfo, pDmxFltType, bSet);
1458
1459 #endif
1460 }
1461
MApi_DMX_Info_Ex(MS_U32 u32DmxId,DMX_Flt_info_Ex * pDmxFltInfo)1462 DMX_FILTER_STATUS MApi_DMX_Info_Ex(MS_U32 u32DmxId, DMX_Flt_info_Ex* pDmxFltInfo)
1463 {
1464 #ifdef DMX_UTOPIA_20
1465
1466 DMX_FLT_INFO_PARAM_Ex infoparam;
1467
1468 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
1469
1470 if(_DMX_IOCtrlOpen() == FALSE)
1471 return DMX_FILTER_STATUS_ERROR;
1472
1473 infoparam.u32DmxId = u32DmxId;
1474 infoparam.pDmxFltInfo = pDmxFltInfo;
1475 infoparam.u32Res = 0;
1476 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Info_Ex,(void*)&infoparam) != UTOPIA_STATUS_SUCCESS)
1477 {
1478 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1479 return DMX_FILTER_STATUS_ERROR;
1480 }
1481 // printf("#######DMX_Flt_info_Ex event = %lx\n",pDmxFltInfo->SectInfo.Info.Event);
1482 #ifdef DMX_UTOPIA_2K
1483
1484 if(_bKrenelMod == TRUE)
1485 {
1486 if(pDmxFltInfo->bSet == TRUE)
1487 {
1488 DMX_Sect_info_Ex stInfoEx;
1489
1490 memset(&stInfoEx, 0, sizeof(stInfoEx));
1491 memcpy(&stInfoEx, &(pDmxFltInfo->SectInfoEx), sizeof(stInfoEx));
1492
1493 //ULOGD("DMX", "_bKrenelMod info %d: type: %lx, %lx , %p , \n", (int)u32DmxId, pDmxFltInfo->DmxFltType,
1494 // pInfo.Event, pInfo.pType2Notify_Ex);
1495 switch(pDmxFltInfo->DmxFltType & ~DMX_FILTER_FLT_MASK)
1496 {
1497 case DMX_FILTER_TYPE_SECTION:
1498 case DMX_FILTER_TYPE_PES:
1499 case DMX_FILTER_TYPE_PACKET:
1500 case DMX_FILTER_TYPE_PCR:
1501 case DMX_FILTER_TYPE_TELETEXT:
1502 case DMX_FILTER_TYPE_SCMBCHK:
1503 #if(defined(TSP_VERSION) && ((TSP_VERSION == TSP_VER_1_0)||(TSP_VERSION == TSP_VER_3_0)))
1504 case DMX_FILTER_TYPE_SECTION_VER:
1505 #endif
1506 //_DMX2K_LOCK();
1507 _SecCbParam[u32DmxId].Event = stInfoEx.Event;
1508 _SecCbParam[u32DmxId].pType2Notify_Ex = stInfoEx.pType2Notify_Ex;
1509 _SecCbParam[u32DmxId].Type2NotifyParam1 = 0;
1510 _SecCbParam[u32DmxId].pNotify = NULL;
1511 _SecCbParam[u32DmxId].pType2Notify = NULL;
1512 _SecCbParam[u32DmxId].pType2NotifyParamEx = stInfoEx.pType2NotifyParamEx;
1513 //_DMX2K_UNLOCK();
1514 break;
1515 default:
1516 break;
1517 }
1518 }
1519 }
1520
1521 #endif
1522
1523 if(infoparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
1524 return DMX_FILTER_STATUS_ERROR;
1525 else
1526 return DMX_FILTER_STATUS_OK;
1527
1528 #else
1529
1530 return _MApi_DMX_Info_Ex(u32DmxId, pDmxFltInfo);
1531
1532 #endif
1533 }
1534
MApi_DMX_Pid(MS_U32 u32DmxId,MS_U16 * pu16Pid,MS_BOOL bSet)1535 DMX_FILTER_STATUS MApi_DMX_Pid(MS_U32 u32DmxId, MS_U16* pu16Pid, MS_BOOL bSet)
1536 {
1537 #ifdef DMX_UTOPIA_20
1538
1539 MS_U32 u32param[4] = {0, 0, 0, 0};
1540
1541 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1542
1543
1544 if(bSet == FALSE)
1545 {
1546 *pu16Pid = 0x1FFF;
1547 }
1548
1549 if(_DMX_IOCtrlOpen() == FALSE)
1550 return DMX_FILTER_STATUS_ERROR;
1551
1552 u32param[0] = u32DmxId;
1553 u32param[1] = ((MS_U32)(*pu16Pid)) & 0xFFFF;
1554 u32param[2] = ((MS_U32)bSet) & 0xFF;
1555 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pid,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1556 {
1557 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1558 return DMX_FILTER_STATUS_ERROR;
1559 }
1560 if(bSet == FALSE)
1561 {
1562 *pu16Pid = (MS_U16)u32param[1];
1563 }
1564
1565 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1566 return DMX_FILTER_STATUS_ERROR;
1567 else
1568 return DMX_FILTER_STATUS_OK;
1569
1570 #else
1571
1572 return _MApi_DMX_Pid(u32DmxId, pu16Pid, bSet);
1573
1574 #endif
1575 }
1576
1577 //-------------------------------------------------------------------------------------------------
1578 /// Set and activate a demux filter
1579 /// @param u16Pid \b IN: PID to set
1580 /// @param DmxFltType \b IN: the demux filer type to set
1581 /// @param pu8DmxId \b OUT: the demux filer Id
1582 /// @return DMX_FILTER_STATUS_OK - Success
1583 /// @return DMX_FILTER_STATUS_ERROR - Failure
1584 /// @note
1585 //-------------------------------------------------------------------------------------------------
MApi_DMX_StartFilter(MS_U16 u16Pid,DMX_FILTER_TYPE DmxFltType,MS_U8 * pu8DmxId)1586 DMX_FILTER_STATUS MApi_DMX_StartFilter(MS_U16 u16Pid, DMX_FILTER_TYPE DmxFltType, MS_U8 *pu8DmxId)
1587 {
1588 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1589
1590 //DMX_ASSERT((pu8DmxId != NULL || u16Pid < DMX_PID_NULL), DMX_DBGMSG(DMX_DBG_ERR, ULOGE("DMX", "[MAPI DMX][%06d] Bad dmxid or pid\n", __LINE__)));
1591
1592 if (DMX_FILTER_STATUS_OK == MApi_DMX_Open(DmxFltType, pu8DmxId))
1593 {
1594 MApi_DMX_Pid(*pu8DmxId, &u16Pid, TRUE);
1595 MApi_DMX_Start(*pu8DmxId);
1596 }
1597 return DMX_FILTER_STATUS_OK;
1598 }
1599
MApi_DMX_SectPatternSet(MS_U32 u32DmxId,MS_U8 * pPattern,MS_U8 * pMask,MS_U8 * pu8NotMask,MS_U32 MatchSize)1600 DMX_FILTER_STATUS MApi_DMX_SectPatternSet(MS_U32 u32DmxId, MS_U8* pPattern, MS_U8* pMask, MS_U8 *pu8NotMask, MS_U32 MatchSize)
1601 {
1602 #ifdef DMX_UTOPIA_20
1603
1604 DMX_FLT_SEC_PAT_PARAM SecPatParam;
1605
1606 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1607
1608 if(_DMX_IOCtrlOpen() == FALSE)
1609 return DMX_FILTER_STATUS_ERROR;
1610
1611 SecPatParam.u32DmxId = u32DmxId;
1612 SecPatParam.pu8Pattern = pPattern;
1613 SecPatParam.pu8Mask = pMask;
1614 SecPatParam.pu8NotMask = pu8NotMask;
1615 SecPatParam.u32MatchSize = MatchSize;
1616 SecPatParam.u32Res = 0;
1617
1618 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Sec_SetPattern,(void*)&SecPatParam) != UTOPIA_STATUS_SUCCESS)
1619 {
1620 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1621 return DMX_FILTER_STATUS_ERROR;
1622 }
1623
1624 if(SecPatParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
1625 return DMX_FILTER_STATUS_ERROR;
1626 else
1627 return DMX_FILTER_STATUS_OK;
1628
1629 #else
1630
1631 return _MApi_DMX_SectPatternSet(u32DmxId, pPattern, pMask, pu8NotMask, MatchSize);
1632
1633 #endif
1634 }
1635
MApi_DMX_SectReset(MS_U32 u32DmxId)1636 DMX_FILTER_STATUS MApi_DMX_SectReset(MS_U32 u32DmxId)
1637 {
1638 #ifdef DMX_UTOPIA_20
1639 MS_U32 u32param[2] = {0, 0};
1640 u32param[0] = u32DmxId;
1641
1642 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1643
1644 if(_DMX_IOCtrlOpen() == FALSE)
1645 return DMX_FILTER_STATUS_ERROR;
1646
1647 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Sec_Reset,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1648 {
1649 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1650 return DMX_FILTER_STATUS_ERROR;
1651 }
1652
1653 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
1654 return DMX_FILTER_STATUS_ERROR;
1655 else
1656 return DMX_FILTER_STATUS_OK;
1657
1658 #else
1659
1660 return _MApi_DMX_SectReset(u32DmxId);
1661
1662 #endif
1663 }
1664
MApi_DMX_SectReadSet(MS_U32 u32DmxId,MS_PHY Read)1665 DMX_FILTER_STATUS MApi_DMX_SectReadSet(MS_U32 u32DmxId, MS_PHY Read)
1666 {
1667 #ifdef DMX_UTOPIA_20
1668
1669 MS_U32 u32param[5] = {0, 0, 0, 0, 0};
1670
1671 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1672
1673 if(_DMX_IOCtrlOpen() == FALSE)
1674 return DMX_FILTER_STATUS_ERROR;
1675
1676 u32param[0] = u32DmxId;
1677 _DMX_PhyAddr_To_U32Param(Read, u32param+1);
1678 u32param[3] = 1;
1679 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Sec_ReadAddr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1680 {
1681 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1682 return DMX_FILTER_STATUS_ERROR;
1683 }
1684
1685 if(u32param[4] != (MS_U32)DMX_FILTER_STATUS_OK)
1686 return DMX_FILTER_STATUS_ERROR;
1687 else
1688 return DMX_FILTER_STATUS_OK;
1689 #else
1690
1691 return _MApi_DMX_SectReadSet(u32DmxId, Read);
1692
1693 #endif
1694 }
1695
MApi_DMX_SectReadGet(MS_U32 u32DmxId,MS_PHY * pRead)1696 DMX_FILTER_STATUS MApi_DMX_SectReadGet(MS_U32 u32DmxId, MS_PHY* pRead)
1697 {
1698 #ifdef DMX_UTOPIA_20
1699
1700 MS_U32 u32param[5] = {0, 0, 0, 0, 0};
1701 void* ptrTmp = (void*)(&u32param[1]);
1702
1703 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1704
1705 *pRead = 0;
1706
1707 if(_DMX_IOCtrlOpen() == FALSE)
1708 return DMX_FILTER_STATUS_ERROR;
1709
1710 u32param[0] = u32DmxId;
1711 u32param[3] = 0;
1712 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Sec_ReadAddr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1713 {
1714 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1715 return DMX_FILTER_STATUS_ERROR;
1716 }
1717 *pRead = *((MS_PHY*)ptrTmp);
1718
1719 if(u32param[4] != (MS_U32)DMX_FILTER_STATUS_OK)
1720 return DMX_FILTER_STATUS_ERROR;
1721 else
1722 return DMX_FILTER_STATUS_OK;
1723
1724 #else
1725
1726 return _MApi_DMX_SectReadGet(u32DmxId, pRead);
1727
1728 #endif
1729 }
1730
MApi_DMX_SectWriteGet(MS_U32 u32DmxId,MS_PHY * pWrite)1731 DMX_FILTER_STATUS MApi_DMX_SectWriteGet(MS_U32 u32DmxId, MS_PHY* pWrite)
1732 {
1733 #ifdef DMX_UTOPIA_20
1734
1735 MS_U32 u32param[4] = {0, 0, 0, 0};
1736 void* ptrTmp = (void*)(&u32param[1]);
1737
1738 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1739
1740 *pWrite = 0;
1741
1742 if(_DMX_IOCtrlOpen() == FALSE)
1743 return DMX_FILTER_STATUS_ERROR;
1744
1745 u32param[0] = u32DmxId;
1746 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Sec_GetWriteAddr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1747 {
1748 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1749 return DMX_FILTER_STATUS_ERROR;
1750 }
1751
1752 *pWrite = *((MS_PHY*)ptrTmp);
1753
1754 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1755 return DMX_FILTER_STATUS_ERROR;
1756 else
1757 return DMX_FILTER_STATUS_OK;
1758
1759 #else
1760
1761 return _MApi_DMX_SectWriteGet(u32DmxId, pWrite);
1762
1763 #endif
1764 }
1765
MApi_DMX_SectStartGet(MS_U32 u32DmxId,MS_PHY * pStart)1766 DMX_FILTER_STATUS MApi_DMX_SectStartGet(MS_U32 u32DmxId, MS_PHY* pStart)
1767 {
1768 #ifdef DMX_UTOPIA_20
1769
1770 MS_U32 u32param[4] = {0, 0, 0, 0};
1771 void* ptrTmp = (void*)(&u32param[1]);
1772
1773 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1774
1775 *pStart = 0;
1776
1777 if(_DMX_IOCtrlOpen() == FALSE)
1778 return DMX_FILTER_STATUS_ERROR;
1779
1780 u32param[0] = u32DmxId;
1781 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Sec_GetStartAddr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1782 {
1783 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1784 return DMX_FILTER_STATUS_ERROR;
1785 }
1786
1787 *pStart = *((MS_PHY*)ptrTmp);
1788
1789 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1790 return DMX_FILTER_STATUS_ERROR;
1791 else
1792 return DMX_FILTER_STATUS_OK;
1793
1794 #else
1795
1796 return _MApi_DMX_SectStartGet(u32DmxId, pStart);
1797
1798 #endif
1799 }
1800
MApi_DMX_SectEndGet(MS_U32 u32DmxId,MS_PHY * pEnd)1801 DMX_FILTER_STATUS MApi_DMX_SectEndGet(MS_U32 u32DmxId, MS_PHY* pEnd)
1802 {
1803 #ifdef DMX_UTOPIA_20
1804
1805 MS_U32 u32param[4] = {0, 0, 0, 0};
1806 void* ptrTmp = (void*)(&u32param[1]);
1807
1808 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1809
1810 *pEnd = 0;
1811
1812 if(_DMX_IOCtrlOpen() == FALSE)
1813 return DMX_FILTER_STATUS_ERROR;
1814
1815 u32param[0] = u32DmxId;
1816 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Sec_GetEndAddr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1817 {
1818 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1819 return DMX_FILTER_STATUS_ERROR;
1820 }
1821
1822 *pEnd = *((MS_PHY*)ptrTmp);
1823
1824 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1825 return DMX_FILTER_STATUS_ERROR;
1826 else
1827 return DMX_FILTER_STATUS_OK;
1828
1829 #else
1830
1831 return _MApi_DMX_SectEndGet(u32DmxId, pEnd);
1832
1833 #endif
1834 }
1835
MApi_DMX_SetFwDataAddr(MS_PHY phyDataAddr,MS_U32 u32size)1836 DMX_FILTER_STATUS MApi_DMX_SetFwDataAddr(MS_PHY phyDataAddr, MS_U32 u32size)
1837 {
1838 #ifdef DMX_UTOPIA_20
1839
1840 MS_U32 u32param[4] = {0, 0, 0, 0};
1841
1842 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1843
1844 if(_DMX_IOCtrlOpen() == FALSE)
1845 return DMX_FILTER_STATUS_ERROR;
1846
1847 _DMX_PhyAddr_To_U32Param(phyDataAddr, u32param);
1848 u32param[2] = u32size;
1849 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetFwMiuDataAddr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1850 {
1851 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1852 return DMX_FILTER_STATUS_ERROR;
1853 }
1854
1855 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1856 return DMX_FILTER_STATUS_ERROR;
1857 else
1858 return DMX_FILTER_STATUS_OK;
1859
1860 #else
1861
1862 return _MApi_DMX_SetFwDataAddr(phyDataAddr, u32size);
1863
1864 #endif
1865 }
1866
MApi_DMX_TTX_WriteGet(MS_U32 u32DmxId,MS_PHY * pWrite)1867 DMX_FILTER_STATUS MApi_DMX_TTX_WriteGet(MS_U32 u32DmxId, MS_PHY* pWrite)
1868 {
1869
1870 #ifdef DMX_UTOPIA_20
1871
1872 MS_U32 u32param[4] = {0, 0, 0, 0};
1873 void* ptrTmp = (void*)(&u32param[1]);
1874
1875 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
1876
1877 *pWrite = 0;
1878
1879 if(_DMX_IOCtrlOpen() == FALSE)
1880 return DMX_FILTER_STATUS_ERROR;
1881
1882 u32param[0] = u32DmxId;
1883 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetTTXWrite,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1884 {
1885 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1886 return DMX_FILTER_STATUS_ERROR;
1887 }
1888
1889 *pWrite = *((MS_PHY*)ptrTmp);
1890
1891 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1892 return DMX_FILTER_STATUS_ERROR;
1893 else
1894 return DMX_FILTER_STATUS_OK;
1895
1896 #else
1897
1898 return _MApi_DMX_TTX_WriteGet(u32DmxId, pWrite);
1899
1900 #endif
1901
1902 }
1903
MApi_DMX_Pvr_SetPlaybackStamp(MS_U32 u32Stamp)1904 DMX_FILTER_STATUS MApi_DMX_Pvr_SetPlaybackStamp(MS_U32 u32Stamp)
1905 {
1906 #ifdef DMX_UTOPIA_20
1907
1908 MS_U32 u32param[4] = {0, 0, 0, 0};
1909
1910 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d (%u)\n", __FUNCTION__, __LINE__, u32Stamp));
1911
1912 if(_DMX_IOCtrlOpen() == FALSE)
1913 return DMX_FILTER_STATUS_ERROR;
1914
1915 u32param[0] = 0;
1916 u32param[1] = u32Stamp;
1917 u32param[2] = 1;
1918 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_PlayStamp,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1919 {
1920 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1921 return DMX_FILTER_STATUS_ERROR;
1922 }
1923
1924 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1925 return DMX_FILTER_STATUS_ERROR;
1926 else
1927 return DMX_FILTER_STATUS_OK;
1928
1929 #else
1930
1931 return _MApi_DMX_Pvr_SetPlaybackStamp(u32Stamp);
1932
1933 #endif
1934
1935 }
1936
MApi_DMX_Filein_Eng_SetPlaybackStamp(DMX_FILEIN_PATH ePath,MS_U32 u32Stamp)1937 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_SetPlaybackStamp(DMX_FILEIN_PATH ePath,MS_U32 u32Stamp)
1938 {
1939 #ifdef DMX_UTOPIA_20
1940
1941 MS_U32 u32param[4] = {0, 0, 0, 0};
1942
1943 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d (%u)\n", __FUNCTION__, __LINE__, u32Stamp));
1944
1945 if(_DMX_IOCtrlOpen() == FALSE)
1946 return DMX_FILTER_STATUS_ERROR;
1947
1948 u32param[0] = (MS_U32)ePath;
1949 u32param[1] = u32Stamp;
1950 u32param[2] = 1;
1951 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_PlayStamp,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1952 {
1953 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1954 return DMX_FILTER_STATUS_ERROR;
1955 }
1956
1957 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1958 return DMX_FILTER_STATUS_ERROR;
1959 else
1960 return DMX_FILTER_STATUS_OK;
1961
1962 #else
1963
1964 return _MApi_DMX_Filein_Eng_SetPlaybackStamp(ePath, u32Stamp);
1965
1966 #endif
1967
1968 }
1969
MApi_DMX_Pvr_GetPlaybackStamp(MS_U32 * pu32Stamp)1970 DMX_FILTER_STATUS MApi_DMX_Pvr_GetPlaybackStamp(MS_U32* pu32Stamp)
1971 {
1972
1973 #ifdef DMX_UTOPIA_20
1974
1975 MS_U32 u32param[4] = {0, 0, 0, 0};
1976
1977 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d (0x%x)\n", __FUNCTION__, __LINE__, (MS_U32)pu32Stamp));
1978
1979 *pu32Stamp = 0;
1980 if(_DMX_IOCtrlOpen() == FALSE)
1981 return DMX_FILTER_STATUS_ERROR;
1982
1983 u32param[0] = 0;
1984 u32param[1] = 0;
1985 u32param[2] = 0;
1986 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_PlayStamp,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
1987 {
1988 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
1989 return DMX_FILTER_STATUS_ERROR;
1990 }
1991
1992 *pu32Stamp = u32param[1];
1993
1994 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
1995 return DMX_FILTER_STATUS_ERROR;
1996 else
1997 return DMX_FILTER_STATUS_OK;
1998 #else
1999
2000 return _MApi_DMX_Pvr_GetPlaybackStamp(pu32Stamp);
2001
2002 #endif
2003
2004 }
2005
MApi_DMX_Filein_Eng_GetPlaybackStamp(DMX_FILEIN_PATH ePath,MS_U32 * pu32Stamp)2006 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_GetPlaybackStamp(DMX_FILEIN_PATH ePath,MS_U32* pu32Stamp)
2007 {
2008
2009 #ifdef DMX_UTOPIA_20
2010
2011 MS_U32 u32param[4] = {0, 0, 0, 0};
2012
2013 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d (0x%x)\n", __FUNCTION__, __LINE__, (MS_U32)pu32Stamp));
2014
2015 *pu32Stamp = 0;
2016 if(_DMX_IOCtrlOpen() == FALSE)
2017 return DMX_FILTER_STATUS_ERROR;
2018
2019 u32param[0] = (MS_U32)ePath;
2020 u32param[1] = 0;
2021 u32param[2] = 0;
2022 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_PlayStamp,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2023 {
2024 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2025 return DMX_FILTER_STATUS_ERROR;
2026 }
2027
2028 *pu32Stamp = u32param[1];
2029
2030 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
2031 return DMX_FILTER_STATUS_ERROR;
2032 else
2033 return DMX_FILTER_STATUS_OK;
2034
2035 #else
2036
2037 return _MApi_DMX_Filein_Eng_GetPlaybackStamp(ePath, pu32Stamp);
2038
2039 #endif
2040
2041 }
2042
MApi_DMX_Pvr_TimeStampEnable(void)2043 DMX_FILTER_STATUS MApi_DMX_Pvr_TimeStampEnable(void)
2044 {
2045 #ifdef DMX_UTOPIA_20
2046
2047 MS_U32 u32param[3] = {0, 0 ,0};
2048
2049 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2050
2051 if(_DMX_IOCtrlOpen() == FALSE)
2052 return DMX_FILTER_STATUS_ERROR;
2053
2054 u32param[0] = 0;
2055 u32param[1] = 1;
2056 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_TimestampMode,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2057 {
2058 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2059 return DMX_FILTER_STATUS_ERROR;
2060 }
2061
2062 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2063 return DMX_FILTER_STATUS_ERROR;
2064 else
2065 return DMX_FILTER_STATUS_OK;
2066
2067 #else
2068
2069 return _MApi_DMX_Pvr_TimeStampEnable();
2070
2071 #endif
2072
2073 }
2074
MApi_DMX_Filein_Eng_PlaybackTimeStampEnable(DMX_FILEIN_PATH ePath)2075 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_PlaybackTimeStampEnable(DMX_FILEIN_PATH ePath)
2076 {
2077 #ifdef DMX_UTOPIA_20
2078
2079 MS_U32 u32param[3] = {0, 0, 0};
2080
2081 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2082
2083 if(_DMX_IOCtrlOpen() == FALSE)
2084 return DMX_FILTER_STATUS_ERROR;
2085
2086 u32param[0] = (MS_U32)ePath;
2087 u32param[1] = 1;
2088 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_TimestampMode,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2089 {
2090 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2091 return DMX_FILTER_STATUS_ERROR;
2092 }
2093
2094 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2095 return DMX_FILTER_STATUS_ERROR;
2096 else
2097 return DMX_FILTER_STATUS_OK;
2098
2099 #else
2100
2101 return _MApi_DMX_Filein_Eng_PlaybackTimeStampEnable(ePath);
2102
2103 #endif
2104
2105 }
2106
MApi_DMX_Pvr_TimeStampDisable(void)2107 DMX_FILTER_STATUS MApi_DMX_Pvr_TimeStampDisable(void)
2108 {
2109 #ifdef DMX_UTOPIA_20
2110
2111 MS_U32 u32param[3] = {0, 0, 0};
2112
2113 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2114
2115 if(_DMX_IOCtrlOpen() == FALSE)
2116 return DMX_FILTER_STATUS_ERROR;
2117
2118 u32param[0] = 0;
2119 u32param[1] = 0;
2120 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_TimestampMode,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2121 {
2122 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2123 return DMX_FILTER_STATUS_ERROR;
2124 }
2125
2126 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2127 return DMX_FILTER_STATUS_ERROR;
2128 else
2129 return DMX_FILTER_STATUS_OK;
2130
2131 #else
2132
2133 return _MApi_DMX_Pvr_TimeStampDisable();
2134
2135 #endif
2136
2137 }
2138
MApi_DMX_Filein_Eng_PlaybackTimeStampDisable(DMX_FILEIN_PATH ePath)2139 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_PlaybackTimeStampDisable(DMX_FILEIN_PATH ePath)
2140 {
2141 #ifdef DMX_UTOPIA_20
2142
2143 MS_U32 u32param[3] = {0, 0, 0};
2144
2145 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2146
2147 if(_DMX_IOCtrlOpen() == FALSE)
2148 return DMX_FILTER_STATUS_ERROR;
2149
2150 u32param[0] = (MS_U32)ePath;
2151 u32param[1] = 0;
2152 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_TimestampMode,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2153 {
2154 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2155 return DMX_FILTER_STATUS_ERROR;
2156 }
2157
2158 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2159 return DMX_FILTER_STATUS_ERROR;
2160 else
2161 return DMX_FILTER_STATUS_OK;
2162
2163 #else
2164
2165 return _MApi_DMX_Filein_Eng_PlaybackTimeStampDisable(ePath);
2166
2167 #endif
2168
2169 }
2170
MApi_DMX_PvrCA_Eng_Pid_Open(DMX_PVR_ENG Eng,MS_U32 Pid,MS_U8 * pu8DmxId,MS_U8 u8ShareKeyType)2171 DMX_FILTER_STATUS MApi_DMX_PvrCA_Eng_Pid_Open(DMX_PVR_ENG Eng, MS_U32 Pid, MS_U8* pu8DmxId, MS_U8 u8ShareKeyType)
2172 {
2173 #ifdef DMX_UTOPIA_20
2174
2175 DMX_PVR_FLTTYPE_PARAM PVRFltParam;
2176
2177 DMX_V2DBGMSG(ULOGD("DMX", "[%s](%d, 0x%08lx, 0x%p) %d\n", __FUNCTION__, (MS_S32)Eng, Pid, pu8DmxId, __LINE__));
2178
2179 *pu8DmxId = 0xFF;
2180
2181 if(_DMX_IOCtrlOpen() == FALSE)
2182 return DMX_FILTER_STATUS_ERROR;
2183
2184 PVRFltParam.u32EngId = ((MS_U32)Eng) & 0xFF;
2185 PVRFltParam.u32DmxId = 0xFFFFFFFF;
2186 PVRFltParam.u32Pid = Pid;
2187 PVRFltParam.u32SelShareFlt = u8ShareKeyType;
2188 PVRFltParam.FltSrc = DMX_FILTER_SOURCE_TYPE_LIVE;
2189 PVRFltParam.u32CAEngSel = ((MS_U32)Eng) & 0xFF;
2190 PVRFltParam.u32Res = 0;
2191
2192 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_PidOpen,(void*)&PVRFltParam) != UTOPIA_STATUS_SUCCESS)
2193 {
2194 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2195 return DMX_FILTER_STATUS_ERROR;
2196 }
2197
2198 *pu8DmxId = (MS_U8)(PVRFltParam.u32DmxId & 0xFF);
2199
2200 if(PVRFltParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
2201 return DMX_FILTER_STATUS_ERROR;
2202 else
2203 return DMX_FILTER_STATUS_OK;
2204
2205 #else
2206 MS_U32 u32DmxId = 0xFFFFFFFF;
2207
2208 if(_MApi_DMX_PvrCA_Eng_Pid_Open(Eng, Pid, &u32DmxId, u8ShareKeyType) == UTOPIA_STATUS_SUCCESS)
2209 {
2210 *pu8DmxId = (MS_U8)u32DmxId;
2211 return DMX_FILTER_STATUS_OK;
2212 }
2213 else
2214 {
2215 *pu8DmxId = 0xFF;
2216 return DMX_FILTER_STATUS_ERROR;
2217 }
2218 #endif
2219
2220 }
2221
MApi_DMX_PvrCA_Eng_Pid_Close(DMX_PVR_ENG Eng,MS_U8 u8DmxId)2222 DMX_FILTER_STATUS MApi_DMX_PvrCA_Eng_Pid_Close(DMX_PVR_ENG Eng, MS_U8 u8DmxId)
2223 {
2224
2225 #ifdef DMX_UTOPIA_20
2226
2227 MS_U32 u32Param[4] = {0, 0, 0, 0};
2228
2229 DMX_V2DBGMSG(ULOGD("DMX", "[%s](%d, %d) %d\n", __FUNCTION__, (MS_S32)Eng, (MS_S32)u8DmxId, __LINE__));
2230
2231 if(_DMX_IOCtrlOpen() == FALSE)
2232 return DMX_FILTER_STATUS_ERROR;
2233
2234 u32Param[0] = ((MS_U32)Eng) & 0xFF;
2235 u32Param[1] = ((MS_U32)u8DmxId) & 0xFF;
2236 u32Param[2] = 1;
2237 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_PidClose,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
2238 {
2239 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2240 return DMX_FILTER_STATUS_ERROR;
2241 }
2242
2243 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
2244 return DMX_FILTER_STATUS_ERROR;
2245 else
2246 return DMX_FILTER_STATUS_OK;
2247
2248 #else
2249
2250 return _MApi_DMX_PvrCA_Eng_Pid_Close(Eng, u8DmxId);
2251
2252 #endif
2253
2254 }
2255
2256 //PVR CA API
2257 //-------------------------------------------------------------------------------------------------------------
2258 // Version 1.0
2259 // PVRCA pair function of PID filter close and open
2260 // 1. MApi_DMX_FlowSet(DMX_FLOW_PVRCA) / MApi_DMX_Pvr_Close ==> Duplicate all FLT0 to FLT1 / Close all FLT1 (PVR1FLT_NOTUSE<->PVR1FLT_CA)
2261 // 2. MApi_DMX_PvrCA_Pid_Open / MApi_DMX_PvrCA_Pid_Close ==> Reserved / Un-reserved FLT1 of record enable (PVR1FLT_CA<->PVR1FLT_CAPVR)
2262 // 3. MApi_DMX_Open / MApi_DMX_Close ==> If TS1(PVRCA enable), also allocate FIL1 or free FLT1, but if recording, not free FLT1(PVR1FLT_CA->PVR1FLT_NOTUSE)
2263 //-------------------------------------------------------------------------------------------------------------
2264 //-------------------------------------------------------------------------------------------------
2265 /// Open PVR PID filter for recording streamble stream
2266 /// @param Pid \b IN: Set the PID to record
2267 /// @param pu8DmxId \b IN: The pointer stored the PID filter index
2268 /// @return DMX_FILTER_STATUS_OK - Success
2269 /// @return DMX_FILTER_STATUS_ERROR - Failure
2270 /// @note
2271 //-------------------------------------------------------------------------------------------------
MApi_DMX_PvrCA_Pid_Open(MS_U32 Pid,MS_U8 * pu8DmxId)2272 DMX_FILTER_STATUS MApi_DMX_PvrCA_Pid_Open(MS_U32 Pid, MS_U8* pu8DmxId)
2273 {
2274 DMX_V2DBGMSG(ULOGD("DMX", "[%s](0x%08lx, 0x%p) %d\n", __FUNCTION__, Pid, pu8DmxId, __LINE__));
2275
2276 #if(defined(TSP_VERSION) && ((TSP_VERSION == TSP_VER_1_0) || (TSP_VERSION == TSP_VER_3_0)))
2277 return (MApi_DMX_PvrCA_Eng_Pid_Open(DMX_PVR_EGN0, Pid, pu8DmxId, 0));
2278 #else
2279 return (MApi_DMX_Pvr_Pid_Open(Pid, pu8DmxId));
2280 #endif
2281 }
2282
2283 //do nothing, before close path switch to TS1
2284 //-------------------------------------------------------------------------------------------------
2285 /// Close PVR PID filter for recording streamble stream
2286 /// @param Pid \b IN: Set the PID to record
2287 /// @return DMX_FILTER_STATUS_OK - Success
2288 /// @return DMX_FILTER_STATUS_ERROR - Failure
2289 /// @note
2290 //-------------------------------------------------------------------------------------------------
MApi_DMX_PvrCA_Pid_Close(MS_U8 u8DmxId)2291 DMX_FILTER_STATUS MApi_DMX_PvrCA_Pid_Close(MS_U8 u8DmxId)
2292 {
2293 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2294
2295 #if(defined(TSP_VERSION) && ((TSP_VERSION == TSP_VER_1_0) || (TSP_VERSION == TSP_VER_3_0)))
2296 return (MApi_DMX_PvrCA_Eng_Pid_Close(DMX_PVR_EGN0, u8DmxId));
2297 #else
2298 return (MApi_DMX_Pvr_Pid_Close(u8DmxId));
2299 #endif
2300 }
2301
2302 //-------------------------------------------------------------------------------------------------
2303 /// Start to record scramble stream
2304 /// @param bPvrAll \b IN: If TRUE, recording all stream data; if false, recording stream data by PIDs
2305 /// @return DMX_FILTER_STATUS_OK - Success
2306 /// @return DMX_FILTER_STATUS_ERROR - Failure
2307 /// @note
2308 //-------------------------------------------------------------------------------------------------
MApi_DMX_PvrCA_Start(MS_BOOL bPvrAll)2309 DMX_FILTER_STATUS MApi_DMX_PvrCA_Start(MS_BOOL bPvrAll)
2310 {
2311 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2312
2313 #if(defined(TSP_VERSION) && ((TSP_VERSION == TSP_VER_1_0) || (TSP_VERSION == TSP_VER_3_0)))
2314 return (MApi_DMX_PvrCA_Eng_Start(DMX_PVR_EGN0, bPvrAll));
2315 #else
2316 return (MApi_DMX_Pvr_Start(bPvrAll));
2317 #endif
2318 }
2319
2320 //-------------------------------------------------------------------------------------------------
2321 /// Stop to record scramble stream
2322 /// @return DMX_FILTER_STATUS_OK - Success
2323 /// @return DMX_FILTER_STATUS_ERROR - Failure
2324 /// @note
2325 //-------------------------------------------------------------------------------------------------
MApi_DMX_PvrCA_Stop(void)2326 DMX_FILTER_STATUS MApi_DMX_PvrCA_Stop(void)
2327 {
2328 DMX_V2DBGMSG( ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2329
2330 #if(defined(TSP_VERSION) && ((TSP_VERSION == TSP_VER_1_0) || (TSP_VERSION == TSP_VER_3_0)))
2331 return (MApi_DMX_PvrCA_Eng_Stop(DMX_PVR_EGN0));
2332 #else
2333 return (MApi_DMX_Pvr_Stop());
2334 #endif
2335 }
2336
2337
MApi_DMX_PvrCA_Eng_Start(DMX_PVR_ENG Eng,MS_BOOL bPvrAll)2338 DMX_FILTER_STATUS MApi_DMX_PvrCA_Eng_Start(DMX_PVR_ENG Eng, MS_BOOL bPvrAll)
2339 {
2340 #ifdef DMX_UTOPIA_20
2341
2342 MS_U32 u32Param[4] = {0, 0, 0, 0};
2343
2344 DMX_V2DBGMSG(ULOGD("DMX", "[%s](%d, %d) %d\n", __FUNCTION__, (MS_S32)Eng, (MS_S32)bPvrAll, __LINE__));
2345
2346 if(_DMX_IOCtrlOpen() == FALSE)
2347 return DMX_FILTER_STATUS_ERROR;
2348
2349 u32Param[0] = ((MS_U32)Eng) & 0xFF;
2350 u32Param[1] = ((MS_U32)bPvrAll) & 0xFF;
2351 u32Param[2] = 1;
2352 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Start,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
2353 {
2354 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2355 return DMX_FILTER_STATUS_ERROR;
2356 }
2357
2358 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
2359 return DMX_FILTER_STATUS_ERROR;
2360 else
2361 return DMX_FILTER_STATUS_OK;
2362
2363 #else
2364
2365 return _MApi_DMX_PvrCA_Eng_Start(Eng, bPvrAll);
2366
2367 #endif
2368
2369 }
2370
MApi_DMX_PvrCA_Eng_Stop(DMX_PVR_ENG Eng)2371 DMX_FILTER_STATUS MApi_DMX_PvrCA_Eng_Stop(DMX_PVR_ENG Eng)
2372 {
2373 #ifdef DMX_UTOPIA_20
2374
2375 MS_U32 u32Param[3] = {0, 0, 0};
2376
2377 DMX_V2DBGMSG(ULOGD("DMX", "[%s](%d) %d\n", __FUNCTION__, (MS_S32)Eng, __LINE__));
2378
2379 if(_DMX_IOCtrlOpen() == FALSE)
2380 return DMX_FILTER_STATUS_ERROR;
2381
2382 u32Param[0] = ((MS_U32)Eng) & 0xFF;
2383 u32Param[1] = 1;
2384 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Stop,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
2385 {
2386 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2387 return DMX_FILTER_STATUS_ERROR;
2388 }
2389
2390 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2391 return DMX_FILTER_STATUS_ERROR;
2392 else
2393 return DMX_FILTER_STATUS_OK;
2394
2395 #else
2396
2397 return _MApi_DMX_PvrCA_Eng_Stop(Eng);
2398
2399 #endif
2400
2401 }
2402
MApi_DMX_Filein_Info(DMX_Filein_info * pFileinInfo)2403 DMX_FILTER_STATUS MApi_DMX_Filein_Info(DMX_Filein_info *pFileinInfo)
2404 {
2405
2406 #ifdef DMX_UTOPIA_20
2407
2408 DMX_FILE_INFO_PARAM FiInfoParam;
2409
2410 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2411
2412 if(_DMX_IOCtrlOpen() == FALSE)
2413 return DMX_FILTER_STATUS_ERROR;
2414
2415 FiInfoParam.u32EngId = 0;
2416 FiInfoParam.pFileinInfo = pFileinInfo;
2417 FiInfoParam.u32Res = 0;
2418 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Info,(void*)&FiInfoParam) != UTOPIA_STATUS_SUCCESS)
2419 {
2420 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2421 return DMX_FILTER_STATUS_ERROR;
2422 }
2423
2424 if(FiInfoParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
2425 return DMX_FILTER_STATUS_ERROR;
2426 else
2427 return DMX_FILTER_STATUS_OK;
2428 #else
2429
2430 return _MApi_DMX_Filein_Info(pFileinInfo);
2431
2432 #endif
2433
2434 }
2435
MApi_DMX_Filein_Eng_Info(DMX_FILEIN_PATH ePath,DMX_Filein_info * pFileinInfo)2436 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_Info(DMX_FILEIN_PATH ePath, DMX_Filein_info *pFileinInfo)
2437 {
2438
2439 #ifdef DMX_UTOPIA_20
2440
2441 DMX_FILE_INFO_PARAM FiInfoParam;
2442
2443 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2444
2445 if(_DMX_IOCtrlOpen() == FALSE)
2446 return DMX_FILTER_STATUS_ERROR;
2447
2448 FiInfoParam.u32EngId = (MS_U32)ePath;
2449 FiInfoParam.pFileinInfo = pFileinInfo;
2450 FiInfoParam.u32Res = 0;
2451 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Eng_Info,(void*)&FiInfoParam) != UTOPIA_STATUS_SUCCESS)
2452 {
2453 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2454 return DMX_FILTER_STATUS_ERROR;
2455 }
2456
2457 if(FiInfoParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
2458 return DMX_FILTER_STATUS_ERROR;
2459 else
2460 return DMX_FILTER_STATUS_OK;
2461
2462 #else
2463
2464 return _MApi_DMX_Filein_Eng_Info(ePath, pFileinInfo);
2465
2466 #endif
2467
2468 }
2469
MApi_DMX_Filein_Start(DMX_FILEIN_DST Dst,MS_PHY pBuf,MS_U32 u32BufSize)2470 DMX_FILTER_STATUS MApi_DMX_Filein_Start(DMX_FILEIN_DST Dst, MS_PHY pBuf, MS_U32 u32BufSize)
2471 {
2472
2473 #ifdef DMX_UTOPIA_20
2474
2475 DMX_FILE_START_PARAM FiStartParam;
2476
2477 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2478
2479 if(_DMX_IOCtrlOpen() == FALSE)
2480 return DMX_FILTER_STATUS_ERROR;
2481
2482 FiStartParam.u32EngId = 0;
2483 FiStartParam.Dst = Dst;
2484 FiStartParam.pBuf = pBuf;
2485 FiStartParam.u32BufSize = u32BufSize;
2486 FiStartParam.u32Res = 0;
2487 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Start,(void*)&FiStartParam) != UTOPIA_STATUS_SUCCESS)
2488 {
2489 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2490 return DMX_FILTER_STATUS_ERROR;
2491 }
2492
2493 if(FiStartParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
2494 return DMX_FILTER_STATUS_ERROR;
2495 else
2496 return DMX_FILTER_STATUS_OK;
2497
2498 #else
2499
2500 return _MApi_DMX_Filein_Start(Dst, pBuf, u32BufSize);
2501
2502 #endif
2503
2504 }
2505
MApi_DMX_Filein_Eng_Start(DMX_FILEIN_PATH ePath,DMX_FILEIN_DST Dst,MS_PHY pBuf,MS_U32 u32BufSize)2506 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_Start(DMX_FILEIN_PATH ePath, DMX_FILEIN_DST Dst, MS_PHY pBuf, MS_U32 u32BufSize)
2507 {
2508 #ifdef DMX_UTOPIA_20
2509
2510 DMX_FILE_START_PARAM FiStartParam;
2511
2512 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2513
2514 if(_DMX_IOCtrlOpen() == FALSE)
2515 return DMX_FILTER_STATUS_ERROR;
2516
2517 FiStartParam.u32EngId = (MS_U32)ePath;
2518 FiStartParam.Dst = Dst;
2519 FiStartParam.pBuf = pBuf;
2520 FiStartParam.u32BufSize = u32BufSize;
2521 FiStartParam.u32Res = 0;
2522 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Start,(void*)&FiStartParam) != UTOPIA_STATUS_SUCCESS)
2523 {
2524 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2525 return DMX_FILTER_STATUS_ERROR;
2526 }
2527
2528 if(FiStartParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
2529 return DMX_FILTER_STATUS_ERROR;
2530 else
2531 return DMX_FILTER_STATUS_OK;
2532
2533 #else
2534
2535 return _MApi_DMX_Filein_Eng_Start(ePath, Dst, pBuf, u32BufSize);
2536
2537 #endif
2538
2539 }
2540
2541
MApi_DMX_Filein_Stop(void)2542 DMX_FILTER_STATUS MApi_DMX_Filein_Stop(void)
2543 {
2544
2545 #ifdef DMX_UTOPIA_20
2546
2547 MS_U32 u32param[2] = {0, 0};
2548
2549 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2550
2551 if(_DMX_IOCtrlOpen() == FALSE)
2552 return DMX_FILTER_STATUS_ERROR;
2553
2554 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Stop,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2555 {
2556 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2557 return DMX_FILTER_STATUS_ERROR;
2558 }
2559
2560 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2561 return DMX_FILTER_STATUS_ERROR;
2562 else
2563 return DMX_FILTER_STATUS_OK;
2564
2565 #else
2566
2567 return _MApi_DMX_Filein_Stop();
2568
2569 #endif
2570
2571 }
2572
MApi_DMX_Filein_Eng_Stop(DMX_FILEIN_PATH ePath)2573 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_Stop(DMX_FILEIN_PATH ePath)
2574 {
2575
2576 #ifdef DMX_UTOPIA_20
2577
2578 MS_U32 u32param[2] = {0, 0};
2579
2580 u32param[0] = (MS_U32)ePath;
2581
2582 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2583
2584 if(_DMX_IOCtrlOpen() == FALSE)
2585 return DMX_FILTER_STATUS_ERROR;
2586
2587 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Stop,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2588 {
2589 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2590 return DMX_FILTER_STATUS_ERROR;
2591 }
2592
2593 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2594 return DMX_FILTER_STATUS_ERROR;
2595 else
2596 return DMX_FILTER_STATUS_OK;
2597
2598 #else
2599
2600 return _MApi_DMX_Filein_Eng_Stop(ePath);
2601
2602 #endif
2603
2604 }
2605
MApi_DMX_Filein_Pause(void)2606 DMX_FILTER_STATUS MApi_DMX_Filein_Pause(void)
2607 {
2608
2609 #ifdef DMX_UTOPIA_20
2610
2611 MS_U32 u32param[2] = {0, 0};
2612
2613 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2614
2615 if(_DMX_IOCtrlOpen() == FALSE)
2616 return DMX_FILTER_STATUS_ERROR;
2617
2618 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Pause,(void*)&u32param) != UTOPIA_STATUS_SUCCESS)
2619 {
2620 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2621 return DMX_FILTER_STATUS_ERROR;
2622 }
2623
2624 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2625 return DMX_FILTER_STATUS_ERROR;
2626 else
2627 return DMX_FILTER_STATUS_OK;
2628 #else
2629
2630 return _MApi_DMX_Filein_Pause();
2631
2632 #endif
2633
2634 }
2635
MApi_DMX_Filein_Eng_Pause(DMX_FILEIN_PATH ePath)2636 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_Pause(DMX_FILEIN_PATH ePath)
2637 {
2638
2639 #ifdef DMX_UTOPIA_20
2640
2641 MS_U32 u32param[2] = {0, 0};
2642
2643 u32param[0] = (MS_U32)ePath;
2644
2645 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2646
2647 if(_DMX_IOCtrlOpen() == FALSE)
2648 return DMX_FILTER_STATUS_ERROR;
2649
2650 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Pause,(void*)&u32param) != UTOPIA_STATUS_SUCCESS)
2651 {
2652 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2653 return DMX_FILTER_STATUS_ERROR;
2654 }
2655
2656 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2657 return DMX_FILTER_STATUS_ERROR;
2658 else
2659 return DMX_FILTER_STATUS_OK;
2660
2661 #else
2662
2663 return _MApi_DMX_Filein_Eng_Pause(ePath);
2664
2665 #endif
2666
2667 }
2668
2669
MApi_DMX_Filein_Resume(void)2670 DMX_FILTER_STATUS MApi_DMX_Filein_Resume(void)
2671 {
2672
2673 #ifdef DMX_UTOPIA_20
2674
2675 MS_U32 u32param[2] = {0, 0};
2676
2677 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2678
2679 if(_DMX_IOCtrlOpen() == FALSE)
2680 return DMX_FILTER_STATUS_ERROR;
2681
2682 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Resume,(void*)&u32param) != UTOPIA_STATUS_SUCCESS)
2683 {
2684 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2685 return DMX_FILTER_STATUS_ERROR;
2686 }
2687
2688 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2689 return DMX_FILTER_STATUS_ERROR;
2690 else
2691 return DMX_FILTER_STATUS_OK;
2692 #else
2693
2694 return _MApi_DMX_Filein_Resume();
2695
2696 #endif
2697
2698 }
2699
MApi_DMX_Filein_Eng_Resume(DMX_FILEIN_PATH ePath)2700 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_Resume(DMX_FILEIN_PATH ePath)
2701 {
2702
2703 #ifdef DMX_UTOPIA_20
2704
2705 MS_U32 u32param[2] = {0, 0};
2706
2707 u32param[0] = (MS_U32)ePath;
2708
2709 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2710
2711 if(_DMX_IOCtrlOpen() == FALSE)
2712 return DMX_FILTER_STATUS_ERROR;
2713
2714 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_Resume,(void*)&u32param) != UTOPIA_STATUS_SUCCESS)
2715 {
2716 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2717 return DMX_FILTER_STATUS_ERROR;
2718 }
2719
2720 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2721 return DMX_FILTER_STATUS_ERROR;
2722 else
2723 return DMX_FILTER_STATUS_OK;
2724
2725 #else
2726
2727 return _MApi_DMX_Filein_Eng_Resume(ePath);
2728
2729 #endif
2730
2731 }
2732
MApi_DMX_Filein_CMDQ_Reset(void)2733 DMX_FILTER_STATUS MApi_DMX_Filein_CMDQ_Reset(void)
2734 {
2735
2736 #ifdef DMX_UTOPIA_20
2737
2738 MS_U32 u32param[2] = {0, 0};
2739
2740 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2741
2742 if(_DMX_IOCtrlOpen() == FALSE)
2743 return DMX_FILTER_STATUS_ERROR;
2744
2745 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_CmdQReset,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2746 {
2747 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2748 return DMX_FILTER_STATUS_ERROR;
2749 }
2750
2751 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2752 return DMX_FILTER_STATUS_ERROR;
2753 else
2754 return DMX_FILTER_STATUS_OK;
2755
2756 #else
2757
2758 return _MApi_DMX_Filein_CMDQ_Reset();
2759
2760 #endif
2761
2762 }
2763
MApi_DMX_Filein_Eng_CMDQ_Reset(DMX_FILEIN_PATH ePath)2764 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_CMDQ_Reset(DMX_FILEIN_PATH ePath)
2765 {
2766
2767 #ifdef DMX_UTOPIA_20
2768
2769 MS_U32 u32param[2] = {0, 0};
2770
2771 u32param[0] = (MS_U32)ePath;
2772
2773 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2774
2775 if(_DMX_IOCtrlOpen() == FALSE)
2776 return DMX_FILTER_STATUS_ERROR;
2777
2778 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_CmdQReset,(void*)&u32param) != UTOPIA_STATUS_SUCCESS)
2779 {
2780 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2781 return DMX_FILTER_STATUS_ERROR;
2782 }
2783
2784 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
2785 return DMX_FILTER_STATUS_ERROR;
2786 else
2787 return DMX_FILTER_STATUS_OK;
2788
2789 #else
2790
2791 return _MApi_DMX_Filein_Eng_CMDQ_Reset(ePath);
2792
2793 #endif
2794
2795 }
2796
MApi_DMX_Filein_CMDQ_GetEmptyNum(MS_U32 * pu32EmptySlot)2797 DMX_FILTER_STATUS MApi_DMX_Filein_CMDQ_GetEmptyNum(MS_U32 *pu32EmptySlot)
2798 {
2799
2800 #ifdef DMX_UTOPIA_20
2801
2802 MS_U32 u32param[3] = {0, 0, 0};
2803
2804 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2805
2806 *pu32EmptySlot = 0;
2807
2808 if(_DMX_IOCtrlOpen() == FALSE)
2809 return DMX_FILTER_STATUS_ERROR;
2810
2811 u32param[0] = 0;
2812 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_CmdQGetEmptyNum,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2813 {
2814 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2815 return DMX_FILTER_STATUS_ERROR;
2816 }
2817
2818 *pu32EmptySlot = u32param[1];
2819
2820 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2821 return DMX_FILTER_STATUS_ERROR;
2822 else
2823 return DMX_FILTER_STATUS_OK;
2824
2825 #else
2826
2827 return _MApi_DMX_Filein_CMDQ_GetEmptyNum(pu32EmptySlot);
2828
2829 #endif
2830
2831 }
2832
MApi_DMX_Filein_Eng_CMDQ_GetEmptyNum(DMX_FILEIN_PATH ePath,MS_U32 * pu32EmptySlot)2833 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_CMDQ_GetEmptyNum(DMX_FILEIN_PATH ePath, MS_U32 *pu32EmptySlot)
2834 {
2835
2836 #ifdef DMX_UTOPIA_20
2837
2838 MS_U32 u32param[3] = {0, 0, 0};
2839
2840 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2841
2842 *pu32EmptySlot = 0;
2843
2844 if(_DMX_IOCtrlOpen() == FALSE)
2845 return DMX_FILTER_STATUS_ERROR;
2846
2847 u32param[0] = (MS_U32)ePath;
2848 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_CmdQGetEmptyNum,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2849 {
2850 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2851 return DMX_FILTER_STATUS_ERROR;
2852 }
2853
2854 *pu32EmptySlot = u32param[1];
2855
2856 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2857 return DMX_FILTER_STATUS_ERROR;
2858 else
2859 return DMX_FILTER_STATUS_OK;
2860
2861 #else
2862
2863 return _MApi_DMX_Filein_Eng_CMDQ_GetEmptyNum(ePath, pu32EmptySlot);
2864
2865 #endif
2866
2867 }
2868
MApi_DMX_Filein_CMDQ_FIFOWriteLevel(MS_U8 * pu8CmdQStatus)2869 DMX_FILTER_STATUS MApi_DMX_Filein_CMDQ_FIFOWriteLevel(MS_U8 *pu8CmdQStatus)
2870 {
2871
2872 #ifdef DMX_UTOPIA_20
2873
2874 MS_U32 u32param[3] = {0, 0, 0};
2875
2876 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2877
2878 *pu8CmdQStatus = 0;
2879
2880 if(_DMX_IOCtrlOpen() == FALSE)
2881 return DMX_FILTER_STATUS_ERROR;
2882
2883 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_CmdQGetFifoLevel,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2884 {
2885 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2886 return DMX_FILTER_STATUS_ERROR;
2887 }
2888
2889 *pu8CmdQStatus = (MS_U8)(u32param[1]);
2890
2891 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2892 return DMX_FILTER_STATUS_ERROR;
2893 else
2894 return DMX_FILTER_STATUS_OK;
2895
2896 #else
2897
2898 return _MApi_DMX_Filein_CMDQ_FIFOWriteLevel(pu8CmdQStatus);
2899
2900 #endif
2901
2902 }
2903
MApi_DMX_Filein_Eng_CMDQ_FIFOWriteLevel(DMX_FILEIN_PATH ePath,MS_U8 * pu8CmdQStatus)2904 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_CMDQ_FIFOWriteLevel(DMX_FILEIN_PATH ePath, MS_U8 *pu8CmdQStatus)
2905 {
2906
2907 #ifdef DMX_UTOPIA_20
2908
2909 MS_U32 u32param[3] = {0, 0, 0};
2910
2911 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2912
2913 *pu8CmdQStatus = 0;
2914
2915 u32param[0] = (MS_U32)ePath;
2916 if(_DMX_IOCtrlOpen() == FALSE)
2917 return DMX_FILTER_STATUS_ERROR;
2918
2919 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_CmdQGetFifoLevel,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2920 {
2921 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2922 return DMX_FILTER_STATUS_ERROR;
2923 }
2924
2925 *pu8CmdQStatus = (MS_U8)(u32param[1]);
2926
2927 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
2928 return DMX_FILTER_STATUS_ERROR;
2929 else
2930 return DMX_FILTER_STATUS_OK;
2931
2932 #else
2933
2934 return _MApi_DMX_Filein_Eng_CMDQ_FIFOWriteLevel(ePath, pu8CmdQStatus);
2935
2936 #endif
2937
2938 }
2939
MApi_DMX_Filein_IsIdle(void)2940 MS_BOOL MApi_DMX_Filein_IsIdle(void)
2941 {
2942
2943 #ifdef DMX_UTOPIA_20
2944
2945 MS_U32 u32param[2] = {0, 0};
2946
2947 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2948
2949 if(_DMX_IOCtrlOpen() == FALSE)
2950 return FALSE;
2951
2952 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_IsIdle,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2953 {
2954 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2955 return FALSE;
2956 }
2957
2958 return ((MS_BOOL)u32param[1]);
2959
2960 #else
2961
2962 return _MApi_DMX_Filein_IsIdle();
2963
2964 #endif
2965
2966 }
2967
MApi_DMX_Filein_Eng_IsIdle(DMX_FILEIN_PATH ePath)2968 MS_BOOL MApi_DMX_Filein_Eng_IsIdle(DMX_FILEIN_PATH ePath)
2969 {
2970
2971 #ifdef DMX_UTOPIA_20
2972
2973 MS_U32 u32param[2] = {0, 0};
2974
2975 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
2976
2977 if(_DMX_IOCtrlOpen() == FALSE)
2978 return FALSE;
2979
2980 u32param[0] = (MS_U32)ePath;
2981 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_IsIdle,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
2982 {
2983 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
2984 return FALSE;
2985 }
2986
2987 return ((MS_BOOL)u32param[1]);
2988
2989 #else
2990
2991 return _MApi_DMX_Filein_Eng_IsIdle(ePath);
2992
2993 #endif
2994
2995 }
2996
2997
MApi_DMX_Filein_IsBusy(void)2998 MS_BOOL MApi_DMX_Filein_IsBusy(void)
2999 {
3000
3001 #ifdef DMX_UTOPIA_20
3002
3003 MS_U32 u32param[2] = {0, 0};
3004
3005 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3006
3007 if(_DMX_IOCtrlOpen() == FALSE)
3008 return FALSE;
3009
3010 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_IsBusy,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3011 {
3012 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3013 return FALSE;
3014 }
3015
3016 return ((MS_BOOL)u32param[1]);
3017
3018 #else
3019
3020 return _MApi_DMX_Filein_IsBusy();
3021
3022 #endif
3023
3024 }
3025
MApi_DMX_Filein_Eng_IsBusy(DMX_FILEIN_PATH ePath)3026 MS_BOOL MApi_DMX_Filein_Eng_IsBusy(DMX_FILEIN_PATH ePath)
3027 {
3028
3029 #ifdef DMX_UTOPIA_20
3030
3031 MS_U32 u32param[2] = {0, 0};
3032
3033 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3034
3035 if(_DMX_IOCtrlOpen() == FALSE)
3036 return FALSE;
3037
3038 u32param[0] = (MS_U32)ePath;
3039 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_IsBusy,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3040 {
3041 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3042 return FALSE;
3043 }
3044
3045 return ((MS_BOOL)u32param[1]);
3046
3047 #else
3048
3049 return _MApi_DMX_Filein_Eng_IsBusy(ePath);
3050
3051 #endif
3052
3053 }
3054
MApi_DMX_Filein_IsPause(void)3055 MS_BOOL MApi_DMX_Filein_IsPause(void)
3056 {
3057
3058 #ifdef DMX_UTOPIA_20
3059
3060 MS_U32 u32param[2] = {0, 0};
3061
3062 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3063
3064 if(_DMX_IOCtrlOpen() == FALSE)
3065 return FALSE;
3066
3067 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_IsPause,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3068 {
3069 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3070 return FALSE;
3071 }
3072
3073 return ((MS_BOOL)u32param[1]);
3074
3075 #else
3076
3077 return _MApi_DMX_Filein_IsPause();
3078
3079 #endif
3080
3081 }
3082
MApi_DMX_Filein_Eng_IsPause(DMX_FILEIN_PATH ePath)3083 MS_BOOL MApi_DMX_Filein_Eng_IsPause(DMX_FILEIN_PATH ePath)
3084 {
3085
3086 #ifdef DMX_UTOPIA_20
3087
3088 MS_U32 u32param[2] = {0, 0};
3089
3090 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3091
3092 if(_DMX_IOCtrlOpen() == FALSE)
3093 return FALSE;
3094
3095 u32param[0] = (MS_U32)ePath;
3096 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_IsPause,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3097 {
3098 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3099 return FALSE;
3100 }
3101
3102 return ((MS_BOOL)u32param[1]);
3103
3104 #else
3105
3106 return _MApi_DMX_Filein_Eng_IsPause(ePath);
3107
3108 #endif
3109
3110 }
3111
MApi_DMX_Open_MultiFlt(DMX_FILTER_TYPE DmxFltType,MS_U8 * pu8DmxId,MS_U8 u8TargetDmxId)3112 DMX_FILTER_STATUS MApi_DMX_Open_MultiFlt(DMX_FILTER_TYPE DmxFltType , MS_U8* pu8DmxId, MS_U8 u8TargetDmxId)
3113 {
3114 #ifdef DMX_UTOPIA_20
3115
3116 MS_U32 u32param[4] = {0, 0, 0, 0};
3117
3118 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3119
3120 *pu8DmxId = 0;
3121
3122 if(_DMX_IOCtrlOpen() == FALSE)
3123 return FALSE;
3124
3125 u32param[0] = (MS_U32)DmxFltType;
3126 u32param[2] = ((MS_U32)u8TargetDmxId) & 0xFF;
3127 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Open_MultiFlt,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3128 {
3129 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3130 return DMX_FILTER_STATUS_ERROR;
3131 }
3132
3133 *pu8DmxId = (MS_U8)u32param[1];
3134
3135 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3136 return DMX_FILTER_STATUS_ERROR;
3137 else
3138 return DMX_FILTER_STATUS_OK;
3139
3140 #else
3141
3142 return _MApi_DMX_Open_MultiFlt(DmxFltType, pu8DmxId, u8TargetDmxId);
3143
3144 #endif
3145
3146 }
3147
3148 //-------------------------------------------------------------------------------------------------
3149 /// Get STC counter
3150 /// @param pu32Stc32 \b OUT: STC counter (bit 32)
3151 /// @param pu32Stc \b OUT: STC counter (bit 31 to bit 0)
3152 /// @return DMX_FILTER_STATUS_OK - Success
3153 /// @return DMX_FILTER_STATUS_ERROR - Failure
3154 /// @note
3155 //-------------------------------------------------------------------------------------------------
MApi_DMX_Stc_Get(MS_U32 * pu32Stc32,MS_U32 * pu32Stc)3156 DMX_FILTER_STATUS MApi_DMX_Stc_Get(MS_U32* pu32Stc32, MS_U32* pu32Stc)
3157 {
3158 return MApi_DMX_Stc_Eng_Get(0, pu32Stc32, pu32Stc);
3159 }
3160
3161 //-------------------------------------------------------------------------------------------------
3162 /// Allocate DMX resource
3163 /// @param eResType \b IN: Resource type to allocate
3164 /// @param pRes \b OUT: Pointer to store resource content
3165 /// @return DMX_FILTER_STATUS_OK - Success
3166 /// @return DMX_FILTER_STATUS_ERROR - Failure
3167 /// @note
3168 /// Please use below resource content for the such resource item
3169 /// DMX_RES_STC_ENG: MS_U32 u32STCEng
3170 //-------------------------------------------------------------------------------------------------
MApi_DMX_ResAllocate(DMX_RES_TYPE eResType,void * pRes)3171 DMX_FILTER_STATUS MApi_DMX_ResAllocate(DMX_RES_TYPE eResType, void *pRes)
3172 {
3173 #ifdef DMX_UTOPIA_20
3174
3175 MS_U32 u32param[3] = {0, 0, 0};
3176
3177 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
3178
3179 if(_DMX_IOCtrlOpen() == FALSE)
3180 return DMX_FILTER_STATUS_ERROR;
3181
3182 u32param[0] = (MS_U32)eResType;
3183
3184 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_RES_ALLOC,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3185 {
3186 DMX_V2DBGMSG(printf("[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3187 return DMX_FILTER_STATUS_ERROR;
3188 }
3189
3190 *((MS_U32*)pRes) = u32param[1];
3191 return (DMX_FILTER_STATUS)u32param[2];
3192 #else
3193 return _MApi_DMX_ResAllocate(eResType,pRes);
3194 #endif
3195 }
3196
3197 //-------------------------------------------------------------------------------------------------
3198 /// Free DMX resource
3199 /// @param eResType \b IN: Resource type to free
3200 /// @param pRes \b IN: Pointer to store resource content
3201 /// @return DMX_FILTER_STATUS_OK - Success
3202 /// @return DMX_FILTER_STATUS_ERROR - Failure
3203 /// @note
3204 /// Please use below resource content for the such resource item
3205 /// DMX_RES_STC_ENG: MS_U32 u32STCEng
3206 //-------------------------------------------------------------------------------------------------
MApi_DMX_ResFree(DMX_RES_TYPE eResType,void * pRes)3207 DMX_FILTER_STATUS MApi_DMX_ResFree(DMX_RES_TYPE eResType, void *pRes)
3208 {
3209 #ifdef DMX_UTOPIA_20
3210
3211 MS_U32 u32param[3] = {0, 0, 0};
3212
3213 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
3214
3215 if(_DMX_IOCtrlOpen() == FALSE)
3216 return DMX_FILTER_STATUS_ERROR;
3217
3218 u32param[0] = (MS_U32)eResType;
3219 u32param[1] = *((MS_U32*)pRes);
3220
3221 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_RES_FREE,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3222 {
3223 DMX_V2DBGMSG(printf("[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3224 return DMX_FILTER_STATUS_ERROR;
3225 }
3226
3227 return (DMX_FILTER_STATUS)u32param[2];
3228 #else
3229
3230 return _MApi_DMX_ResFree(eResType,pRes);
3231
3232 #endif
3233
3234
3235 }
3236
3237 //-------------------------------------------------------------------------------------------------
3238 /// Get STC engine which PCR PID index mapping to
3239 /// @param PcrFltId \b IN: PCR PID index
3240 /// @param u32StcEng \b OUT: STC engine id
3241 /// @return DMX_FILTER_STATUS_OK - Success
3242 /// @return DMX_FILTER_STATUS_ERROR - Failure
3243 /// @note
3244 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pcr_Get_MapSTC(MS_U32 u32PcrFltId,MS_U32 * pu32StcEng)3245 DMX_FILTER_STATUS MApi_DMX_Pcr_Get_MapSTC(MS_U32 u32PcrFltId, MS_U32 *pu32StcEng)
3246 {
3247 #ifdef DMX_UTOPIA_20
3248
3249 MS_U32 u32param[3] = {0, 0, 0};
3250
3251 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
3252
3253 if(_DMX_IOCtrlOpen() == FALSE)
3254 return DMX_FILTER_STATUS_ERROR;
3255
3256 u32param[0] = u32PcrFltId;
3257
3258 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_PCR_GET_MAP_STC,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3259 {
3260 DMX_V2DBGMSG(printf("[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3261 return DMX_FILTER_STATUS_ERROR;
3262 }
3263
3264 *pu32StcEng = u32param[1];
3265
3266 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
3267 return DMX_FILTER_STATUS_ERROR;
3268 else
3269 return DMX_FILTER_STATUS_OK;
3270 #else
3271
3272 return _MApi_DMX_Pcr_Get_MapSTC(u32PcrFltId, pu32StcEng);
3273
3274 #endif
3275 }
3276
3277 //-------------------------------------------------------------------------------------------------
3278 /// Set STC counter
3279 /// @param u32Stc32 \b IN: STC counter (bit 32)
3280 /// @param u32Stc \b IN: STC counter (bit 31 to bit 0)
3281 /// @return DMX_FILTER_STATUS_OK - Success
3282 /// @return DMX_FILTER_STATUS_ERROR - Failure
3283 /// @note
3284 //-------------------------------------------------------------------------------------------------
MApi_DMX_Stc_Set(MS_U32 u32Stc32,MS_U32 u32Stc)3285 DMX_FILTER_STATUS MApi_DMX_Stc_Set(MS_U32 u32Stc32, MS_U32 u32Stc)
3286 {
3287 return MApi_DMX_Stc_Eng_Set(0, u32Stc32, u32Stc);
3288 }
3289
MApi_DMX_Stc_Eng_Get(MS_U8 u8Eng,MS_U32 * pu32Stc32,MS_U32 * pu32Stc)3290 DMX_FILTER_STATUS MApi_DMX_Stc_Eng_Get(MS_U8 u8Eng, MS_U32* pu32Stc32, MS_U32* pu32Stc)
3291 {
3292
3293 #ifdef DMX_UTOPIA_20
3294
3295 MS_U32 u32param[4] = {0, 0, 0, 0};
3296
3297 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3298
3299 *pu32Stc32 = 0;
3300 *pu32Stc = 0;
3301
3302 if(_DMX_IOCtrlOpen() == FALSE)
3303 return DMX_FILTER_STATUS_ERROR;
3304
3305 u32param[0] = ((MS_U32)u8Eng) & 0xFF;
3306 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Stc_Get,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3307 {
3308 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3309 return DMX_FILTER_STATUS_ERROR;
3310 }
3311
3312 *pu32Stc32 = u32param[1];
3313 *pu32Stc = u32param[2];
3314
3315 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3316 return DMX_FILTER_STATUS_ERROR;
3317 else
3318 return DMX_FILTER_STATUS_OK;
3319 #else
3320
3321 return _MApi_DMX_Stc_Eng_Get(u8Eng, pu32Stc32, pu32Stc);
3322
3323 #endif
3324
3325 }
3326
MApi_DMX_Stc_Eng_Set(MS_U8 u8Eng,MS_U32 u32Stc32,MS_U32 u32Stc)3327 DMX_FILTER_STATUS MApi_DMX_Stc_Eng_Set(MS_U8 u8Eng, MS_U32 u32Stc32, MS_U32 u32Stc)
3328 {
3329
3330 #ifdef DMX_UTOPIA_20
3331
3332 MS_U32 u32param[4] = {0, 0, 0, 0};
3333
3334 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3335
3336 if(_DMX_IOCtrlOpen() == FALSE)
3337 return DMX_FILTER_STATUS_ERROR;
3338
3339 u32param[0] = ((MS_U32)u8Eng) & 0xFF;
3340 u32param[1] = u32Stc32;
3341 u32param[2] = u32Stc;
3342 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Stc_Set,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3343 {
3344 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3345 return DMX_FILTER_STATUS_ERROR;
3346 }
3347
3348 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3349 return DMX_FILTER_STATUS_ERROR;
3350 else
3351 return DMX_FILTER_STATUS_OK;
3352
3353 #else
3354
3355 return _MApi_DMX_Stc_Eng_Set(u8Eng, u32Stc32, u32Stc);
3356
3357 #endif
3358
3359 }
3360
MApi_DMX_STC_UpdateCtrl(MS_U8 u8Eng,eStcUpdateCtrlMode eMode)3361 DMX_FILTER_STATUS MApi_DMX_STC_UpdateCtrl(MS_U8 u8Eng, eStcUpdateCtrlMode eMode)
3362 {
3363
3364 #ifdef DMX_UTOPIA_20
3365
3366 MS_U32 u32param[3] = {0, 0, 0};
3367
3368 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3369
3370 if(_DMX_IOCtrlOpen() == FALSE)
3371 return DMX_FILTER_STATUS_ERROR;
3372
3373 u32param[0] = ((MS_U32)u8Eng) & 0xFF;
3374 u32param[1] = ((MS_U32)eMode) & 0xFF;
3375 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Stc_UpdateCtrl,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3376 {
3377 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3378 return DMX_FILTER_STATUS_ERROR;
3379 }
3380
3381 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
3382 return DMX_FILTER_STATUS_ERROR;
3383 else
3384 return DMX_FILTER_STATUS_OK;
3385
3386 #else
3387
3388 return _MApi_DMX_STC_UpdateCtrl(u8Eng, eMode);
3389
3390 #endif
3391
3392 }
3393
MApi_DMX_Stc_Eng_SetOffset(MS_U32 u32Eng,MS_U32 u32Offset,MS_BOOL bAdd)3394 DMX_FILTER_STATUS MApi_DMX_Stc_Eng_SetOffset(MS_U32 u32Eng, MS_U32 u32Offset, MS_BOOL bAdd)
3395 {
3396
3397 #ifdef DMX_UTOPIA_20
3398
3399 MS_U32 u32param[4] = {0, 0, 0, 0};
3400
3401 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3402
3403 if(_DMX_IOCtrlOpen() == FALSE)
3404 return DMX_FILTER_STATUS_ERROR;
3405
3406 u32param[0] = u32Eng;
3407 u32param[1] = u32Offset;
3408 u32param[2] = ((MS_U32)bAdd) & 0xFF;
3409 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Stc_SetOffset,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3410 {
3411 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3412 return DMX_FILTER_STATUS_ERROR;
3413 }
3414
3415 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3416 return DMX_FILTER_STATUS_ERROR;
3417 else
3418 return DMX_FILTER_STATUS_OK;
3419
3420 #else
3421
3422 return _MApi_DMX_Stc_Eng_SetOffset(u32Eng, u32Offset, bAdd);
3423
3424 #endif
3425
3426 }
3427
MApi_DMX_Stc_Clk_Adjust(MS_U32 u32EngId,MS_BOOL bUpClk,MS_U32 u32Percentage)3428 DMX_FILTER_STATUS MApi_DMX_Stc_Clk_Adjust(MS_U32 u32EngId, MS_BOOL bUpClk, MS_U32 u32Percentage)
3429 {
3430
3431 #ifdef DMX_UTOPIA_20
3432
3433 MS_U32 u32param[4] = {0, 0, 0, 0};
3434
3435 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3436
3437 if(_DMX_IOCtrlOpen() == FALSE)
3438 return DMX_FILTER_STATUS_ERROR;
3439
3440 u32param[0] = u32EngId;
3441 u32param[1] = ((MS_U32)bUpClk) & 0xFF;
3442 u32param[2] = u32Percentage;
3443 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Stc_ClkAdjust,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3444 {
3445 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3446 return DMX_FILTER_STATUS_ERROR;
3447 }
3448
3449 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3450 return DMX_FILTER_STATUS_ERROR;
3451 else
3452 return DMX_FILTER_STATUS_OK;
3453
3454 #else
3455
3456 return _MApi_DMX_Stc_Clk_Adjust(u32EngId, bUpClk, u32Percentage);
3457
3458 #endif
3459
3460 }
3461
MApi_DMX_Stc_Select(DMX_FILTER_TYPE eFltSrc,MS_U32 u32StcEng)3462 DMX_FILTER_STATUS MApi_DMX_Stc_Select(DMX_FILTER_TYPE eFltSrc, MS_U32 u32StcEng)
3463 {
3464 #ifdef DMX_UTOPIA_20
3465
3466 MS_U32 u32param[3] = {0, 0, 0};
3467
3468 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3469
3470 if(_DMX_IOCtrlOpen() == FALSE)
3471 return DMX_FILTER_STATUS_ERROR;
3472
3473 u32param[0] = eFltSrc;
3474 u32param[1] = u32StcEng;
3475 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_STCEng_Sel,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3476 {
3477 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3478 return DMX_FILTER_STATUS_ERROR;
3479 }
3480
3481 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
3482 return DMX_FILTER_STATUS_ERROR;
3483 else
3484 return DMX_FILTER_STATUS_OK;
3485
3486 #else
3487
3488 return _MApi_DMX_Stc_Select(eFltSrc, u32StcEng);
3489
3490 #endif
3491 }
3492
MApi_DMX_Pcr_Get(MS_U32 * pu32Pcr32,MS_U32 * pu32Pcr)3493 DMX_FILTER_STATUS MApi_DMX_Pcr_Get(MS_U32* pu32Pcr32, MS_U32* pu32Pcr)
3494 {
3495
3496 #ifdef DMX_UTOPIA_20
3497
3498 MS_U32 u32param[4] = {0, 0, 0, 0};
3499
3500 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3501
3502 *pu32Pcr32 = 0;
3503 *pu32Pcr = 0;
3504
3505 if(_DMX_IOCtrlOpen() == FALSE)
3506 return DMX_FILTER_STATUS_ERROR;
3507
3508 u32param[0] = 0;
3509 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetPcr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3510 {
3511 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3512 return DMX_FILTER_STATUS_ERROR;
3513 }
3514
3515 *pu32Pcr32 = u32param[1];
3516 *pu32Pcr = u32param[2];
3517
3518 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3519 return DMX_FILTER_STATUS_ERROR;
3520 else
3521 return DMX_FILTER_STATUS_OK;
3522
3523 #else
3524
3525 return _MApi_DMX_Pcr_Get(pu32Pcr32, pu32Pcr);
3526
3527 #endif
3528
3529 }
3530
MApi_DMX_Pcr_Eng_Get(MS_U8 u8PcrEng,MS_U32 * pu32Pcr32,MS_U32 * pu32Pcr)3531 DMX_FILTER_STATUS MApi_DMX_Pcr_Eng_Get(MS_U8 u8PcrEng, MS_U32* pu32Pcr32, MS_U32* pu32Pcr)
3532 {
3533 #ifdef DMX_UTOPIA_20
3534
3535 MS_U32 u32param[4] = {0, 0, 0, 0};
3536
3537 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3538
3539 *pu32Pcr32 = 0;
3540 *pu32Pcr = 0;
3541
3542 if(_DMX_IOCtrlOpen() == FALSE)
3543 return DMX_FILTER_STATUS_ERROR;
3544
3545 u32param[0] = ((MS_U32)u8PcrEng) & 0xFF;
3546 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetPcr,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3547 {
3548 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3549 return DMX_FILTER_STATUS_ERROR;
3550 }
3551
3552 *pu32Pcr32 = u32param[1];
3553 *pu32Pcr = u32param[2];
3554
3555 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3556 return DMX_FILTER_STATUS_ERROR;
3557 else
3558 return DMX_FILTER_STATUS_OK;
3559
3560 #else
3561
3562 return _MApi_DMX_Pcr_Eng_Get(u8PcrEng, pu32Pcr32, pu32Pcr);
3563
3564 #endif
3565 }
3566
MApi_DMX_Proc(MS_U32 u32DmxId,DMX_EVENT * pEvent)3567 DMX_FILTER_STATUS MApi_DMX_Proc(MS_U32 u32DmxId, DMX_EVENT* pEvent) // for non-OS TSP scheduling
3568 {
3569
3570 #ifdef DMX_UTOPIA_20
3571
3572 DMX_FLT_EVENT_PARAM FltEventParam;
3573
3574 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3575
3576 if(_DMX_IOCtrlOpen() == FALSE)
3577 return DMX_FILTER_STATUS_ERROR;
3578
3579 FltEventParam.u32DmxId = u32DmxId;
3580 FltEventParam.pEvent = pEvent;
3581 FltEventParam.u32Res = 0;
3582 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Proc,(void*)&FltEventParam) != UTOPIA_STATUS_SUCCESS)
3583 {
3584 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3585 return DMX_FILTER_STATUS_ERROR;
3586 }
3587
3588 if(FltEventParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
3589 return DMX_FILTER_STATUS_ERROR;
3590 else
3591 return DMX_FILTER_STATUS_OK;
3592
3593 #else
3594
3595 return _MApi_DMX_Proc(u32DmxId, pEvent);
3596
3597 #endif
3598
3599 }
3600
MApi_DMX_Parl_Invert(DMX_FLOW DmxFlow,MS_BOOL bInvert)3601 DMX_FILTER_STATUS MApi_DMX_Parl_Invert(DMX_FLOW DmxFlow, MS_BOOL bInvert)
3602 {
3603
3604 #ifdef DMX_UTOPIA_20
3605
3606 MS_U32 u32param[3] = {0, 0, 0};
3607
3608 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3609
3610 if(_DMX_IOCtrlOpen() == FALSE)
3611 return DMX_FILTER_STATUS_ERROR;
3612
3613 u32param[0] = (MS_U32)DmxFlow;
3614 u32param[1] = ((MS_U32)bInvert & 0xFF);
3615 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Flow_ParlInvert,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3616 {
3617 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3618 return DMX_FILTER_STATUS_ERROR;
3619 }
3620
3621 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
3622 return DMX_FILTER_STATUS_ERROR;
3623 else
3624 return DMX_FILTER_STATUS_OK;
3625
3626 #else
3627
3628 return _MApi_DMX_Parl_Invert(DmxFlow, bInvert);
3629
3630 #endif
3631
3632 }
3633
MApi_DMX_CopyData(MS_U32 u32DmxId,MS_U8 * pu8Buf,MS_U32 u32BufSize,MS_U32 * pu32ActualSize,MS_U32 * pu32RmnSize,DMX_CheckCb pfCheckCB)3634 DMX_FILTER_STATUS MApi_DMX_CopyData(MS_U32 u32DmxId, MS_U8* pu8Buf, MS_U32 u32BufSize, MS_U32* pu32ActualSize, MS_U32* pu32RmnSize, DMX_CheckCb pfCheckCB)
3635 {
3636
3637 #ifdef DMX_UTOPIA_20
3638
3639 DMX_FLT_COPY_PARAM FltCopyParam;
3640
3641 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3642
3643 *pu32ActualSize = 0;
3644 *pu32RmnSize = 0;
3645
3646 if(_DMX_IOCtrlOpen() == FALSE)
3647 return DMX_FILTER_STATUS_ERROR;
3648
3649 FltCopyParam.u32DmxId = u32DmxId;
3650 FltCopyParam.pu8Buf = pu8Buf;
3651 FltCopyParam.u32BufSize = u32BufSize;
3652 FltCopyParam.pfCheckCB = pfCheckCB;
3653 FltCopyParam.u32ActualSize = 0;
3654 FltCopyParam.u32RmnSize = 0;
3655 FltCopyParam.u32Res = 0;
3656 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_CopyData,(void*)&FltCopyParam) != UTOPIA_STATUS_SUCCESS)
3657 {
3658 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3659 return DMX_FILTER_STATUS_ERROR;
3660 }
3661
3662 *pu32ActualSize = FltCopyParam.u32ActualSize;
3663 *pu32RmnSize = FltCopyParam.u32RmnSize;
3664
3665 if(FltCopyParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
3666 return DMX_FILTER_STATUS_ERROR;
3667 else
3668 return DMX_FILTER_STATUS_OK;
3669
3670 #else
3671
3672 return _MApi_DMX_CopyData(u32DmxId, pu8Buf, u32BufSize, pu32ActualSize, pu32RmnSize, pfCheckCB);
3673
3674 #endif
3675
3676 }
3677
MApi_DMX_WriteProtect_Enable(MS_BOOL bEnable,MS_PHY * pphyStartAddr,MS_PHY * pphyEndAddr)3678 void MApi_DMX_WriteProtect_Enable(MS_BOOL bEnable, MS_PHY* pphyStartAddr, MS_PHY* pphyEndAddr)
3679 {
3680 #ifdef DMX_UTOPIA_20
3681
3682 DMX_WP_PARAM stWPParam;
3683
3684 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3685
3686 if(_DMX_IOCtrlOpen() == FALSE)
3687 return;
3688
3689 stWPParam.bEnable = bEnable;
3690 stWPParam.pu32StartAddr = pphyStartAddr;
3691 stWPParam.pu32EndAddr = pphyEndAddr;
3692 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_WProtectEnable,(void*)&stWPParam) != UTOPIA_STATUS_SUCCESS)
3693 {
3694 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3695 return;
3696 }
3697
3698 #else
3699
3700 _MApi_DMX_WriteProtect_Enable(bEnable, pphyStartAddr, pphyEndAddr);
3701
3702 #endif
3703 }
3704
MApi_DMX_OrzWriteProtect_Enable(MS_BOOL bEnable,MS_PHY phyStartAddr,MS_PHY phyEndAddr)3705 void MApi_DMX_OrzWriteProtect_Enable(MS_BOOL bEnable, MS_PHY phyStartAddr, MS_PHY phyEndAddr)
3706 {
3707 #ifdef DMX_UTOPIA_20
3708
3709 MS_U32 u32Param[5] = {0, 0, 0, 0, 0};
3710
3711 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3712
3713 if(_DMX_IOCtrlOpen() == FALSE)
3714 return;
3715
3716 u32Param[0] = ((MS_U32)bEnable) & 0xFFUL;
3717 _DMX_PhyAddr_To_U32Param(phyStartAddr, u32Param+1);
3718 _DMX_PhyAddr_To_U32Param(phyEndAddr, u32Param+3);
3719
3720 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_OrzWProtectEnable,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
3721 {
3722 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3723 return;
3724 }
3725
3726 #else
3727
3728 _MApi_DMX_OrzWriteProtect_Enable(bEnable, phyStartAddr, phyEndAddr);
3729
3730 #endif
3731 }
3732
MApi_DMX_FlowEnable(DMX_FLOW DmxFlow,MS_BOOL bEnable)3733 DMX_FILTER_STATUS MApi_DMX_FlowEnable(DMX_FLOW DmxFlow, MS_BOOL bEnable)
3734 {
3735
3736 #ifdef DMX_UTOPIA_20
3737
3738 MS_U32 u32Param[3] = {0, 0, 0};
3739
3740 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3741
3742 if(_DMX_IOCtrlOpen() == FALSE)
3743 return DMX_FILTER_STATUS_ERROR;
3744
3745 u32Param[0] = (MS_U32)DmxFlow;
3746 u32Param[1] = ((MS_U32)bEnable) & 0xFF;
3747 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Flow_ENABLE,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
3748 {
3749 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3750 return DMX_FILTER_STATUS_ERROR;
3751 }
3752
3753 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
3754 return DMX_FILTER_STATUS_ERROR;
3755 else
3756 return DMX_FILTER_STATUS_OK;
3757
3758 #else
3759
3760 return _MApi_DMX_FlowEnable(DmxFlow, bEnable);
3761
3762 #endif
3763
3764 }
3765
MApi_DMX_Flow_DscmbEng(DMX_TSIF eTsIf,MS_U32 * pu32EngId,MS_BOOL bSet)3766 DMX_FILTER_STATUS MApi_DMX_Flow_DscmbEng(DMX_TSIF eTsIf, MS_U32* pu32EngId, MS_BOOL bSet)
3767 {
3768 #ifdef DMX_UTOPIA_20
3769
3770 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3771
3772 DMX_FLOW_DSCMBENG_PARAM stDmxDscmbEng;
3773
3774 stDmxDscmbEng.eTsif = eTsIf;
3775 stDmxDscmbEng.bSet = bSet;
3776 stDmxDscmbEng.u32Res = 0;
3777 if(bSet == TRUE)
3778 {
3779 stDmxDscmbEng.u32DscmbEng = *pu32EngId;
3780 }
3781 else
3782 {
3783 *pu32EngId = 0xFF;
3784 }
3785
3786 if(_DMX_IOCtrlOpen() == FALSE)
3787 return DMX_FILTER_STATUS_ERROR;
3788
3789 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FlowDscmbEng,(void*)&stDmxDscmbEng) != UTOPIA_STATUS_SUCCESS)
3790 {
3791 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3792 return DMX_FILTER_STATUS_ERROR;
3793 }
3794
3795 if(bSet == FALSE)
3796 {
3797 *pu32EngId = stDmxDscmbEng.u32DscmbEng;
3798 }
3799
3800 if(stDmxDscmbEng.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
3801 return DMX_FILTER_STATUS_ERROR;
3802 else
3803 return DMX_FILTER_STATUS_OK;
3804
3805 #else
3806
3807 return _MApi_DMX_Flow_DscmbEng(eTsIf, pu32EngId, bSet);
3808
3809 #endif
3810
3811 }
3812
MApi_DMX_TsOutputPadCfg(DMX_FLOW_OUTPUT_PAD eOutPad,DMX_FLOW_INPUT eInSrcPad,MS_BOOL bInParallel,MS_U32 u32ResvNum,MS_U32 * pu32Resv)3813 DMX_FILTER_STATUS MApi_DMX_TsOutputPadCfg(DMX_FLOW_OUTPUT_PAD eOutPad, DMX_FLOW_INPUT eInSrcPad, MS_BOOL bInParallel, MS_U32 u32ResvNum, MS_U32 *pu32Resv)
3814 {
3815
3816 #ifdef DMX_UTOPIA_20
3817
3818 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3819
3820 DMX_OutputPad_Cfg stOutPadCfg;
3821
3822 stOutPadCfg.eOutPad = eOutPad;
3823 stOutPadCfg.eInSrcPad = eInSrcPad;
3824 stOutPadCfg.bInParallel = bInParallel;
3825 stOutPadCfg.u32ResvNum = u32ResvNum;
3826 stOutPadCfg.pu32Resv = pu32Resv;
3827 stOutPadCfg.u32Res = 0;
3828
3829 if(_DMX_IOCtrlOpen() == FALSE)
3830 return DMX_FILTER_STATUS_ERROR;
3831
3832 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_OutPadCfg,(void*)&stOutPadCfg) != UTOPIA_STATUS_SUCCESS)
3833 {
3834 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3835 return DMX_FILTER_STATUS_ERROR;
3836 }
3837
3838 if(stOutPadCfg.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
3839 return DMX_FILTER_STATUS_ERROR;
3840 else
3841 return DMX_FILTER_STATUS_OK;
3842
3843 #else
3844
3845 return _MApi_DMX_TsOutputPadCfg(eOutPad, eInSrcPad, bInParallel, u32ResvNum, pu32Resv);
3846
3847 #endif
3848
3849 }
3850
MApi_DMX_TsS2POutputClkPhase(MS_U16 u16Val,MS_BOOL bEnable,MS_U32 u32S2pOpt)3851 DMX_FILTER_STATUS MApi_DMX_TsS2POutputClkPhase(MS_U16 u16Val, MS_BOOL bEnable, MS_U32 u32S2pOpt)
3852 {
3853 #ifdef DMX_UTOPIA_20
3854
3855 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3856
3857 MS_U32 u32param[4] = {0, 0, 0, 0};
3858
3859 u32param[0] = ((MS_U32)u16Val) & 0xFFFF;
3860 u32param[1] = ((MS_U32)bEnable) & 0xFF;
3861 u32param[2] = u32S2pOpt;
3862
3863 if(_DMX_IOCtrlOpen() == FALSE)
3864 return DMX_FILTER_STATUS_ERROR;
3865
3866 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TsOutPhase,(void*)u32param) != UTOPIA_STATUS_SUCCESS)
3867 {
3868 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3869 return DMX_FILTER_STATUS_ERROR;
3870 }
3871
3872 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3873 return DMX_FILTER_STATUS_ERROR;
3874 else
3875 return DMX_FILTER_STATUS_OK;
3876
3877 #else
3878
3879 return _MApi_DMX_TsS2POutputClkPhase(u16Val, bEnable, u32S2pOpt);
3880
3881 #endif
3882
3883 }
3884
MApi_DMX_Read_DropPktCnt(MS_U16 * pu16ADropCnt,MS_U16 * pu16VDropCnt)3885 DMX_FILTER_STATUS MApi_DMX_Read_DropPktCnt(MS_U16* pu16ADropCnt, MS_U16* pu16VDropCnt)
3886 {
3887
3888 #ifdef DMX_UTOPIA_20
3889
3890 MS_U32 u32Param[3] = {0, 0, 0};
3891
3892 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3893
3894 *pu16ADropCnt = 0;
3895 *pu16VDropCnt = 0;
3896
3897 if(_DMX_IOCtrlOpen() == FALSE)
3898 return DMX_FILTER_STATUS_ERROR;
3899
3900 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_ReadDropCount,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
3901 {
3902 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3903 return DMX_FILTER_STATUS_ERROR;
3904 }
3905
3906 *pu16ADropCnt = (MS_U16)(u32Param[0]);
3907 *pu16VDropCnt = (MS_U16)(u32Param[1]);
3908
3909 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
3910 return DMX_FILTER_STATUS_ERROR;
3911 else
3912 return DMX_FILTER_STATUS_OK;
3913
3914 #else
3915
3916 return _MApi_DMX_Read_DropPktCnt(pu16ADropCnt, pu16VDropCnt);
3917
3918 #endif
3919
3920 }
3921
MApi_DMX_SetOwner(MS_U32 u32DmxIdStart,MS_U32 u32DmxIdEnd,MS_BOOL bOwner)3922 DMX_FILTER_STATUS MApi_DMX_SetOwner(MS_U32 u32DmxIdStart, MS_U32 u32DmxIdEnd, MS_BOOL bOwner)
3923 {
3924
3925 #ifdef DMX_UTOPIA_20
3926
3927 MS_U32 u32Param[4] = {0, 0, 0, 0};
3928
3929 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3930
3931 if(_DMX_IOCtrlOpen() == FALSE)
3932 return DMX_FILTER_STATUS_ERROR;
3933
3934 u32Param[0] = u32DmxIdStart;
3935 u32Param[1] = u32DmxIdEnd;
3936 u32Param[2] = ((MS_U32)bOwner) & 0xFF;
3937 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetOwner,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
3938 {
3939 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3940 return DMX_FILTER_STATUS_ERROR;
3941 }
3942
3943 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
3944 return DMX_FILTER_STATUS_ERROR;
3945 else
3946 return DMX_FILTER_STATUS_OK;
3947
3948 #else
3949 return _MApi_DMX_SetOwner(u32DmxIdStart, u32DmxIdEnd, bOwner);
3950
3951 #endif
3952
3953 }
3954
MApi_DMX_GetOwner(MS_U32 u32DmxId,MS_BOOL * pbOwner)3955 DMX_FILTER_STATUS MApi_DMX_GetOwner(MS_U32 u32DmxId, MS_BOOL* pbOwner)
3956 {
3957
3958 #ifdef DMX_UTOPIA_20
3959
3960 MS_U32 u32Param[3] = {0, 0, 0};
3961
3962 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
3963
3964 *pbOwner = FALSE;
3965
3966 if(_DMX_IOCtrlOpen() == FALSE)
3967 return DMX_FILTER_STATUS_ERROR;
3968
3969 u32Param[0] = u32DmxId;
3970 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetOwner,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
3971 {
3972 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
3973 return DMX_FILTER_STATUS_ERROR;
3974 }
3975
3976 *pbOwner = (MS_BOOL)u32Param[1];
3977
3978 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
3979 return DMX_FILTER_STATUS_ERROR;
3980 else
3981 return DMX_FILTER_STATUS_OK;
3982
3983 #else
3984
3985 return _MApi_DMX_GetOwner(MS_U32, pbOwner);
3986
3987 #endif
3988
3989 }
3990
MApi_DMX_GetAccess(MS_U32 u32Try)3991 DMX_FILTER_STATUS MApi_DMX_GetAccess(MS_U32 u32Try)
3992 {
3993
3994 #ifdef DMX_UTOPIA_20
3995
3996 MS_U32 u32Param[2] = {0, 0};
3997
3998 u32Param[0]= u32Try;
3999
4000 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4001
4002 if(_DMX_IOCtrlOpen() == FALSE)
4003 return DMX_FILTER_STATUS_ERROR;
4004
4005 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetAccess,(void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4006 {
4007 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4008 return DMX_FILTER_STATUS_ERROR;
4009 }
4010
4011 if(u32Param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
4012 return DMX_FILTER_STATUS_ERROR;
4013 else
4014 return DMX_FILTER_STATUS_OK;
4015
4016 #else
4017
4018 return _MApi_DMX_GetAccess(u32Try);
4019
4020 #endif
4021
4022 }
4023
MApi_DMX_ReleaseAccess(void)4024 DMX_FILTER_STATUS MApi_DMX_ReleaseAccess(void)
4025 {
4026
4027 #ifdef DMX_UTOPIA_20
4028
4029 MS_U32 u32param = 0;
4030
4031 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4032
4033 if(_DMX_IOCtrlOpen() == FALSE)
4034 return DMX_FILTER_STATUS_ERROR;
4035
4036 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_ReleaseAccess, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
4037 {
4038 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4039 return DMX_FILTER_STATUS_ERROR;
4040 }
4041
4042 if(u32param != (MS_U32)DMX_FILTER_STATUS_OK)
4043 return DMX_FILTER_STATUS_ERROR;
4044 else
4045 return DMX_FILTER_STATUS_OK;
4046
4047 #else
4048
4049 return _MApi_DMX_ReleaseAccess();
4050
4051 #endif
4052
4053 }
4054
MApi_DMX_SetHK(MS_BOOL bIsHK)4055 DMX_FILTER_STATUS MApi_DMX_SetHK(MS_BOOL bIsHK)
4056 {
4057 #ifdef DMX_UTOPIA_20
4058
4059 MS_U32 u32Data[2] = {0, 0};
4060
4061 u32Data[0]= (MS_U32)bIsHK;
4062
4063 DMX_V2DBGMSG(ULOGD("DMX", "[%s][%d](%d)\n", __FUNCTION__, __LINE__, (MS_S32)bIsHK));
4064
4065 if(_DMX_IOCtrlOpen() == FALSE)
4066 {
4067 return DMX_FILTER_STATUS_ERROR;
4068 }
4069
4070 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetHK, (void*)u32Data) != UTOPIA_STATUS_SUCCESS)
4071 {
4072 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4073 return DMX_FILTER_STATUS_ERROR;
4074 }
4075
4076 if(u32Data[1] != (MS_U32)DMX_FILTER_STATUS_OK)
4077 return DMX_FILTER_STATUS_ERROR;
4078 else
4079 return DMX_FILTER_STATUS_OK;
4080
4081 #else
4082
4083 return _MApi_DMX_SetHK(bIsHK);
4084
4085 #endif
4086
4087 }
4088
MApi_DMX_AVFifo_Reset(DMX_FILTER_TYPE DmxFltType,MS_BOOL bReset)4089 DMX_FILTER_STATUS MApi_DMX_AVFifo_Reset(DMX_FILTER_TYPE DmxFltType, MS_BOOL bReset)
4090 {
4091
4092 #ifdef DMX_UTOPIA_20
4093
4094 DMX_AVFIFO_PARAM AvfifoParam;
4095
4096 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4097
4098 if(_DMX_IOCtrlOpen() == FALSE)
4099 return DMX_FILTER_STATUS_ERROR;
4100
4101 AvfifoParam.DmxFltType = DmxFltType;
4102 AvfifoParam.u32Data = ((MS_U32)bReset) & 0xFF;
4103 AvfifoParam.u32Res = 0;
4104 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_AVFIFO_Reset, (void*)&AvfifoParam) != UTOPIA_STATUS_SUCCESS)
4105 {
4106 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4107 return DMX_FILTER_STATUS_ERROR;
4108 }
4109
4110 if(AvfifoParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4111 return DMX_FILTER_STATUS_ERROR;
4112 else
4113 return DMX_FILTER_STATUS_OK;
4114 #else
4115
4116 return _MApi_DMX_AVFifo_Reset(DmxFltType, bReset);
4117
4118 #endif
4119
4120 }
4121
MApi_DMX_AVFifo_Status(DMX_FILTER_TYPE DmxFltType,DMX_FIFO_STATUS * u32FifoLevel)4122 DMX_FILTER_STATUS MApi_DMX_AVFifo_Status(DMX_FILTER_TYPE DmxFltType, DMX_FIFO_STATUS* u32FifoLevel)
4123 {
4124
4125 #ifdef DMX_UTOPIA_20
4126
4127 DMX_AVFIFO_PARAM AvfifoParam;
4128
4129 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4130
4131 *u32FifoLevel = 0;
4132
4133 if(_DMX_IOCtrlOpen() == FALSE)
4134 return DMX_FILTER_STATUS_ERROR;
4135
4136 AvfifoParam.DmxFltType = DmxFltType;
4137 AvfifoParam.u32Data = 0;
4138 AvfifoParam.u32Res = 0;
4139 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_AVFIFO_Status, (void*)&AvfifoParam) != UTOPIA_STATUS_SUCCESS)
4140 {
4141 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4142 return DMX_FILTER_STATUS_ERROR;
4143 }
4144
4145 *u32FifoLevel = AvfifoParam.u32Data;
4146
4147 if(AvfifoParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4148 return DMX_FILTER_STATUS_ERROR;
4149 else
4150 return DMX_FILTER_STATUS_OK;
4151
4152 #else
4153
4154 return _MApi_DMX_AVFifo_Status(DmxFltType, u32FifoLevel);
4155
4156 #endif
4157
4158 }
4159
MApi_DMX_GetLibVer(const MSIF_Version ** ppVersion)4160 DMX_FILTER_STATUS MApi_DMX_GetLibVer(const MSIF_Version **ppVersion)
4161 {
4162 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4163
4164 return _MApi_DMX_GetLibVer(ppVersion);
4165 }
4166
MApi_DMX_GetCap(DMX_QUERY_TYPE DmxQueryType,void * pOutput)4167 DMX_FILTER_STATUS MApi_DMX_GetCap(DMX_QUERY_TYPE DmxQueryType, void* pOutput)
4168 {
4169
4170 #ifdef DMX_UTOPIA_20
4171
4172 DMX_CAP_PARAM CapParam;
4173
4174 DMX_V2DBGMSG(ULOGD("DMX", "[%s][%d](%d , %p)\n", __FUNCTION__, __LINE__, (MS_U32)DmxQueryType, pOutput));
4175
4176 if(_DMX_IOCtrlOpen() == FALSE)
4177 return DMX_FILTER_STATUS_ERROR;
4178
4179 CapParam.Quetype = DmxQueryType;
4180 CapParam.pdata = pOutput;
4181 CapParam.u32Res = 0;
4182 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetCap, (void*)&CapParam) != UTOPIA_STATUS_SUCCESS)
4183 {
4184 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4185 return DMX_FILTER_STATUS_ERROR;
4186 }
4187
4188 if(CapParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4189 return DMX_FILTER_STATUS_ERROR;
4190 else
4191 return DMX_FILTER_STATUS_OK;
4192
4193 #else
4194
4195 return _MApi_DMX_GetCap(DmxQueryType, pOutput);
4196
4197 #endif
4198
4199 }
4200
MApi_DMX_GetCap_Ex(char * pstrQueryType,MS_S32 s32Strlen,void * pOutput,MS_S32 * ps32OutSize)4201 DMX_FILTER_STATUS MApi_DMX_GetCap_Ex(char* pstrQueryType, MS_S32 s32Strlen, void* pOutput, MS_S32* ps32OutSize)
4202 {
4203
4204 #ifdef DMX_UTOPIA_20
4205
4206 DMX_CAP_EX_PARAM CapExParam;
4207
4208 DMX_V2DBGMSG(ULOGD("DMX", "[%s][%d](%s , %p)\n", __FUNCTION__, __LINE__, pstrQueryType, pOutput));
4209
4210 if(_DMX_IOCtrlOpen() == FALSE)
4211 return DMX_FILTER_STATUS_ERROR;
4212
4213 CapExParam.InputStrLen = s32Strlen;
4214 CapExParam.StrQuetype = pstrQueryType;
4215 CapExParam.OutputSize = 0;
4216 CapExParam.pdata = pOutput;
4217 CapExParam.u32Res = 0;
4218 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetCapEx, (void*)&CapExParam) != UTOPIA_STATUS_SUCCESS)
4219 {
4220 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4221 return DMX_FILTER_STATUS_ERROR;
4222 }
4223
4224 *ps32OutSize = CapExParam.OutputSize;
4225
4226 if(CapExParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4227 return DMX_FILTER_STATUS_ERROR;
4228 else
4229 return DMX_FILTER_STATUS_OK;
4230
4231 #else
4232
4233 return _MApi_DMX_GetCap_Ex(pstrQueryType, s32Strlen, pOutput, ps32OutSize);
4234
4235 #endif
4236
4237 }
4238
4239
MApi_DMX_SetBurstLen(DMX_BURSTTYPE BurstType)4240 DMX_FILTER_STATUS MApi_DMX_SetBurstLen(DMX_BURSTTYPE BurstType)
4241 {
4242
4243 #ifdef DMX_UTOPIA_20
4244
4245 DMX_BURSTTYPE type = BurstType;
4246
4247 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4248
4249 if(_DMX_IOCtrlOpen() == FALSE)
4250 return DMX_FILTER_STATUS_ERROR;
4251
4252 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetBurstLen, (void*)&type) != UTOPIA_STATUS_SUCCESS)
4253 {
4254 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4255 return DMX_FILTER_STATUS_ERROR;
4256 }
4257
4258 return DMX_FILTER_STATUS_OK;
4259
4260 #else
4261
4262 return _MApi_DMX_SetBurstLen(BurstType);
4263
4264 #endif
4265
4266 }
4267
MApi_DMX_GetFileInTimeStamp(MS_U32 * pu32FileInTS)4268 DMX_FILTER_STATUS MApi_DMX_GetFileInTimeStamp(MS_U32 *pu32FileInTS)
4269 {
4270
4271 #ifdef DMX_UTOPIA_20
4272
4273 MS_U32 u32Param[3] = {0, 0, 0};
4274
4275 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4276
4277 *pu32FileInTS = 0;
4278
4279 if(_DMX_IOCtrlOpen() == FALSE)
4280 return DMX_FILTER_STATUS_ERROR;
4281
4282 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_GetFileTimeStamp, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4283 {
4284 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4285 return DMX_FILTER_STATUS_ERROR;
4286 }
4287
4288 *pu32FileInTS = u32Param[1];
4289
4290 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
4291 return DMX_FILTER_STATUS_ERROR;
4292 else
4293 return DMX_FILTER_STATUS_OK;
4294
4295 #else
4296
4297 return _MApi_DMX_GetFileInTimeStamp(pu32FileInTS);
4298
4299 #endif
4300
4301 }
4302
MApi_DMX_Filein_Eng_GetFileInTimeStamp(DMX_FILEIN_PATH ePath,MS_U32 * pu32FileInTS)4303 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_GetFileInTimeStamp(DMX_FILEIN_PATH ePath, MS_U32 *pu32FileInTS)
4304 {
4305
4306 #ifdef DMX_UTOPIA_20
4307
4308 MS_U32 u32Param[3] = {0, 0, 0};
4309
4310 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4311
4312 *pu32FileInTS = 0;
4313
4314 if(_DMX_IOCtrlOpen() == FALSE)
4315 return DMX_FILTER_STATUS_ERROR;
4316
4317 u32Param[0] = (MS_U32)ePath;
4318 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_GetFileTimeStamp, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4319 {
4320 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4321 return DMX_FILTER_STATUS_ERROR;
4322 }
4323
4324 *pu32FileInTS = u32Param[1];
4325
4326 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
4327 return DMX_FILTER_STATUS_ERROR;
4328 else
4329 return DMX_FILTER_STATUS_OK;
4330
4331 #else
4332
4333 return _MApi_DMX_Filein_Eng_GetFileInTimeStamp(ePath, pu32FileInTS);
4334
4335 #endif
4336
4337 }
4338
MApi_DMX_Filein_GetReadAddr(MS_PHY * pphyRead)4339 DMX_FILTER_STATUS MApi_DMX_Filein_GetReadAddr(MS_PHY* pphyRead)
4340 {
4341
4342 #ifdef DMX_UTOPIA_20
4343
4344 MS_U32 u32Param[4] = {0, 0, 0, 0};
4345 void* ptrTmp = (void*)(&u32Param[1]);
4346
4347 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4348
4349 *pphyRead = 0;
4350
4351 if(_DMX_IOCtrlOpen() == FALSE)
4352 return DMX_FILTER_STATUS_ERROR;
4353
4354 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_GetReadAddr, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4355 {
4356 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4357 return DMX_FILTER_STATUS_ERROR;
4358 }
4359
4360 *pphyRead = *((MS_PHY*)ptrTmp);
4361
4362 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
4363 return DMX_FILTER_STATUS_ERROR;
4364 else
4365 return DMX_FILTER_STATUS_OK;
4366 #else
4367
4368 return _MApi_DMX_Filein_GetReadAddr(pphyRead);
4369
4370 #endif
4371
4372 }
4373
MApi_DMX_Filein_Eng_GetReadAddr(DMX_FILEIN_PATH ePath,MS_PHY * pphyRead)4374 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_GetReadAddr(DMX_FILEIN_PATH ePath, MS_PHY* pphyRead)
4375 {
4376
4377 #ifdef DMX_UTOPIA_20
4378
4379 MS_U32 u32Param[4] = {0, 0, 0, 0};
4380 void* ptrTmp = (void*)(&u32Param[1]);
4381
4382 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4383
4384 *pphyRead = 0;
4385
4386 if(_DMX_IOCtrlOpen() == FALSE)
4387 return DMX_FILTER_STATUS_ERROR;
4388
4389 u32Param[0] = (MS_U32)ePath;
4390 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_GetReadAddr, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4391 {
4392 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4393 return DMX_FILTER_STATUS_ERROR;
4394 }
4395
4396 *pphyRead = *((MS_PHY*)ptrTmp);
4397
4398 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
4399 return DMX_FILTER_STATUS_ERROR;
4400 else
4401 return DMX_FILTER_STATUS_OK;
4402
4403 #else
4404
4405 return _MApi_DMX_Filein_Eng_GetReadAddr(ePath, pphyRead);
4406
4407 #endif
4408
4409 }
4410
MApi_DMX_BypassFileInTimeStamp(MS_BOOL bbypass)4411 void MApi_DMX_BypassFileInTimeStamp(MS_BOOL bbypass)
4412 {
4413
4414 #ifdef DMX_UTOPIA_20
4415
4416 MS_U32 u32Param[2] = {0, 0};
4417
4418 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4419
4420 if(_DMX_IOCtrlOpen() == FALSE)
4421 return;
4422
4423 u32Param[1] = ((MS_U32)bbypass) & 0xFF;
4424 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_BypassFileTimestamp, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4425 {
4426 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4427 return;
4428 }
4429
4430 #else
4431
4432 _MApi_DMX_BypassFileInTimeStamp(bbypass);
4433
4434 #endif
4435
4436 }
4437
MApi_DMX_Filein_Eng_BypassFileInTimeStamp(DMX_FILEIN_PATH ePath,MS_BOOL bbypass)4438 void MApi_DMX_Filein_Eng_BypassFileInTimeStamp(DMX_FILEIN_PATH ePath, MS_BOOL bbypass)
4439 {
4440
4441 #ifdef DMX_UTOPIA_20
4442
4443 MS_U32 u32Param[2] = {0, 0};
4444
4445 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4446
4447 if(_DMX_IOCtrlOpen() == FALSE)
4448 return;
4449
4450 u32Param[0] = (MS_U32)ePath;
4451 u32Param[1] = ((MS_U32)bbypass) & 0xFF;
4452 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_BypassFileTimestamp, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4453 {
4454 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4455 return;
4456 }
4457
4458 #else
4459
4460 _MApi_DMX_Filein_Eng_BypassFileInTimeStamp(ePath, bbypass);
4461
4462 #endif
4463
4464 }
4465
MApi_TSP_Get_FW_VER(MS_U32 * u32FWVer)4466 DMX_FILTER_STATUS MApi_TSP_Get_FW_VER(MS_U32* u32FWVer)
4467 {
4468 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4469 return _MApi_TSP_Get_FW_VER(u32FWVer);
4470 }
4471
MApi_DMX_RemoveDupAVPkt(MS_BOOL bEnable)4472 DMX_FILTER_STATUS MApi_DMX_RemoveDupAVPkt(MS_BOOL bEnable)
4473 {
4474
4475 #ifdef DMX_UTOPIA_20
4476
4477 DMX_AVFIFO_DROP_PARAM AvFifoDrop;
4478
4479 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4480
4481 if(_DMX_IOCtrlOpen() == FALSE)
4482 return DMX_FILTER_STATUS_ERROR;
4483
4484 AvFifoDrop.bAllFifo = TRUE;
4485 AvFifoDrop.bEnable = bEnable;
4486 AvFifoDrop.u32Res = 0;
4487
4488 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_RemoveDupAVFifoPkt, (void*)&AvFifoDrop) != UTOPIA_STATUS_SUCCESS)
4489 {
4490 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4491 return DMX_FILTER_STATUS_ERROR;
4492 }
4493
4494 if(AvFifoDrop.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4495 return DMX_FILTER_STATUS_ERROR;
4496 else
4497 return DMX_FILTER_STATUS_OK;
4498
4499 #else
4500
4501 return _MApi_DMX_RemoveDupAVPkt(bEnable);
4502
4503 #endif
4504
4505 }
4506
MApi_DMX_RemoveDupAVFifoPkt(DMX_FILTER_TYPE DmxFltType,MS_BOOL bEnable)4507 DMX_FILTER_STATUS MApi_DMX_RemoveDupAVFifoPkt(DMX_FILTER_TYPE DmxFltType, MS_BOOL bEnable)
4508 {
4509
4510 #ifdef DMX_UTOPIA_20
4511
4512 DMX_AVFIFO_DROP_PARAM AvFifoDrop;
4513
4514 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4515
4516 if(_DMX_IOCtrlOpen() == FALSE)
4517 return DMX_FILTER_STATUS_ERROR;
4518
4519 AvFifoDrop.bAllFifo = FALSE;
4520 AvFifoDrop.bEnable = bEnable;
4521 AvFifoDrop.DmxFltType = DmxFltType;
4522 AvFifoDrop.u32Res = 0;
4523
4524 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_RemoveDupAVFifoPkt, (void*)&AvFifoDrop) != UTOPIA_STATUS_SUCCESS)
4525 {
4526 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4527 return DMX_FILTER_STATUS_ERROR;
4528 }
4529
4530 if(AvFifoDrop.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4531 return DMX_FILTER_STATUS_ERROR;
4532 else
4533 return DMX_FILTER_STATUS_OK;
4534
4535 #else
4536
4537 return _MApi_DMX_RemoveDupAVFifoPkt(DmxFltType, bEnable);
4538
4539 #endif
4540
4541 }
4542
MApi_DMX_Change_FilterSource(MS_U32 u32DmxId,DMX_FILTER_TYPE DmxFltSrcType)4543 DMX_FILTER_STATUS MApi_DMX_Change_FilterSource(MS_U32 u32DmxId, DMX_FILTER_TYPE DmxFltSrcType)
4544 {
4545
4546 #ifdef DMX_UTOPIA_20
4547
4548 DMX_FLT_TYPE_PARAM FltTypeParam;
4549
4550 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4551
4552 if(_DMX_IOCtrlOpen() == FALSE)
4553 return DMX_FILTER_STATUS_ERROR;
4554
4555 FltTypeParam.u32DmxId = u32DmxId;
4556 FltTypeParam.DmxFltType = DmxFltSrcType;
4557 FltTypeParam.u32Res = 0;
4558 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_ChangeFltSrc, (void*)&FltTypeParam) != UTOPIA_STATUS_SUCCESS)
4559 {
4560 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4561 return DMX_FILTER_STATUS_ERROR;
4562 }
4563
4564 if(FltTypeParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4565 return DMX_FILTER_STATUS_ERROR;
4566 else
4567 return DMX_FILTER_STATUS_OK;
4568
4569 #else
4570
4571 return _MApi_DMX_Change_FilterSource(u32DmxId, DmxFltSrcType);
4572
4573 #endif
4574
4575 }
4576
MApi_DMX_SetDbgLevel(DMX_DBGMSG_LEVEL level)4577 DMX_FILTER_STATUS MApi_DMX_SetDbgLevel(DMX_DBGMSG_LEVEL level)
4578 {
4579
4580 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4581
4582 #ifdef DMX_UTOPIA_20
4583
4584 MS_U32 u32param[2] = {0, 0};
4585
4586 u32param[0] = (MS_U32)level;
4587 if(_DMX_IOCtrlOpen() == FALSE)
4588 return DMX_FILTER_STATUS_ERROR;
4589
4590 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetDbgLevel, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
4591 {
4592 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4593 return DMX_FILTER_STATUS_ERROR;
4594 }
4595
4596 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
4597 return DMX_FILTER_STATUS_ERROR;
4598 else
4599 return DMX_FILTER_STATUS_OK;
4600
4601 #else
4602
4603 return _MApi_DMX_SetDbgLevel(level);
4604
4605 #endif
4606
4607 }
4608
MApi_DMX_STC64_Mode_Enable(MS_BOOL bEnable)4609 DMX_FILTER_STATUS MApi_DMX_STC64_Mode_Enable(MS_BOOL bEnable)
4610 {
4611
4612 #ifdef DMX_UTOPIA_20
4613
4614 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4615
4616 MS_U32 u32Param[2] = {0, 0};
4617
4618 u32Param[0] = ((MS_U32)bEnable) & 0xFFUL;
4619 if(_DMX_IOCtrlOpen() == FALSE)
4620 return DMX_FILTER_STATUS_ERROR;
4621
4622 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_STC64ModeEnable, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4623 {
4624 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4625 return DMX_FILTER_STATUS_ERROR;
4626 }
4627
4628 if(u32Param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
4629 return DMX_FILTER_STATUS_ERROR;
4630 else
4631 return DMX_FILTER_STATUS_OK;
4632
4633 #else
4634
4635 return _MApi_DMX_STC64_Mode_Enable(bEnable);
4636
4637 #endif
4638
4639 }
4640
MApi_DMX_MMFI_Filein_IsIdle(DMX_MMFI_PATH ePath)4641 MS_BOOL MApi_DMX_MMFI_Filein_IsIdle(DMX_MMFI_PATH ePath)
4642 {
4643
4644 #ifdef DMX_UTOPIA_20
4645
4646 MS_U32 u32param[2] = {0, 0};
4647
4648 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4649
4650 if(_DMX_IOCtrlOpen() == FALSE)
4651 return FALSE;
4652
4653 u32param[0] = (MS_U32)ePath;
4654 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_IsIdle, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
4655 {
4656 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4657 return FALSE;
4658 }
4659
4660 return (MS_BOOL)(u32param[1]);
4661
4662 #else
4663
4664 return _MApi_DMX_MMFI_Filein_IsIdle(ePath);
4665
4666 #endif
4667
4668 }
4669
MApi_DMX_MMFI_Filein_IsBusy(DMX_MMFI_PATH ePath)4670 MS_BOOL MApi_DMX_MMFI_Filein_IsBusy(DMX_MMFI_PATH ePath)
4671 {
4672
4673 #ifdef DMX_UTOPIA_20
4674
4675 MS_U32 u32param[2] = {0, 0};
4676
4677 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4678
4679 if(_DMX_IOCtrlOpen() == FALSE)
4680 return FALSE;
4681
4682 u32param[0] = (MS_U32)ePath;
4683 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_IsBusy, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
4684 {
4685 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4686 return FALSE;
4687 }
4688
4689 return (MS_BOOL)(u32param[1]);
4690
4691 #else
4692
4693 return _MApi_DMX_MMFI_Filein_IsBusy(ePath);
4694
4695 #endif
4696
4697 }
4698
MApi_DMX_MMFI_Filein_CMDQ_Reset(DMX_MMFI_PATH ePath)4699 DMX_FILTER_STATUS MApi_DMX_MMFI_Filein_CMDQ_Reset(DMX_MMFI_PATH ePath)
4700 {
4701
4702 #ifdef DMX_UTOPIA_20
4703
4704 MS_U32 u32param[2] = {0, 0};
4705
4706 u32param[0] = (MS_U32)ePath;
4707
4708 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4709
4710 if(_DMX_IOCtrlOpen() == FALSE)
4711 return DMX_FILTER_STATUS_ERROR;
4712
4713 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_CmdQReset, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
4714 {
4715 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4716 return DMX_FILTER_STATUS_ERROR;
4717 }
4718
4719 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
4720 return DMX_FILTER_STATUS_ERROR;
4721 else
4722 return DMX_FILTER_STATUS_OK;
4723
4724 #else
4725
4726 return _MApi_DMX_MMFI_Filein_CMDQ_Reset(ePath);
4727
4728 #endif
4729
4730 }
4731
MApi_DMX_MMFI_Filein_CMDQ_GetEmptyNum(DMX_MMFI_PATH ePath,MS_U32 * pu32EmptySlot)4732 DMX_FILTER_STATUS MApi_DMX_MMFI_Filein_CMDQ_GetEmptyNum(DMX_MMFI_PATH ePath, MS_U32 *pu32EmptySlot)
4733 {
4734
4735 #ifdef DMX_UTOPIA_20
4736
4737 MS_U32 u32param[3] = {0, 0, 0};
4738
4739 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4740
4741 *pu32EmptySlot = 0;
4742
4743 if(_DMX_IOCtrlOpen() == FALSE)
4744 return DMX_FILTER_STATUS_ERROR;
4745
4746 u32param[0] = (MS_U32)ePath;
4747 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_GetEmptyNum, (void*)&u32param) != UTOPIA_STATUS_SUCCESS)
4748 {
4749 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4750 return DMX_FILTER_STATUS_ERROR;
4751 }
4752
4753 *pu32EmptySlot = u32param[1];
4754
4755 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
4756 return DMX_FILTER_STATUS_ERROR;
4757 else
4758 return DMX_FILTER_STATUS_OK;
4759
4760 #else
4761
4762 return _MApi_DMX_MMFI_Filein_CMDQ_GetEmptyNum(ePath, pu32EmptySlot);
4763
4764 #endif
4765
4766 }
4767
MApi_DMX_MMFI_Filein_Start(DMX_MMFI_DST eDst,MS_PHY pBuf,MS_U32 u32BufSize)4768 DMX_FILTER_STATUS MApi_DMX_MMFI_Filein_Start(DMX_MMFI_DST eDst, MS_PHY pBuf, MS_U32 u32BufSize)
4769 {
4770
4771 #ifdef DMX_UTOPIA_20
4772
4773 DMX_MMFI_START_PARAM FltStartParam;
4774
4775 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4776
4777 if(_DMX_IOCtrlOpen() == FALSE)
4778 return DMX_FILTER_STATUS_ERROR;
4779
4780 FltStartParam.Dst = eDst;
4781 FltStartParam.pBuf = pBuf;
4782 FltStartParam.u32BufSize = u32BufSize;
4783 FltStartParam.u32Res = 0;
4784 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_Start, (void*)&FltStartParam) != UTOPIA_STATUS_SUCCESS)
4785 {
4786 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4787 return DMX_FILTER_STATUS_ERROR;
4788 }
4789
4790 if(FltStartParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4791 return DMX_FILTER_STATUS_ERROR;
4792 else
4793 return DMX_FILTER_STATUS_OK;
4794
4795 #else
4796
4797 return _MApi_DMX_MMFI_Filein_Start(eDst, pBuf, u32BufSize);
4798
4799 #endif
4800
4801 }
4802
MApi_DMX_MMFI_GetFileInTimeStamp(DMX_MMFI_PATH ePath,MS_U32 * pu32FileInTS)4803 DMX_FILTER_STATUS MApi_DMX_MMFI_GetFileInTimeStamp(DMX_MMFI_PATH ePath, MS_U32 *pu32FileInTS)
4804 {
4805
4806 #ifdef DMX_UTOPIA_20
4807
4808 MS_U32 u32param[3] = {0, 0, 0};
4809
4810 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4811
4812 *pu32FileInTS = 0;
4813
4814 if(_DMX_IOCtrlOpen() == FALSE)
4815 return DMX_FILTER_STATUS_ERROR;
4816
4817 u32param[0] = (MS_U32)ePath;
4818 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_GetFileTimeStamp, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
4819 {
4820 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4821 return DMX_FILTER_STATUS_ERROR;
4822 }
4823
4824 *pu32FileInTS = u32param[1];
4825
4826
4827 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
4828 return DMX_FILTER_STATUS_ERROR;
4829 else
4830 return DMX_FILTER_STATUS_OK;
4831
4832 #else
4833
4834 return _MApi_DMX_MMFI_GetFileInTimeStamp(ePath, pu32FileInTS);
4835
4836 #endif
4837
4838 }
4839
MApi_DMX_MMFI_Pid_Open(DMX_MMFI_FLTTYPE flttype,MS_U16 u16Pid,MS_U8 * pu8DmxId)4840 DMX_FILTER_STATUS MApi_DMX_MMFI_Pid_Open(DMX_MMFI_FLTTYPE flttype, MS_U16 u16Pid, MS_U8* pu8DmxId)
4841 {
4842
4843 #ifdef DMX_UTOPIA_20
4844
4845 DMX_MMFI_FLT_PARAM MmfiFltParam;
4846
4847 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4848
4849 *pu8DmxId = 0xFF;
4850
4851 if(_DMX_IOCtrlOpen() == FALSE)
4852 return DMX_FILTER_STATUS_ERROR;
4853
4854 MmfiFltParam.flttype = (DMX_MMFI_FLTTYPE)flttype;
4855 MmfiFltParam.u32DmxId = 0xFF;
4856 MmfiFltParam.u32Pid = ((MS_U32)u16Pid) & 0xFFFF;
4857 MmfiFltParam.u32Res = 0;
4858 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_PidOpen, (void*)&MmfiFltParam) != UTOPIA_STATUS_SUCCESS)
4859 {
4860 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4861 return DMX_FILTER_STATUS_ERROR;
4862 }
4863
4864 *pu8DmxId = (MS_U8)(MmfiFltParam.u32DmxId & 0xFF);
4865
4866 if(MmfiFltParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
4867 return DMX_FILTER_STATUS_ERROR;
4868 else
4869 return DMX_FILTER_STATUS_OK;
4870
4871 #else
4872
4873 return _MApi_DMX_MMFI_Pid_Open(flttype, u16Pid, pu8DmxId);
4874
4875 #endif
4876
4877 }
4878
MApi_DMX_MMFI_Pid_Close(MS_U8 u8DmxId)4879 DMX_FILTER_STATUS MApi_DMX_MMFI_Pid_Close(MS_U8 u8DmxId)
4880 {
4881
4882 #ifdef DMX_UTOPIA_20
4883
4884 MS_U32 u32Param[3] = {0, 0, 0};
4885
4886 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4887
4888 if(_DMX_IOCtrlOpen() == FALSE)
4889 return DMX_FILTER_STATUS_ERROR;
4890
4891 u32Param[1] = ((MS_U32)u8DmxId) & 0xFF;
4892 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_PidClose, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4893 {
4894 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4895 return DMX_FILTER_STATUS_ERROR;
4896 }
4897
4898 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
4899 return DMX_FILTER_STATUS_ERROR;
4900 else
4901 return DMX_FILTER_STATUS_OK;
4902 #else
4903
4904 return _MApi_DMX_MMFI_Pid_Close(u8DmxId);
4905
4906 #endif
4907
4908 }
4909
MApi_DMX_MMFI_Filein_CMDQ_FIFOWriteLevel(DMX_MMFI_PATH ePath,MS_U8 * pu8CmdQStatus)4910 DMX_FILTER_STATUS MApi_DMX_MMFI_Filein_CMDQ_FIFOWriteLevel(DMX_MMFI_PATH ePath, MS_U8 *pu8CmdQStatus)
4911 {
4912
4913 #ifdef DMX_UTOPIA_20
4914
4915 MS_U32 u32Param[3] = {0, 0, 0};
4916
4917 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4918
4919 *pu8CmdQStatus = 0;
4920
4921 if(_DMX_IOCtrlOpen() == FALSE)
4922 return DMX_FILTER_STATUS_ERROR;
4923
4924 u32Param[0] = (MS_U32)ePath;
4925 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_GetFifoLevel, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4926 {
4927 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4928 return DMX_FILTER_STATUS_ERROR;
4929 }
4930
4931 *pu8CmdQStatus = (MS_U8)u32Param[1];
4932
4933 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
4934 return DMX_FILTER_STATUS_ERROR;
4935 else
4936 return DMX_FILTER_STATUS_OK;
4937
4938 #else
4939
4940 return _MApi_DMX_MMFI_Filein_CMDQ_FIFOWriteLevel(ePath, pu8CmdQStatus);
4941
4942 #endif
4943
4944 }
4945
MApi_DMX_MMFI_SetPlaybackTimeStamp(DMX_MMFI_PATH ePath,MS_U32 u32pcr2)4946 DMX_FILTER_STATUS MApi_DMX_MMFI_SetPlaybackTimeStamp(DMX_MMFI_PATH ePath, MS_U32 u32pcr2)
4947 {
4948
4949 #ifdef DMX_UTOPIA_20
4950
4951 MS_U32 u32Param[3] = {0, 0, 0};
4952
4953 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4954
4955 if(_DMX_IOCtrlOpen() == FALSE)
4956 return DMX_FILTER_STATUS_ERROR;
4957
4958 u32Param[0] = (MS_U32)ePath;
4959 u32Param[1] = u32pcr2;
4960 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_PlayStamp_Set, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4961 {
4962 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4963 return DMX_FILTER_STATUS_ERROR;
4964 }
4965
4966 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
4967 return DMX_FILTER_STATUS_ERROR;
4968 else
4969 return DMX_FILTER_STATUS_OK;
4970
4971 #else
4972
4973 return _MApi_DMX_MMFI_SetPlaybackTimeStamp(ePath, u32pcr2);
4974
4975 #endif
4976
4977 }
4978
MApi_DMX_MMFI_GetPlaybackTimeStamp(DMX_MMFI_PATH ePath,MS_U32 * pu32pcr2)4979 DMX_FILTER_STATUS MApi_DMX_MMFI_GetPlaybackTimeStamp(DMX_MMFI_PATH ePath, MS_U32 *pu32pcr2)
4980 {
4981
4982 #ifdef DMX_UTOPIA_20
4983
4984 MS_U32 u32Param[3] = {0, 0, 0};
4985
4986 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
4987
4988 *pu32pcr2 = 0;
4989
4990 if(_DMX_IOCtrlOpen() == FALSE)
4991 return DMX_FILTER_STATUS_ERROR;
4992
4993 u32Param[0] = (MS_U32)ePath;
4994 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_PlayStamp_Get, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
4995 {
4996 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
4997 return DMX_FILTER_STATUS_ERROR;
4998 }
4999
5000 *pu32pcr2 = u32Param[1];
5001
5002 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5003 return DMX_FILTER_STATUS_ERROR;
5004 else
5005 return DMX_FILTER_STATUS_OK;
5006
5007 #else
5008
5009 return _MApi_DMX_MMFI_GetPlaybackTimeStamp(ePath, pu32pcr2);
5010
5011 #endif
5012
5013 }
5014
MApi_DMX_MMFI_RemoveDupAVPkt(MS_BOOL bEnable)5015 DMX_FILTER_STATUS MApi_DMX_MMFI_RemoveDupAVPkt(MS_BOOL bEnable)
5016 {
5017 #ifdef DMX_UTOPIA_20
5018
5019 DMX_AVFIFO_DROP_PARAM AVFifoDropParam;
5020
5021 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5022
5023 if(_DMX_IOCtrlOpen() == FALSE)
5024 return DMX_FILTER_STATUS_ERROR;
5025
5026 AVFifoDropParam.DmxFltType = 0;
5027 AVFifoDropParam.bAllFifo = TRUE;
5028 AVFifoDropParam.bEnable = bEnable;
5029 AVFifoDropParam.u32Res = 0;
5030 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_RemoveDupAVPkt, (void*)&AVFifoDropParam) != UTOPIA_STATUS_SUCCESS)
5031 {
5032 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5033 return DMX_FILTER_STATUS_ERROR;
5034 }
5035
5036 if(AVFifoDropParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
5037 return DMX_FILTER_STATUS_ERROR;
5038 else
5039 return DMX_FILTER_STATUS_OK;
5040
5041 #else
5042
5043 return _MApi_DMX_MMFI_RemoveDupAVPkt(bEnable);
5044
5045 #endif
5046
5047 }
5048
MApi_DMX_MMFI_MOBF_Enable(DMX_MMFI_PATH ePath,MS_BOOL bEnable,MS_U32 u32key)5049 DMX_FILTER_STATUS MApi_DMX_MMFI_MOBF_Enable(DMX_MMFI_PATH ePath, MS_BOOL bEnable, MS_U32 u32key)
5050 {
5051 #ifdef DMX_UTOPIA_20
5052
5053 MS_U32 u32param[4] = {0, 0, 0, 0};
5054
5055 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5056
5057 if(_DMX_IOCtrlOpen() == FALSE)
5058 return DMX_FILTER_STATUS_ERROR;
5059
5060 u32param[0] = ((MS_U32)ePath) & 0xFF;
5061 u32param[1] = u32key;
5062 u32param[2] = ((MS_U32)bEnable) & 0xFF;
5063
5064 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_SetMOBFKey, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
5065 {
5066 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5067 return DMX_FILTER_STATUS_ERROR;
5068 }
5069
5070 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
5071 return DMX_FILTER_STATUS_ERROR;
5072 else
5073 return DMX_FILTER_STATUS_OK;
5074
5075 #else
5076
5077 return _MApi_DMX_MMFI_MOBF_Enable(ePath, bEnable, u32key);
5078
5079 #endif
5080
5081 }
5082
MApi_DMX_MMFI_TimeStampClk(DMX_MMFI_PATH ePath,DMX_TimeStamp_Clk eClk)5083 DMX_FILTER_STATUS MApi_DMX_MMFI_TimeStampClk(DMX_MMFI_PATH ePath, DMX_TimeStamp_Clk eClk)
5084 {
5085
5086 #ifdef DMX_UTOPIA_20
5087
5088 MS_U32 u32Param[3] = {0, 0, 0};
5089
5090 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5091
5092 if(_DMX_IOCtrlOpen() == FALSE)
5093 return DMX_FILTER_STATUS_ERROR;
5094
5095 u32Param[0] = (MS_U32)ePath;
5096 u32Param[1] = (MS_U32)eClk;
5097 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_SetTimeStampClk, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5098 {
5099 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5100 return DMX_FILTER_STATUS_ERROR;
5101 }
5102
5103 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5104 return DMX_FILTER_STATUS_ERROR;
5105 else
5106 return DMX_FILTER_STATUS_OK;
5107
5108 #else
5109
5110 return _MApi_DMX_MMFI_TimeStampClk(ePath, eClk);
5111
5112 #endif
5113
5114 }
5115
MApi_DMX_MMFI_TimeStampEnable(DMX_MMFI_PATH ePath)5116 DMX_FILTER_STATUS MApi_DMX_MMFI_TimeStampEnable(DMX_MMFI_PATH ePath)
5117 {
5118
5119 #ifdef DMX_UTOPIA_20
5120
5121 MS_U32 u32Param[3] = {0, 0, 0};
5122
5123 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5124
5125 if(_DMX_IOCtrlOpen() == FALSE)
5126 return DMX_FILTER_STATUS_ERROR;
5127
5128 u32Param[0] = (MS_U32)ePath;
5129 u32Param[1] = 1;
5130 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_Timestamp_En, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5131 {
5132 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5133 return DMX_FILTER_STATUS_ERROR;
5134 }
5135
5136 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5137 return DMX_FILTER_STATUS_ERROR;
5138 else
5139 return DMX_FILTER_STATUS_OK;
5140
5141 #else
5142
5143 return _MApi_DMX_MMFI_TimeStampEnable(ePath);
5144
5145 #endif
5146
5147 }
5148
MApi_DMX_MMFI_TimeStampDisable(DMX_MMFI_PATH ePath)5149 DMX_FILTER_STATUS MApi_DMX_MMFI_TimeStampDisable(DMX_MMFI_PATH ePath)
5150 {
5151
5152 #ifdef DMX_UTOPIA_20
5153
5154 MS_U32 u32Param[3] = {0, 0, 0};
5155
5156 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5157
5158 if(_DMX_IOCtrlOpen() == FALSE)
5159 return DMX_FILTER_STATUS_ERROR;
5160
5161 u32Param[0] = (MS_U32)ePath;
5162 u32Param[1] = 0;
5163 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_Timestamp_En, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5164 {
5165 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5166 return DMX_FILTER_STATUS_ERROR;
5167 }
5168
5169 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5170 return DMX_FILTER_STATUS_ERROR;
5171 else
5172 return DMX_FILTER_STATUS_OK;
5173
5174 #else
5175
5176 return _MApi_DMX_MMFI_TimeStampDisable(ePath);
5177
5178 #endif
5179
5180 }
5181
MApi_DMX_Pvr_Eng_MOBF_Enable(MS_U8 u8Eng,MS_BOOL bEnable,MS_U32 u32key0,MS_U32 u32key1)5182 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_MOBF_Enable(MS_U8 u8Eng, MS_BOOL bEnable, MS_U32 u32key0, MS_U32 u32key1)
5183 {
5184
5185 #ifdef DMX_UTOPIA_20
5186
5187 MS_U32 u32Param[5] = {0, 0, 0, 0, 0};
5188
5189 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5190
5191 if(_DMX_IOCtrlOpen() == FALSE)
5192 return DMX_FILTER_STATUS_ERROR;
5193
5194 u32Param[0] = ((MS_U32)u8Eng) & 0xFF;
5195 u32Param[1] = u32key0;
5196 u32Param[2] = u32key1;
5197 u32Param[3] = ((MS_U32)bEnable) & 0xFF;
5198 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_SetMobfKey, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5199 {
5200 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5201 return DMX_FILTER_STATUS_ERROR;
5202 }
5203
5204 if(u32Param[4] != (MS_U32)DMX_FILTER_STATUS_OK)
5205 return DMX_FILTER_STATUS_ERROR;
5206 else
5207 return DMX_FILTER_STATUS_OK;
5208
5209 #else
5210
5211 return _MApi_DMX_Pvr_Eng_MOBF_Enable(u8Eng, bEnable, u32key0, u32key1);
5212
5213 #endif
5214
5215 }
5216
MApi_DMX_Filein_MOBF_Enable(MS_BOOL bEnable,MS_U32 u32key)5217 DMX_FILTER_STATUS MApi_DMX_Filein_MOBF_Enable(MS_BOOL bEnable, MS_U32 u32key)
5218 {
5219
5220 #ifdef DMX_UTOPIA_20
5221
5222 MS_U32 u32Param[4] = {0, 0, 0, 0};
5223
5224 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5225
5226 if(_DMX_IOCtrlOpen() == FALSE)
5227 return DMX_FILTER_STATUS_ERROR;
5228
5229 u32Param[1] = ((MS_U32)bEnable) & 0xFF;
5230 u32Param[2] = u32key;
5231 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_SetMobfKey, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5232 {
5233 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5234 return DMX_FILTER_STATUS_ERROR;
5235 }
5236
5237 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
5238 return DMX_FILTER_STATUS_ERROR;
5239 else
5240 return DMX_FILTER_STATUS_OK;
5241
5242 #else
5243
5244 return _MApi_DMX_Filein_MOBF_Enable(bEnable, u32key);
5245
5246 #endif
5247
5248 }
5249
MApi_DMX_Filein_Eng_MOBF_Enable(DMX_FILEIN_PATH ePath,MS_BOOL bEnable,MS_U32 u32key)5250 DMX_FILTER_STATUS MApi_DMX_Filein_Eng_MOBF_Enable(DMX_FILEIN_PATH ePath, MS_BOOL bEnable, MS_U32 u32key)
5251 {
5252
5253 #ifdef DMX_UTOPIA_20
5254
5255 MS_U32 u32Param[4] = {0, 0, 0, 0};
5256
5257 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5258
5259 if(_DMX_IOCtrlOpen() == FALSE)
5260 return DMX_FILTER_STATUS_ERROR;
5261
5262 u32Param[0] = (MS_U32)ePath;
5263 u32Param[1] = ((MS_U32)bEnable) & 0xFF;
5264 u32Param[2] = u32key;
5265 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_SetMobfKey, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5266 {
5267 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5268 return DMX_FILTER_STATUS_ERROR;
5269 }
5270
5271 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
5272 return DMX_FILTER_STATUS_ERROR;
5273 else
5274 return DMX_FILTER_STATUS_OK;
5275
5276 #else
5277
5278 return _MApi_DMX_Filein_Eng_MOBF_Enable(ePath, bEnable, u32key);
5279
5280 #endif
5281
5282 }
5283
MApi_DMX_MMFI_Filein_Info(DMX_MMFI_PATH ePath,DMX_Filein_info * pFileinInfo)5284 DMX_FILTER_STATUS MApi_DMX_MMFI_Filein_Info(DMX_MMFI_PATH ePath, DMX_Filein_info *pFileinInfo)
5285 {
5286
5287 #ifdef DMX_UTOPIA_20
5288
5289 DMX_FILE_INFO_PARAM stparam;
5290
5291 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5292
5293 if(_DMX_IOCtrlOpen() == FALSE)
5294 return DMX_FILTER_STATUS_ERROR;
5295
5296 stparam.u32EngId = (MS_U32)ePath;
5297 stparam.pFileinInfo = pFileinInfo;
5298 stparam.u32Res = 0;
5299 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_Info, (void*)&stparam) != UTOPIA_STATUS_SUCCESS)
5300 {
5301 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5302 return DMX_FILTER_STATUS_ERROR;
5303 }
5304
5305 if(stparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
5306 return DMX_FILTER_STATUS_ERROR;
5307 else
5308 return DMX_FILTER_STATUS_OK;
5309
5310 #else
5311
5312 return _MApi_DMX_MMFI_Filein_Info(ePath, pFileinInfo);
5313
5314 #endif
5315
5316 }
5317
MApi_DMX_MMFI_Filein_BypassTimeStamp(DMX_MMFI_PATH ePath,MS_BOOL bbypass)5318 void MApi_DMX_MMFI_Filein_BypassTimeStamp(DMX_MMFI_PATH ePath, MS_BOOL bbypass)
5319 {
5320
5321 #ifdef DMX_UTOPIA_20
5322
5323 MS_U32 u32param[2] = {0, 0};
5324
5325 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5326
5327 if(_DMX_IOCtrlOpen() == FALSE)
5328 return;
5329
5330 u32param[0] = (MS_U32)ePath;
5331 u32param[1] = ((MS_U32)bbypass) & 0xFF;
5332 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MMFI_BypassStamp, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
5333 {
5334 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5335 return;
5336 }
5337
5338 #else
5339
5340 _MApi_DMX_MMFI_Filein_BypassTimeStamp(ePath, bbypass);
5341
5342 #endif
5343
5344 }
5345
MApi_DMX_GetDbgPortInfo(MS_U32 u32DbgSel,MS_U32 * u32DbgInfo)5346 DMX_FILTER_STATUS MApi_DMX_GetDbgPortInfo(MS_U32 u32DbgSel,MS_U32* u32DbgInfo)
5347 {
5348
5349 #ifdef DMX_UTOPIA_20
5350
5351 MS_U32 u32param[3] = {0, 0, 0};
5352
5353 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5354
5355 if(_DMX_IOCtrlOpen() == FALSE)
5356 return DMX_FILTER_STATUS_ERROR;
5357
5358 u32param[0] = u32DbgSel;
5359 u32param[1] = 0;
5360 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Get_DbgPortInfo, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
5361 {
5362 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5363 return DMX_FILTER_STATUS_ERROR;
5364 }
5365
5366 *u32DbgInfo = u32param[1];
5367
5368 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5369 return DMX_FILTER_STATUS_ERROR;
5370 else
5371 return DMX_FILTER_STATUS_OK;
5372
5373 #else
5374
5375 return _MApi_DMX_GetDbgPortInfo(u32DbgSel, u32DbgInfo);
5376
5377 #endif
5378
5379 }
5380
5381
MApi_DMX_Pvr_Eng_Open(DMX_PVR_ENG Eng,DMX_Pvr_info * pPvrInfo)5382 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Open(DMX_PVR_ENG Eng ,DMX_Pvr_info* pPvrInfo)
5383 {
5384 #ifdef DMX_UTOPIA_20
5385
5386 DMX_PVR_INFO_PARAM Pvrinfo;
5387
5388 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
5389
5390 if(_DMX_IOCtrlOpen() == FALSE)
5391 return DMX_FILTER_STATUS_ERROR;
5392
5393 #ifdef DMX_UTOPIA_2K
5394 if(_bKrenelMod == TRUE)
5395 {
5396 _PvrEngCb[Eng] = NULL;
5397 }
5398 #endif
5399
5400 Pvrinfo.u32EngId = Eng;
5401 Pvrinfo.pPvrInfo = pPvrInfo;
5402 Pvrinfo.u32Res = 0;
5403
5404 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Open, (void*)&Pvrinfo) != UTOPIA_STATUS_SUCCESS)
5405 {
5406 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5407 return DMX_FILTER_STATUS_ERROR;
5408 }
5409
5410 #ifdef DMX_UTOPIA_2K
5411 if(_bKrenelMod == TRUE)
5412 {
5413 _PvrEngCb[Eng] = pPvrInfo->pNotify;
5414 }
5415 #endif
5416
5417 if(Pvrinfo.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
5418 return DMX_FILTER_STATUS_ERROR;
5419 else
5420 return DMX_FILTER_STATUS_OK;
5421
5422 #else
5423
5424 return _MApi_DMX_Pvr_Eng_Open(Eng, pPvrInfo);
5425
5426 #endif
5427
5428 }
5429
5430 // PVR API
5431 //-------------------------------------------------------------------------------------------------
5432 /// Set up the recording parameters
5433 /// @param pInfo \b IN: the recording parameters
5434 /// @return DMX_FILTER_STATUS_OK - Success
5435 /// @return DMX_FILTER_STATUS_ERROR - Failure
5436 /// @note
5437 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_Open(DMX_Pvr_info * pInfo)5438 DMX_FILTER_STATUS MApi_DMX_Pvr_Open(DMX_Pvr_info* pInfo)
5439 {
5440 return MApi_DMX_Pvr_Eng_Open(DMX_PVR_EGN0, pInfo);
5441 }
5442
5443 //-------------------------------------------------------------------------------------------------
5444 /// Clear the recording parameters
5445 /// @return DMX_FILTER_STATUS_OK - Success
5446 /// @return DMX_FILTER_STATUS_ERROR - Failure
5447 /// @note
5448 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_Close(void)5449 DMX_FILTER_STATUS MApi_DMX_Pvr_Close(void)
5450 {
5451 return MApi_DMX_Pvr_Eng_Close(DMX_PVR_EGN0);
5452 }
5453
5454 //-------------------------------------------------------------------------------------------------
5455 /// Set the PID to be recorded
5456 /// @param Pid \b IN: The target PID to be recorded
5457 /// @param pu8DmxId \b OUT: The demux filter Id for this recorded PID
5458 /// @return DMX_FILTER_STATUS_OK - Success
5459 /// @return DMX_FILTER_STATUS_ERROR - Failure
5460 /// @note
5461 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_Pid_Open(MS_U32 Pid,MS_U8 * pu8DmxId)5462 DMX_FILTER_STATUS MApi_DMX_Pvr_Pid_Open(MS_U32 Pid, MS_U8* pu8DmxId)
5463 {
5464 return MApi_DMX_Pvr_Eng_Pid_Open(DMX_PVR_EGN0, Pid, pu8DmxId);
5465 }
5466
5467 //-------------------------------------------------------------------------------------------------
5468 /// Free the PID to be recorded
5469 /// @param u8DmxId \b IN: The demux filter Id from MApi_DMX_Pvr_Pid_Open
5470 /// @return DMX_FILTER_STATUS_OK - Success
5471 /// @return DMX_FILTER_STATUS_ERROR - Failure
5472 /// @note
5473 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_Pid_Close(MS_U8 u8DmxId)5474 DMX_FILTER_STATUS MApi_DMX_Pvr_Pid_Close(MS_U8 u8DmxId)
5475 {
5476 return MApi_DMX_Pvr_Eng_Pid_Close(DMX_PVR_EGN0, u8DmxId);
5477 }
5478
5479 //-------------------------------------------------------------------------------------------------
5480 /// Start to record
5481 /// @param bPvrAll \b IN: TRUE to record original bit stream
5482 /// FALSE to recording the PIDs of interests
5483 /// @return DMX_FILTER_STATUS_OK - Success
5484 /// @return DMX_FILTER_STATUS_ERROR - Failure
5485 /// @note
5486 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_Start(MS_BOOL bPvrAll)5487 DMX_FILTER_STATUS MApi_DMX_Pvr_Start(MS_BOOL bPvrAll)
5488 {
5489 return MApi_DMX_Pvr_Eng_Start(DMX_PVR_EGN0, bPvrAll);
5490 }
5491
5492 //-------------------------------------------------------------------------------------------------
5493 /// Stop recording
5494 /// @return DMX_FILTER_STATUS_OK - Success
5495 /// @return DMX_FILTER_STATUS_ERROR - Failure
5496 /// @note
5497 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_Stop(void)5498 DMX_FILTER_STATUS MApi_DMX_Pvr_Stop(void)
5499 {
5500 return MApi_DMX_Pvr_Eng_Stop(DMX_PVR_EGN0);
5501 }
5502
5503 //-------------------------------------------------------------------------------------------------
5504 /// Pause/Resume PVR engine
5505 /// @return DMX_FILTER_STATUS_OK - Success
5506 /// @return DMX_FILTER_STATUS_ERROR - Failure
5507 /// @note
5508 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_Pause(MS_BOOL bPause)5509 DMX_FILTER_STATUS MApi_DMX_Pvr_Pause(MS_BOOL bPause)
5510 {
5511 #if(defined(TSP_VERSION) && ((TSP_VERSION == TSP_VER_1_0)||(TSP_VERSION == TSP_VER_3_0)))
5512 ULOGD("DMX", "[%s][%d] Not Implement Yet !\n",__FUNCTION__,__LINE__);
5513 #else
5514 MApi_DMX_Pvr_Eng_Pause(DMX_PVR_EGN0, bPause);
5515 #endif
5516 return DMX_FILTER_STATUS_OK;
5517 }
5518
5519 //-------------------------------------------------------------------------------------------------
5520 /// Get write pointer of recording buffer
5521 /// @return DMX_FILTER_STATUS_OK - Success
5522 /// @return DMX_FILTER_STATUS_ERROR - Failure
5523 /// @note
5524 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_WriteGet(MS_PHY * pphyWrite)5525 DMX_FILTER_STATUS MApi_DMX_Pvr_WriteGet(MS_PHY* pphyWrite)
5526 {
5527 return MApi_DMX_Pvr_Eng_WriteGet(DMX_PVR_EGN0, pphyWrite);
5528 }
5529
5530 //-------------------------------------------------------------------------------------------------
5531 /// Set recording packet mode
5532 /// @return DMX_FILTER_STATUS_OK - Success
5533 /// @return DMX_FILTER_STATUS_ERROR - Failure
5534 /// @note
5535 //-------------------------------------------------------------------------------------------------
MApi_DMX_PVR_SetPacketMode(MS_BOOL bSet)5536 DMX_FILTER_STATUS MApi_DMX_PVR_SetPacketMode(MS_BOOL bSet)
5537 {
5538 return MApi_DMX_Pvr_Eng_SetPacketMode(DMX_PVR_EGN0, bSet);
5539 }
5540
5541 //-------------------------------------------------------------------------------------------------
5542 /// Set recording starting time stamp
5543 /// @return DMX_FILTER_STATUS_OK - Success
5544 /// @return DMX_FILTER_STATUS_ERROR - Failure
5545 /// @note
5546 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_SetRecordStamp(MS_U32 u32Stamp)5547 DMX_FILTER_STATUS MApi_DMX_Pvr_SetRecordStamp(MS_U32 u32Stamp)
5548 {
5549 return MApi_DMX_Pvr_Eng_SetRecordStamp(DMX_PVR_EGN0, u32Stamp);
5550 }
5551
5552 //-------------------------------------------------------------------------------------------------
5553 /// Get current recording time stamp
5554 /// @return DMX_FILTER_STATUS_OK - Success
5555 /// @return DMX_FILTER_STATUS_ERROR - Failure
5556 /// @note
5557 //-------------------------------------------------------------------------------------------------
MApi_DMX_Pvr_GetRecordStamp(MS_U32 * pu32Stamp)5558 DMX_FILTER_STATUS MApi_DMX_Pvr_GetRecordStamp(MS_U32* pu32Stamp)
5559 {
5560 return MApi_DMX_Pvr_Eng_GetRecordStamp(DMX_PVR_EGN0, pu32Stamp);
5561 }
5562
MApi_DMX_Pvr_Eng_Close(DMX_PVR_ENG Eng)5563 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Close(DMX_PVR_ENG Eng)
5564 {
5565
5566 #ifdef DMX_UTOPIA_20
5567
5568 MS_U32 u32Param[2] = {0, 0};
5569
5570 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5571
5572 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5573
5574 if(_DMX_IOCtrlOpen() == FALSE)
5575 return DMX_FILTER_STATUS_ERROR;
5576
5577 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Close, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5578 {
5579 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5580 return DMX_FILTER_STATUS_ERROR;
5581 }
5582
5583 #ifdef DMX_UTOPIA_2K
5584 if(_bKrenelMod == TRUE)
5585 {
5586 _PvrEngCb[Eng] = NULL;
5587 }
5588 #endif
5589
5590 if(u32Param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
5591 return DMX_FILTER_STATUS_ERROR;
5592 else
5593 return DMX_FILTER_STATUS_OK;
5594
5595 #else
5596
5597 return _MApi_DMX_Pvr_Eng_Close(Eng);
5598
5599 #endif
5600
5601 }
5602
MApi_DMX_Pvr_Eng_Pid_Open(DMX_PVR_ENG Eng,MS_U32 Pid,MS_U8 * pu8DmxId)5603 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Pid_Open(DMX_PVR_ENG Eng ,MS_U32 Pid, MS_U8* pu8DmxId)
5604 {
5605
5606 #ifdef DMX_UTOPIA_20
5607
5608 DMX_PVR_FLTTYPE_PARAM PvrFltTypeParam;
5609
5610 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5611
5612 *pu8DmxId = 0xFF;
5613
5614 if(_DMX_IOCtrlOpen() == FALSE)
5615 return DMX_FILTER_STATUS_ERROR;
5616
5617 PvrFltTypeParam.u32EngId = ((MS_U32)Eng) & 0xFF;
5618 PvrFltTypeParam.u32Pid = Pid;
5619 PvrFltTypeParam.u32CAEngSel = 0xFFFFFFFF;
5620 PvrFltTypeParam.u32SelShareFlt = 0;
5621 PvrFltTypeParam.u32DmxId = 0;
5622 PvrFltTypeParam.u32Res = 0;
5623 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_PidOpen, (void*)&PvrFltTypeParam) != UTOPIA_STATUS_SUCCESS)
5624 {
5625 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5626 return DMX_FILTER_STATUS_ERROR;
5627 }
5628
5629 *pu8DmxId = (MS_U8)(PvrFltTypeParam.u32DmxId & 0xFF);
5630
5631 if(PvrFltTypeParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
5632 return DMX_FILTER_STATUS_ERROR;
5633 else
5634 return DMX_FILTER_STATUS_OK;
5635
5636 #else
5637
5638 return _MApi_DMX_Pvr_Eng_Pid_Open(Eng, Pid, pu8DmxId);
5639
5640 #endif
5641
5642 }
5643
MApi_DMX_Pvr_Eng_Pid_Close(DMX_PVR_ENG Eng,MS_U8 u8DmxId)5644 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Pid_Close(DMX_PVR_ENG Eng ,MS_U8 u8DmxId)
5645 {
5646
5647 #ifdef DMX_UTOPIA_20
5648
5649 MS_U32 u32Param[4] = {0, 0, 0, 0};
5650
5651 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5652
5653 if(_DMX_IOCtrlOpen() == FALSE)
5654 return DMX_FILTER_STATUS_ERROR;
5655
5656 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5657 u32Param[1] = ((MS_U32)u8DmxId) & 0xFF;
5658 u32Param[2] = 0;
5659 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_PidClose, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5660 {
5661 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5662 return DMX_FILTER_STATUS_ERROR;
5663 }
5664
5665 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
5666 return DMX_FILTER_STATUS_ERROR;
5667 else
5668 return DMX_FILTER_STATUS_OK;
5669
5670 #else
5671
5672 return _MApi_DMX_Pvr_Eng_Pid_Close(Eng, u8DmxId);
5673
5674 #endif
5675
5676 }
5677
MApi_DMX_Pvr_Eng_Start(DMX_PVR_ENG Eng,MS_BOOL bPvrAll)5678 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Start(DMX_PVR_ENG Eng, MS_BOOL bPvrAll)
5679 {
5680
5681 #ifdef DMX_UTOPIA_20
5682 MS_U32 u32Param[4] = {0, 0, 0, 0};
5683
5684 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5685
5686 if(_DMX_IOCtrlOpen() == FALSE)
5687 return DMX_FILTER_STATUS_ERROR;
5688
5689 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5690 u32Param[1] = ((MS_U32)bPvrAll) & 0xFF;
5691 u32Param[2] = 0;
5692 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Start, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5693 {
5694 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5695 return DMX_FILTER_STATUS_ERROR;
5696 }
5697
5698 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
5699 return DMX_FILTER_STATUS_ERROR;
5700 else
5701 return DMX_FILTER_STATUS_OK;
5702 #else
5703
5704 return _MApi_DMX_Pvr_Eng_Start(Eng, bPvrAll);
5705
5706 #endif
5707
5708 }
5709
MApi_DMX_Pvr_Eng_Stop(DMX_PVR_ENG Eng)5710 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Stop(DMX_PVR_ENG Eng)
5711 {
5712 #ifdef DMX_UTOPIA_20
5713
5714 MS_U32 u32Param[3] = {0, 0, 0};
5715
5716 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5717
5718
5719 if(_DMX_IOCtrlOpen() == FALSE)
5720 return DMX_FILTER_STATUS_ERROR;
5721
5722 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5723 u32Param[1] = 0;
5724 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Stop, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5725 {
5726 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5727 return DMX_FILTER_STATUS_ERROR;
5728 }
5729
5730 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5731 return DMX_FILTER_STATUS_ERROR;
5732 else
5733 return DMX_FILTER_STATUS_OK;
5734
5735 #else
5736
5737 return _MApi_DMX_Pvr_Eng_Stop(Eng);
5738
5739 #endif
5740
5741 }
5742
MApi_DMX_Pvr_Eng_WriteGet(DMX_PVR_ENG Eng,MS_PHY * pphyWrite)5743 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_WriteGet(DMX_PVR_ENG Eng ,MS_PHY* pphyWrite)
5744 {
5745 #ifdef DMX_UTOPIA_20
5746
5747 MS_U32 u32Param[4] = {0, 0, 0, 0};
5748 void* ptrTmp = (void*)(&u32Param[1]);
5749
5750 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5751
5752 *pphyWrite = 0;
5753
5754 if(_DMX_IOCtrlOpen() == FALSE)
5755 return DMX_FILTER_STATUS_ERROR;
5756
5757 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5758 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_GetWriteAddr, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5759 {
5760 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5761 return DMX_FILTER_STATUS_ERROR;
5762 }
5763
5764 *pphyWrite = *((MS_PHY*)ptrTmp);
5765
5766 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
5767 return DMX_FILTER_STATUS_ERROR;
5768 else
5769 return DMX_FILTER_STATUS_OK;
5770
5771 #else
5772
5773 return _MApi_DMX_Pvr_Eng_WriteGet(Eng, pphyWrite);
5774
5775 #endif
5776
5777 }
5778
MApi_DMX_Pvr_Eng_SetPacketMode(DMX_PVR_ENG Eng,MS_BOOL bSet)5779 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_SetPacketMode(DMX_PVR_ENG Eng ,MS_BOOL bSet)
5780 {
5781
5782 #ifdef DMX_UTOPIA_20
5783
5784 MS_U32 u32Param[3] = {0, 0, 0};
5785
5786 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5787
5788 if(_DMX_IOCtrlOpen() == FALSE)
5789 return DMX_FILTER_STATUS_ERROR;
5790
5791 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5792 u32Param[1] = ((MS_U32)bSet) & 0xFF;
5793 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_SetPktMode, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5794 {
5795 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5796 return DMX_FILTER_STATUS_ERROR;
5797 }
5798
5799 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5800 return DMX_FILTER_STATUS_ERROR;
5801 else
5802 return DMX_FILTER_STATUS_OK;
5803
5804 #else
5805
5806 return _MApi_DMX_Pvr_Eng_SetPacketMode(Eng, bSet);
5807
5808 #endif
5809 }
5810
MApi_DMX_Pvr_Eng_SetRecordStamp(DMX_PVR_ENG Eng,MS_U32 u32Stamp)5811 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_SetRecordStamp(DMX_PVR_ENG Eng ,MS_U32 u32Stamp)
5812 {
5813
5814 #ifdef DMX_UTOPIA_20
5815
5816 MS_U32 u32Param[3] = {0, 0, 0};
5817
5818 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5819
5820 if(_DMX_IOCtrlOpen() == FALSE)
5821 return DMX_FILTER_STATUS_ERROR;
5822
5823 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5824 u32Param[1] = u32Stamp;
5825 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_SetRecordStamp, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5826 {
5827 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5828 return DMX_FILTER_STATUS_ERROR;
5829 }
5830
5831 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5832 return DMX_FILTER_STATUS_ERROR;
5833 else
5834 return DMX_FILTER_STATUS_OK;
5835
5836 #else
5837
5838 return _MApi_DMX_Pvr_Eng_SetRecordStamp(Eng, u32Stamp);
5839
5840 #endif
5841
5842 }
5843
MApi_DMX_Pvr_Eng_GetRecordStamp(DMX_PVR_ENG Eng,MS_U32 * pu32Stamp)5844 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_GetRecordStamp(DMX_PVR_ENG Eng ,MS_U32* pu32Stamp)
5845 {
5846
5847 #ifdef DMX_UTOPIA_20
5848
5849 MS_U32 u32Param[3] = {0, 0, 0};
5850
5851 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5852
5853 *pu32Stamp = 0;
5854
5855 if(_DMX_IOCtrlOpen() == FALSE)
5856 return DMX_FILTER_STATUS_ERROR;
5857
5858 u32Param[0] = ((MS_U32)Eng) & 0xFF;
5859 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_GetRecordStamp, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
5860 {
5861 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5862 return DMX_FILTER_STATUS_ERROR;
5863 }
5864
5865 *pu32Stamp = u32Param[1];
5866
5867 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
5868 return DMX_FILTER_STATUS_ERROR;
5869 else
5870 return DMX_FILTER_STATUS_OK;
5871
5872 #else
5873
5874 return _MApi_DMX_Pvr_Eng_GetRecordStamp(Eng, pu32Stamp);
5875
5876 #endif
5877
5878 }
5879
MApi_DMX_Pvr_Eng_SetPlaybackStampClk(MS_U8 u8Eng,DMX_TimeStamp_Clk eClkSrc)5880 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_SetPlaybackStampClk(MS_U8 u8Eng, DMX_TimeStamp_Clk eClkSrc)
5881 {
5882 #ifdef DMX_UTOPIA_20
5883
5884 DMX_TIMESTAMP_CLK_PARAM TimestampClk;
5885
5886 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5887
5888 if(_DMX_IOCtrlOpen() == FALSE)
5889 return DMX_FILTER_STATUS_ERROR;
5890
5891 TimestampClk.u32EngId = ((MS_U32)u8Eng) & 0xFF;
5892 TimestampClk.eClk = eClkSrc;
5893 TimestampClk.u32Res = 0;
5894 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FI_SetPlaybackStampClk, (void*)&TimestampClk) != UTOPIA_STATUS_SUCCESS)
5895 {
5896 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5897 return DMX_FILTER_STATUS_ERROR;
5898 }
5899
5900 if(TimestampClk.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
5901 return DMX_FILTER_STATUS_ERROR;
5902 else
5903 return DMX_FILTER_STATUS_OK;
5904 #else
5905
5906 return _MApi_DMX_Pvr_Eng_SetPlaybackStampClk(u8Eng, eClkSrc);
5907
5908 #endif
5909
5910 }
5911
MApi_DMX_Pvr_Eng_SetRecordStampClk(DMX_PVR_ENG Eng,DMX_TimeStamp_Clk eClkSrc)5912 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_SetRecordStampClk(DMX_PVR_ENG Eng, DMX_TimeStamp_Clk eClkSrc)
5913 {
5914
5915 #ifdef DMX_UTOPIA_20
5916
5917 DMX_TIMESTAMP_CLK_PARAM TimestampClk;
5918
5919 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5920
5921 if(_DMX_IOCtrlOpen() == FALSE)
5922 return DMX_FILTER_STATUS_ERROR;
5923
5924 TimestampClk.u32EngId = ((MS_U32)Eng) & 0xFF;
5925 TimestampClk.eClk = eClkSrc;
5926 TimestampClk.u32Res = 0;
5927
5928 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_SetRecordStampClk, (void*)&TimestampClk) != UTOPIA_STATUS_SUCCESS)
5929 {
5930 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5931 return DMX_FILTER_STATUS_ERROR;
5932 }
5933
5934 if(TimestampClk.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
5935 return DMX_FILTER_STATUS_ERROR;
5936 else
5937 return DMX_FILTER_STATUS_OK;
5938
5939 #else
5940
5941 return _MApi_DMX_Pvr_Eng_SetRecordStampClk(Eng, eClkSrc);
5942
5943 #endif
5944
5945 }
5946
MApi_DMX_LiveSrcSwitch(DMX_FILTER_TYPE TgtFlow)5947 DMX_FILTER_STATUS MApi_DMX_LiveSrcSwitch(DMX_FILTER_TYPE TgtFlow)
5948 {
5949 #ifdef DMX_UTOPIA_20
5950
5951 DMX_FLT_TYPE_PARAM FltTypeParam;
5952
5953 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5954
5955 if(_DMX_IOCtrlOpen() == FALSE)
5956 return DMX_FILTER_STATUS_ERROR;
5957
5958 FltTypeParam.u32DmxId = 0L;
5959 FltTypeParam.DmxFltType = TgtFlow;
5960 FltTypeParam.u32Res = 0;
5961 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_ChangeFltSrc, (void*)&FltTypeParam) != UTOPIA_STATUS_SUCCESS)
5962 {
5963 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5964 return DMX_FILTER_STATUS_ERROR;
5965 }
5966
5967 if(FltTypeParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
5968 return DMX_FILTER_STATUS_ERROR;
5969 else
5970 return DMX_FILTER_STATUS_OK;
5971
5972 #else
5973
5974 return _MApi_DMX_LiveSrcSwitch(TgtFlow);
5975
5976 #endif
5977
5978 }
5979
MApi_DMX_AU_BD_Mode_Enable(MS_BOOL bEnable)5980 DMX_FILTER_STATUS MApi_DMX_AU_BD_Mode_Enable(MS_BOOL bEnable)
5981 {
5982 #ifdef DMX_UTOPIA_20
5983
5984 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
5985
5986 MS_U32 u32param[2] = {0, 0};
5987
5988 u32param[0] = ((MS_U32)bEnable) & 0xFF;
5989
5990 if(_DMX_IOCtrlOpen() == FALSE)
5991 return DMX_FILTER_STATUS_ERROR;
5992
5993 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_AUBD_Enable, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
5994 {
5995 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
5996 return DMX_FILTER_STATUS_ERROR;
5997 }
5998
5999 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
6000 return DMX_FILTER_STATUS_ERROR;
6001 else
6002 return DMX_FILTER_STATUS_OK;
6003
6004 #else
6005
6006 return _MApi_DMX_AU_BD_Mode_Enable(bEnable);
6007
6008 #endif
6009
6010 }
6011
MApi_DMX_Get_PipeId(DMX_PIPEID_GROUP eGroup,DMX_GENERAL_ENGID EngId,MS_U32 * pu32PipeId)6012 DMX_FILTER_STATUS MApi_DMX_Get_PipeId(DMX_PIPEID_GROUP eGroup, DMX_GENERAL_ENGID EngId, MS_U32 *pu32PipeId)
6013 {
6014 #ifdef DMX_UTOPIA_20
6015
6016 MS_U32 u32param[4] = {0, 0, 0, 0};
6017
6018 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6019
6020 if(_DMX_IOCtrlOpen() == FALSE)
6021 return DMX_FILTER_STATUS_ERROR;
6022
6023 u32param[0] = (MS_U32)eGroup;
6024
6025 switch(eGroup)
6026 {
6027 case DMX_PIPEID_GRP_PVR:
6028 u32param[1] = (MS_U32)(EngId.PvrEng);
6029 break;
6030 case DMX_PIPEID_GRP_FILE:
6031 u32param[1] = (MS_U32)(EngId.FileinPath);
6032 break;
6033 case DMX_PIPEID_GRP_MMFI:
6034 u32param[1] = (MS_U32)(EngId.MmfiPath);
6035 break;
6036 default:
6037 return DMX_FILTER_STATUS_ERROR;
6038 }
6039
6040 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Get_PipeId, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
6041 {
6042 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6043 return DMX_FILTER_STATUS_ERROR;
6044 }
6045
6046 *pu32PipeId = u32param[2];
6047
6048 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
6049 return DMX_FILTER_STATUS_ERROR;
6050 else
6051 return DMX_FILTER_STATUS_OK;
6052
6053 #else
6054 return _MApi_DMX_Get_PipeId(eGroup, EngId, pu32PipeId);
6055 #endif
6056
6057 }
6058
MApi_DMX_CMD_Run(MS_U32 u32Cmd,MS_U32 u32Config,MS_U32 u32DataNum,void * pData)6059 DMX_FILTER_STATUS MApi_DMX_CMD_Run(MS_U32 u32Cmd, MS_U32 u32Config, MS_U32 u32DataNum, void *pData)
6060 {
6061 #ifdef DMX_UTOPIA_20
6062
6063 DMX_CMDRUN_PARAM CmdRunParam;
6064
6065 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6066
6067 if(_DMX_IOCtrlOpen() == FALSE)
6068 return DMX_FILTER_STATUS_ERROR;
6069
6070 CmdRunParam.u32Cmd = u32Cmd;
6071 CmdRunParam.u32Config = u32Config;
6072 CmdRunParam.u32DataNum = u32DataNum;
6073 CmdRunParam.pData = pData;
6074 CmdRunParam.u32Res= 0;
6075 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_CmdRun, (void*)&CmdRunParam) != UTOPIA_STATUS_SUCCESS)
6076 {
6077 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6078 return DMX_FILTER_STATUS_ERROR;
6079 }
6080
6081 if(CmdRunParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6082 return DMX_FILTER_STATUS_ERROR;
6083 else
6084 return DMX_FILTER_STATUS_OK;
6085
6086 #else
6087
6088 return _MApi_DMX_CMD_Run(u32Cmd, u32Config, u32DataNum, pData);
6089
6090 #endif
6091 }
6092
MApi_DMX_SetPowerState(EN_POWER_MODE u16PowerState,MS_PHY phyFWAddr,MS_U32 u32FWSize)6093 MS_U32 MApi_DMX_SetPowerState(EN_POWER_MODE u16PowerState, MS_PHY phyFWAddr, MS_U32 u32FWSize)
6094 {
6095 #ifdef DMX_UTOPIA_20
6096
6097 DMX_POWSTATE_PARAM PowSteParam;
6098
6099 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6100
6101 if(_DMX_IOCtrlOpen() == FALSE)
6102 return DMX_FILTER_STATUS_ERROR;
6103
6104 PowSteParam.u16PowerState = u16PowerState;
6105 PowSteParam.u32FWAddr = phyFWAddr;
6106 PowSteParam.u32FWSize = u32FWSize;
6107 PowSteParam.u32Res = 0;
6108 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetPowerState, (void*)&PowSteParam) != UTOPIA_STATUS_SUCCESS)
6109 {
6110 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6111 return DMX_FILTER_STATUS_ERROR;
6112 }
6113
6114 if(PowSteParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6115 return DMX_FILTER_STATUS_ERROR;
6116 else
6117 return DMX_FILTER_STATUS_OK;
6118
6119 #else
6120
6121 return _MApi_DMX_SetPowerState(u16PowerState, phyFWAddr, u32FWSize);
6122
6123 #endif
6124 }
6125
MApi_DMX_SetPacketMode(DMX_FLOW DmxFlow,DMX_PacketMode ePktMode)6126 DMX_FILTER_STATUS MApi_DMX_SetPacketMode(DMX_FLOW DmxFlow, DMX_PacketMode ePktMode)
6127 {
6128 #ifdef DMX_UTOPIA_20
6129
6130 DMX_PKT_MODE_PARAM stPktMode;
6131
6132 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6133
6134 if(_DMX_IOCtrlOpen() == FALSE)
6135 return DMX_FILTER_STATUS_ERROR;
6136
6137 stPktMode.eFlow = DmxFlow;
6138 stPktMode.ePktMode = ePktMode;
6139 stPktMode.u32Res = 0;
6140 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetPktMode, (void*)&stPktMode) != UTOPIA_STATUS_SUCCESS)
6141 {
6142 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6143 return DMX_FILTER_STATUS_ERROR;
6144 }
6145
6146 return stPktMode.u32Res;
6147
6148 #else
6149
6150 return _MApi_DMX_SetPacketMode(DmxFlow, ePktMode);
6151
6152 #endif
6153 }
6154
MApi_DMX_SetMergeStrSyncByte(MS_U32 u32SrcID,MS_U8 u8SyncByte)6155 DMX_FILTER_STATUS MApi_DMX_SetMergeStrSyncByte(MS_U32 u32SrcID, MS_U8 u8SyncByte)
6156 {
6157 #ifdef DMX_UTOPIA_20
6158
6159 MS_U32 u32Param[3] = {0, 0, 0};
6160
6161 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6162
6163 if(_DMX_IOCtrlOpen() == FALSE)
6164 return DMX_FILTER_STATUS_ERROR;
6165
6166 u32Param[0] = u32SrcID;
6167 u32Param[1] = (MS_U32)u8SyncByte;
6168 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetMergeStrSync, (void*)&u32Param) != UTOPIA_STATUS_SUCCESS)
6169 {
6170 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6171 return DMX_FILTER_STATUS_ERROR;
6172 }
6173
6174 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6175 return DMX_FILTER_STATUS_ERROR;
6176 else
6177 return DMX_FILTER_STATUS_OK;
6178
6179 #else
6180
6181 return _MApi_DMX_SetMergeStrSyncByte(u32SrcID, u8SyncByte);
6182
6183 #endif
6184 }
6185
MApi_DMX_TSO_Filein_Info(MS_U8 u8Eng,DMX_Filein_info * pFileinInfo)6186 DMX_FILTER_STATUS MApi_DMX_TSO_Filein_Info(MS_U8 u8Eng, DMX_Filein_info *pFileinInfo)
6187 {
6188 #ifdef DMX_UTOPIA_20
6189
6190 DMX_FILE_INFO_PARAM stFileInfo;
6191
6192 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6193
6194 if(_DMX_IOCtrlOpen() == FALSE)
6195 return DMX_FILTER_STATUS_ERROR;
6196
6197 stFileInfo.u32EngId = (MS_U32)u8Eng;
6198 stFileInfo.pFileinInfo = pFileinInfo;
6199 stFileInfo.u32Res = 0;
6200 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileInfo, (void*)&stFileInfo) != UTOPIA_STATUS_SUCCESS)
6201 {
6202 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6203 return DMX_FILTER_STATUS_ERROR;
6204 }
6205
6206 if(stFileInfo.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6207 return DMX_FILTER_STATUS_ERROR;
6208 else
6209 return DMX_FILTER_STATUS_OK;
6210
6211 #else
6212
6213 return _MApi_DMX_TSO_Filein_Info(u8Eng, pFileinInfo);
6214 #endif
6215
6216 }
6217
MApi_DMX_TSO_Filein_IsIdle(MS_U8 u8Eng)6218 MS_BOOL MApi_DMX_TSO_Filein_IsIdle(MS_U8 u8Eng)
6219 {
6220 #ifdef DMX_UTOPIA_20
6221
6222 MS_U32 u32parem[2] = {0, 0};
6223
6224 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6225
6226 if(_DMX_IOCtrlOpen() == FALSE)
6227 return FALSE;
6228
6229 u32parem[0] = (MS_U32)u8Eng;
6230 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileIsIdle, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6231 {
6232 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6233 return DMX_FILTER_STATUS_ERROR;
6234 }
6235
6236 return (MS_BOOL)(u32parem[1]);
6237
6238 #else
6239
6240 return _MApi_DMX_TSO_Filein_IsIdle(u8Eng);
6241 #endif
6242
6243 }
6244
MApi_DMX_TSO_Filein_CMDQ_GetEmptyNum(MS_U8 u8Eng,MS_U32 * pu32EmptySlot)6245 DMX_FILTER_STATUS MApi_DMX_TSO_Filein_CMDQ_GetEmptyNum(MS_U8 u8Eng, MS_U32 *pu32EmptySlot)
6246 {
6247 #ifdef DMX_UTOPIA_20
6248
6249 MS_U32 u32parem[3] = {0, 0, 0};
6250
6251 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6252
6253 *pu32EmptySlot = 0;
6254
6255 if(_DMX_IOCtrlOpen() == FALSE)
6256 return DMX_FILTER_STATUS_ERROR;
6257
6258 u32parem[0] = (MS_U32)u8Eng;
6259 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileGetCmdQEmptyNum, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6260 {
6261 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6262 return DMX_FILTER_STATUS_ERROR;
6263 }
6264
6265 *pu32EmptySlot = u32parem[1];
6266
6267 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6268 return DMX_FILTER_STATUS_ERROR;
6269 else
6270 return DMX_FILTER_STATUS_OK;
6271
6272 #else
6273
6274 return _MApi_DMX_TSO_Filein_CMDQ_GetEmptyNum(u8Eng, pu32EmptySlot);
6275 #endif
6276
6277 }
6278
MApi_DMX_TSO_Filein_CMDQ_Reset(MS_U8 u8Eng)6279 DMX_FILTER_STATUS MApi_DMX_TSO_Filein_CMDQ_Reset(MS_U8 u8Eng)
6280 {
6281 #ifdef DMX_UTOPIA_20
6282
6283 MS_U32 u32parem[2] = {0, 0};
6284
6285 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6286
6287 if(_DMX_IOCtrlOpen() == FALSE)
6288 return DMX_FILTER_STATUS_ERROR;
6289
6290 u32parem[0] = ((MS_U32)u8Eng) & 0xFF;
6291 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_CmdQReset, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6292 {
6293 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6294 return DMX_FILTER_STATUS_ERROR;
6295 }
6296
6297 if(u32parem[1] != (MS_U32)DMX_FILTER_STATUS_OK)
6298 return DMX_FILTER_STATUS_ERROR;
6299 else
6300 return DMX_FILTER_STATUS_OK;
6301
6302 #else
6303
6304 return _MApi_DMX_TSO_Filein_CMDQ_Reset(u8Eng);
6305 #endif
6306
6307 }
6308
MApi_DMX_TSO_Filein_Start(MS_U8 u8Eng,MS_PHY pBuf,MS_U32 u32BufSize)6309 DMX_FILTER_STATUS MApi_DMX_TSO_Filein_Start(MS_U8 u8Eng, MS_PHY pBuf, MS_U32 u32BufSize)
6310 {
6311 #ifdef DMX_UTOPIA_20
6312
6313 MS_U32 u32parem[5] = {0, 0, 0, 0, 0};
6314
6315 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6316
6317 if(_DMX_IOCtrlOpen() == FALSE)
6318 return DMX_FILTER_STATUS_ERROR;
6319
6320 u32parem[0] = (MS_U32)u8Eng;
6321 _DMX_PhyAddr_To_U32Param(pBuf, u32parem+1);
6322 u32parem[3] = u32BufSize;
6323 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileStart, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6324 {
6325 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6326 return DMX_FILTER_STATUS_ERROR;
6327 }
6328
6329 if(u32parem[4] != (MS_U32)DMX_FILTER_STATUS_OK)
6330 return DMX_FILTER_STATUS_ERROR;
6331 else
6332 return DMX_FILTER_STATUS_OK;
6333
6334 #else
6335
6336 return _MApi_DMX_TSO_Filein_Start(u8Eng, pBuf, u32BufSize);
6337 #endif
6338
6339 }
6340
MApi_DMX_TSO_Filein_Stop(MS_U8 u8Eng)6341 DMX_FILTER_STATUS MApi_DMX_TSO_Filein_Stop(MS_U8 u8Eng)
6342 {
6343 #ifdef DMX_UTOPIA_20
6344
6345 MS_U32 u32parem[2] = {0, 0};
6346
6347 u32parem[0] = ((MS_U32)u8Eng) & 0xFF;
6348
6349 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6350
6351 if(_DMX_IOCtrlOpen() == FALSE)
6352 return DMX_FILTER_STATUS_ERROR;
6353
6354 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileStop, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6355 {
6356 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6357 return DMX_FILTER_STATUS_ERROR;
6358 }
6359
6360 if(u32parem[1] != (MS_U32)DMX_FILTER_STATUS_OK)
6361 return DMX_FILTER_STATUS_ERROR;
6362 else
6363 return DMX_FILTER_STATUS_OK;
6364
6365 #else
6366
6367 return _MApi_DMX_TSO_Filein_Stop(u8Eng);
6368 #endif
6369
6370 }
6371
MApi_DMX_TSO_SetPlaybackTimeStamp(MS_U8 u8Eng,MS_U32 u32Stamp)6372 DMX_FILTER_STATUS MApi_DMX_TSO_SetPlaybackTimeStamp(MS_U8 u8Eng, MS_U32 u32Stamp)
6373 {
6374 #ifdef DMX_UTOPIA_20
6375
6376 MS_U32 u32parem[4] = {0, 0, 0, 0};
6377
6378 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6379
6380 if(_DMX_IOCtrlOpen() == FALSE)
6381 return DMX_FILTER_STATUS_ERROR;
6382
6383 u32parem[0] = ((MS_U32)u8Eng) & 0xFF;
6384 u32parem[1] = u32Stamp;
6385 u32parem[2] = 1;
6386 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FilePlayStamp, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6387 {
6388 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6389 return DMX_FILTER_STATUS_ERROR;
6390 }
6391
6392 if(u32parem[3] != (MS_U32)DMX_FILTER_STATUS_OK)
6393 return DMX_FILTER_STATUS_ERROR;
6394 else
6395 return DMX_FILTER_STATUS_OK;
6396
6397 #else
6398
6399 return _MApi_DMX_TSO_SetPlaybackTimeStamp(u8Eng, u32Stamp);
6400 #endif
6401
6402 }
6403
MApi_DMX_TSO_GetPlaybackStamp(MS_U8 u8Eng,MS_U32 * pu32Stamp)6404 DMX_FILTER_STATUS MApi_DMX_TSO_GetPlaybackStamp(MS_U8 u8Eng, MS_U32* pu32Stamp)
6405 {
6406 #ifdef DMX_UTOPIA_20
6407
6408 MS_U32 u32parem[4] = {0, 0, 0, 0};
6409
6410 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6411
6412 *pu32Stamp = 0;
6413
6414 if(_DMX_IOCtrlOpen() == FALSE)
6415 return DMX_FILTER_STATUS_ERROR;
6416
6417 u32parem[0] = ((MS_U32)u8Eng) & 0xFF;
6418 u32parem[2] = 0;
6419 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FilePlayStamp, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6420 {
6421 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6422 return DMX_FILTER_STATUS_ERROR;
6423 }
6424
6425 *pu32Stamp = u32parem[1];
6426
6427 if(u32parem[3] != (MS_U32)DMX_FILTER_STATUS_OK)
6428 return DMX_FILTER_STATUS_ERROR;
6429 else
6430 return DMX_FILTER_STATUS_OK;
6431
6432 #else
6433
6434 return _MApi_DMX_TSO_GetPlaybackStamp(u8Eng, pu32Stamp);
6435
6436 #endif
6437
6438 }
6439
MApi_DMX_TSO_GetFileInTimeStamp(MS_U8 u8Eng,MS_U32 * pu32Stamp)6440 DMX_FILTER_STATUS MApi_DMX_TSO_GetFileInTimeStamp(MS_U8 u8Eng, MS_U32 *pu32Stamp)
6441 {
6442 #ifdef DMX_UTOPIA_20
6443
6444 MS_U32 u32parem[3] = {0, 0, 0};
6445
6446 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6447
6448 *pu32Stamp = 0;
6449
6450 if(_DMX_IOCtrlOpen() == FALSE)
6451 return DMX_FILTER_STATUS_ERROR;
6452
6453 u32parem[0] = (MS_U32)u8Eng;
6454 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileGetTimeStamp, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6455 {
6456 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6457 return DMX_FILTER_STATUS_ERROR;
6458 }
6459
6460 *pu32Stamp = u32parem[1];
6461
6462 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6463 return DMX_FILTER_STATUS_ERROR;
6464 else
6465 return DMX_FILTER_STATUS_OK;
6466 #else
6467
6468 return _MApi_DMX_TSO_GetFileInTimeStamp(u8Eng, pu32Stamp);
6469
6470 #endif
6471
6472 }
6473
MApi_DMX_TSO_BypassFileInTimeStamp(MS_U8 u8Eng,MS_BOOL bbypass)6474 DMX_FILTER_STATUS MApi_DMX_TSO_BypassFileInTimeStamp(MS_U8 u8Eng, MS_BOOL bbypass)
6475 {
6476 #ifdef DMX_UTOPIA_20
6477
6478 MS_U32 u32parem[3] = {0, 0, 0};
6479
6480 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6481
6482 if(_DMX_IOCtrlOpen() == FALSE)
6483 return DMX_FILTER_STATUS_ERROR;
6484
6485 u32parem[0] = (MS_U32)u8Eng;
6486 u32parem[1] = (MS_U32)bbypass;
6487 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileBypassStamp, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6488 {
6489 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6490 return DMX_FILTER_STATUS_ERROR;
6491 }
6492
6493 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6494 return DMX_FILTER_STATUS_ERROR;
6495 else
6496 return DMX_FILTER_STATUS_OK;
6497
6498 #else
6499
6500 return _MApi_DMX_TSO_BypassFileInTimeStamp(u8Eng, bbypass);
6501
6502 #endif
6503
6504 }
6505
MApi_DMX_TSO_TimeStampEnable(MS_U8 u8Eng)6506 DMX_FILTER_STATUS MApi_DMX_TSO_TimeStampEnable(MS_U8 u8Eng)
6507 {
6508 #ifdef DMX_UTOPIA_20
6509
6510 MS_U32 u32parem[3] = {0, 0, 0};
6511
6512 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6513
6514 if(_DMX_IOCtrlOpen() == FALSE)
6515 return DMX_FILTER_STATUS_ERROR;
6516
6517 u32parem[0] = (MS_U32)u8Eng;
6518 u32parem[1] = 1;
6519 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileTimeStampEnable, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6520 {
6521 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6522 return DMX_FILTER_STATUS_ERROR;
6523 }
6524
6525 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6526 return DMX_FILTER_STATUS_ERROR;
6527 else
6528 return DMX_FILTER_STATUS_OK;
6529 #else
6530
6531 return _MApi_DMX_TSO_TimeStampEnable(u8Eng);
6532
6533 #endif
6534
6535 }
6536
MApi_DMX_TSO_TimeStampDisable(MS_U8 u8Eng)6537 DMX_FILTER_STATUS MApi_DMX_TSO_TimeStampDisable(MS_U8 u8Eng)
6538 {
6539 #ifdef DMX_UTOPIA_20
6540
6541 MS_U32 u32parem[3] = {0, 0, 0};
6542
6543 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6544
6545 if(_DMX_IOCtrlOpen() == FALSE)
6546 return DMX_FILTER_STATUS_ERROR;
6547
6548 u32parem[0] = (MS_U32)u8Eng;
6549 u32parem[1] = 0;
6550 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FileTimeStampEnable, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6551 {
6552 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6553 return DMX_FILTER_STATUS_ERROR;
6554 }
6555
6556 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6557 return DMX_FILTER_STATUS_ERROR;
6558 else
6559 return DMX_FILTER_STATUS_OK;
6560
6561 #else
6562
6563 return _MApi_DMX_TSO_TimeStampDisable(u8Eng);
6564 #endif
6565
6566 }
6567
MApi_DMX_TSO_SetOutClk(MS_U8 u8Eng,DMX_TSO_OutClk eTsOutClk,DMX_TSO_OutClkSrc eTsOutClkSrc,MS_U16 u16DivNum,MS_BOOL bClkInv)6568 DMX_FILTER_STATUS MApi_DMX_TSO_SetOutClk(MS_U8 u8Eng, DMX_TSO_OutClk eTsOutClk, DMX_TSO_OutClkSrc eTsOutClkSrc, MS_U16 u16DivNum, MS_BOOL bClkInv)
6569 {
6570 #ifdef DMX_UTOPIA_20
6571
6572 DMX_TSO_OUTCLK_PARAM stParam;
6573
6574 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6575
6576 if(_DMX_IOCtrlOpen() == FALSE)
6577 return DMX_FILTER_STATUS_ERROR;
6578
6579 stParam.u32Res = 0;
6580 stParam.u32Eng = (MS_U32)u8Eng;
6581 stParam.eTsoOutClk = eTsOutClk;
6582 stParam.eTsoOutClkSrc = eTsOutClkSrc;
6583 stParam.u16DivNum = u16DivNum;
6584 stParam.bClkInv = bClkInv;
6585 stParam.bSet = TRUE;
6586 stParam.u32Res = 0;
6587 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_OutClk, (void*)&stParam) != UTOPIA_STATUS_SUCCESS)
6588 {
6589 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6590 return DMX_FILTER_STATUS_ERROR;
6591 }
6592
6593 if(stParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6594 return DMX_FILTER_STATUS_ERROR;
6595 else
6596 return DMX_FILTER_STATUS_OK;
6597
6598 #else
6599
6600 return _MApi_DMX_TSO_SetOutClk(u8Eng, eTsOutClk, eTsOutClkSrc, u16DivNum, bClkInv);
6601 #endif
6602
6603 }
6604
MApi_DMX_TSO_OutputEnable(MS_U8 u8Eng,MS_BOOL bEnable)6605 DMX_FILTER_STATUS MApi_DMX_TSO_OutputEnable(MS_U8 u8Eng, MS_BOOL bEnable)
6606 {
6607 #ifdef DMX_UTOPIA_20
6608
6609 MS_U32 u32Param[3] = {0, 0, 0};
6610
6611 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6612
6613 if(_DMX_IOCtrlOpen() == FALSE)
6614 return DMX_FILTER_STATUS_ERROR;
6615
6616 u32Param[0] = ((MS_U32)u8Eng) & 0xFF;
6617 u32Param[1] = ((MS_U32)bEnable) & 0xFF;
6618 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_OutputEn, (void*)&u32Param) != UTOPIA_STATUS_SUCCESS)
6619 {
6620 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6621 return DMX_FILTER_STATUS_ERROR;
6622 }
6623
6624 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6625 return DMX_FILTER_STATUS_ERROR;
6626 else
6627 return DMX_FILTER_STATUS_OK;
6628
6629 #else
6630
6631 return _MApi_DMX_TSO_OutputEnable(u8Eng, bEnable);
6632 #endif
6633
6634 }
6635
MApi_DMX_TSO_LocalStreamId(MS_U8 u8Eng,DMX_TSIF eIf,MS_U8 * pu8StrId,MS_BOOL bSet)6636 DMX_FILTER_STATUS MApi_DMX_TSO_LocalStreamId(MS_U8 u8Eng, DMX_TSIF eIf, MS_U8* pu8StrId, MS_BOOL bSet)
6637 {
6638 #ifdef DMX_UTOPIA_20
6639
6640 DMX_TSO_LOCSTRID_PARAM stParam;
6641
6642 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6643
6644 if(bSet == FALSE)
6645 {
6646 *pu8StrId = 0xFF;
6647 }
6648 if(_DMX_IOCtrlOpen() == FALSE)
6649 return DMX_FILTER_STATUS_ERROR;
6650
6651 stParam.u8Eng = u8Eng;
6652 stParam.eIf = eIf;
6653 stParam.pu8StrId = pu8StrId;
6654 stParam.bSet = bSet;
6655 stParam.u32Res = 0;
6656 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_LocStrId, (void*)&stParam) != UTOPIA_STATUS_SUCCESS)
6657 {
6658 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6659 return DMX_FILTER_STATUS_ERROR;
6660 }
6661
6662 if(stParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6663 return DMX_FILTER_STATUS_ERROR;
6664 else
6665 return DMX_FILTER_STATUS_OK;
6666 #else
6667
6668 return _MApi_DMX_TSO_LocalStreamId(u8Eng, eIf, pu8StrId, bSet);
6669 #endif
6670
6671 }
6672
MApi_DMX_TSO_SVQBuf_Set(MS_U8 u8Eng,MS_PHY phyAddr,MS_U32 u32BufSize)6673 DMX_FILTER_STATUS MApi_DMX_TSO_SVQBuf_Set(MS_U8 u8Eng, MS_PHY phyAddr, MS_U32 u32BufSize)
6674 {
6675 #ifdef DMX_UTOPIA_20
6676
6677 MS_U32 u32parem[5] = {0, 0, 0, 0, 0};
6678
6679 if(_DMX_IOCtrlOpen() == FALSE)
6680 return DMX_FILTER_STATUS_ERROR;
6681
6682 u32parem[0] = (MS_U32)(u8Eng & 0xFF);
6683 _DMX_PhyAddr_To_U32Param(phyAddr, u32parem+1);
6684 u32parem[3] = u32BufSize;
6685 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_SvqBufSet, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6686 {
6687 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6688 return DMX_FILTER_STATUS_ERROR;
6689 }
6690
6691 if(u32parem[4] != (MS_U32)DMX_FILTER_STATUS_OK)
6692 return DMX_FILTER_STATUS_ERROR;
6693 else
6694 return DMX_FILTER_STATUS_OK;
6695 #else
6696
6697 return _MApi_DMX_TSO_SVQBuf_Set(u8Eng, phyAddr, u32BufSize);
6698 #endif
6699 }
6700
MApi_DMX_TSO_Flow_InputCfg(DMX_TSO_InputCfg * pstInputCfg)6701 DMX_FILTER_STATUS MApi_DMX_TSO_Flow_InputCfg(DMX_TSO_InputCfg* pstInputCfg)
6702 {
6703 #ifdef DMX_UTOPIA_20
6704
6705 if(_DMX_IOCtrlOpen() == FALSE)
6706 return DMX_FILTER_STATUS_ERROR;
6707
6708 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_InputCfg, (void*)pstInputCfg) != UTOPIA_STATUS_SUCCESS)
6709 {
6710 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6711 return DMX_FILTER_STATUS_ERROR;
6712 }
6713
6714 if(pstInputCfg->u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6715 return DMX_FILTER_STATUS_ERROR;
6716 else
6717 return DMX_FILTER_STATUS_OK;
6718
6719 #else
6720
6721 return _MApi_DMX_TSO_Flow_InputCfg(pstInputCfg);
6722
6723 #endif
6724 }
6725
MApi_DMX_TSO_Flow_OutputCfg(DMX_TSO_OutputCfg * pstOutputCfg)6726 DMX_FILTER_STATUS MApi_DMX_TSO_Flow_OutputCfg(DMX_TSO_OutputCfg* pstOutputCfg)
6727 {
6728 #ifdef DMX_UTOPIA_20
6729
6730 if(_DMX_IOCtrlOpen() == FALSE)
6731 return DMX_FILTER_STATUS_ERROR;
6732
6733 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_OutputCfg, (void*)pstOutputCfg) != UTOPIA_STATUS_SUCCESS)
6734 {
6735 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6736 return DMX_FILTER_STATUS_ERROR;
6737 }
6738
6739 if(pstOutputCfg->u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6740 return DMX_FILTER_STATUS_ERROR;
6741 else
6742 return DMX_FILTER_STATUS_OK;
6743
6744 #else
6745
6746 return _MApi_DMX_TSO_Flow_OutputCfg(pstOutputCfg);
6747
6748 #endif
6749 }
6750
MApi_DMX_TSO_Configure(DMX_TSO_Cfg * pstTsoCfg)6751 DMX_FILTER_STATUS MApi_DMX_TSO_Configure(DMX_TSO_Cfg* pstTsoCfg)
6752 {
6753 #ifdef DMX_UTOPIA_20
6754
6755 DMX_V2DBGMSG(printf("[%s] %d\n", __FUNCTION__, __LINE__));
6756
6757 if(_DMX_IOCtrlOpen() == FALSE)
6758 return DMX_FILTER_STATUS_ERROR;
6759
6760 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_Configure, (void*)pstTsoCfg) != UTOPIA_STATUS_SUCCESS)
6761 {
6762 DMX_V2DBGMSG(printf("[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6763 return DMX_FILTER_STATUS_ERROR;
6764 }
6765
6766 if(pstTsoCfg->u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6767 return DMX_FILTER_STATUS_ERROR;
6768 else
6769 return DMX_FILTER_STATUS_OK;
6770
6771 #else
6772
6773 return _MApi_DMX_TSO_Configure(pstTsoCfg);
6774
6775 #endif
6776 }
6777
MApi_DMX_TSO_Pid_Open(MS_U8 u8Eng,DMX_TSIF eTSOInSrc,MS_U16 u16Pid,MS_U16 * pu16DmxId)6778 DMX_FILTER_STATUS MApi_DMX_TSO_Pid_Open(MS_U8 u8Eng, DMX_TSIF eTSOInSrc, MS_U16 u16Pid, MS_U16* pu16DmxId)
6779 {
6780 #ifdef DMX_UTOPIA_20
6781
6782 MS_U32 u32parem[5] = {0, 0, 0, 0, 0};
6783
6784 if(_DMX_IOCtrlOpen() == FALSE)
6785 return DMX_FILTER_STATUS_ERROR;
6786
6787 u32parem[0] = ((MS_U32)u8Eng) & 0xFFUL;
6788 u32parem[1] = (MS_U32)eTSOInSrc;
6789 u32parem[2] = ((MS_U32)u16Pid) & 0xFFFFUL;
6790 u32parem[3] = 0xFFUL;
6791 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_PidOpen, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6792 {
6793 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6794 return DMX_FILTER_STATUS_ERROR;
6795 }
6796
6797 *pu16DmxId = (MS_U16)u32parem[3];
6798 if(u32parem[4] != (MS_U32)DMX_FILTER_STATUS_OK)
6799 return DMX_FILTER_STATUS_ERROR;
6800 else
6801 return DMX_FILTER_STATUS_OK;
6802
6803 #else
6804
6805 return _MApi_DMX_TSO_Pid_Open(u8Eng, eTSOInSrc, u16Pid, pu16DmxId);
6806
6807 #endif
6808 }
6809
MApi_DMX_TSO_Pid_Close(MS_U8 u8Eng,MS_U16 u16DmxId)6810 DMX_FILTER_STATUS MApi_DMX_TSO_Pid_Close(MS_U8 u8Eng, MS_U16 u16DmxId)
6811 {
6812 #ifdef DMX_UTOPIA_20
6813
6814 MS_U32 u32parem[3] = {0, 0, 0};
6815
6816 u32parem[0] = ((MS_U32)u8Eng) & 0xFFUL;
6817 u32parem[1] = ((MS_U32)u16DmxId) & 0xFFFFUL;
6818
6819 if(_DMX_IOCtrlOpen() == FALSE)
6820 return DMX_FILTER_STATUS_ERROR;
6821
6822 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_PidClose, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6823 {
6824 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6825 return DMX_FILTER_STATUS_ERROR;
6826 }
6827
6828 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6829 return DMX_FILTER_STATUS_ERROR;
6830 else
6831 return DMX_FILTER_STATUS_OK;
6832
6833 #else
6834
6835 return _MApi_DMX_TSO_Pid_Close(u8Eng, u16DmxId);
6836
6837 #endif
6838 }
6839
MApi_DMX_TSO_Filein_GetReadAddr(MS_U8 u8Eng,MS_PHY * pphyRead)6840 DMX_FILTER_STATUS MApi_DMX_TSO_Filein_GetReadAddr(MS_U8 u8Eng, MS_PHY* pphyRead)
6841 {
6842
6843 #ifdef DMX_UTOPIA_20
6844
6845 MS_U32 u32Param[4] = {0, 0, 0, 0};
6846 void* ptrTmp = (void*)(&u32Param[1]);
6847
6848 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
6849
6850 *pphyRead = 0;
6851
6852 if(_DMX_IOCtrlOpen() == FALSE)
6853 return DMX_FILTER_STATUS_ERROR;
6854
6855 u32Param[0] = (MS_U32)u8Eng;
6856 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSO_FI_GetReadAddr, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
6857 {
6858 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6859 return DMX_FILTER_STATUS_ERROR;
6860 }
6861
6862 *pphyRead = *((MS_PHY*)ptrTmp);
6863
6864 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
6865 return DMX_FILTER_STATUS_ERROR;
6866 else
6867 return DMX_FILTER_STATUS_OK;
6868
6869 #else
6870 return _MApi_DMX_TSO_Filein_GetReadAddr(u8Eng, pphyRead);
6871
6872 #endif
6873
6874 }
6875
MApi_DMX_FQ_SetFltRushPass(MS_U32 u32DmxId,MS_U8 u8Enable)6876 DMX_FILTER_STATUS MApi_DMX_FQ_SetFltRushPass(MS_U32 u32DmxId, MS_U8 u8Enable)
6877 {
6878 #ifdef DMX_UTOPIA_20
6879
6880 MS_U32 u32parem[4] = {0, 0, 0, 0};
6881
6882 if(_DMX_IOCtrlOpen() == FALSE)
6883 return DMX_FILTER_STATUS_ERROR;
6884 u32parem[0] = u32DmxId;
6885 u32parem[1] = (MS_U32)u8Enable;
6886 u32parem[2] = 0;
6887 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_SetFltRushPass, (void*)u32parem) != UTOPIA_STATUS_SUCCESS)
6888 {
6889 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6890 return DMX_FILTER_STATUS_ERROR;
6891 }
6892
6893 if(u32parem[3] != (MS_U32)DMX_FILTER_STATUS_OK)
6894 return DMX_FILTER_STATUS_ERROR;
6895 else
6896 return DMX_FILTER_STATUS_OK;
6897 #else
6898 return _MApi_DMX_FQ_SetFltRushPass(u32DmxId, u8Enable);
6899 #endif
6900
6901 }
6902
MApi_DMX_FQ_Init(MS_U32 u32FQEng,DMX_FQ_Info * pFQInfo)6903 DMX_FILTER_STATUS MApi_DMX_FQ_Init(MS_U32 u32FQEng, DMX_FQ_Info* pFQInfo)
6904 {
6905 #ifdef DMX_UTOPIA_20
6906 DMX_FQ_INIT_PARAM stParam;
6907 if(_DMX_IOCtrlOpen() == FALSE)
6908 return DMX_FILTER_STATUS_ERROR;
6909 stParam.u32Eng= u32FQEng;
6910 stParam.pInfo = pFQInfo;
6911 stParam.u32Res = 0;
6912 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_Init, (void*)&stParam) != UTOPIA_STATUS_SUCCESS)
6913 {
6914 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6915 return DMX_FILTER_STATUS_ERROR;
6916 }
6917
6918 if(stParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6919 return DMX_FILTER_STATUS_ERROR;
6920 else
6921 return DMX_FILTER_STATUS_OK;
6922
6923 #else
6924 return _MApi_DMX_FQ_Init(u32FQEng, pFQInfo);
6925 #endif
6926
6927 }
6928
MApi_DMX_FQ_Exit(MS_U32 u32FQEng)6929 DMX_FILTER_STATUS MApi_DMX_FQ_Exit(MS_U32 u32FQEng)
6930 {
6931 #ifdef DMX_UTOPIA_20
6932 MS_U32 u32parem[3] = {0, 0, 0};
6933 if(_DMX_IOCtrlOpen() == FALSE)
6934 return DMX_FILTER_STATUS_ERROR;
6935 u32parem[0] = (MS_U32)u32FQEng;
6936 u32parem[1] = 0;
6937
6938 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_Exit, (void*)&u32parem) != UTOPIA_STATUS_SUCCESS)
6939 {
6940 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6941 return DMX_FILTER_STATUS_ERROR;
6942 }
6943
6944 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6945 return DMX_FILTER_STATUS_ERROR;
6946 else
6947 return DMX_FILTER_STATUS_OK;
6948
6949 #else
6950 return _MApi_DMX_FQ_Exit(u32FQEng);
6951 #endif
6952
6953 }
6954
MApi_DMX_FQ_RushEnable(MS_U32 u32FQEng)6955 DMX_FILTER_STATUS MApi_DMX_FQ_RushEnable(MS_U32 u32FQEng)
6956 {
6957 #ifdef DMX_UTOPIA_20
6958
6959 MS_U32 u32parem[3] = {0, 0, 0};
6960 if(_DMX_IOCtrlOpen() == FALSE)
6961 return DMX_FILTER_STATUS_ERROR;
6962 u32parem[0] = (MS_U32)u32FQEng;
6963 u32parem[1] = 0;
6964
6965 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_RushEnable, (void*)&u32parem) != UTOPIA_STATUS_SUCCESS)
6966 {
6967 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6968 return DMX_FILTER_STATUS_ERROR;
6969 }
6970
6971 if(u32parem[2] != (MS_U32)DMX_FILTER_STATUS_OK)
6972 return DMX_FILTER_STATUS_ERROR;
6973 else
6974 return DMX_FILTER_STATUS_OK;
6975
6976 #else
6977 return _MApi_DMX_FQ_RushEnable(u32FQEng);
6978 #endif
6979
6980 }
6981
MApi_DMX_FQ_SkipRushData(MS_U32 u32FQEng,DMX_FQ_SkipPath eSkipPath)6982 DMX_FILTER_STATUS MApi_DMX_FQ_SkipRushData(MS_U32 u32FQEng, DMX_FQ_SkipPath eSkipPath)
6983 {
6984 #ifdef DMX_UTOPIA_20
6985
6986 DMX_FQ_SKIP_RUSH_DATA_PARAM stParam;
6987 if(_DMX_IOCtrlOpen() == FALSE)
6988 return DMX_FILTER_STATUS_ERROR;
6989 stParam.u32Eng = u32FQEng;
6990 stParam.eSkipPath = eSkipPath;
6991 stParam.u32Res = 0;
6992 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_SkipRushData, (void*)&stParam) != UTOPIA_STATUS_SUCCESS)
6993 {
6994 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
6995 return DMX_FILTER_STATUS_ERROR;
6996 }
6997
6998 if(stParam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
6999 return DMX_FILTER_STATUS_ERROR;
7000 else
7001 return DMX_FILTER_STATUS_OK;
7002
7003 #else
7004 return _MApi_DMX_FQ_SkipRushData(u32FQEng, eSkipPath);
7005 #endif
7006
7007 }
7008
MApi_DMX_FQ_Configure(DMX_FQ_Cfg * pstFqCfg)7009 DMX_FILTER_STATUS MApi_DMX_FQ_Configure(DMX_FQ_Cfg* pstFqCfg)
7010 {
7011 #ifdef DMX_UTOPIA_20
7012
7013 if(_DMX_IOCtrlOpen() == FALSE)
7014 return DMX_FILTER_STATUS_ERROR;
7015
7016 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_Configure, (void*)pstFqCfg) != UTOPIA_STATUS_SUCCESS)
7017 {
7018 DMX_V2DBGMSG(printf("[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7019 return DMX_FILTER_STATUS_ERROR;
7020 }
7021
7022 if(pstFqCfg->u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7023 return DMX_FILTER_STATUS_ERROR;
7024 else
7025 return DMX_FILTER_STATUS_OK;
7026
7027 #else
7028 return _MApi_DMX_FQ_Configure(pstFqCfg);
7029 #endif
7030 }
7031
MApi_DMX_FQ_SetRushAddr(MS_U32 u32FQEng,MS_PHY phyRushAddr)7032 DMX_FILTER_STATUS MApi_DMX_FQ_SetRushAddr(MS_U32 u32FQEng, MS_PHY phyRushAddr)
7033 {
7034 #ifdef DMX_UTOPIA_20
7035
7036 MS_U32 u32Param[4] = {0, 0, 0, 0};
7037
7038 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7039
7040 if(_DMX_IOCtrlOpen() == FALSE)
7041 return DMX_FILTER_STATUS_ERROR;
7042
7043 u32Param[0] = u32FQEng;
7044
7045 _DMX_PhyAddr_To_U32Param(phyRushAddr, u32Param+1);
7046
7047 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_SetRushAddr, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7048 {
7049 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7050 return DMX_FILTER_STATUS_ERROR;
7051 }
7052
7053 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
7054 return DMX_FILTER_STATUS_ERROR;
7055 else
7056 return DMX_FILTER_STATUS_OK;
7057
7058 #else
7059
7060 return _MApi_DMX_FQ_SetRushAddr(u32FQEng, phyRushAddr);
7061 #endif
7062
7063 }
7064
MApi_DMX_FQ_ReadGet(MS_U32 u32FQEng,MS_PHY * pphyRead)7065 DMX_FILTER_STATUS MApi_DMX_FQ_ReadGet(MS_U32 u32FQEng, MS_PHY* pphyRead)
7066 {
7067 #ifdef DMX_UTOPIA_20
7068
7069 MS_U32 u32Param[4] = {0, 0, 0, 0};
7070 void* ptrTmp = (void*)(&u32Param[1]);
7071
7072 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7073
7074 *pphyRead = 0;
7075
7076 if(_DMX_IOCtrlOpen() == FALSE)
7077 return DMX_FILTER_STATUS_ERROR;
7078
7079 u32Param[0] = ((MS_U32)u32FQEng) & 0xFF;
7080
7081 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_ReadGet, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7082 {
7083 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7084 return DMX_FILTER_STATUS_ERROR;
7085 }
7086
7087 *pphyRead= *((MS_PHY*)ptrTmp);
7088
7089 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
7090 return DMX_FILTER_STATUS_ERROR;
7091 else
7092 return DMX_FILTER_STATUS_OK;
7093
7094 #else
7095
7096 return _MApi_DMX_FQ_ReadGet(u32FQEng, pphyRead);
7097
7098 #endif
7099
7100 }
7101
MApi_DMX_FQ_WriteGet(MS_U32 u32FQEng,MS_PHY * pphyWrite)7102 DMX_FILTER_STATUS MApi_DMX_FQ_WriteGet(MS_U32 u32FQEng, MS_PHY *pphyWrite)
7103 {
7104 #ifdef DMX_UTOPIA_20
7105
7106 MS_U32 u32Param[4] = {0, 0, 0, 0};
7107 void* ptrTmp = (void*)(&u32Param[1]);
7108
7109 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7110
7111 *pphyWrite = 0;
7112
7113 if(_DMX_IOCtrlOpen() == FALSE)
7114 return DMX_FILTER_STATUS_ERROR;
7115
7116 u32Param[0] = ((MS_U32)u32FQEng) & 0xFF;
7117
7118 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_FQ_WriteGet, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7119 {
7120 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7121 return DMX_FILTER_STATUS_ERROR;
7122 }
7123
7124 *pphyWrite = *((MS_PHY*)ptrTmp);
7125
7126 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
7127 return DMX_FILTER_STATUS_ERROR;
7128 else
7129 return DMX_FILTER_STATUS_OK;
7130
7131 #else
7132
7133 return _MApi_DMX_FQ_WriteGet(u32FQEng, pphyWrite);
7134
7135 #endif
7136
7137 }
7138
7139
MApi_DMX_Get_DisContiCnt(DMX_DisContiCnt_info * pDmxInfo,MS_U32 * pu32Cnt)7140 DMX_FILTER_STATUS MApi_DMX_Get_DisContiCnt(DMX_DisContiCnt_info* pDmxInfo, MS_U32 *pu32Cnt)
7141 {
7142 #ifdef DMX_UTOPIA_20
7143
7144 DMX_PKT_DISCONCNT_PARAM Param;
7145
7146 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7147
7148 *pu32Cnt = 0;
7149
7150 if(_DMX_IOCtrlOpen() == FALSE)
7151 return DMX_FILTER_STATUS_ERROR;
7152
7153 Param.pInfo = pDmxInfo;
7154 Param.u32Cnt = 0;
7155 Param.u32Res = 0;
7156 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_DBG_GET_DISCONCNT, (void*)&Param) != UTOPIA_STATUS_SUCCESS)
7157 {
7158 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7159 return DMX_FILTER_STATUS_ERROR;
7160 }
7161
7162 *pu32Cnt = Param.u32Cnt;
7163
7164 if(Param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7165 return DMX_FILTER_STATUS_ERROR;
7166 else
7167 return DMX_FILTER_STATUS_OK;
7168
7169 #else
7170
7171 return _MApi_DMX_Get_DisContiCnt(pDmxInfo, pu32Cnt);
7172 #endif
7173
7174 }
7175
MApi_DMX_Get_DropPktCnt(DMX_DropPktCnt_info * pDmxInfo,MS_U32 * pu32Cnt)7176 DMX_FILTER_STATUS MApi_DMX_Get_DropPktCnt(DMX_DropPktCnt_info* pDmxInfo, MS_U32 *pu32Cnt)
7177 {
7178 #ifdef DMX_UTOPIA_20
7179
7180 DMX_PKT_DROPCNT_PARAM Param;
7181
7182 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7183
7184 *pu32Cnt = 0;
7185
7186 if(_DMX_IOCtrlOpen() == FALSE)
7187 return DMX_FILTER_STATUS_ERROR;
7188
7189 Param.pInfo = pDmxInfo;
7190 Param.u32Cnt = 0;
7191 Param.u32Res = 0;
7192 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_DBG_GET_DROPPKTCNT, (void*)&Param) != UTOPIA_STATUS_SUCCESS)
7193 {
7194 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7195 return DMX_FILTER_STATUS_ERROR;
7196 }
7197
7198 *pu32Cnt = Param.u32Cnt;
7199
7200 if(Param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7201 return DMX_FILTER_STATUS_ERROR;
7202 else
7203 return DMX_FILTER_STATUS_OK;
7204 #else
7205
7206 return _MApi_DMX_Get_DropPktCnt(pDmxInfo, pu32Cnt);
7207 #endif
7208
7209 }
7210
MApi_DMX_Get_LockPktCnt(DMX_LockPktCnt_info * pDmxInfo,MS_U32 * pu32Cnt)7211 DMX_FILTER_STATUS MApi_DMX_Get_LockPktCnt(DMX_LockPktCnt_info* pDmxInfo, MS_U32 *pu32Cnt)
7212 {
7213 #ifdef DMX_UTOPIA_20
7214
7215 DMX_PKT_LOCKCNT_PARAM Param;
7216
7217 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7218
7219 *pu32Cnt = 0;
7220
7221 if(_DMX_IOCtrlOpen() == FALSE)
7222 return DMX_FILTER_STATUS_ERROR;
7223
7224 Param.pInfo = pDmxInfo;
7225 Param.u32Cnt = 0;
7226 Param.u32Res = 0;
7227 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_DBG_GET_LOCKPKTCNT, (void*)&Param) != UTOPIA_STATUS_SUCCESS)
7228 {
7229 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7230 return DMX_FILTER_STATUS_ERROR;
7231 }
7232
7233 *pu32Cnt = Param.u32Cnt;
7234
7235 if(Param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7236 return DMX_FILTER_STATUS_ERROR;
7237 else
7238 return DMX_FILTER_STATUS_OK;
7239 #else
7240
7241 return _MApi_DMX_Get_LockPktCnt(pDmxInfo, pu32Cnt);
7242
7243 #endif
7244
7245 }
7246
MApi_DMX_Get_AVPktCnt(DMX_AVPktCnt_info * DmxInfo,MS_U32 * pu32Cnt)7247 DMX_FILTER_STATUS MApi_DMX_Get_AVPktCnt(DMX_AVPktCnt_info *DmxInfo, MS_U32 *pu32Cnt)
7248 {
7249 #ifdef DMX_UTOPIA_20
7250
7251 DMX_PKT_AVCNT_PARAM Param;
7252
7253 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7254
7255 *pu32Cnt = 0;
7256
7257 if(_DMX_IOCtrlOpen() == FALSE)
7258 return DMX_FILTER_STATUS_ERROR;
7259
7260 Param.pInfo = DmxInfo;
7261 Param.u32Cnt = 0;
7262 Param.u32Res = 0;
7263
7264 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_DBG_GET_AVPKTCNT, (void*)&Param) != UTOPIA_STATUS_SUCCESS)
7265 {
7266 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7267 return DMX_FILTER_STATUS_ERROR;
7268 }
7269
7270 *pu32Cnt = Param.u32Cnt;
7271
7272 if(Param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7273 return DMX_FILTER_STATUS_ERROR;
7274 else
7275 return DMX_FILTER_STATUS_OK;
7276
7277 #else
7278
7279 return _MApi_DMX_Get_AVPktCnt(DmxInfo, pu32Cnt);
7280
7281 #endif
7282
7283 }
7284
MApi_DMX_Get_SecTEI_PktCount(DMX_FILTER_TYPE FltSrc,MS_U32 * pu32PktCnt)7285 DMX_FILTER_STATUS MApi_DMX_Get_SecTEI_PktCount(DMX_FILTER_TYPE FltSrc, MS_U32* pu32PktCnt)
7286 {
7287 #ifdef DMX_UTOPIA_20
7288
7289 DMX_PKT_SECTEI_PARAM Param;
7290
7291 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7292
7293 *pu32PktCnt = 0;
7294
7295 if(_DMX_IOCtrlOpen() == FALSE)
7296 return DMX_FILTER_STATUS_ERROR;
7297
7298 Param.eType = FltSrc;
7299 Param.u32Cnt = 0;
7300 Param.u32Res = 0;
7301 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GET_SECTEI_PKTCNT, (void*)&Param) != UTOPIA_STATUS_SUCCESS)
7302 {
7303 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7304 return DMX_FILTER_STATUS_ERROR;
7305 }
7306
7307 *pu32PktCnt = Param.u32Cnt;
7308
7309 if(Param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7310 return DMX_FILTER_STATUS_ERROR;
7311 else
7312 return DMX_FILTER_STATUS_OK;
7313
7314 #else
7315
7316 return _MApi_DMX_Get_SecTEI_PktCount(FltSrc, pu32PktCnt);
7317
7318 #endif
7319
7320 }
7321
MApi_DMX_Reset_SecTEI_PktCount(DMX_FILTER_TYPE FltSrc)7322 DMX_FILTER_STATUS MApi_DMX_Reset_SecTEI_PktCount(DMX_FILTER_TYPE FltSrc)
7323 {
7324 #ifdef DMX_UTOPIA_20
7325
7326 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7327
7328 MS_U32 u32param[2] = {0, 0};
7329
7330 u32param[0] = (MS_U32)FltSrc;
7331
7332 if(_DMX_IOCtrlOpen() == FALSE)
7333 return DMX_FILTER_STATUS_ERROR;
7334
7335 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_RESET_SECTEI_PKTCNT, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7336 {
7337 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7338 return DMX_FILTER_STATUS_ERROR;
7339 }
7340
7341 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
7342 return DMX_FILTER_STATUS_ERROR;
7343 else
7344 return DMX_FILTER_STATUS_OK;
7345
7346 #else
7347
7348 return _MApi_DMX_Reset_SecTEI_PktCount(FltSrc);
7349
7350 #endif
7351 }
7352
MApi_DMX_Get_SecDisCont_PktCount(MS_U32 u32DmxID,MS_U32 * pu32PktCnt)7353 DMX_FILTER_STATUS MApi_DMX_Get_SecDisCont_PktCount(MS_U32 u32DmxID, MS_U32* pu32PktCnt)
7354 {
7355 #ifdef DMX_UTOPIA_20
7356
7357 MS_U32 u32param[3] = {0, 0, 0};
7358
7359 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7360
7361 *pu32PktCnt = 0;
7362
7363 if(_DMX_IOCtrlOpen() == FALSE)
7364 return DMX_FILTER_STATUS_ERROR;
7365
7366 u32param[0] = u32DmxID;
7367 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GET_SECDISCON_PKTCNT, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7368 {
7369 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7370 return DMX_FILTER_STATUS_ERROR;
7371 }
7372
7373 *pu32PktCnt = u32param[1];
7374
7375 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
7376 return DMX_FILTER_STATUS_ERROR;
7377 else
7378 return DMX_FILTER_STATUS_OK;
7379
7380 #else
7381
7382 return _MApi_DMX_Get_SecDisCont_PktCount(u32DmxID, pu32PktCnt);
7383
7384 #endif
7385
7386 }
7387
MApi_DMX_Reset_SecDisCont_PktCount(MS_U32 u32DmxID)7388 DMX_FILTER_STATUS MApi_DMX_Reset_SecDisCont_PktCount(MS_U32 u32DmxID)
7389 {
7390 #ifdef DMX_UTOPIA_20
7391
7392 MS_U32 u32param[2] = {0, 0};
7393
7394 u32param[0] = u32DmxID;
7395
7396 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7397
7398 if(_DMX_IOCtrlOpen() == FALSE)
7399 return DMX_FILTER_STATUS_ERROR;
7400
7401 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_RESET_SECDISCON_PKTCNT, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7402 {
7403 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7404 return DMX_FILTER_STATUS_ERROR;
7405 }
7406
7407 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
7408 return DMX_FILTER_STATUS_ERROR;
7409 else
7410 return DMX_FILTER_STATUS_OK;
7411 #else
7412
7413 return _MApi_DMX_Reset_SecDisCont_PktCount(u32DmxID);
7414
7415 #endif
7416
7417 }
7418
MApi_DMX_Pvr_Eng_CallbackSize(DMX_PVR_ENG Eng,MS_U32 * pu32CallbackSize,MS_BOOL bSet)7419 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_CallbackSize(DMX_PVR_ENG Eng, MS_U32* pu32CallbackSize, MS_BOOL bSet)
7420 {
7421 #ifdef DMX_UTOPIA_20
7422
7423 MS_U32 u32param[4] = {0, 0, 0, 0};
7424
7425 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7426
7427 if(bSet == FALSE)
7428 {
7429 *pu32CallbackSize = 0;
7430 }
7431
7432 if(_DMX_IOCtrlOpen() == FALSE)
7433 return DMX_FILTER_STATUS_ERROR;
7434
7435 u32param[0] = (MS_U32)Eng;
7436 u32param[2] = (MS_U32)bSet;
7437 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_CBSize, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7438 {
7439 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7440 return DMX_FILTER_STATUS_ERROR;
7441 }
7442
7443 *pu32CallbackSize = u32param[1];
7444
7445 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
7446 return DMX_FILTER_STATUS_ERROR;
7447 else
7448 return DMX_FILTER_STATUS_OK;
7449
7450 #else
7451
7452 return _MApi_DMX_Pvr_Eng_CallbackSize(Eng, pu32CallbackSize, bSet);
7453
7454 #endif
7455
7456 }
7457
MApi_DMX_Pvr_Eng_SetCaMode(DMX_PVR_ENG Eng,DMX_CA_PVRMODE eCaMode,MS_BOOL bspsEnable)7458 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_SetCaMode(DMX_PVR_ENG Eng, DMX_CA_PVRMODE eCaMode, MS_BOOL bspsEnable)
7459 {
7460 #ifdef DMX_UTOPIA_20
7461
7462 MS_U32 u32param[4] = {0, 0, 0, 0};
7463
7464 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7465
7466 if(_DMX_IOCtrlOpen() == FALSE)
7467 return DMX_FILTER_STATUS_ERROR;
7468
7469 u32param[0] = (MS_U32)Eng;
7470 u32param[1] = (MS_U32)eCaMode;
7471 u32param[2] = (MS_U32)bspsEnable;
7472 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_SetCaMode, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7473 {
7474 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7475 return DMX_FILTER_STATUS_ERROR;
7476 }
7477
7478 if(u32param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
7479 return DMX_FILTER_STATUS_ERROR;
7480 else
7481 return DMX_FILTER_STATUS_OK;
7482
7483 #else
7484
7485 return _MApi_DMX_Pvr_Eng_SetCaMode(Eng, eCaMode, bspsEnable);
7486
7487 #endif
7488
7489 }
7490
MApi_DMX_Pvr_Eng_IsStart(DMX_PVR_ENG Eng,MS_BOOL * pbIsStart)7491 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_IsStart(DMX_PVR_ENG Eng, MS_BOOL *pbIsStart)
7492 {
7493 #ifdef DMX_UTOPIA_20
7494
7495 MS_U32 u32param[3] = {0, 0, 0};
7496
7497 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7498
7499 *pbIsStart = FALSE;
7500
7501 if(_DMX_IOCtrlOpen() == FALSE)
7502 return DMX_FILTER_STATUS_ERROR;
7503
7504 u32param[0] = (MS_U32)Eng;
7505 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_IsStart, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7506 {
7507 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7508 return DMX_FILTER_STATUS_ERROR;
7509 }
7510
7511 *pbIsStart = (MS_BOOL)u32param[1];
7512
7513 if(u32param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
7514 return DMX_FILTER_STATUS_ERROR;
7515 else
7516 return DMX_FILTER_STATUS_OK;
7517 #else
7518
7519 return _MApi_DMX_Pvr_Eng_IsStart(Eng, pbIsStart);
7520
7521 #endif
7522
7523 }
7524
7525
MApi_DMX_Get_Intr_Count(MS_U32 * pu32Count)7526 DMX_FILTER_STATUS MApi_DMX_Get_Intr_Count(MS_U32* pu32Count)
7527 {
7528 #ifdef DMX_UTOPIA_20
7529
7530 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7531
7532 MS_U32 u32param[2] = {0, 0};
7533
7534 *pu32Count = 0;
7535
7536 if(_DMX_IOCtrlOpen() == FALSE)
7537 return DMX_FILTER_STATUS_ERROR;
7538
7539 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_GetIntCnt, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7540 {
7541 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7542 return DMX_FILTER_STATUS_ERROR;
7543 }
7544
7545 *pu32Count = u32param[0];
7546
7547 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
7548 return DMX_FILTER_STATUS_ERROR;
7549 else
7550 return DMX_FILTER_STATUS_OK;
7551
7552 #else
7553
7554 return _MApi_DMX_Get_Intr_Count(pu32Count);
7555
7556 #endif
7557
7558 }
7559
MApi_DMX_Drop_Enable(MS_BOOL bSet)7560 DMX_FILTER_STATUS MApi_DMX_Drop_Enable(MS_BOOL bSet)
7561 {
7562 #ifdef DMX_UTOPIA_20
7563
7564 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7565
7566 MS_U32 u32param[2] = {0, 0};
7567
7568 u32param[0] = ((MS_U32)bSet) & 0xFF;
7569
7570 if(_DMX_IOCtrlOpen() == FALSE)
7571 return DMX_FILTER_STATUS_ERROR;
7572
7573 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_DropEn, (void*)u32param) != UTOPIA_STATUS_SUCCESS)
7574 {
7575 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7576 return DMX_FILTER_STATUS_ERROR;
7577 }
7578
7579 if(u32param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
7580 return DMX_FILTER_STATUS_ERROR;
7581 else
7582 return DMX_FILTER_STATUS_OK;
7583
7584 #else
7585
7586 return _MApi_DMX_Drop_Enable(bSet);
7587
7588 #endif
7589 }
7590
MApi_DMX_VQ_Enable(MS_BOOL bEnable)7591 DMX_FILTER_STATUS MApi_DMX_VQ_Enable(MS_BOOL bEnable)
7592 {
7593 #ifdef DMX_UTOPIA_20
7594
7595 return DMX_FILTER_STATUS_ERROR;
7596
7597 #else
7598
7599 return _MApi_DMX_VQ_Enable(bEnable);
7600
7601 #endif
7602 }
7603
MApi_DMX_TEI_RemoveErrorPkt(DMX_TEI_RmPktType eDmxPktType,MS_BOOL bEnable)7604 DMX_FILTER_STATUS MApi_DMX_TEI_RemoveErrorPkt(DMX_TEI_RmPktType eDmxPktType, MS_BOOL bEnable)
7605 {
7606 #ifdef DMX_UTOPIA_20
7607
7608 MS_U32 u32Param[3] = {0, 0, 0};
7609
7610 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7611
7612 if(_DMX_IOCtrlOpen() == FALSE)
7613 return DMX_FILTER_STATUS_ERROR;
7614
7615 u32Param[0] = (DMX_TEI_RmPktType)eDmxPktType;
7616 u32Param[1] = ((MS_U32)bEnable) & 0xFF;
7617 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TeiRmErrPkt, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7618 {
7619 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7620 return DMX_FILTER_STATUS_ERROR;
7621 }
7622
7623 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
7624 return DMX_FILTER_STATUS_ERROR;
7625 else
7626 return DMX_FILTER_STATUS_OK;
7627
7628 #else
7629
7630 return _MApi_DMX_TEI_RemoveErrorPkt(eDmxPktType, bEnable);
7631
7632 #endif
7633 }
7634
MApi_DMX_SetFwDbgParam(MS_PHY phyAddr,MS_U32 u32Size,MS_U32 u32DbgWord)7635 DMX_FILTER_STATUS MApi_DMX_SetFwDbgParam(MS_PHY phyAddr, MS_U32 u32Size, MS_U32 u32DbgWord)
7636 {
7637 #ifdef DMX_UTOPIA_20
7638
7639 MS_U32 u32Param[5] = {0, 0, 0, 0, 0};
7640
7641 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7642
7643 if(_DMX_IOCtrlOpen() == FALSE)
7644 return DMX_FILTER_STATUS_ERROR;
7645
7646 _DMX_PhyAddr_To_U32Param(phyAddr, u32Param);
7647 u32Param[2] = u32Size;
7648 u32Param[3] = u32DbgWord;
7649 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_SetFwDbgParam, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7650 {
7651 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7652 return DMX_FILTER_STATUS_ERROR;
7653 }
7654
7655 if(u32Param[4] != (MS_U32)DMX_FILTER_STATUS_OK)
7656 return DMX_FILTER_STATUS_ERROR;
7657 else
7658 return DMX_FILTER_STATUS_OK;
7659
7660 #else
7661
7662 return _MApi_DMX_SetFwDbgParam(phyAddr, u32Size, u32DbgWord);
7663
7664 #endif
7665 }
7666
MApi_DMX_SetAVPause(MS_BOOL bSet)7667 DMX_FILTER_STATUS MApi_DMX_SetAVPause(MS_BOOL bSet)
7668 {
7669 #ifdef DMX_UTOPIA_20
7670
7671 return DMX_FILTER_STATUS_ERROR;
7672
7673 #else
7674
7675 return _MApi_DMX_SetAVPause(bSet);
7676
7677 #endif
7678 }
7679
MApi_DMX_Pvr_MOBF_Enable(MS_BOOL bEnable,MS_U32 u32key0,MS_U32 u32key1)7680 DMX_FILTER_STATUS MApi_DMX_Pvr_MOBF_Enable(MS_BOOL bEnable, MS_U32 u32key0, MS_U32 u32key1)
7681 {
7682 #ifdef DMX_UTOPIA_20
7683
7684 MS_U32 u32Param[4] = {0, 0, 0, 0};
7685
7686 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7687
7688 if(_DMX_IOCtrlOpen() == FALSE)
7689 return DMX_FILTER_STATUS_ERROR;
7690
7691 u32Param[0] = ((MS_U32)bEnable) & 0xFF;
7692 u32Param[1] = u32key0;
7693 u32Param[2] = u32key1;
7694 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_PVR_MOBFEn, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7695 {
7696 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7697 return DMX_FILTER_STATUS_ERROR;
7698 }
7699
7700 if(u32Param[3] != (MS_U32)DMX_FILTER_STATUS_OK)
7701 return DMX_FILTER_STATUS_ERROR;
7702 else
7703 return DMX_FILTER_STATUS_OK;
7704
7705 #else
7706
7707 return _MApi_DMX_Pvr_MOBF_Enable(bEnable, u32key0, u32key1);
7708
7709 #endif
7710 }
7711
MApi_DMX_Filein_Pvr_Eng_Pid_Open(DMX_PVR_ENG Eng,MS_U32 Pid,MS_U8 * pu8DmxId,MS_U8 u8ShareKeyType)7712 DMX_FILTER_STATUS MApi_DMX_Filein_Pvr_Eng_Pid_Open(DMX_PVR_ENG Eng, MS_U32 Pid, MS_U8* pu8DmxId, MS_U8 u8ShareKeyType)
7713 {
7714 #ifdef DMX_UTOPIA_20
7715
7716 MS_U32 u32Param[5] = {0, 0, 0, 0, 0};
7717
7718 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7719
7720 *pu8DmxId = 0xFF;
7721
7722 if(_DMX_IOCtrlOpen() == FALSE)
7723 return DMX_FILTER_STATUS_ERROR;
7724
7725 u32Param[0] = (MS_U32)Eng;
7726 u32Param[1] = Pid;
7727 u32Param[3] = ((MS_U32)u8ShareKeyType) & 0xFF;
7728 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_File_PVR_PidOpen, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7729 {
7730 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7731 return DMX_FILTER_STATUS_ERROR;
7732 }
7733
7734 *pu8DmxId = (MS_U8)u32Param[2];
7735
7736 if(u32Param[4] != (MS_U32)DMX_FILTER_STATUS_OK)
7737 return DMX_FILTER_STATUS_ERROR;
7738 else
7739 return DMX_FILTER_STATUS_OK;
7740 #else
7741
7742 return _MApi_DMX_Filein_Pvr_Eng_Pid_Open(Eng, Pid, pu8DmxId, u8ShareKeyType);
7743
7744 #endif
7745 }
7746
MApi_DMX_Filein_Pvr_Eng_Pid_Close(DMX_PVR_ENG Eng,MS_U8 u8DmxId)7747 DMX_FILTER_STATUS MApi_DMX_Filein_Pvr_Eng_Pid_Close(DMX_PVR_ENG Eng, MS_U8 u8DmxId)
7748 {
7749 #ifdef DMX_UTOPIA_20
7750
7751 MS_U32 u32Param[3] = {0, 0, 0};
7752
7753 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7754
7755 if(_DMX_IOCtrlOpen() == FALSE)
7756 return DMX_FILTER_STATUS_ERROR;
7757
7758 u32Param[0] = (MS_U32)Eng;
7759 u32Param[1] = ((MS_U32)u8DmxId) & 0xFF;
7760 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_File_PVR_PidClose, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7761 {
7762 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7763 return DMX_FILTER_STATUS_ERROR;
7764 }
7765
7766 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
7767 return DMX_FILTER_STATUS_ERROR;
7768 else
7769 return DMX_FILTER_STATUS_OK;
7770
7771 #else
7772
7773 return _MApi_DMX_Filein_Pvr_Eng_Pid_Close(Eng, u8DmxId);
7774
7775 #endif
7776 }
7777
MApi_DMX_Filein_Pvr_Eng_Start(DMX_PVR_ENG Eng,MS_BOOL bPvrAll)7778 DMX_FILTER_STATUS MApi_DMX_Filein_Pvr_Eng_Start(DMX_PVR_ENG Eng, MS_BOOL bPvrAll)
7779 {
7780 #ifdef DMX_UTOPIA_20
7781
7782 MS_U32 u32Param[3] = {0, 0, 0};
7783
7784 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7785
7786 if(_DMX_IOCtrlOpen() == FALSE)
7787 return DMX_FILTER_STATUS_ERROR;
7788
7789 u32Param[0] = (MS_U32)Eng;
7790 u32Param[1] = ((MS_U32)bPvrAll) & 0xFF;
7791 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_File_PVR_Start, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7792 {
7793 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7794 return DMX_FILTER_STATUS_ERROR;
7795 }
7796
7797 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
7798 return DMX_FILTER_STATUS_ERROR;
7799 else
7800 return DMX_FILTER_STATUS_OK;
7801
7802 #else
7803
7804 return _MApi_DMX_Filein_Pvr_Eng_Start(Eng, bPvrAll);
7805
7806 #endif
7807
7808 }
7809
MApi_DMX_Filein_Pvr_Eng_Stop(DMX_PVR_ENG Eng)7810 DMX_FILTER_STATUS MApi_DMX_Filein_Pvr_Eng_Stop(DMX_PVR_ENG Eng)
7811 {
7812 #ifdef DMX_UTOPIA_20
7813
7814 MS_U32 u32Param[2] = {0, 0};
7815
7816 u32Param[0] = ((MS_U32)Eng) & 0xFF;
7817
7818 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7819
7820 if(_DMX_IOCtrlOpen() == FALSE)
7821 return DMX_FILTER_STATUS_ERROR;
7822
7823 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_File_PVR_Stop, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7824 {
7825 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7826 return DMX_FILTER_STATUS_ERROR;
7827 }
7828
7829 if(u32Param[1] != (MS_U32)DMX_FILTER_STATUS_OK)
7830 return DMX_FILTER_STATUS_ERROR;
7831 else
7832 return DMX_FILTER_STATUS_OK;
7833
7834 #else
7835
7836 return _MApi_DMX_Filein_Pvr_Eng_Stop(Eng);
7837
7838 #endif
7839
7840 }
7841
MApi_DMX_Pvr_Eng_Pause(DMX_PVR_ENG Eng,MS_BOOL bPause)7842 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Pause(DMX_PVR_ENG Eng ,MS_BOOL bPause)
7843 {
7844 #ifdef DMX_UTOPIA_20
7845
7846 MS_U32 u32Param[3] = {0, 0, 0};
7847
7848 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7849
7850 if(_DMX_IOCtrlOpen() == FALSE)
7851 return DMX_FILTER_STATUS_ERROR;
7852
7853 u32Param[0] = (MS_U32)Eng;
7854 u32Param[1] = ((MS_U32)bPause) & 0xFF;
7855 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Pause, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7856 {
7857 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7858 return DMX_FILTER_STATUS_ERROR;
7859 }
7860
7861 if(u32Param[2] != (MS_U32)DMX_FILTER_STATUS_OK)
7862 return DMX_FILTER_STATUS_ERROR;
7863 else
7864 return DMX_FILTER_STATUS_OK;
7865
7866 #else
7867
7868 return _MApi_DMX_Pvr_Eng_Pause(Eng, bPause);
7869
7870 #endif
7871
7872 }
7873
MApi_DMX_Pvr_Eng_Pid(DMX_PVR_ENG Eng,MS_U8 u8DmxId,MS_U32 * Pid,MS_BOOL bSet)7874 DMX_FILTER_STATUS MApi_DMX_Pvr_Eng_Pid(DMX_PVR_ENG Eng ,MS_U8 u8DmxId , MS_U32 *Pid, MS_BOOL bSet)
7875 {
7876 #ifdef DMX_UTOPIA_20
7877
7878 MS_U32 u32Param[5] = {0, 0, 0, 0, 0};
7879
7880 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7881
7882 if(_DMX_IOCtrlOpen() == FALSE)
7883 return DMX_FILTER_STATUS_ERROR;
7884
7885 u32Param[0] = (MS_U32)Eng;
7886 u32Param[1] = ((MS_U32)u8DmxId) & 0xFF;
7887 u32Param[2] = *Pid;
7888 u32Param[3] = ((MS_U32)bSet) & 0xFF;
7889 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_Pvr_Pid, (void*)u32Param) != UTOPIA_STATUS_SUCCESS)
7890 {
7891 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7892 return DMX_FILTER_STATUS_ERROR;
7893 }
7894
7895 if(bSet == FALSE)
7896 {
7897 *Pid = u32Param[2];
7898 }
7899
7900 if(u32Param[4] != (MS_U32)DMX_FILTER_STATUS_OK)
7901 return DMX_FILTER_STATUS_ERROR;
7902 else
7903 return DMX_FILTER_STATUS_OK;
7904
7905 #else
7906 MS_U32 u32DmxId = ((MS_U32)u8DmxId) & 0xFF;
7907
7908 return _MApi_DMX_Pvr_Eng_Pid(Eng, u32DmxId, Pid, bSet);
7909
7910 #endif
7911
7912 }
7913
7914
MApi_DMX_DropScmbPkt(DMX_FILTER_TYPE pDmxFltType,MS_BOOL bEnable)7915 DMX_FILTER_STATUS MApi_DMX_DropScmbPkt(DMX_FILTER_TYPE pDmxFltType, MS_BOOL bEnable)
7916 {
7917 #ifdef DMX_UTOPIA_20
7918 DMX_DROP_SCMB_PKT_PARAM infoparam;
7919
7920 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7921
7922 if(_DMX_IOCtrlOpen() == FALSE)
7923 return DMX_FILTER_STATUS_ERROR;
7924
7925 infoparam.eType = pDmxFltType;
7926 infoparam.bEnable = bEnable;
7927 infoparam.u32Res = 0;
7928
7929 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_DropScmbPkt,(void*)&infoparam) != UTOPIA_STATUS_SUCCESS)
7930 {
7931 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7932 return DMX_FILTER_STATUS_ERROR;
7933 }
7934 if(infoparam.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7935 return DMX_FILTER_STATUS_ERROR;
7936 else
7937 return DMX_FILTER_STATUS_OK;
7938
7939 #else
7940
7941 return _MApi_DMX_DropScmbPkt(pDmxFltType,bEnable);
7942
7943 #endif
7944 }
7945
7946 //-----------------------------------------------------
7947 // Merge stream API
7948 //-----------------------------------------------------
MApi_DMX_MStr_SyncByte(DMX_TSIF eIf,MS_U8 u8StrId,MS_U8 * pu8SyncByte,MS_BOOL bSet)7949 DMX_FILTER_STATUS MApi_DMX_MStr_SyncByte(DMX_TSIF eIf, MS_U8 u8StrId, MS_U8* pu8SyncByte, MS_BOOL bSet)
7950 {
7951 #ifdef DMX_UTOPIA_20
7952 DMX_MSTR_SYNCBY_PARAM param;
7953
7954 if(_DMX_IOCtrlOpen() == FALSE)
7955 return DMX_FILTER_STATUS_ERROR;
7956
7957 param.eIf = eIf;
7958 param.u8StrId = u8StrId;
7959 param.pu8SyncByte = pu8SyncByte;
7960 param.bSet = bSet;
7961 param.u32Res = 0;
7962 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_MStr_SyncBy, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
7963 {
7964 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7965 return DMX_FILTER_STATUS_ERROR;
7966 }
7967
7968 return param.u32Res;
7969
7970 #else
7971
7972 return _MApi_DMX_MStr_SyncByte(eIf, u8StrId, pu8SyncByte, bSet);
7973
7974 #endif
7975 }
7976
MApi_DMX_TSIO_Service_SetDMAoutVC(MS_U16 u16Handle,TSIO_DMAOUT_SET * eSet)7977 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_SetDMAoutVC(MS_U16 u16Handle, TSIO_DMAOUT_SET *eSet)
7978 {
7979 #ifdef DMX_UTOPIA_20
7980
7981 DMX_TSIO_Service_SetDMAoutVC_PARAM param;
7982
7983 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
7984
7985 if(_DMX_IOCtrlOpen() == FALSE)
7986 return DMX_FILTER_STATUS_ERROR;
7987
7988 param.u16Handle = u16Handle;
7989 param.eSet = eSet;
7990
7991 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_SetDMAoutVC, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
7992 {
7993 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
7994 return DMX_FILTER_STATUS_ERROR;
7995 }
7996
7997 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
7998 return DMX_FILTER_STATUS_ERROR;
7999 else
8000 return DMX_FILTER_STATUS_OK;
8001
8002 #else
8003
8004 return _MApi_DMX_TSIO_Service_SetDMAoutVC(u16Handle, eSet);
8005
8006 #endif
8007 }
8008
MApi_DMX_TSIO_Service_DMAout_WriteGet(MS_U16 u16Handle,MS_PHY * pphyWrite)8009 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_DMAout_WriteGet(MS_U16 u16Handle, MS_PHY* pphyWrite)
8010 {
8011 #ifdef DMX_UTOPIA_20
8012
8013 DMX_TSIO_Service_DMAout_WriteGet_PARAM param;
8014
8015 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8016
8017 if(_DMX_IOCtrlOpen() == FALSE)
8018 return DMX_FILTER_STATUS_ERROR;
8019
8020 param.u16Handle = u16Handle;
8021 param.pphyWrite = pphyWrite;
8022
8023 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_DMAout_WriteGet, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8024 {
8025 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8026 return DMX_FILTER_STATUS_ERROR;
8027 }
8028
8029 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8030 return DMX_FILTER_STATUS_ERROR;
8031 else
8032 return DMX_FILTER_STATUS_OK;
8033
8034 #else
8035
8036 return _MApi_DMX_TSIO_Service_DMAout_WriteGet(u16Handle, pphyWrite);
8037
8038 #endif
8039 }
8040
MApi_DMX_TSIO_Service_SetDestination(MS_U16 u16Handle,TSIO_SERVICEDEST eDest)8041 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_SetDestination(MS_U16 u16Handle, TSIO_SERVICEDEST eDest)
8042 {
8043 #ifdef DMX_UTOPIA_20
8044
8045 DMX_TSIO_Service_SetDestination_PARAM param;
8046
8047 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8048
8049 if(_DMX_IOCtrlOpen() == FALSE)
8050 return DMX_FILTER_STATUS_ERROR;
8051
8052 param.u16Handle = u16Handle;
8053 param.eDest = eDest;
8054
8055 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_SetDestination, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8056 {
8057 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8058 return DMX_FILTER_STATUS_ERROR;
8059 }
8060
8061 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8062 return DMX_FILTER_STATUS_ERROR;
8063 else
8064 return DMX_FILTER_STATUS_OK;
8065
8066 #else
8067
8068 return _MApi_DMX_TSIO_Service_SetDestination(u16Handle, eDest);
8069
8070 #endif
8071 }
8072
MApi_DMX_TSIO_Service_SetDMAinVC(MS_U16 u16Handle,TSIO_DMAIN_SET * eSet)8073 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_SetDMAinVC(MS_U16 u16Handle, TSIO_DMAIN_SET *eSet)
8074 {
8075 #ifdef DMX_UTOPIA_20
8076
8077 DMX_TSIO_Service_SetDMAinVC_PARAM param;
8078
8079 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8080
8081 if(_DMX_IOCtrlOpen() == FALSE)
8082 return DMX_FILTER_STATUS_ERROR;
8083
8084 param.u16Handle = u16Handle;
8085 param.eSet = eSet;
8086
8087 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_SetDMAinVC, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8088 {
8089 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8090 return DMX_FILTER_STATUS_ERROR;
8091 }
8092
8093 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8094 return DMX_FILTER_STATUS_ERROR;
8095 else
8096 return DMX_FILTER_STATUS_OK;
8097
8098 #else
8099
8100 return _MApi_DMX_TSIO_Service_SetSgdmaInVC(u16Handle, eSet);
8101
8102 #endif
8103 }
8104
MApi_DMX_TSIO_Service_DMAinVC_Start(MS_U16 u16Handle,MS_U32 u32Pacing)8105 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_DMAinVC_Start(MS_U16 u16Handle, MS_U32 u32Pacing)
8106 {
8107 #ifdef DMX_UTOPIA_20
8108
8109 DMX_TSIO_Service_DMAinVC_Start_PARAM param;
8110
8111 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8112
8113 if(_DMX_IOCtrlOpen() == FALSE)
8114 return DMX_FILTER_STATUS_ERROR;
8115
8116 param.u16Handle = u16Handle;
8117 param.u32Pacing = u32Pacing;
8118
8119 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_DMAinVC_Start, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8120 {
8121 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8122 return DMX_FILTER_STATUS_ERROR;
8123 }
8124
8125 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8126 return DMX_FILTER_STATUS_ERROR;
8127 else
8128 return DMX_FILTER_STATUS_OK;
8129
8130 #else
8131
8132 return _MApi_DMX_TSIO_Service_DMAinVC_Start(u16Handle, u32Pacing);
8133
8134 #endif
8135 }
8136
MApi_DMX_TSIO_Service_SetLocdecKey(MS_U16 u16Handle,TSIO_LOCKEY_SET * eSet)8137 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_SetLocdecKey(MS_U16 u16Handle, TSIO_LOCKEY_SET *eSet)
8138 {
8139 #ifdef DMX_UTOPIA_20
8140
8141 DMX_TSIO_Service_SetLocdecKey_PARAM param;
8142
8143 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8144
8145 if(_DMX_IOCtrlOpen() == FALSE)
8146 return DMX_FILTER_STATUS_ERROR;
8147
8148 param.u16Handle = u16Handle;
8149 param.eSet = eSet;
8150
8151 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_SetLocdecKey, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8152 {
8153 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8154 return DMX_FILTER_STATUS_ERROR;
8155 }
8156
8157 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8158 return DMX_FILTER_STATUS_ERROR;
8159 else
8160 return DMX_FILTER_STATUS_OK;
8161
8162 #else
8163
8164 return _MApi_DMX_TSIO_Service_SetLocdecKey(u16Handle, eSet);
8165
8166 #endif
8167 }
8168
MApi_DMX_TSIO_Service_LocdecKeyEnable(MS_U16 u16Handle,MS_BOOL bEnable)8169 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_LocdecKeyEnable(MS_U16 u16Handle, MS_BOOL bEnable)
8170 {
8171 #ifdef DMX_UTOPIA_20
8172
8173 DMX_TSIO_Service_LocdecKeyEnable_PARAM param;
8174
8175 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8176
8177 if(_DMX_IOCtrlOpen() == FALSE)
8178 return DMX_FILTER_STATUS_ERROR;
8179
8180 param.u16Handle = u16Handle;
8181 param.bEnable = bEnable;
8182
8183 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_LocdecKeyEnable, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8184 {
8185 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8186 return DMX_FILTER_STATUS_ERROR;
8187 }
8188
8189 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8190 return DMX_FILTER_STATUS_ERROR;
8191 else
8192 return DMX_FILTER_STATUS_OK;
8193
8194 #else
8195
8196 return _MApi_DMX_TSIO_Service_LocdecKeyEnable(u16Handle, bEnable);
8197
8198 #endif
8199 }
8200
MApi_DMX_TSIO_Service_PidOpen(MS_U16 u16Handle,DMX_TSIF eTSOInSrc,MS_U16 u16Pid,MS_U16 * pu16DmxId)8201 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_PidOpen(MS_U16 u16Handle, DMX_TSIF eTSOInSrc, MS_U16 u16Pid, MS_U16* pu16DmxId)
8202 {
8203 #ifdef DMX_UTOPIA_20
8204
8205 DMX_TSIO_Service_PidOpen_PARAM param;
8206
8207 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8208
8209 if(_DMX_IOCtrlOpen() == FALSE)
8210 return DMX_FILTER_STATUS_ERROR;
8211
8212 param.u16Handle = u16Handle;
8213 param.eTSOInSrc = eTSOInSrc;
8214 param.u16Pid = u16Pid;
8215 param.pu16DmxId = pu16DmxId;
8216
8217 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_PidOpen, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8218 {
8219 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8220 return DMX_FILTER_STATUS_ERROR;
8221 }
8222
8223 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8224 return DMX_FILTER_STATUS_ERROR;
8225 else
8226 return DMX_FILTER_STATUS_OK;
8227
8228 #else
8229
8230 return _MApi_DMX_TSIO_Service_PidOpen(u16Handle, eTSOInSrc, u16Pid, pu16DmxId);
8231
8232 #endif
8233 }
8234
MApi_DMX_TSIO_Service_PidClose(MS_U16 u16Handle,MS_U16 u16DmxId)8235 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_PidClose(MS_U16 u16Handle, MS_U16 u16DmxId)
8236 {
8237 #ifdef DMX_UTOPIA_20
8238
8239 DMX_TSIO_Service_PidClose_PARAM param;
8240
8241 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8242
8243 if(_DMX_IOCtrlOpen() == FALSE)
8244 return DMX_FILTER_STATUS_ERROR;
8245
8246 param.u16Handle = u16Handle;
8247 param.u16DmxId = u16DmxId;
8248
8249 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_PidClose, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8250 {
8251 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8252 return DMX_FILTER_STATUS_ERROR;
8253 }
8254
8255 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8256 return DMX_FILTER_STATUS_ERROR;
8257 else
8258 return DMX_FILTER_STATUS_OK;
8259
8260 #else
8261
8262 return _MApi_DMX_TSIO_Service_PidClose(u16Handle, u16DmxId);
8263
8264 #endif
8265 }
8266
MApi_DMX_TSIO_Service_Alloc(MS_U8 u8Sid,MS_U16 * u16Handle)8267 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_Alloc(MS_U8 u8Sid, MS_U16 *u16Handle)
8268 {
8269 #ifdef DMX_UTOPIA_20
8270
8271 DMX_TSIO_Service_Alloc_PARAM param;
8272
8273 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8274
8275 if(_DMX_IOCtrlOpen() == FALSE)
8276 return DMX_FILTER_STATUS_ERROR;
8277
8278 param.u8Sid = u8Sid;
8279 param.u16Handle = u16Handle;
8280
8281 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_Alloc, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8282 {
8283 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8284 return DMX_FILTER_STATUS_ERROR;
8285 }
8286
8287 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8288 return DMX_FILTER_STATUS_ERROR;
8289 else
8290 return DMX_FILTER_STATUS_OK;
8291
8292 #else
8293
8294 return _MApi_DMX_TSIO_Service_Alloc(u8Sid, u16Handle);
8295
8296 #endif
8297 }
8298
MApi_DMX_TSIO_Service_Free(MS_U16 u16Handle)8299 DMX_FILTER_STATUS MApi_DMX_TSIO_Service_Free(MS_U16 u16Handle)
8300 {
8301 #ifdef DMX_UTOPIA_20
8302
8303 DMX_TSIO_Service_Free_PARAM param;
8304
8305 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8306
8307 if(_DMX_IOCtrlOpen() == FALSE)
8308 return DMX_FILTER_STATUS_ERROR;
8309
8310 param.u16Handle = u16Handle;
8311
8312 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Service_Free, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8313 {
8314 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8315 return DMX_FILTER_STATUS_ERROR;
8316 }
8317
8318 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8319 return DMX_FILTER_STATUS_ERROR;
8320 else
8321 return DMX_FILTER_STATUS_OK;
8322
8323 #else
8324
8325 return _MApi_DMX_TSIO_Service_Free(u16Handle);
8326
8327 #endif
8328 }
8329
MApi_DMX_TSIO_RegisterIntCb(TSIOIntTypeCB efn)8330 DMX_FILTER_STATUS MApi_DMX_TSIO_RegisterIntCb(TSIOIntTypeCB efn)
8331 {
8332 #ifdef DMX_UTOPIA_20
8333
8334 DMX_TSIO_RegisterIntCb_PARAM param;
8335
8336 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8337
8338 if(_DMX_IOCtrlOpen() == FALSE)
8339 return DMX_FILTER_STATUS_ERROR;
8340
8341 param.efn = efn;
8342
8343 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_RegisterIntCb, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8344 {
8345 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8346 return DMX_FILTER_STATUS_ERROR;
8347 }
8348
8349 #if (defined(DMX_UTOPIA_2K) && defined(TSIO_ENABLE))
8350 if(_bKrenelMod == TRUE)
8351 {
8352 _TsioIntCb = efn;
8353 }
8354 #endif
8355
8356 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8357 return DMX_FILTER_STATUS_ERROR;
8358 else
8359 return DMX_FILTER_STATUS_OK;
8360
8361 #else
8362
8363 return _MApi_DMX_TSIO_RegisterIntCb(efn);
8364
8365 #endif
8366 }
8367
MApi_DMX_TSIO_Init(TSIO_Init_Set * eParm)8368 DMX_FILTER_STATUS MApi_DMX_TSIO_Init(TSIO_Init_Set *eParm)
8369 {
8370 #ifdef DMX_UTOPIA_20
8371
8372 DMX_TSIO_Init_PARAM param;
8373
8374 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8375
8376 if(_DMX_IOCtrlOpen() == FALSE)
8377 return DMX_FILTER_STATUS_ERROR;
8378
8379 param.eParm = eParm;
8380
8381 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Init, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8382 {
8383 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8384 return DMX_FILTER_STATUS_ERROR;
8385 }
8386
8387 #if (defined(DMX_UTOPIA_2K) && defined(TSIO_ENABLE))
8388 if(_bKrenelMod == TRUE)
8389 {
8390 if(_s32DmxTsioTaskId == -1)
8391 {
8392 _s32DmxTsioTaskId = MsOS_CreateTask((TaskEntry)_DMX_TSIO_Proc_Task,
8393 0,
8394 E_TASK_PRI_MEDIUM,
8395 TRUE,
8396 _u8DmxTsioStack,
8397 DMX_TASK_STACK_SIZE,
8398 "TSIO Proc Task");
8399 }
8400 }
8401 #endif
8402
8403 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8404 return DMX_FILTER_STATUS_ERROR;
8405 else
8406 return DMX_FILTER_STATUS_OK;
8407
8408 #else
8409
8410 return _MApi_DMX_TSIO_Init(eParm);
8411
8412 #endif
8413 }
8414
MApi_DMX_TSIO_Open(TSIO_CLK eClk)8415 DMX_FILTER_STATUS MApi_DMX_TSIO_Open(TSIO_CLK eClk)
8416 {
8417 #ifdef DMX_UTOPIA_20
8418
8419 DMX_TSIO_Open_PARAM param;
8420
8421 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8422
8423 if(_DMX_IOCtrlOpen() == FALSE)
8424 return DMX_FILTER_STATUS_ERROR;
8425
8426 param.eClk = eClk;
8427
8428 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Open, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8429 {
8430 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8431 return DMX_FILTER_STATUS_ERROR;
8432 }
8433
8434 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8435 return DMX_FILTER_STATUS_ERROR;
8436 else
8437 return DMX_FILTER_STATUS_OK;
8438
8439 #else
8440
8441 return _MApi_DMX_TSIO_Open(eClk);
8442
8443 #endif
8444 }
8445
MApi_DMX_TSIO_Cmd(TSIO_CMD eCmd,MS_U32 u32Value)8446 DMX_FILTER_STATUS MApi_DMX_TSIO_Cmd(TSIO_CMD eCmd, MS_U32 u32Value)
8447 {
8448 #ifdef DMX_UTOPIA_20
8449
8450 DMX_TSIO_Cmd_PARAM param;
8451
8452 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8453
8454 if(_DMX_IOCtrlOpen() == FALSE)
8455 return DMX_FILTER_STATUS_ERROR;
8456
8457 param.eCmd = eCmd;
8458 param.u32Value = u32Value;
8459
8460 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Cmd, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8461 {
8462 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8463 return DMX_FILTER_STATUS_ERROR;
8464 }
8465
8466 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8467 return DMX_FILTER_STATUS_ERROR;
8468 else
8469 return DMX_FILTER_STATUS_OK;
8470
8471 #else
8472
8473 return _MApi_DMX_TSIO_Cmd(eCmd, u32Value);
8474
8475 #endif
8476 }
8477
MApi_DMX_TSIO_Exit(void)8478 DMX_FILTER_STATUS MApi_DMX_TSIO_Exit(void)
8479 {
8480 #ifdef DMX_UTOPIA_20
8481
8482 MS_U32 param;
8483
8484 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8485
8486 if(_DMX_IOCtrlOpen() == FALSE)
8487 return DMX_FILTER_STATUS_ERROR;
8488
8489 #if (defined(DMX_UTOPIA_2K) && defined(TSIO_ENABLE))
8490 if(_bKrenelMod == TRUE)
8491 {
8492 _u8TsioThrState = 1;
8493 }
8494 #endif
8495
8496 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Exit, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8497 {
8498 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8499 return DMX_FILTER_STATUS_ERROR;
8500 }
8501
8502 #if (defined(DMX_UTOPIA_2K) && defined(TSIO_ENABLE))
8503 MS_U32 u32Timer = 0;
8504 if(_bKrenelMod == TRUE)
8505 {
8506 u32Timer = MsOS_GetSystemTime();
8507 while(_s32DmxTsioTaskId > 0)
8508 {
8509 if(_u8TsioThrState == 2)
8510 break;
8511
8512 if (MsOS_GetSystemTime()-u32Timer > 10000)
8513 {
8514 DMX_V2DBGMSG(ULOGD("DMX", "[%s][%d] TSIO Proc task exit timeout!!!!!!\n", __FUNCTION__, __LINE__));
8515 break;
8516 }
8517 }
8518 }
8519 _TsioIntCb = NULL;
8520 #endif
8521
8522 if(param != (MS_U32)DMX_FILTER_STATUS_OK)
8523 return DMX_FILTER_STATUS_ERROR;
8524 else
8525 return DMX_FILTER_STATUS_OK;
8526
8527 #else
8528
8529 return _MApi_DMX_TSIO_Exit();
8530
8531 #endif
8532 }
8533
MApi_DMX_TSIO_Close(void)8534 DMX_FILTER_STATUS MApi_DMX_TSIO_Close(void)
8535 {
8536 #ifdef DMX_UTOPIA_20
8537
8538 MS_U32 param;
8539
8540 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8541
8542 if(_DMX_IOCtrlOpen() == FALSE)
8543 return DMX_FILTER_STATUS_ERROR;
8544
8545 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_Close, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8546 {
8547 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8548 return DMX_FILTER_STATUS_ERROR;
8549 }
8550
8551 if(param != (MS_U32)DMX_FILTER_STATUS_OK)
8552 return DMX_FILTER_STATUS_ERROR;
8553 else
8554 return DMX_FILTER_STATUS_OK;
8555
8556 #else
8557
8558 return _MApi_DMX_TSIO_Close();
8559
8560 #endif
8561 }
8562
MApi_DMX_TSIO_CC(TSIO_CC_Set * Parm,TSIO_CC_RESULT * pResult)8563 DMX_FILTER_STATUS MApi_DMX_TSIO_CC(TSIO_CC_Set *Parm, TSIO_CC_RESULT* pResult)
8564 {
8565 #ifdef DMX_UTOPIA_20
8566
8567 DMX_TSIO_CC_PARAM param;
8568
8569 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8570
8571 if(_DMX_IOCtrlOpen() == FALSE)
8572 return DMX_FILTER_STATUS_ERROR;
8573
8574 param.Parm = Parm;
8575 param.pResult = pResult;
8576
8577 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_CC, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8578 {
8579 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8580 return DMX_FILTER_STATUS_ERROR;
8581 }
8582
8583 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8584 return DMX_FILTER_STATUS_ERROR;
8585 else
8586 return DMX_FILTER_STATUS_OK;
8587
8588 #else
8589
8590 return _MApi_DMX_TSIO_CC(Parm, pResult);
8591
8592 #endif
8593 }
8594
MApi_DMX_TSIO_GetInfo(TSIO_INFO eInfo,MS_U32 u32Arg,MS_U32 * u32Retinfo)8595 DMX_FILTER_STATUS MApi_DMX_TSIO_GetInfo(TSIO_INFO eInfo , MS_U32 u32Arg, MS_U32 *u32Retinfo)
8596 {
8597 #ifdef DMX_UTOPIA_20
8598
8599 DMX_TSIO_GetInfo_PARAM param;
8600
8601 DMX_V2DBGMSG(ULOGD("DMX", "[%s] %d\n", __FUNCTION__, __LINE__));
8602
8603 if(_DMX_IOCtrlOpen() == FALSE)
8604 return DMX_FILTER_STATUS_ERROR;
8605
8606 param.eInfo = eInfo;
8607 param.u32Arg = u32Arg;
8608 param.u32Retinfo = u32Retinfo;
8609
8610 if (UtopiaIoctl(_pInstantDmx, MApi_CMD_DMX_TSIO_GetInfo, (void*)¶m) != UTOPIA_STATUS_SUCCESS)
8611 {
8612 DMX_V2DBGMSG(ULOGE("DMX", "[MAPI DMX][%s][%06d] fail\n", __FUNCTION__, __LINE__));
8613 return DMX_FILTER_STATUS_ERROR;
8614 }
8615
8616 if(param.u32Res != (MS_U32)DMX_FILTER_STATUS_OK)
8617 return DMX_FILTER_STATUS_ERROR;
8618 else
8619 return DMX_FILTER_STATUS_OK;
8620
8621 #else
8622
8623 return _MApi_DMX_TSIO_GetInfo(eInfo, u32Arg, u32Retinfo);
8624
8625 #endif
8626 }
8627
8628