API tools faq
paste
Advertisement
kernel_memory_dump

Untitled

kernel_memory_dump
Apr 25th, 2014
268
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 34.47 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. * tdal_dmx_filter.c
  3. *
  4. * Created on: Apr 5, 2012
  5. * Author: mudri
  6. */
  7.  
  8. /***********************************************************************/
  9. /* Includes */
  10. /***********************************************************************/
  11.  
  12. #include "tdal_dmx_priv.h"
  13.  
  14. /***********************************************************************/
  15. /* Defines */
  16. /***********************************************************************/
  17.  
  18.  
  19. /***********************************************************************/
  20. /* Macros */
  21. /***********************************************************************/
  22.  
  23. #define CRC32_MAX_COEFFICIENTS 256
  24. #define CRC32_POLYNOMIAL 0x04C11DB7
  25. #ifdef PATCH_SECTION_PE
  26. #define kTDAL_DMX_PAT_TABLE_ID 0x00
  27. #define kTDAL_DMX_SDT_TABLE_ID 0x42
  28. #endif //PATCH_SECTION_PE
  29.  
  30. /***********************************************************************/
  31. /* Typedefs */
  32. /***********************************************************************/
  33.  
  34.  
  35. /***********************************************************************/
  36. /* Global Variables (GLOBAL/IMPORT) */
  37. /***********************************************************************/
  38.  
  39.  
  40. /***********************************************************************/
  41. /* Local Module Variables (MODULE) */
  42. /***********************************************************************/
  43.  
  44.  
  45. /***********************************************************************/
  46. /* Local File Variables (LOCAL) */
  47. /***********************************************************************/
  48. #ifdef PATCH_SECTION_PE
  49. #define PAT_SECTIONS_TO_SKIP 2
  50. #define SDT_SECTIONS_TO_SKIP 2
  51.  
  52. GLOBAL uint16_t patTsId = 0xFFFF;
  53. GLOBAL uint16_t sdtTsId = 0xFFFF;
  54.  
  55. LOCAL uint8_t patCount = PAT_SECTIONS_TO_SKIP;
  56. LOCAL uint8_t sdtCount = SDT_SECTIONS_TO_SKIP;
  57. #endif //PATCH_SECTION_PE
  58. /***********************************************************************/
  59. /* Local Functions Declarations (LOCAL) */
  60. /***********************************************************************/
  61.  
  62. LOCAL tTDAL_DMX_FilterId p_LookForFreeFilter(void);
  63.  
  64. LOCAL void p_writeChecksum(uint8_t * const checksum, uint8_t const * block, size_t const length);
  65.  
  66. /***********************************************************************/
  67. /* Functions Definitions (GLOBAL) */
  68. /***********************************************************************/
  69.  
  70. /************************************************************************
  71. * Function Name : TDAL_DMX_Allocate_Filter
  72. *
  73. * Description : This function allocates a filter on a channel. The output
  74. * is the filter Id if succedded. Else the output is
  75. * kTDAL_DMX_ILLEGAL_FILTER.
  76. *
  77. * Side effects :
  78. *
  79. * Return : kTDAL_DMX_NO_ERROR if all is correct
  80. * kTDAL_DMX_ERROR_INVALID_CHANNEL_ID if bad Id
  81. * kTDAL_DMX_ERROR_TOO_MANY_REQ if there is no more filter available
  82. * kTDAL_DMX_ERROR_MUTEX for mutex issue
  83. * kTDAL_DMX_ERROR_UNABLE_TO_GRANT
  84. *
  85. ***********************************************************************/
  86. tTDAL_DMX_Error TDAL_DMX_Allocate_Filter(tTDAL_DMX_ChannelId ChannelId, tTDAL_DMX_FilterId *pFilterId)
  87. {
  88. tTDAL_DMX_Error Error = kTDAL_DMX_NO_ERROR;
  89. HRESULT hr = S_OK;
  90. tTDAL_DMX_FilterId FilterId;
  91. UINT32 BufferSize = 0, hBuffer = 0;
  92. uint8_t *pFilter = NULL;
  93. uint8_t *pMask = NULL;
  94. uint8_t *pMode = NULL;
  95. uint8_t i;
  96.  
  97. mTBOX_FCT_ENTER("TDAL_DMX_Allocate_Filter");
  98.  
  99. TDAL_LockMutex(TDAL_DMX_SectionMutex);
  100.  
  101. if (!TDAL_DMX_Initialized)
  102. {
  103. mTBOX_TRACE((kTBOX_NIV_CRITICAL, "TDAL_DMX_Allocate_Filter: TDAL_DMX module has not been initialized\n"));
  104. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  105. Error = kTDAL_DMX_ERROR_NOT_INITIALIZED;
  106. mTBOX_RETURN(Error);
  107. }
  108.  
  109. if ((ChannelId < 0 || ChannelId >= kTDAL_DMX_MAX_NB_OF_CHANNELS) ||
  110. (TDAL_DMX_Channel[ChannelId].used == FALSE))
  111. {
  112. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"TDAL_DMX_Allocate_Filter: ChannelId not available or not allocated\n"));
  113. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  114. Error = kTDAL_DMX_ERROR_INVALID_CHANNEL_ID;
  115. mTBOX_RETURN(Error);
  116. }
  117.  
  118. if(TDAL_DMX_Channel[ChannelId].ChannelStream != eTDAL_DMX_SECTION_STREAM)
  119. {
  120. for(i = 0; i < kTDAL_DMX_MAX_NB_OF_FILTERS; i++)
  121. {
  122. if((TDAL_DMX_Filter[i].AssociatedChannelId == ChannelId) &&
  123. (TDAL_DMX_Filter[i].used == TRUE))
  124. {
  125. #if defined(TTXT_OSD_ON) && defined(TTXT_VBI_ON)
  126. if((TDAL_DMX_Filter[ChannelId].used) &&
  127. (TDAL_DMX_Filter[ChannelId].ChannelStream == eTDAL_DMX_TELETEXT_STREAM))
  128. {
  129. *pFilterId = TDAL_DMX_Filter[i].FilterId;
  130. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  131. mTBOX_RETURN(kTDAL_DMX_NO_ERROR);
  132. }
  133. #endif
  134. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Allocate_Filter: filter already exist on this PES channel\n"));
  135. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  136. Error = kTDAL_DMX_ERROR_TOO_MANY_REQ;
  137. mTBOX_RETURN(Error);
  138. }
  139. }
  140. }
  141.  
  142. FilterId = p_LookForFreeFilter();
  143.  
  144. if (FilterId == kTDAL_DMX_ILLEGAL_FILTER)
  145. {
  146. mTBOX_TRACE((kTBOX_NIV_CRITICAL, "Allocate_Filter: Unable to found a free filter\n"));
  147. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  148. Error = kTDAL_DMX_ERROR_TOO_MANY_REQ;
  149. mTBOX_RETURN(Error);
  150. }
  151.  
  152. if (TDAL_DMX_Channel[ChannelId].ChannelStream == eTDAL_DMX_SECTION_STREAM)
  153. {
  154. pFilter = TDAL_Malloc(kTDAL_DMX_DEPTH_SIZE);
  155.  
  156. if (pFilter == NULL)
  157. {
  158. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Allocate_Filter: Unable to allocate size for FilterBytes\n"));
  159. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  160. Error = kTDAL_DMX_ERROR_MUTEX;
  161. mTBOX_RETURN(Error);
  162. }
  163.  
  164. pMask = TDAL_Malloc(kTDAL_DMX_DEPTH_SIZE);
  165.  
  166. if (pMask == NULL)
  167. {
  168. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Allocate_Filter: Unable to allocate size for FilterMasks\n"));
  169. TDAL_Free(pFilter);
  170. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  171. Error = kTDAL_DMX_ERROR_MUTEX;
  172. mTBOX_RETURN(Error);
  173. }
  174.  
  175. pMode = TDAL_Malloc(kTDAL_DMX_DEPTH_SIZE);
  176.  
  177. if (pMode == NULL)
  178. {
  179. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Allocate_Filter: Unable to allocate size for ModePattern\n"));
  180.  
  181. TDAL_Free(pFilter);
  182. TDAL_Free(pMask);
  183.  
  184. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  185. Error = kTDAL_DMX_ERROR_MUTEX;
  186. mTBOX_RETURN(Error);
  187. }
  188.  
  189. memset(pFilter, 0x00, kTDAL_DMX_DEPTH_SIZE);
  190. memset(pMask, 0x00, kTDAL_DMX_DEPTH_SIZE);
  191. memset(pMode, 0x00, kTDAL_DMX_DEPTH_SIZE);
  192.  
  193. BufferSize = 8 * kTDAL_DMX_MAX_SECTION_SIZE;
  194.  
  195. hr = MV_PE_StreamBufAllocate(TDAL_DMX_hPE, BufferSize, &hBuffer);
  196. if(hr != S_OK)
  197. {
  198. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Control_Filter: Error in MV_PE_StreamBufAllocate\n"));
  199.  
  200. TDAL_Free(pFilter);
  201. TDAL_Free(pMask);
  202. TDAL_Free(pMode);
  203.  
  204. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  205. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  206. mTBOX_RETURN(Error);
  207. }
  208. }
  209.  
  210. TDAL_DMX_Filter[FilterId].FilterId = FilterId;
  211. TDAL_DMX_Filter[FilterId].AssociatedChannelId = ChannelId;
  212.  
  213. TDAL_DMX_Filter[FilterId].used = TRUE;
  214. TDAL_DMX_Filter[FilterId].enable = FALSE;
  215. TDAL_DMX_Filter[FilterId].waitingEnable = FALSE;
  216.  
  217. TDAL_DMX_Filter[FilterId].set = FALSE;
  218. TDAL_DMX_Filter[FilterId].tag = 0;
  219.  
  220. TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer = NULL;
  221. TDAL_DMX_Filter[FilterId].sectionBuffer.bufferSize = BufferSize;
  222. TDAL_DMX_Filter[FilterId].sectionBuffer.sectionSize = 0;
  223.  
  224. TDAL_DMX_Filter[FilterId].hSource = kTDAL_DMX_INVALID_PE_SOURCE;
  225. TDAL_DMX_Filter[FilterId].hBuffer = hBuffer;
  226. TDAL_DMX_Filter[FilterId].BufferSize = BufferSize;
  227. TDAL_DMX_Filter[FilterId].hFilter = 0;
  228.  
  229. TDAL_DMX_Filter[FilterId].Filter = pFilter;
  230. TDAL_DMX_Filter[FilterId].Mask = pMask;
  231. TDAL_DMX_Filter[FilterId].Mode = pMode;
  232. TDAL_DMX_Filter[FilterId].Size = 0;
  233.  
  234. TDAL_DMX_Filter[FilterId].efilterCRCMode = eTDAL_DMX_CRC_CHECK;
  235.  
  236. *pFilterId = FilterId;
  237.  
  238. mTBOX_TRACE((kTBOX_NIV_3, "Allocate_Filter: PID -->> 0x%x, FilterId -->> %d\n", TDAL_DMX_Channel[TDAL_DMX_Filter[FilterId].AssociatedChannelId].ChannelPid, FilterId));
  239.  
  240. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  241.  
  242. mTBOX_RETURN(Error);
  243. }
  244.  
  245.  
  246. /***********************************************************************
  247. * Function Name : TDAL_DMX_Set_Filter
  248. *
  249. * Description : This function sets a hardware section filter on channel with
  250. * specific condition ( table_id, table_id extension,
  251. * version number, section number .....)
  252. *
  253. * Side effects :
  254. *
  255. * Return : kTDAL_DMX_NO_ERROR if all is correct
  256. * kTDAL_DMX_ERROR_INVALID_CHANNEL_ID if channel is invalid
  257. * or channel not used or bad PID on the channel
  258. * kTDAL_DMX_ERROR_INVALID_FILTER_ID if filter is invalid
  259. * kTDAL_DMX_ERROR_BAD_PARAMETERS if size is bad
  260. * kTDAL_DMX_ERROR_MUTEX for mutex error
  261. * kTDAL_DMX_ERROR_UNABLE_TO_GRANT
  262. *
  263. **********************************************************************/
  264. tTDAL_DMX_Error TDAL_DMX_Set_Filter(tTDAL_DMX_ChannelId ChannelId,
  265. tTDAL_DMX_FilterId FilterId,
  266. uint32_t Filter_track,
  267. uint8_t Size,
  268. uint8_t *pFilter,
  269. uint8_t *pMask,
  270. uint8_t *pMode,
  271. tTDAL_DMX_FilterCRCMode eCRCMode)
  272. {
  273. tTDAL_DMX_Error Error = kTDAL_DMX_NO_ERROR;
  274. uint8_t i;
  275.  
  276. mTBOX_FCT_ENTER("TDAL_DMX_Set_Filter");
  277.  
  278. TDAL_LockMutex(TDAL_DMX_SectionMutex);
  279.  
  280. mTBOX_TRACE((kTBOX_NIV_1, "TDAL_DMX_Set_Filter: FilterId -->> %d\n", FilterId));
  281.  
  282. if (!TDAL_DMX_Initialized)
  283. {
  284. mTBOX_TRACE((kTBOX_NIV_CRITICAL, "TDAL_DMX_Set_Filter: TDAL_DMX module has not been initialized\n"));
  285. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  286. Error = kTDAL_DMX_ERROR_NOT_INITIALIZED;
  287. mTBOX_RETURN(Error);
  288. }
  289.  
  290. if ((ChannelId < 0 || ChannelId >= kTDAL_DMX_MAX_NB_OF_CHANNELS) ||
  291. (TDAL_DMX_Channel[ChannelId].used == FALSE ) ||
  292. (TDAL_DMX_Channel[ChannelId].ChannelPid == kTDAL_DMX_ILLEGAL_PID))
  293. {
  294. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"TDAL_DMX_Allocate_Filter: ChannelId not available or not allocated\n"));
  295. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  296. Error = kTDAL_DMX_ERROR_INVALID_CHANNEL_ID;
  297. mTBOX_RETURN(Error);
  298. }
  299.  
  300. if (FilterId < 0 || FilterId >= kTDAL_DMX_MAX_NB_OF_FILTERS ||TDAL_DMX_Filter[FilterId].used == FALSE)
  301. {
  302. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Set_Filter: Argument FilterId not available\n"));
  303. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  304. Error = kTDAL_DMX_ERROR_INVALID_FILTER_ID;
  305. mTBOX_RETURN(Error);
  306. }
  307.  
  308. if (Size > 8 || pFilter == (uint8_t*) NULL || pMask == (uint8_t*) NULL || pMode == (uint8_t*) NULL)
  309. {
  310. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Set_Filter: bad argument size\n"));
  311. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  312. Error = kTDAL_DMX_ERROR_BAD_PARAMETERS;
  313. mTBOX_RETURN(Error);
  314. }
  315.  
  316. if(TDAL_DMX_Channel[TDAL_DMX_Filter[FilterId].AssociatedChannelId].ChannelStream == eTDAL_DMX_SECTION_STREAM)
  317. {
  318. for(i = 0; i < Size; i++)
  319. {
  320. TDAL_DMX_Filter[FilterId].Filter[i]= pFilter[i];
  321. TDAL_DMX_Filter[FilterId].Mask[i] = pMask[i];
  322. TDAL_DMX_Filter[FilterId].Mode[i] = pMode[i];
  323. }
  324.  
  325. TDAL_DMX_Filter[FilterId].Size = Size;
  326. }
  327.  
  328. TDAL_DMX_Filter[FilterId].efilterCRCMode = eCRCMode;
  329. TDAL_DMX_Filter[FilterId].tag = Filter_track;
  330.  
  331. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  332.  
  333. mTBOX_RETURN(Error);
  334. }
  335.  
  336.  
  337. /***********************************************************************
  338. * Function Name : TDAL_DMX_Control_Filter
  339. *
  340. * Description : This function is used to control a filter
  341. * (enabling, stopping, resetting)
  342. *
  343. * Side effects :
  344. *
  345. * Return : kTDAL_DMX_NO_ERROR if all is correct
  346. * kTDAL_DMX_ERROR_INVALID_FILTER_ID if no filter is invalid
  347. * kTDAL_DMX_ERROR_BAD_PARAMETERS if bad argument
  348. * kTDAL_DMX_ERROR_MUTEX for mutex issue
  349. * kTDAL_DMX_ERROR_CANT_CONTROL_FREE_FILTER if filter is not used
  350. * kTDAL_DMX_ERROR_UNABLE_TO_GRANT if not able to start or
  351. * to stop the filter
  352. *
  353. **********************************************************************/
  354. tTDAL_DMX_Error TDAL_DMX_Control_Filter(tTDAL_DMX_FilterId FilterId, tTDAL_DMX_Ctrl Ctrl)
  355. {
  356. tTDAL_DMX_Error Error = kTDAL_DMX_NO_ERROR;
  357. HRESULT hr = S_OK;
  358. MV_PE_SECTION_FILTER_PARAM Param;
  359. uint8_t i;
  360. tTDAL_DMX_ChannelId ChannelId;
  361.  
  362. mTBOX_FCT_ENTER("TDAL_DMX_Control_Filter");
  363.  
  364. TDAL_LockMutex(TDAL_DMX_SectionMutex);
  365.  
  366. /* TO_DO */
  367. /* Perform error checking, (initialized?, FilterId out of bounds?, Filter is used?, Channel has illegal PID?) */
  368. /* moramo da koristimo funkcije
  369. nanastavnim materijalom,
  370. */
  371. if (!TDAL_DMX_Initialized)
  372. {
  373. mTBOX_TRACE((kTBOX_NIV_CRITICAL, "TDAL_DMX_Set_Filter: TDAL_DMX module has not been initialized\n"));
  374. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  375. Error = kTDAL_DMX_ERROR_NOT_INITIALIZED;
  376. mTBOX_RETURN(Error);
  377. }
  378.  
  379. if (FilterId < 0 || FilterId >= kTDAL_DMX_MAX_NB_OF_FILTERS ||TDAL_DMX_Filter[FilterId].used == FALSE)
  380. {
  381. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Set_Filter: Argument FilterId not available\n"));
  382. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  383. Error = kTDAL_DMX_ERROR_INVALID_FILTER_ID;
  384. mTBOX_RETURN(Error);
  385. }
  386.  
  387. ChannelId = TDAL_DMX_Filter[FilterId].AssociatedChannelId;
  388.  
  389. if ((ChannelId < 0 || ChannelId >= kTDAL_DMX_MAX_NB_OF_CHANNELS) ||
  390. (TDAL_DMX_Channel[ChannelId].used == FALSE ) ||
  391. (TDAL_DMX_Channel[ChannelId].ChannelPid == kTDAL_DMX_ILLEGAL_PID))
  392. {
  393. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"TDAL_DMX_Allocate_Filter: ChannelId not available or not allocated\n"));
  394. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  395. Error = kTDAL_DMX_ERROR_INVALID_CHANNEL_ID;
  396. mTBOX_RETURN(Error);
  397. }
  398.  
  399. /* TO_DO */
  400. /* Depending on the Ctrl parameter perform enabling or disabling of the filter given by FilterId */
  401. memset(&Param, 0, sizeof(Param));
  402. Param.Pid = TDAL_DMX_Channel[ChannelId].ChannelPid;
  403.  
  404. Param.Mask[0] = TDAL_DMX_Filter[FilterId].Mask[0];
  405. Param.NotMask[0] = ~TDAL_DMX_Filter[FilterId].Mode[0];
  406. Param.Match[0] = TDAL_DMX_Filter[FilterId].Filter[0];
  407.  
  408. // NENAD BI OVO URADIO PREKO MECPY BREEE
  409. // "Ja bih to uradio preko memcpy." - Nenad Jovanovic - 2014
  410.  
  411. for( i = 1; i<TDAL_DMX_Filter[FilterId].Size; i++)
  412. {
  413. Param.Mask[i+2] = TDAL_DMX_Filter[FilterId].Mask[i];
  414. Param.Match[i+2] = TDAL_DMX_Filter[FilterId].Filter[i];
  415. Param.NotMask[i+2] = ~TDAL_DMX_Filter[FilterId].Mode[i];
  416. }
  417.  
  418.  
  419. // === //
  420. // \\
  421. // \\
  422. // // \\ //
  423. tTDAL_DMX_DemuxId DemuxId = TDAL_DMX_Channel[ChannelId].DemuxId ;
  424. UINT32 hSource;
  425. hSource = TDAL_DMX_Demux[DemuxId].hSource;
  426.  
  427. switch(Ctrl)
  428. {
  429. case eTDAL_DMX_CTRL_ENABLE:
  430. hr = MV_PE_SourceAddSectionFilter(TDAL_DMX_hPE, hSource, &Param,
  431. TDAL_DMX_Filter[FilterId].hBuffer, 0, &TDAL_DMX_Filter[FilterId].hFilter);
  432.  
  433. if (hr != S_OK)
  434. {
  435. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Control_Filter: MV_PE_SourceAddSectionFilter FAILED [%d]\n", Ctrl));
  436. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  437. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  438. mTBOX_RETURN(Error);
  439. }
  440.  
  441. TDAL_DMX_Filter[FilterId].enable = true;
  442. break;
  443. case eTDAL_DMX_CTRL_DISABLE:
  444. hr = MV_PE_SourceRemoveSectionFilter(TDAL_DMX_hPE, hSource, TDAL_DMX_Filter[FilterId].hFilter);
  445. if(hr != S_OK)
  446. {
  447. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"MV_PE_SourceRemoveSectionFilter\n"));
  448. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  449. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  450. mTBOX_RETURN(Error);
  451. }
  452. break;
  453. case eTDAL_DMX_CTRL_RESET:
  454. break;
  455. default:
  456. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Control_Filter: Argument Ctrl is an unknown value [%d]\n", Ctrl));
  457. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  458. Error = kTDAL_DMX_ERROR_BAD_PARAMETERS;
  459. mTBOX_RETURN(Error);
  460. break;
  461. }
  462.  
  463.  
  464.  
  465.  
  466.  
  467.  
  468.  
  469.  
  470.  
  471. /* Note */
  472. /* Carefully fill in Param structure needed for adding section filter */
  473. /* bytes with index 0 are copied to index 0 but bytes with nonzero index i are copied to index i+2 */
  474.  
  475. // enbablovan filter
  476. // treba da iskoristimo da bi to staviti u filter hadnele
  477.  
  478.  
  479. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  480.  
  481. mTBOX_RETURN(Error);
  482. }
  483.  
  484.  
  485. /***********************************************************************
  486. * Function Name : TDAL_DMX_Free_Filter
  487. *
  488. * Description : This function is used to free a filter from a channel
  489. *
  490. * Side effects :
  491. *
  492. * Return : kTDAL_DMX_NO_ERROR if all is correct
  493. * kTDAL_DMX_ERROR_INVALID_FILTER_ID if filter Id is invalid
  494. * kTDAL_DMX_ERROR_MUTEX for mutex issue
  495. * kTDAL_DMX_ERROR_CANT_CONTROL_FREE_FILTER if filter is not used
  496. * kTDAL_DMX_ERROR_UNABLE_TO_GRANT if not able to stop or to
  497. * deallocate the filter
  498. *
  499. **********************************************************************/
  500. tTDAL_DMX_Error TDAL_DMX_Free_Filter(tTDAL_DMX_FilterId FilterId)
  501. {
  502. tTDAL_DMX_Error Error = kTDAL_DMX_NO_ERROR;
  503. bool result = TRUE;
  504.  
  505. mTBOX_FCT_ENTER("TDAL_DMX_Free_Filter");
  506.  
  507. TDAL_LockMutex(TDAL_DMX_SectionMutex);
  508.  
  509. mTBOX_TRACE((kTBOX_NIV_3, "TDAL_DMX_Free_Filter: FilterId -->> %d\n",FilterId));
  510. if (!TDAL_DMX_Initialized)
  511. {
  512. mTBOX_TRACE((kTBOX_NIV_CRITICAL, "TDAL_DMX_Free_Filter: TDAL_DMX module has not been initialized\n"));
  513. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  514. Error = kTDAL_DMX_ERROR_NOT_INITIALIZED;
  515. mTBOX_RETURN(Error);
  516. }
  517.  
  518. if (FilterId < 0 || FilterId >= kTDAL_DMX_MAX_NB_OF_FILTERS)
  519. {
  520. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"TDAL_DMX_Free_Filter: FilterId not valid or filter not used\n"));
  521. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  522. Error = kTDAL_DMX_ERROR_INVALID_FILTER_ID;
  523. mTBOX_RETURN(Error);
  524. }
  525.  
  526. if (TDAL_DMX_Filter[FilterId].used == FALSE)
  527. {
  528. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"TDAL_DMX_Free_Filter: Filter not used\t FilterId -> %d\n", FilterId));
  529. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  530. Error = kTDAL_DMX_ERROR_CANT_CONTROL_FREE_FILTER;
  531. mTBOX_RETURN(Error);
  532. }
  533. #if defined(TTXT_OSD_ON) && defined(TTXT_VBI_ON)
  534. if((TDAL_DMX_Channel[TDAL_DMX_Filter[FilterId].AssociatedChannelId].ChannelStream == eTDAL_DMX_TELETEXT_STREAM) &&
  535. (TDAL_DMX_Filter[FilterId].used))
  536. {
  537. mTBOX_RETURN(kTDAL_DMX_NO_ERROR);
  538. }
  539. #endif
  540. result = m_FreeFilterAndAssociatedRessources(FilterId);
  541. if(!result)
  542. {
  543. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"TDAL_DMX_Free_Filter: Error in m_FreeFilterAndAssociatedRessources\n"));
  544. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  545. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  546. mTBOX_RETURN(Error);
  547. }
  548.  
  549. TDAL_DMX_Filter[FilterId].used = FALSE;
  550.  
  551. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  552.  
  553. mTBOX_RETURN(Error);
  554. }
  555.  
  556.  
  557. /***********************************************************************
  558. * Function Name : TDAL_DMX_Free_Buffer
  559. *
  560. * Description : This function is used to free a buffer
  561. *
  562. * Side effects :
  563. *
  564. * Return : kTDAL_DMX_NO_ERROR if all is correct
  565. * kTDAL_DMX_ERROR_BAD_PARAMETERS if buffer is null
  566. *
  567. **********************************************************************/
  568. tTDAL_DMX_Error TDAL_DMX_Free_Buffer(void * buffer)
  569. {
  570. tTDAL_DMX_Error Error = kTDAL_DMX_NO_ERROR;
  571.  
  572. mTBOX_FCT_ENTER("TDAL_DMX_Free_Buffer");
  573.  
  574. TDAL_LockMutex(TDAL_DMX_SectionMutex);
  575.  
  576. if (!TDAL_DMX_Initialized)
  577. {
  578. mTBOX_TRACE((kTBOX_NIV_CRITICAL, "Free_Buffer: TDAL_DMX module has not been initialized\n"));
  579. Error = kTDAL_DMX_ERROR_NOT_INITIALIZED;
  580. }
  581. else
  582. {
  583. if (buffer == NULL)
  584. {
  585. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"Free_Buffer: buffer null \n"));
  586. Error = kTDAL_DMX_ERROR_BAD_PARAMETERS;
  587. }
  588. else
  589. {
  590. TDAL_Free(buffer);
  591. }
  592. }
  593.  
  594. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  595.  
  596. mTBOX_RETURN(Error);
  597. }
  598.  
  599.  
  600. /***********************************************************************/
  601. /* Functions Definitions (MODULE) */
  602. /***********************************************************************/
  603.  
  604. /***********************************************************************
  605. * Function Name : m_FreeFilterAndAssociatedRessources
  606. *
  607. * Description :
  608. *
  609. * Side effects :
  610. *
  611. * Comment :
  612. *
  613. **********************************************************************/
  614. bool m_FreeFilterAndAssociatedRessources(tTDAL_DMX_FilterId FilterId)
  615. {
  616. tTDAL_DMX_Error Error = kTDAL_DMX_NO_ERROR;
  617. HRESULT hr = S_OK;
  618.  
  619. mTBOX_FCT_ENTER("m_FreeFilterAndAssociatedRessources");
  620.  
  621. if(TDAL_DMX_Channel[TDAL_DMX_Filter[FilterId].AssociatedChannelId].ChannelStream == eTDAL_DMX_SECTION_STREAM)
  622. {
  623. TDAL_Free(TDAL_DMX_Filter[FilterId].Filter);
  624. TDAL_Free(TDAL_DMX_Filter[FilterId].Mask);
  625. TDAL_Free(TDAL_DMX_Filter[FilterId].Mode);
  626.  
  627. hr = MV_PE_StreamBufRelease(TDAL_DMX_hPE, TDAL_DMX_Filter[FilterId].hBuffer);
  628. if(hr != S_OK)
  629. {
  630. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"m_FreeFilterAndAssociatedRessources: Error in MV_PE_StreamBufRelease\n"));
  631. mTBOX_RETURN(FALSE);
  632. }
  633. }
  634.  
  635. mTBOX_RETURN(TRUE);
  636. }
  637.  
  638.  
  639. /***********************************************************************
  640. * Function Name : m_sectionReceivedCallback
  641. *
  642. * Description :
  643. *
  644. * Side effects :
  645. *
  646. * Comment :
  647. *
  648. **********************************************************************/
  649. HRESULT m_sectionReceivedCallback(UINT32 EventCode, void *EventInfo, void *Context)
  650. {
  651. tTDAL_DMX_Error Error = kTDAL_DMX_NO_ERROR;
  652. HRESULT hr = S_OK;
  653. tTDAL_DMX_FilterId FilterId;
  654. UINT32 Fullness = 0, hBufOffset = 0;
  655. uint32_t checksum;
  656. MV_PE_SECTION_FILTER_PARAM Param;
  657. MV_PE_SECTION_INFO sectionInfo;
  658. uint8_t i;
  659.  
  660. mTBOX_FCT_ENTER("m_sectionReceivedCallback");
  661.  
  662. TDAL_LockMutex(TDAL_DMX_SectionMutex);
  663.  
  664. sectionInfo = *(MV_PE_SECTION_INFO*) EventInfo;
  665.  
  666. for(i = 0; i < kTDAL_DMX_MAX_NB_OF_FILTERS; i++)
  667. {
  668. if((sectionInfo.hFilter == (HANDLE)TDAL_DMX_Filter[i].hFilter) &&
  669. (TDAL_DMX_Filter[i].used == TRUE) &&
  670. (TDAL_DMX_Filter[i].enable == TRUE) &&
  671. (TDAL_DMX_Filter[i].waitingEnable == FALSE))
  672. {
  673. FilterId = i;
  674. break;
  675. }
  676. }
  677.  
  678. if(i == kTDAL_DMX_MAX_NB_OF_FILTERS)
  679. {
  680. mTBOX_TRACE((kTBOX_NIV_3,"m_sectionReceivedCallback: Error in FilterID\n"));
  681. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  682. mTBOX_RETURN(E_FAIL);
  683. }
  684.  
  685. if(Error == kTDAL_DMX_NO_ERROR)
  686. {
  687. hr = MV_PE_StreamBufGetFullness(TDAL_DMX_hPE, TDAL_DMX_Filter[FilterId].hBuffer, &Fullness);
  688. if(hr != S_OK)
  689. {
  690. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"m_sectionReceivedCallback: Error in MV_PE_StreamBufGetFullness\n"));
  691. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  692. }
  693. else
  694. {
  695. if(!Fullness)
  696. {
  697. mTBOX_TRACE((kTBOX_NIV_WARNING,"m_sectionReceivedCallback: Fullness is 0\n"));
  698. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  699. }
  700. }
  701. }
  702.  
  703. if(Error == kTDAL_DMX_NO_ERROR)
  704. {
  705. TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer = TDAL_Malloc(TDAL_DMX_Filter[FilterId].sectionBuffer.bufferSize);
  706. if(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer == NULL)
  707. {
  708. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"m_sectionReceivedCallback: Error in TDAL_Malloc\n"));
  709. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  710. }
  711. else
  712. {
  713. memset(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer, 0, TDAL_DMX_Filter[FilterId].sectionBuffer.bufferSize);
  714. TDAL_DMX_Filter[FilterId].sectionBuffer.sectionSize = 0;
  715. }
  716. }
  717.  
  718. if(Error == kTDAL_DMX_NO_ERROR)
  719. {
  720. hr = MV_PE_StreamBufRead(TDAL_DMX_hPE, TDAL_DMX_Filter[FilterId].hBuffer, TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer, kTDAL_DMX_SECTION_SIZE_INFO);
  721. if(hr != S_OK)
  722. {
  723. mTBOX_TRACE((kTBOX_NIV_WARNING,"m_sectionReceivedCallback: Error in MV_PE_StreamBufRead1\n"));
  724. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  725. }
  726. else
  727. {
  728. hBufOffset += kTDAL_DMX_SECTION_SIZE_INFO;
  729. }
  730. }
  731.  
  732. if(Error == kTDAL_DMX_NO_ERROR)
  733. {
  734. TDAL_DMX_Filter[FilterId].sectionBuffer.sectionSize = (uint16_t) (TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[2] |
  735. ((TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[1] & 0x0F) << 8));
  736.  
  737. hr = MV_PE_StreamBufRead(TDAL_DMX_hPE,
  738. TDAL_DMX_Filter[FilterId].hBuffer,
  739. &TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[3],
  740. TDAL_DMX_Filter[FilterId].sectionBuffer.sectionSize);
  741. if(hr != S_OK)
  742. {
  743. mTBOX_TRACE((kTBOX_NIV_WARNING,"m_sectionReceivedCallback: Error in MV_PE_StreamBufRead2\n"));
  744. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  745. }
  746. else
  747. {
  748. hBufOffset += TDAL_DMX_Filter[FilterId].sectionBuffer.sectionSize;
  749. }
  750. }
  751.  
  752. if(Error == kTDAL_DMX_NO_ERROR)
  753. {
  754. if(TDAL_DMX_Filter[FilterId].efilterCRCMode == eTDAL_DMX_CRC_CHECK)
  755. {
  756. p_writeChecksum((uint8_t*) &checksum,
  757. TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer,
  758. TDAL_DMX_Filter[FilterId].sectionBuffer.sectionSize + kTDAL_DMX_SECTION_SIZE_INFO);
  759. if(checksum)
  760. {
  761. mTBOX_TRACE((kTBOX_NIV_3,"m_sectionReceivedCallback: CRC Error for table id -> 0x%x\n", TDAL_DMX_Filter[FilterId].Filter[0]));
  762. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  763. }
  764. }
  765. }
  766.  
  767. if(Error == kTDAL_DMX_NO_ERROR)
  768. {
  769. #ifdef PATCH_SECTION_PE
  770. if(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[0] == kTDAL_DMX_PAT_TABLE_ID)
  771. {
  772. if((patTsId != ((uint16_t)(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[3] << 8 | TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[4]))) ||
  773. (patCount == 0))
  774. {
  775. patTsId = (uint16_t)(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[3] << 8 | TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[4]);
  776. patCount = PAT_SECTIONS_TO_SKIP;
  777. }
  778. else
  779. {
  780. patCount --;
  781. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  782. }
  783.  
  784. }
  785. else if(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[0] == kTDAL_DMX_SDT_TABLE_ID)
  786. {
  787. if((sdtTsId != ((uint16_t)(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[3] << 8 | TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[4]))) ||
  788. (sdtCount == 0))
  789. {
  790. sdtTsId = (uint16_t)(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[3] << 8 | TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer[4]);
  791. sdtCount = SDT_SECTIONS_TO_SKIP;
  792. }
  793. else
  794. {
  795. sdtCount --;
  796. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  797. }
  798. }
  799. #endif
  800. }
  801.  
  802. if(Error == kTDAL_DMX_NO_ERROR)
  803. {
  804. if (TDAL_DMX_Channel[TDAL_DMX_Filter[FilterId].AssociatedChannelId].Callback != NULL)
  805. {
  806. TDAL_DMX_Channel[TDAL_DMX_Filter[FilterId].AssociatedChannelId].Callback(TDAL_DMX_Filter[FilterId].AssociatedChannelId,
  807. FilterId,
  808. TDAL_DMX_Filter[FilterId].tag,
  809. (TDAL_DMX_Filter[FilterId].sectionBuffer.sectionSize +
  810. kTDAL_DMX_SECTION_SIZE_INFO),
  811. TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer);
  812.  
  813. TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer = NULL;
  814. }
  815. else
  816. {
  817. mTBOX_TRACE((kTBOX_NIV_CRITICAL,"m_sectionReceivedCallback: Channel callback is NULL\n"));
  818. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  819. }
  820. }
  821.  
  822. if(Error != kTDAL_DMX_NO_ERROR)
  823. {
  824. if(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer != NULL)
  825. {
  826. TDAL_Free(TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer);
  827. TDAL_DMX_Filter[FilterId].sectionBuffer.pBuffer = NULL;
  828. }
  829.  
  830. if((Fullness - hBufOffset) > 0)
  831. {
  832. hr = MV_PE_StreamBufRead(TDAL_DMX_hPE,
  833. TDAL_DMX_Filter[FilterId].hBuffer,
  834. NULL,
  835. (Fullness - hBufOffset));
  836. if(hr != S_OK)
  837. {
  838. mTBOX_TRACE((kTBOX_NIV_WARNING,"m_sectionReceivedCallback: Error in MV_PE_StreamBufRead3\n"));
  839. Error = kTDAL_DMX_ERROR_UNABLE_TO_GRANT;
  840. }
  841. }
  842. }
  843.  
  844. TDAL_UnlockMutex(TDAL_DMX_SectionMutex);
  845.  
  846. mTBOX_RETURN(((Error == kTDAL_DMX_NO_ERROR) ? S_OK : E_FAIL));
  847. }
  848.  
  849.  
  850. /***********************************************************************/
  851. /* Functions Definitions (LOCAL) */
  852. /***********************************************************************/
  853.  
  854. /***********************************************************************
  855. * Function Name : p_LookForFreeFilter
  856. *
  857. * Description : This function returns a free filter
  858. *
  859. * Side effects :
  860. *
  861. * Return : FilterId if found a free channel
  862. * kTDAL_DMX_ILLEGAL_FILTER otherwise
  863. *
  864. **********************************************************************/
  865. LOCAL tTDAL_DMX_FilterId p_LookForFreeFilter(void)
  866. {
  867. tTDAL_DMX_FilterId FilterId = kTDAL_DMX_ILLEGAL_FILTER;
  868. uint8_t i;
  869.  
  870. mTBOX_FCT_ENTER("p_LookForFreeFilter");
  871.  
  872. for (i = 0; i < kTDAL_DMX_MAX_NB_OF_FILTERS; i++)
  873. {
  874. if (TDAL_DMX_Filter[i].used == FALSE)
  875. {
  876. FilterId = i;
  877. break;
  878. }
  879. }
  880.  
  881. mTBOX_RETURN(FilterId);
  882. }
  883.  
  884.  
  885. /***********************************************************************
  886. * Function Name : p_writeChecksum
  887. *
  888. * Description :
  889. *
  890. * Side effects :
  891. *
  892. * Comment :
  893. *
  894. **********************************************************************/
  895. LOCAL void p_writeChecksum(uint8_t * const checksum, uint8_t const * block, size_t const length)
  896. {
  897. static int32_t crc32_table[ CRC32_MAX_COEFFICIENTS ] = {1};
  898.  
  899. mTBOX_FCT_ENTER("p_writeChecksum");
  900.  
  901. if (crc32_table[0])
  902. {
  903. int loopCntCoef, loopCntBit;
  904.  
  905. for (loopCntCoef = 0; loopCntCoef < CRC32_MAX_COEFFICIENTS; loopCntCoef++)
  906. {
  907. uint32_t coef32 = (uint32_t) loopCntCoef << 24;
  908.  
  909. for (loopCntBit = 0; loopCntBit < 8; loopCntBit++)
  910. if (coef32 & 0x80000000)
  911. coef32 = ((coef32 << 1) ^ CRC32_POLYNOMIAL);
  912. else
  913. coef32 <<= 1;
  914.  
  915. crc32_table[loopCntCoef] = coef32;
  916. }
  917. }
  918.  
  919. uint8_t const * const end = block + length;
  920.  
  921. uint32_t crc32 = 0xFFFFFFFF;
  922.  
  923. for (; block < end; block++)
  924. crc32 = (crc32 << 8) ^ crc32_table[ ((crc32 >> 24) ^ *block) & 0x000000FF ];
  925.  
  926. checksum[0] = (uint8_t) (crc32 >> 24);
  927. checksum[1] = (uint8_t) (crc32 >> 16);
  928. checksum[2] = (uint8_t) (crc32 >> 8);
  929. checksum[3] = (uint8_t) (crc32);
  930.  
  931. mTBOX_RETURN;
  932. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!