开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
dmx.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：36k
源码类别：

DVD

开发平台：

C/C++

dmx.c：源码内容
  1. #include <string.h>
  2. #include "stevt.h"
  3. #include "stsys.h"
  4. #include "stcommon.h"
  5. #include "stpti.h"
  7. #include "errors.h"
  8. #include "osp.h"
  9. #include "dmx.h"
  10. #include "stpti_hal.h"
  12. #include "appltype.h"
  13. #include "sti5105.h"
  14. #include "swconfig.h"
  15. #if defined(DUAL_DVR)
  16.     #define KB_PTI_MAX_NUM 3
  17. #elif defined(PIP_SUPPORT)
  18.     #define KB_PTI_MAX_NUM 2
  19. #else
  20.     #define KB_PTI_MAX_NUM 1
  21. #endif
  23. /* STPTI */
  24. #define PTI_DEVICE               STPTI_DEVICE_PTI_4
  25. #define PTI_TCDEVICEADDRESS      (STPTI_DevicePtr_t)PTI_BASE_ADDRESS
  26. #define PTI_INTERRUPTNUMBER      PTI_INTERRUPT
  27. #define PTI_SECTIONFILTERMODE    STPTI_FILTER_OPERATING_MODE_32x8
  28. #define PTI_DVBTCLOADER          STPTI_DVBTCLoaderUL
  30. #define PTIB_TCDEVICEADDRESS     0
  31. #define PTIB_INTERRUPTNUMBER     0
  32. #define DMX_SECTION_SIZE (4*1024)
  34. #if (KB_PTI_MAX_NUM==3)
  35.     ST_DeviceName_t g_KB_PTIDeviceNameMultiple[KB_PTI_MAX_NUM] = {"PTI0","PTI1","PTI2"};
  36. #elif (KB_PTI_MAX_NUM==2)
  37.     ST_DeviceName_t g_KB_PTIDeviceNameMultiple[KB_PTI_MAX_NUM] = {"PTI0","PTI1"};
  38. #else
  39.     ST_DeviceName_t g_KB_PTIDeviceNameMultiple[KB_PTI_MAX_NUM] = {"PTI0"};
  40. #endif
  41. STPTI_Handle_t g_KB_PTIHandleMultiple[KB_PTI_MAX_NUM];
  42. #define DEFAULT_PTI (0)
  43. #define DMX_TOTAL_KEY_PAIRS          (12) /* total number of key index */
  46. extern ST_Partition_t *NcachePartition; /* non-cached partition */
  47. extern ST_Partition_t *SystemPartition; /* general partition    */
  49. typedef struct
  50. {
  51. BOOL   Allocated; /* indicates whether channel is allocated */
  52. BOOL   Started;              /* indicates whether channel is started */
  53. BOOL   InternalUnlock; /* indicates whether channel data is released internal */
  54. KB_DMXChannelType Type;      /* channel type enumeration */
  55. STPTI_Slot_t    SlotHandle;     /* Slot handle */
  56.     STPTI_Pid_t     Pid;            /* PID */
  57.     STPTI_Buffer_t  BufferHandle;   /* PTI Destination Buffer handle */
  58. UINT32          BufferSize;     /* PTI Destination Buffer size   */
  59. UINT8           *UserBuffer_p;  /* User Buffer */
  60.     UINT32          UserBufferSize; /* User Buffer */
  61. STPTI_Signal_t  SignalHandle;   /* PTI Destination Signal handle */
  62. STPTI_Descrambler_t DescramblerHandle; /* The ID of the descrambler currently used */
  63. KB_DMX_NotifyFunc NotifyFunctionPtr;
  65. }DMX_Channel;
  68. /*********************** Use generic slots *********************/
  69. const STPTI_SlotType_t STPTI_SlotTypes[] =
  70. {
  71. STPTI_SLOT_TYPE_NULL, /* Invalid */
  72.     STPTI_SLOT_TYPE_PES,    /* GENERIC_PES */
  73.     STPTI_SLOT_TYPE_SECTION,/* SECTION */
  74.     STPTI_SLOT_TYPE_EMM, /* EMM */
  75.     STPTI_SLOT_TYPE_ECM, /* ECM */
  76.     STPTI_SLOT_TYPE_RAW, /* RAW */
  77. };
  79. typedef struct _backdata{
  80. UINT32 channelID;
  81. UINT32 filterID;
  82. }BackData;
  84. #define BACKDATA_N 500
  85. static BackData g_backdata[BACKDATA_N];
  86. #define BACKID_N 100
  87. //static UINT32 g_backid[BACKID_N];
  89.  #define EXM_BUFF_LEN 1024
  90.  static STPTI_Signal_t  g_SignalHandle_for_TF;
  91.  static UINT8    Exm_Buf[EXM_BUFF_LEN];
  94. static DMX_Channel gChnnlInfo[KB_DMX_TOTAL_GENERIC_CHANNELS];
  95. static STPTI_Signal_t  gSinHandle;
  96. extern ST_Partition_t  *DemuxPartition;
  97. static UINT8 *Dmx_Buf;
  99. static void Dmx_Task(void *params);
  100. static INT32 KD_DmxAllocateBuf(UINT32 channelID, UINT32 bufferSize);
  102. static void* KD_DMXAllocate(UINT32 size);
  103. static void  KD_DMXFree(void *ptr);
  105. /* Semaphore for protect channel operation */
  106. static UINT32 Dmx_SemLock;
  108. /* get the first empty channel */
  109. static INT32 GetFirstEmptyChannelID(void)
  110. {
  111. INT32 i;
  112. for(i = 0; i < KB_DMX_TOTAL_GENERIC_CHANNELS; i++)
  113. {
  114. if(gChnnlInfo[i].Allocated == FALSE)
  115. {
  116. break;
  117. }
  118. }
  120. return i;
  121. }
  123. static void Dmx_Task(void *params)
  124. {
  125. ST_ErrorCode_t  ST_ErrorCode;
  126. STPTI_Buffer_t  WhichBufferGotSignal;
  127. DMX_Channel  *pChInfo;
  129. UINT32 DataSize;
  130. U32   NumFilterMatches = 0;
  131. BOOL  CRCValid;
  132. INT32  chId;
  134. while(1)
  135. {
  136. ST_ErrorCode = STPTI_SignalWaitBuffer(gSinHandle, &WhichBufferGotSignal, STPTI_TIMEOUT_INFINITY);
  138. /* STPTI_SignalWaitBuffer() generated an error */
  139.     if (ST_ErrorCode == ST_ERROR_TIMEOUT)
  140.     {
  141.         continue;
  142.     }
  143.     /* if not a harmless timeout then get rid of anything in the STPTI internal buffer */
  144.     else if (ST_ErrorCode != ST_NO_ERROR)
  145.     {
  146.         STPTI_BufferFlush(WhichBufferGotSignal);
  147. continue;
  148.     }
  150. /* Find the channel, that buffer handle equal WhichBufferGotSignal */
  151. for(chId = 0; chId < KB_DMX_TOTAL_GENERIC_CHANNELS; chId++)
  152. {
  153. if( (gChnnlInfo[chId].Allocated == TRUE)
  154. && (gChnnlInfo[chId].BufferHandle == WhichBufferGotSignal) )
  155. {
  156. /* got it */
  157. break;
  158. }
  159. }
  161. if(chId >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  162. {
  163. STPTI_BufferFlush(WhichBufferGotSignal);
  164. continue;
  165. }
  167. KB_OSPSemGet(Dmx_SemLock, KB_Wait, 0);
  169. pChInfo = &gChnnlInfo[chId];
  170. DataSize = 0;
  171. Dmx_Buf = KD_DMXAllocate(DMX_SECTION_SIZE);
  172. if(Dmx_Buf == NULL)
  173. {
  174.             DBGPrint("Dmx_Buf == NULLn");
  175. KB_OSPSemSet(Dmx_SemLock);
  176. continue;
  177. }
  179. switch(STPTI_SlotTypes[pChInfo->Type])
  180. {
  181. case STPTI_SLOT_TYPE_PES:
  182. #ifdef STPTI_DVB_SUPPORT
  183. ST_ErrorCode = STPTI_BufferReadPes(pChInfo->BufferHandle, (U8*)Dmx_Buf, (U32)DMX_SECTION_SIZE,
  184.    NULL, 0, (U32*)&DataSize,
  185.    STPTI_COPY_TRANSFER_BY_MEMCPY);
  186. #else
  187. STPTI_BufferFlush(WhichBufferGotSignal);
  188. KD_DMXFree(Dmx_Buf);
  189. KB_OSPSemSet(Dmx_SemLock);
  190. continue;
  191. #endif
  192. break;
  194.     case STPTI_SLOT_TYPE_SECTION: /* three type are same: section */
  195.     case STPTI_SLOT_TYPE_EMM:
  196.     case STPTI_SLOT_TYPE_ECM:
  197. ST_ErrorCode = STPTI_BufferReadSection(pChInfo->BufferHandle, NULL, 0, &NumFilterMatches, &CRCValid,
  198.                                                (U8*)Dmx_Buf, (U32)DMX_SECTION_SIZE, NULL, 0,
  199.                                                (U32*)&DataSize, STPTI_COPY_TRANSFER_BY_MEMCPY);
  200. break;
  202.     case STPTI_SLOT_TYPE_RAW:
  203. ST_ErrorCode = STPTI_BufferReadTSPacket(pChInfo->BufferHandle, (U8*)Dmx_Buf, (U32)DMX_SECTION_SIZE,
  204.    NULL, 0, (U32*)&DataSize,
  205.    STPTI_COPY_TRANSFER_BY_MEMCPY);
  206. break;
  208. default:
  209. /* do no support type */
  210. STPTI_BufferFlush(WhichBufferGotSignal);
  211. KD_DMXFree(Dmx_Buf);
  212. KB_OSPSemSet(Dmx_SemLock);
  213. continue;
  214. break;
  215. }
  217.         if (ST_ErrorCode != ST_NO_ERROR)    /* unexpected fault reading data */
  218.         {
  219.                      STPTI_BufferFlush(WhichBufferGotSignal);
  220. KD_DMXFree(Dmx_Buf);
  221. KB_OSPSemSet(Dmx_SemLock);
  222. continue;
  223.         }
  225. if(DataSize == 0)
  226. {
  227. KD_DMXFree(Dmx_Buf);
  228. KB_OSPSemSet(Dmx_SemLock);
  229. continue;
  230. }
  232. if(pChInfo->NotifyFunctionPtr != NULL)
  233. {
  234. pChInfo->NotifyFunctionPtr(chId, Dmx_Buf, DataSize);
  235. if(pChInfo->InternalUnlock == TRUE)
  236. {
  237. KD_DMXFree(Dmx_Buf);
  238. }
  239. }
  241. KB_OSPSemSet(Dmx_SemLock);
  243. }
  244. }
  247. static INT32 Associate(UINT32 channelID, UINT32 filterID)
  248. {
  249. int i;
  250. for(i=0;i<BACKDATA_N;i++){
  251. if(g_backdata[i].channelID==channelID&&g_backdata[i].filterID==filterID)
  252. break;
  253. }
  254. if(i==BACKDATA_N){
  255. for(i=0;i<BACKDATA_N;i++){
  256. if(g_backdata[i].channelID==0&&g_backdata[i].filterID==0){
  257. g_backdata[i].channelID=channelID;
  258. g_backdata[i].filterID=filterID;
  259. break;
  260. }
  261. }
  262. if(i==BACKDATA_N)
  263. return RETFIAL1;
  264. }
  265. else
  266. return RETFIAL1;
  268. return RETOK;
  270. }
  272. static  INT32 Disassociate(UINT32 channelID, UINT32 filterID)
  273. {
  274. int i;
  275. for(i=0;i<BACKDATA_N;i++){
  276. if(g_backdata[i].channelID==channelID&&g_backdata[i].filterID==filterID){
  277. g_backdata[i].channelID=0;
  278. g_backdata[i].filterID=0;
  279. break;
  280. }
  281. }
  282. if(i==BACKDATA_N)
  283. return RETFIAL1;
  285. return RETOK;
  287. }
  288. #if 0
  289. static void AddDescramblerId(UINT32 descramblerID)
  290. {
  291. int i;
  292. for(i=0;i<BACKID_N;i++){
  293. if(g_backid[i]==0){
  294. g_backid[i]=descramblerID;
  295. break;
  296. }
  297. }
  298. }
  300. static BOOL RemoveDescramblerId(UINT32 descramblerID)
  301. {
  302. int i;
  303. for(i=0;i<BACKID_N;i++){
  304. if(g_backid[i]==descramblerID){
  305. g_backid[i]=0;
  306. return TRUE;
  307. }
  308. }
  309. return FALSE;
  310. }
  312. static BOOL IsDescramblerId(UINT32 descramblerID)
  313. {
  314. int i;
  315. for(i=0;i<BACKID_N;i++){
  316. if(g_backid[i]==descramblerID)
  317. return TRUE;
  318. }
  319. return FALSE;
  320. }
  321. #endif
  322. INT32 KB_DmxInit(void)
  323. {
  324. INT32 i, Index;
  325. ST_ErrorCode_t         ST_ErrorCode;
  326.     STPTI_InitParams_t     STPTI_InitParams;
  327.     STPTI_OpenParams_t     STPTI_OpenParams;
  329. UINT32 taskId;
  331. KB_OSPSemInit("DMXS", 1, J_OSP_WAIT_FIFO, &Dmx_SemLock);
  333. /* Init the data struct info */
  334. for(i = 0; i < KB_DMX_TOTAL_GENERIC_CHANNELS; i++)
  335. {
  336. gChnnlInfo[i].Allocated  = FALSE;
  337. gChnnlInfo[i].Started = FALSE;
  338. gChnnlInfo[i].InternalUnlock = TRUE;
  339. gChnnlInfo[i].Type = DMX_CHANNEL_INVALID;
  340. gChnnlInfo[i].SlotHandle = STPTI_NullHandle();
  341. gChnnlInfo[i].Pid = STPTI_InvalidPid();
  342. gChnnlInfo[i].BufferHandle = STPTI_NullHandle();
  343. gChnnlInfo[i].BufferSize = 0;
  344. gChnnlInfo[i].UserBuffer_p = NULL;
  345. gChnnlInfo[i].UserBufferSize  = 0;
  346. gChnnlInfo[i].SignalHandle = STPTI_NullHandle();
  347. gChnnlInfo[i].DescramblerHandle = STPTI_NullHandle();
  348. gChnnlInfo[i].NotifyFunctionPtr = NULL;
  349. }
  351. /* Init stpti */
  352. STPTI_InitParams.Device                     = PTI_DEVICE;
  353.     STPTI_InitParams.TCDeviceAddress_p          = (STPTI_DevicePtr_t)PTI_TCDEVICEADDRESS;
  354.     STPTI_InitParams.InterruptNumber            = PTI_INTERRUPTNUMBER;
  356.     STPTI_InitParams.DescramblerAssociation     = STPTI_DESCRAMBLER_ASSOCIATION_ASSOCIATE_WITH_PIDS;
  357.     STPTI_InitParams.Partition_p                = SystemPartition;
  358.     STPTI_InitParams.NCachePartition_p          = NcachePartition;
  359.     strcpy( STPTI_InitParams.EventHandlerName, "EVT" );
  360.     STPTI_InitParams.EventProcessPriority       = STPTI_EVENT_PROCESS_PRIORITY;
  361.     STPTI_InitParams.InterruptProcessPriority   = STPTI_INTERRUPT_PROCESS_PRIORITY;
  362.     #if defined(STPTI_CAROUSEL_SUPPORT)
  363.         STPTI_InitParams.CarouselProcessPriority    = 0;
  364.         STPTI_InitParams.CarouselEntryType          = STPTI_CAROUSEL_ENTRY_TYPE_SIMPLE;
  365.     #endif
  366.     STPTI_InitParams.InterruptLevel             = PTI_INTERRUPT_LEVEL;
  367.     STPTI_InitParams.SectionFilterOperatingMode = PTI_SECTIONFILTERMODE;
  368.     #if defined(STPTI_INDEX_SUPPORT)
  369.         STPTI_InitParams.IndexAssociation           = STPTI_INDEX_ASSOCIATION_ASSOCIATE_WITH_SLOTS;
  370.         STPTI_InitParams.IndexProcessPriority       = 0;
  371.     #endif
  372.     STPTI_InitParams.StreamID = STPTI_STREAM_ID_NOTAGS;
  374.     STPTI_InitParams.PacketArrivalTimeSource = STPTI_ARRIVAL_TIME_SOURCE_PTI;
  376. for(Index = 0; Index < KB_PTI_MAX_NUM ; Index++)
  377. {
  378. STPTI_InitParams.TCLoader_p = PTI_DVBTCLOADER; /* for PTI4 */
  379.         STPTI_InitParams.TCCodes    = STPTI_SUPPORTED_TCCODES_SUPPORTS_DVB;
  381. STPTI_InitParams.NumberOfSlots      = KB_DMX_TOTAL_GENERIC_CHANNELS;
  382.     STPTI_InitParams.DiscardOnCrcError  = FALSE;
  384. /* initialises PTI device */
  385.     ST_ErrorCode = STPTI_Init(g_KB_PTIDeviceNameMultiple[Index], &STPTI_InitParams);
  386.     if (ST_ErrorCode != ST_NO_ERROR)
  387.     {
  388.       STTBX_Print(("%sn", KB_ErrorGetText(ST_ErrorCode) ));
  389.       return( ST_ErrorCode );
  390.     }
  391.     STTBX_Print(("%sn", STPTI_GetRevision() ));
  393. STPTI_OpenParams.DriverPartition_p    = SystemPartition;
  394.         STPTI_OpenParams.NonCachedPartition_p = NcachePartition;
  396.         /* open PTI device */
  397.         STTBX_Print(("PTI_Open = "));
  398.         ST_ErrorCode = STPTI_Open(g_KB_PTIDeviceNameMultiple[Index], &STPTI_OpenParams, &g_KB_PTIHandleMultiple[Index]);
  399.         STTBX_Print(("%sn", KB_ErrorGetText(ST_ErrorCode) ));
  400.         if (ST_ErrorCode != ST_NO_ERROR) return RETFIAL1;
  402. ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_SECTIONS_DISCARDED_ON_CRC_CHECK_EVT);
  403.         if (ST_ErrorCode != ST_NO_ERROR)
  404.             return( ST_ErrorCode );
  406.         ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_TC_CODE_FAULT_EVT);
  407.         if (ST_ErrorCode != ST_NO_ERROR)
  408.             return( ST_ErrorCode );
  410.         ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_INVALID_PARAMETER_EVT);
  411.         if (ST_ErrorCode != ST_NO_ERROR)
  412.             return( ST_ErrorCode );
  414.         ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_BUFFER_OVERFLOW_EVT);
  415.         if (ST_ErrorCode != ST_NO_ERROR)
  416.             return( ST_ErrorCode );
  418.         /* Enable receipt of a number of STPTI events */
  420.         ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_CC_ERROR_EVT);
  421.         if (ST_ErrorCode != ST_NO_ERROR)
  422.             return( ST_ErrorCode );
  424.         ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_INTERRUPT_FAIL_EVT);
  425.         if (ST_ErrorCode != ST_NO_ERROR)
  426.             return( ST_ErrorCode );
  428.         ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_INVALID_LINK_EVT);
  429.         if (ST_ErrorCode != ST_NO_ERROR)
  430.             return( ST_ErrorCode );
  432.         ST_ErrorCode = STPTI_EnableErrorEvent(g_KB_PTIDeviceNameMultiple[Index], STPTI_EVENT_PACKET_ERROR_EVT);
  433.         if (ST_ErrorCode != ST_NO_ERROR)
  434.             return( ST_ErrorCode );
  435. }
  437. ST_ErrorCode = STPTI_SignalAllocate(g_KB_PTIHandleMultiple[DEFAULT_PTI], &gSinHandle);
  438. if (ST_ErrorCode != ST_NO_ERROR) return( ST_ErrorCode );
  440. KB_OSPTaskInit("DMXT", 10240, Dmx_Task, DMX_PRIORITY, NULL, &taskId);
  442. return( ST_ErrorCode );
  443. }
  445. INT32 KB_DmxAllocateChnnl(KB_DMXChannelType channelType, UINT32 bufferSize, BOOL isInternal, UINT32 *channelID)
  446. {
  447. INT32 rc = RETFIAL1;
  448. ST_ErrorCode_t   ST_ErrorCode;
  449. STPTI_SlotData_t STPTI_SlotData;
  450. INT32 index;
  452. if( (channelType == DMX_CHANNEL_INVALID) || (channelID == NULL) )
  453. {
  454. return RETFAIL3;
  455. }
  457. *channelID = KB_DMX_TOTAL_GENERIC_CHANNELS;
  459. STPTI_SlotData.SlotType = STPTI_SlotTypes[channelType];
  460.     STPTI_SlotData.SlotFlags.SignalOnEveryTransportPacket   = FALSE;
  461.     STPTI_SlotData.SlotFlags.CollectForAlternateOutputOnly  = FALSE;
  462.     STPTI_SlotData.SlotFlags.AlternateOutputInjectCarouselPacket = FALSE;
  463.     STPTI_SlotData.SlotFlags.StoreLastTSHeader  = FALSE;
  464.     STPTI_SlotData.SlotFlags.InsertSequenceError    = FALSE;
  465.     STPTI_SlotData.SlotFlags.OutPesWithoutMetadata  = FALSE;
  466.     STPTI_SlotData.SlotFlags.ForcePesLengthToZero   = FALSE;
  467.     STPTI_SlotData.SlotFlags.AppendSyncBytePrefixToRawData = FALSE;
  468.     STPTI_SlotData.SlotFlags.SoftwareCDFifo = FALSE;
  470. index = GetFirstEmptyChannelID();
  471. if(index == KB_DMX_TOTAL_GENERIC_CHANNELS)
  472. {
  473. return rc;
  474. }
  475. else
  476. {
  477. ST_ErrorCode = STPTI_SlotAllocate( g_KB_PTIHandleMultiple[DEFAULT_PTI],
  478.                                            &gChnnlInfo[index].SlotHandle,
  479.                                            &STPTI_SlotData);
  480.         if (ST_ErrorCode == ST_NO_ERROR)
  481.         {
  482. gChnnlInfo[index].Allocated = TRUE;
  483. gChnnlInfo[index].Type = channelType;
  485. if(RETOK == KD_DmxAllocateBuf(index, bufferSize))
  486. {
  487. gChnnlInfo[index].InternalUnlock = isInternal;
  488. *channelID = index;
  489. rc = RETOK;
  490. }
  491. else
  492. {
  493. /* can't allocate buffer, so deallocate the slot */
  494. STPTI_SlotDeallocate(gChnnlInfo[index].SlotHandle);
  495. gChnnlInfo[index].SlotHandle = STPTI_NullHandle();
  496. gChnnlInfo[index].Allocated = FALSE;
  497. gChnnlInfo[index].Type = DMX_CHANNEL_INVALID;
  498. }
  499.         }
  500. }
  502. return rc;
  503. }
  506. INT32 KB_DmxFreeChnnl(UINT32 channelID)
  507. {
  508. DMX_Channel *pChInfo;
  510. if(channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS) return RETFAIL3;
  512. if(gChnnlInfo[channelID].Allocated == FALSE)
  513. {
  514. /* This channel has not been allocated. return success immediately */
  515. return RETOK;
  516. }
  518. pChInfo = &gChnnlInfo[channelID];
  520. /* Stop the channel first */
  521. if(pChInfo->Started == TRUE)
  522. {
  523. pChInfo->Started = FALSE;
  524. }
  526. if(pChInfo->BufferHandle != STPTI_NullHandle())
  527. {
  528.     STPTI_SlotUnLink(pChInfo->SlotHandle);
  529. if(pChInfo->SignalHandle != STPTI_NullHandle())
  530. {
  531.      STPTI_SignalDisassociateBuffer(pChInfo->SignalHandle, pChInfo->BufferHandle);
  532. pChInfo->SignalHandle = STPTI_NullHandle();
  533.     }
  534.     STPTI_BufferDeallocate(pChInfo->BufferHandle);
  535. pChInfo->BufferHandle = STPTI_NullHandle();
  536. }
  537.     STPTI_SlotDeallocate(pChInfo->SlotHandle);
  538. pChInfo->SlotHandle = STPTI_NullHandle();
  540. pChInfo->Allocated = FALSE;
  541. pChInfo->Type = DMX_CHANNEL_INVALID;
  542. pChInfo->InternalUnlock = TRUE;
  544. return RETOK;
  545. }
  548. INT32 KB_DmxSetChnnlPID(UINT32 channelID, UINT16 pid)
  549. {
  550. ST_ErrorCode_t   ST_ErrorCode;
  551. INT32 rc;
  552. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  553.    || (gChnnlInfo[channelID].Allocated == FALSE) )
  554. {
  555. return RETFAIL3;
  556. }
  557.    ST_ErrorCode = STPTI_SlotClearPid(gChnnlInfo[channelID].SlotHandle);
  558. if(ST_NO_ERROR != ST_ErrorCode)
  559. {
  560. rc = RETFIAL1;
  561. }
  563. ST_ErrorCode = STPTI_SlotSetPid(gChnnlInfo[channelID].SlotHandle, (STPTI_Pid_t)pid);
  564. if(ST_NO_ERROR != ST_ErrorCode)
  565. {
  566. rc = RETFIAL1;
  567. }
  568. else
  569. {
  570. gChnnlInfo[channelID].Pid = pid;
  571. if(gChnnlInfo[channelID].BufferHandle != STPTI_NullHandle())
  572. {
  573. STPTI_BufferFlush(gChnnlInfo[channelID].BufferHandle);
  574. }
  575. rc = RETOK;
  576. }
  578. return rc;
  579. }
  582. INT32 KB_DmxControlChnnl(UINT32 channelID, UINT32 channelCmd)
  583. {
  584. ST_ErrorCode_t   ST_ErrorCode = ST_NO_ERROR;
  586. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  587.    || (gChnnlInfo[channelID].Allocated == FALSE) )
  588. {
  589. return RETFAIL3;
  590. }
  592. switch(channelCmd)
  593. {
  594. case KB_DMX_START:
  595. ST_ErrorCode = STPTI_SlotSetPid(gChnnlInfo[channelID].SlotHandle, (STPTI_Pid_t)gChnnlInfo[channelID].Pid);
  596. break;
  598. case KB_DMX_STOP:
  599. ST_ErrorCode = STPTI_SlotClearPid(gChnnlInfo[channelID].SlotHandle);
  600. break;
  602. case KB_DMX_RESET:
  603. break;
  604. }
  606. if(ST_NO_ERROR != ST_ErrorCode)
  607. {
  608. return RETFIAL1;
  609. }
  611. return RETOK;
  612. }
  615. INT32 KB_DmxRegNotice(UINT32 channelID, KB_DMX_NotifyFunc funcPtr)
  616. {
  617. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  618.    || (gChnnlInfo[channelID].Allocated == FALSE) )
  619. {
  620. return RETFAIL3;
  621. }
  623. gChnnlInfo[channelID].NotifyFunctionPtr = funcPtr;
  624. return RETOK;
  625. }
  628. /* filter functions */
  629. INT32 KB_DmxAllocateFilter(KB_DMXFilterType filterType, UINT32 filterDepth, UINT32 *filterID)
  630. {
  631. ST_ErrorCode_t  ST_ErrorCode;
  632. STPTI_FilterType_t stpti_FilterType;
  634. if(filterID == NULL)
  635. {
  636. return RETFAIL3;
  637. }
  639. switch(filterType)
  640. {
  641. case DMX_SECTION_FILTER:
  642. stpti_FilterType = STPTI_FILTER_TYPE_SECTION_FILTER_SHORT_MODE;
  643. break;
  645.     case DMX_SECTION_FILTER_NEG_MATCH_MODE:
  646. stpti_FilterType = STPTI_FILTER_TYPE_SECTION_FILTER_NEG_MATCH_MODE;
  647. break;
  649.     case DMX_PES_FILTER:
  650. stpti_FilterType = STPTI_FILTER_TYPE_PES_FILTER;
  651. break;
  653.     case DMX_TSHEADER_FILTER:
  654. stpti_FilterType = STPTI_FILTER_TYPE_TSHEADER_FILTER;
  655. break;
  657. default:
  658. return RETFIAL1;
  659. break;
  660. }
  662. filterDepth = filterDepth; /* avoid compiler warning */
  663. *filterID = STPTI_NullHandle();
  664. ST_ErrorCode = STPTI_FilterAllocate(g_KB_PTIHandleMultiple[DEFAULT_PTI],
  665.   stpti_FilterType,
  666.   (STPTI_Filter_t*)filterID);
  668. if(ST_NO_ERROR != ST_ErrorCode)
  669. {
  670. return RETFIAL1;
  671. }
  673. return RETOK;
  674. }
  677. INT32 KB_DmxFreeFilter(UINT32 filterID)
  678. {
  679. ST_ErrorCode_t  ST_ErrorCode;
  681. if(filterID == STPTI_NullHandle()) return RETFAIL3;
  683. ST_ErrorCode = STPTI_FilterDeallocate((STPTI_Filter_t)filterID);
  685. if(ST_NO_ERROR != ST_ErrorCode)
  686. {
  687. return RETFIAL1;
  688. }
  690. return RETOK;
  691. }
  694. INT32 KB_DmxSetFilter(UINT32 filterID, UINT8* filterMatch, UINT8* filterMask, UINT32 filterNegate)
  695. {
  696. ST_ErrorCode_t  ST_ErrorCode;
  697. STPTI_FilterData_t FilterData;
  698. WORD2BYTE *DataMask;
  699. UINT8 stFilterMatch[16];
  700. UINT8 stFilterMask[16];
  702. if( (filterID == STPTI_NullHandle())
  703. || (filterMatch == NULL) || (filterMask == NULL) )
  704. {
  705. return RETFAIL3;
  706. }
  708. filterNegate = filterNegate; /* No effect. Only avoid compiler warning */
  711. /* incoming data is in the following format:
  712.     * BYTE DESCRIPTION BYTE_POSITION_IN_SF EXAMPLE
  713.     * =============================================================
  714.     * 0 TABLE_ID (8) MS_WORD.BYTE0 PAT_TABLE_ID
  715.     * 1,2 SECTION_LENGTH (12) - -
  716.     * 3,4 TP_STREAM_ID (16) MS_WORD.BYTE1,2 0x0000
  717.     * 5.6-7 RESERVED (2) MS_WORD.BYTE3.6-7 0x3
  718.     * 5.5-1 VERSION_NUMBER (5) MS_WORD.BYTE3.5-1 0
  719.     * 5.0 CUR_NXT_INDICATOR (1) MS_WORD.BYTE3.0 0
  720.     * 6 SECTION_NUMBER (8) LS_WORD.BYTE0 0
  721.     * 7 LAST_SECTION_NUMBER (8) LS_WORD.BYTE1 0
  722.     * 8 - LS_WORD.BYTE2 0
  723.     * 9 - LS_WORD.BYTE3 0
  724.     */
  725. memset(stFilterMatch, 0, sizeof(stFilterMatch));
  726. memset(stFilterMask, 0, sizeof(stFilterMask));
  728. DataMask = (WORD2BYTE *)&stFilterMatch[0];
  729. DataMask->byte.ucByte0 = filterMatch[0];
  730. DataMask->byte.ucByte1 = filterMatch[3];
  731. DataMask->byte.ucByte2 = filterMatch[4];
  732. DataMask->byte.ucByte3 = filterMatch[5];
  733. DataMask = (WORD2BYTE *)&stFilterMatch[4];
  734. DataMask->byte.ucByte0 = filterMatch[6];
  735. DataMask->byte.ucByte1 = filterMatch[7];
  737. DataMask = (WORD2BYTE *)&stFilterMask[0];
  738. DataMask->byte.ucByte0 = filterMask[0];
  739. DataMask->byte.ucByte1 = filterMask[3];
  740. DataMask->byte.ucByte2 = filterMask[4];
  741. DataMask->byte.ucByte3 = filterMask[5];
  742. DataMask = (WORD2BYTE *)&stFilterMask[4];
  743. DataMask->byte.ucByte0 = filterMask[6];
  744. DataMask->byte.ucByte1 = filterMask[7];
  747. FilterData.FilterBytes_p = (U8*)stFilterMatch;
  748. FilterData.FilterMasks_p = (U8*)stFilterMask;
  749. FilterData.FilterType = STPTI_FILTER_TYPE_SECTION_FILTER_SHORT_MODE;
  750. FilterData.FilterRepeatMode = STPTI_FILTER_REPEAT_MODE_STPTI_FILTER_REPEATED;
  751.     FilterData.InitialStateEnabled = TRUE; 
  752. FilterData.u.SectionFilter.DiscardOnCrcError  = TRUE;
  753.     FilterData.u.SectionFilter.ModePattern_p      = NULL;
  754.     FilterData.u.SectionFilter.NotMatchMode       = FALSE;
  756. ST_ErrorCode = STPTI_FilterSet((STPTI_Filter_t)filterID, &FilterData);
  758. if(ST_NO_ERROR != ST_ErrorCode)
  759. {
  760. return RETFIAL1;
  761. }
  763. return RETOK;
  764. }
  767. //-add by shriek-
  768. INT32 KB_DmxSetFilterByType(UINT32 filterID, UINT8* filterMatch, UINT8* filterMask, UINT32 filterNegate, STPTI_FilterType_t filterType)
  769. {
  770. ST_ErrorCode_t  ST_ErrorCode;
  771. STPTI_FilterData_t FilterData;
  772. WORD2BYTE *DataMask;
  773. UINT8 stFilterMatch[16];
  774. UINT8 stFilterMask[16];
  776. if( (filterID == STPTI_NullHandle())
  777. || (filterMatch == NULL) || (filterMask == NULL) )
  778. {
  779. return RETFAIL3;
  780. }
  782. filterNegate = filterNegate; /* No effect. Only avoid compiler warning */
  785. /* incoming data is in the following format:
  786.     * BYTE DESCRIPTION BYTE_POSITION_IN_SF EXAMPLE
  787.     * =============================================================
  788.     * 0 TABLE_ID (8) MS_WORD.BYTE0 PAT_TABLE_ID
  789.     * 1,2 SECTION_LENGTH (12) - -
  790.     * 3,4 TP_STREAM_ID (16) MS_WORD.BYTE1,2 0x0000
  791.     * 5.6-7 RESERVED (2) MS_WORD.BYTE3.6-7 0x3
  792.     * 5.5-1 VERSION_NUMBER (5) MS_WORD.BYTE3.5-1 0
  793.     * 5.0 CUR_NXT_INDICATOR (1) MS_WORD.BYTE3.0 0
  794.     * 6 SECTION_NUMBER (8) LS_WORD.BYTE0 0
  795.     * 7 LAST_SECTION_NUMBER (8) LS_WORD.BYTE1 0
  796.     * 8 - LS_WORD.BYTE2 0
  797.     * 9 - LS_WORD.BYTE3 0
  798.     */
  799. memset(stFilterMatch, 0, sizeof(stFilterMatch));
  800. memset(stFilterMask, 0, sizeof(stFilterMask));
  802. DataMask = (WORD2BYTE *)&stFilterMatch[0];
  803. DataMask->byte.ucByte0 = filterMatch[0];
  804. DataMask->byte.ucByte1 = filterMatch[3];
  805. DataMask->byte.ucByte2 = filterMatch[4];
  806. DataMask->byte.ucByte3 = filterMatch[5];
  807. DataMask = (WORD2BYTE *)&stFilterMatch[4];
  808. DataMask->byte.ucByte0 = filterMatch[6];
  809. DataMask->byte.ucByte1 = filterMatch[7];
  811. DataMask = (WORD2BYTE *)&stFilterMask[0];
  812. DataMask->byte.ucByte0 = filterMask[0];
  813. DataMask->byte.ucByte1 = filterMask[3];
  814. DataMask->byte.ucByte2 = filterMask[4];
  815. DataMask->byte.ucByte3 = filterMask[5];
  816. DataMask = (WORD2BYTE *)&stFilterMask[4];
  817. DataMask->byte.ucByte0 = filterMask[6];
  818. DataMask->byte.ucByte1 = filterMask[7];
  821. FilterData.FilterBytes_p = (U8*)stFilterMatch;
  822. FilterData.FilterMasks_p = (U8*)stFilterMask;
  823. FilterData.FilterType = STPTI_FILTER_TYPE_SECTION_FILTER_SHORT_MODE;
  824. FilterData.FilterRepeatMode = filterType;
  825.        FilterData.InitialStateEnabled = TRUE; 
  826. FilterData.u.SectionFilter.DiscardOnCrcError  = TRUE;
  827.        FilterData.u.SectionFilter.ModePattern_p      = NULL;
  828.        FilterData.u.SectionFilter.NotMatchMode       = FALSE;
  830. ST_ErrorCode = STPTI_FilterSet((STPTI_Filter_t)filterID, &FilterData);
  832. if(ST_NO_ERROR != ST_ErrorCode)
  833. {
  834. printf("n [KB_DmxSetFilterByType]: ST_ErrorCode=%d",ST_ErrorCode);
  835. return RETFIAL1;
  836. }
  838. return RETOK;
  839. }
  842. INT32 KB_DmxAssociateFilter(UINT32 channelID, UINT32 filterID)
  843. {
  844. ST_ErrorCode_t  ST_ErrorCode;
  846. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  847.    || (gChnnlInfo[channelID].Allocated == FALSE)
  848.    || (filterID == STPTI_NullHandle()) )
  849. {
  850. return RETFAIL3;
  851. }
  853. ST_ErrorCode = STPTI_FilterAssociate((STPTI_Filter_t)filterID, gChnnlInfo[channelID].SlotHandle);
  855. if(ST_NO_ERROR != ST_ErrorCode)
  856. {
  857. return RETFIAL1;
  858. }
  859. Associate(channelID, filterID);
  861. return RETOK;
  862. }
  865. INT32 KB_DmxDisassociateFilter(UINT32 channelID, UINT32 filterID)
  866. {
  867. ST_ErrorCode_t  ST_ErrorCode;
  869. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  870.    || (gChnnlInfo[channelID].Allocated == FALSE)
  871.    || (filterID == STPTI_NullHandle()) )
  872. {
  873. return RETFAIL3;
  874. }
  876. if(Disassociate(channelID, filterID)==RETFIAL1)
  877. return RETFIAL1;
  878. ST_ErrorCode = STPTI_FilterDisassociate((STPTI_Filter_t)filterID, gChnnlInfo[channelID].SlotHandle);
  880. if(ST_NO_ERROR != ST_ErrorCode)
  881. {
  882. return RETFIAL1;
  883. }
  885. return RETOK;
  886. }
  889. /* buffer functions */
  890. static INT32 KD_DmxAllocateBuf(UINT32 channelID, UINT32 bufferSize)
  891. {
  892. ST_ErrorCode_t   ST_ErrorCode;
  893. DMX_Channel *pChInfo;
  895. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  896.    || (gChnnlInfo[channelID].Allocated == FALSE) )
  897. {
  898. return RETFAIL3;
  899. }
  901. if(0 == bufferSize)
  902. {
  903. return RETFAIL3;
  904. }
  906. pChInfo = &gChnnlInfo[channelID];
  908. if(pChInfo->BufferHandle != STPTI_NullHandle()) /* Already allocated buffer for this slot */
  909. {
  910. return RETFIAL1;
  911. }
  913. ST_ErrorCode = STPTI_BufferAllocate(g_KB_PTIHandleMultiple[DEFAULT_PTI],
  914. (U32)bufferSize, 1, &(pChInfo->BufferHandle));
  916. if(ST_NO_ERROR != ST_ErrorCode) goto Err_End;
  918. pChInfo->BufferSize = bufferSize;
  919. ST_ErrorCode = STPTI_SlotLinkToBuffer(pChInfo->SlotHandle, pChInfo->BufferHandle);
  920. if(ST_NO_ERROR != ST_ErrorCode) goto Err_Buf;
  922. STPTI_SlotClearPid(pChInfo->SlotHandle);
  924. STPTI_BufferFlush(pChInfo->BufferHandle);
  926. pChInfo->SignalHandle = gSinHandle;// 所有buffer均用同一个signal
  927. ST_ErrorCode = STPTI_SignalAssociateBuffer(pChInfo->SignalHandle, pChInfo->BufferHandle);
  928. if(ST_NO_ERROR != ST_ErrorCode)
  929. {
  930. pChInfo->SignalHandle = STPTI_NullHandle();
  931. goto Err_Buf;
  932. }
  934. return RETOK;
  936. Err_Buf:
  937. STPTI_SlotUnLink(pChInfo->SlotHandle);
  938. STPTI_BufferDeallocate(pChInfo->BufferHandle);
  939. pChInfo->BufferHandle = STPTI_NullHandle();
  940. pChInfo->BufferSize = 0;
  942. Err_End:
  943. return RETFIAL1;
  944. }
  947. INT32 KB_DmxUnlock(UINT32 channelID, UINT8* bufferPtr)
  948. {
  949. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  950.    || (gChnnlInfo[channelID].Allocated == FALSE) )
  951. {
  952. return RETFAIL3;
  953. }
  955. if(gChnnlInfo[channelID].InternalUnlock == TRUE)
  956. {
  957. return RETFIAL1;
  958. }
  960. KD_DMXFree(bufferPtr);
  962. return RETOK;
  963. }
  965. static void* KD_DMXAllocate(UINT32 size)
  966. {
  967. return memory_allocate(DemuxPartition, (size_t)size);
  969. }
  971. static void  KD_DMXFree(void *ptr)
  972. {
  973. if(ptr == NULL) return;
  974. memory_deallocate(DemuxPartition, ptr);
  975. }
  977. /* descrambler functions */
  978. INT32 KB_DmxOpenDescrambler(void)
  979. {
  980. ST_ErrorCode_t Error;
  981.     STPTI_Descrambler_t DescramblerHandle;
  983.     if (ST_NO_ERROR != (Error = STPTI_DescramblerAllocate(g_KB_PTIHandleMultiple[DEFAULT_PTI], &DescramblerHandle, STPTI_DESCRAMBLER_TYPE_DVB_DESCRAMBLER )))
  984.     {
  985.         return RETFIAL1;
  986.     }
  987. return (INT32)DescramblerHandle;
  988. }
  991. INT32 KB_DmxCloseDescrambler(UINT32 descramblerID)
  992. {
  993. ST_ErrorCode_t Error;
  996.     if (ST_NO_ERROR != (Error = STPTI_DescramblerDeallocate((STPTI_Descrambler_t)descramblerID)))
  997.     {
  998.         return RETFIAL1;
  999.     }
  1001. return RETOK;
  1002. }
  1005. INT32 KB_DmxSetEventKey(UINT32 descramblerID, const UINT8* evenKey)
  1006. {
  1007. ST_ErrorCode_t Error;
  1009. if(evenKey == NULL)
  1010. {
  1011. return RETFAIL3;
  1012. }
  1014. if (ST_NO_ERROR != (Error = STPTI_DescramblerSet((STPTI_Descrambler_t)descramblerID, STPTI_KEY_PARITY_EVEN_PARITY, STPTI_KEY_USAGE_VALID_FOR_TRANSPORT, (U8*)evenKey)))
  1015. {
  1016.         return RETFIAL1;
  1017. }
  1019. return RETOK;
  1020. }
  1022. INT32 KB_DmxSetOddKey(UINT32 descramblerID, const UINT8* oddKey)
  1023. {
  1024. ST_ErrorCode_t Error;
  1026. if(oddKey == NULL)
  1027. {
  1028. return RETFAIL3;
  1029. }
  1031. if (ST_NO_ERROR != (Error = STPTI_DescramblerSet((STPTI_Descrambler_t)descramblerID, STPTI_KEY_PARITY_ODD_PARITY, STPTI_KEY_USAGE_VALID_FOR_TRANSPORT, (U8*)oddKey)))
  1032. {
  1033.         return RETFIAL1;
  1034. }
  1036. return RETOK;
  1037. }
  1039. INT32 KB_DmxSetDescPID(UINT32 descramblerID, UINT16 pid)
  1040. {
  1041. ST_ErrorCode_t Error;
  1042. STPTI_SlotOrPid_t   SlotOrPid;
  1044. SlotOrPid.Pid = (STPTI_Pid_t)pid;            
  1046.     if (ST_NO_ERROR != (Error = STPTI_DescramblerAssociate((STPTI_Descrambler_t)descramblerID, SlotOrPid)))
  1047.     {
  1048.         return RETFIAL1;
  1049.     }
  1051. return RETOK;
  1052. }
  1053. INT32 KD_DmxCloseDescPID(UINT32 descramblerID, UINT16 pid)
  1054. {
  1055. ST_ErrorCode_t Error;
  1056. STPTI_SlotOrPid_t   SlotOrPid;
  1058. SlotOrPid.Pid = (STPTI_Pid_t)pid;  
  1060.     if (ST_NO_ERROR != (Error = STPTI_DescramblerDisassociate((STPTI_Descrambler_t)descramblerID, SlotOrPid)))
  1061.     {
  1062.         return RETFIAL1;
  1063.     }
  1065. return RETOK;
  1066. }
  1068. static INT32 KD_DmxAllocateBuffCA(UINT32 channelID, UINT32 bufferSize)
  1069. {
  1070. ST_ErrorCode_t   ST_ErrorCode;
  1071. DMX_Channel *pChInfo;
  1073. if( (channelID >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  1074.    || (gChnnlInfo[channelID].Allocated == FALSE) )
  1075. {
  1076. return RETFAIL3;
  1077. }
  1079. if(0 == bufferSize)
  1080. {
  1081. return RETFAIL3;
  1082. }
  1084. pChInfo = &gChnnlInfo[channelID];
  1086. if(pChInfo->BufferHandle != STPTI_NullHandle()) /* Already allocated buffer for this slot */
  1087. {
  1088. return RETFIAL1;
  1089. }
  1091. ST_ErrorCode = STPTI_BufferAllocate(g_KB_PTIHandleMultiple[DEFAULT_PTI],
  1092. (U32)bufferSize, 1, &(pChInfo->BufferHandle));
  1094. if(ST_NO_ERROR != ST_ErrorCode) goto Err_End;
  1096. pChInfo->BufferSize = bufferSize;
  1097. ST_ErrorCode = STPTI_SlotLinkToBuffer(pChInfo->SlotHandle, pChInfo->BufferHandle);
  1098. if(ST_NO_ERROR != ST_ErrorCode) goto Err_Buf;
  1100. STPTI_SlotClearPid(pChInfo->SlotHandle);
  1102. STPTI_BufferFlush(pChInfo->BufferHandle);
  1104. pChInfo->SignalHandle = g_SignalHandle_for_TF;// 所有Ecm Emm均用同一个signal
  1105. ST_ErrorCode = STPTI_SignalAssociateBuffer(pChInfo->SignalHandle, pChInfo->BufferHandle);
  1106. if(ST_NO_ERROR != ST_ErrorCode)
  1107. {
  1108. pChInfo->SignalHandle = STPTI_NullHandle();
  1109. goto Err_Buf;
  1110. }
  1112. return RETOK;
  1114. Err_Buf:
  1115. STPTI_SlotUnLink(pChInfo->SlotHandle);
  1116. STPTI_BufferDeallocate(pChInfo->BufferHandle);
  1117. pChInfo->BufferHandle = STPTI_NullHandle();
  1118. pChInfo->BufferSize = 0;
  1120. Err_End:
  1121. return RETFIAL1;
  1122. }
  1125. INT32 KD_DmxAllocateChnnlCA(KB_DMXChannelType channelType, UINT32 bufferSize, BOOL isInternal, UINT32 *channelID)
  1126. {
  1127. INT32 rc = RETFIAL1;
  1128. ST_ErrorCode_t   ST_ErrorCode;
  1129. STPTI_SlotData_t STPTI_SlotData;
  1130. INT32 index;
  1132. if( (channelType == DMX_CHANNEL_INVALID) || (channelID == NULL) )
  1133. {
  1134. return RETFAIL3;
  1135. }
  1137. *channelID = KB_DMX_TOTAL_GENERIC_CHANNELS;
  1139. STPTI_SlotData.SlotType = STPTI_SlotTypes[channelType];
  1140.     STPTI_SlotData.SlotFlags.SignalOnEveryTransportPacket   = FALSE;
  1141.     STPTI_SlotData.SlotFlags.CollectForAlternateOutputOnly  = FALSE;
  1142.     STPTI_SlotData.SlotFlags.AlternateOutputInjectCarouselPacket = FALSE;
  1143.     STPTI_SlotData.SlotFlags.StoreLastTSHeader  = FALSE;
  1144.     STPTI_SlotData.SlotFlags.InsertSequenceError    = FALSE;
  1145.     STPTI_SlotData.SlotFlags.OutPesWithoutMetadata  = FALSE;
  1146.     STPTI_SlotData.SlotFlags.ForcePesLengthToZero   = FALSE;
  1147.     STPTI_SlotData.SlotFlags.AppendSyncBytePrefixToRawData = FALSE;
  1148.     STPTI_SlotData.SlotFlags.SoftwareCDFifo = FALSE;
  1150. index = GetFirstEmptyChannelID();
  1151. if(index == KB_DMX_TOTAL_GENERIC_CHANNELS)
  1152. {
  1153. }
  1154. else
  1155. {
  1156. ST_ErrorCode = STPTI_SlotAllocate( g_KB_PTIHandleMultiple[DEFAULT_PTI],
  1157.                                            &gChnnlInfo[index].SlotHandle,
  1158.                                            &STPTI_SlotData);
  1159.         if (ST_ErrorCode == ST_NO_ERROR)
  1160.         {
  1161. gChnnlInfo[index].Allocated = TRUE;
  1162. gChnnlInfo[index].Type = channelType;
  1164. if(RETOK == KD_DmxAllocateBuffCA(index, bufferSize))
  1165. {
  1166. gChnnlInfo[index].InternalUnlock = isInternal;
  1167. *channelID = index;
  1168. rc = RETOK;
  1169. }
  1170. else
  1171. {
  1172. /* can't allocate buffer, so deallocate the slot */
  1173. STPTI_SlotDeallocate(gChnnlInfo[index].SlotHandle);
  1174. gChnnlInfo[index].SlotHandle = STPTI_NullHandle();
  1175. gChnnlInfo[index].Allocated = FALSE;
  1176. gChnnlInfo[index].Type = DMX_CHANNEL_INVALID;
  1177. }
  1178.         }
  1179.         
  1180. }
  1182. return rc;
  1183. }
  1185. static void Exm_Task(void *params)
  1186. {
  1187. ST_ErrorCode_t  ST_ErrorCode;
  1188. STPTI_Buffer_t  WhichBufferGotSignal;
  1189. DMX_Channel  *pChInfo;
  1191. UINT32 DataSize;
  1192. U32   NumFilterMatches = 0;
  1193. BOOL  CRCValid;
  1194. INT32  chId;
  1196. while(1)
  1197. {
  1198. ST_ErrorCode = STPTI_SignalWaitBuffer(g_SignalHandle_for_TF, &WhichBufferGotSignal, STPTI_TIMEOUT_INFINITY);
  1200. /* STPTI_SignalWaitBuffer() generated an error */
  1201.     if (ST_ErrorCode == ST_ERROR_TIMEOUT)
  1202.     {
  1203.         continue;
  1204.     }
  1205.     /* if not a harmless timeout then get rid of anything in the STPTI internal buffer */
  1206.     else if (ST_ErrorCode != ST_NO_ERROR)
  1207.     {
  1208.         STPTI_BufferFlush(WhichBufferGotSignal);
  1209. continue;
  1210.     }
  1212. /* Find the channel, that buffer handle equal WhichBufferGotSignal */
  1213. for(chId = 0; chId < KB_DMX_TOTAL_GENERIC_CHANNELS; chId++)
  1214. {
  1215. if( (gChnnlInfo[chId].Allocated == TRUE)
  1216. && (gChnnlInfo[chId].BufferHandle == WhichBufferGotSignal) )
  1217. {
  1218. /* got it */
  1219. break;
  1220. }
  1221. }
  1223. if(chId >= KB_DMX_TOTAL_GENERIC_CHANNELS)
  1224. {
  1225. STPTI_BufferFlush(WhichBufferGotSignal);
  1226. continue;
  1227. }
  1229. pChInfo = &gChnnlInfo[chId];
  1230. DataSize = 0;
  1231. memset(Exm_Buf,0,EXM_BUFF_LEN);
  1232. switch(STPTI_SlotTypes[pChInfo->Type])
  1233. {
  1234. case STPTI_SLOT_TYPE_PES:
  1235. #ifdef STPTI_DVB_SUPPORT
  1236. ST_ErrorCode = STPTI_BufferReadPes(pChInfo->BufferHandle, (U8*)Exm_Buf, (U32)EXM_BUFF_LEN,
  1237.    NULL, 0, (U32*)&DataSize,
  1238.    STPTI_COPY_TRANSFER_BY_MEMCPY);
  1239. #else
  1240. STPTI_BufferFlush(WhichBufferGotSignal);
  1241. continue;
  1242. #endif
  1243. break;
  1245.     case STPTI_SLOT_TYPE_SECTION: /* three type are same: section */
  1246.     case STPTI_SLOT_TYPE_EMM:
  1247.     case STPTI_SLOT_TYPE_ECM:
  1248. ST_ErrorCode = STPTI_BufferReadSection(pChInfo->BufferHandle, NULL, 0, &NumFilterMatches, &CRCValid,
  1249.                                                (U8*)Exm_Buf, (U32)EXM_BUFF_LEN, NULL, 0,
  1250.                                                (U32*)&DataSize, STPTI_COPY_TRANSFER_BY_MEMCPY);
  1251. break;
  1253.     case STPTI_SLOT_TYPE_RAW:
  1254. ST_ErrorCode = STPTI_BufferReadTSPacket(pChInfo->BufferHandle, (U8*)Exm_Buf, (U32)EXM_BUFF_LEN,
  1255.    NULL, 0, (U32*)&DataSize,
  1256.    STPTI_COPY_TRANSFER_BY_MEMCPY);
  1257. break;
  1259. default:
  1260. /* do no support type */
  1261. STPTI_BufferFlush(WhichBufferGotSignal);
  1262. continue;
  1263. break;
  1264. }
  1266. if (ST_ErrorCode != ST_NO_ERROR)    /* unexpected fault reading data */
  1267. {
  1268. STPTI_BufferFlush(WhichBufferGotSignal);
  1269. continue;
  1270. }
  1272. if(DataSize == 0)
  1273. {
  1274. continue;
  1275. }
  1277. if(pChInfo->NotifyFunctionPtr != NULL)
  1278. {
  1279. pChInfo->NotifyFunctionPtr(chId, Exm_Buf, DataSize);
  1281. }
  1282. }
  1283. }
  1286. INT32 KD_DmxInitCA(void)
  1287. {
  1288. ST_ErrorCode_t         ST_ErrorCode;
  1289. UINT32 taskId;
  1291. ST_ErrorCode = STPTI_SignalAllocate(g_KB_PTIHandleMultiple[DEFAULT_PTI], &g_SignalHandle_for_TF);
  1292. if (ST_ErrorCode != ST_NO_ERROR) return( ST_ErrorCode );
  1294. KB_OSPTaskInit("EXMT", 10240, Exm_Task, DMX_PRIORITY, NULL, &taskId);
  1296. return( ST_ErrorCode );
  1297. }
  1301. /* EOF --------------------------------------------------------------------- */