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

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

DVD

开发平台：

C/C++

osp.c：源码内容
  1. #include <osp.h>
  2. #include <task.h>
  3. #include <message.h>
  4. #include <ostime.h>
  5. #include <string.h>
  6. #include <stddefs.h>
  7. #include "stcommon.h"
  8. /*
  9. #ifdef ST_OS21
  10. #define MS_TO_TICKS(X) ((X)*(time_ticks_per_sec()/1000))
  11. #else
  12. #define MS_TO_TICKS(X) ((X)*(ST_GetClocksPerSecond()/1000))
  13. #endif
  14. */
  16. static OSP_TaskInfo *taskLink = NULL;
  17. static T_OSP_QueueInfo *queueLink = NULL;
  19. static void KD_InserTaskNode(OSP_TaskInfo *node)
  20. {
  21. if(node != NULL)
  22. {
  23. node->pNext = taskLink;
  24. taskLink = node;
  25. }
  26. }
  28. static OSP_TaskInfo* KD_RemoveTaskNode(task_t *taskId)
  29. {
  30. OSP_TaskInfo *cur, *prv;
  32. cur = taskLink;
  33. prv = NULL;
  35. while((cur != NULL) && (cur->pTask != taskId))
  36. {
  37. prv = cur;
  38. cur = cur->pNext;
  39. }
  41. if(cur != NULL)
  42. {
  43. if(cur == taskLink)
  44. {
  45. taskLink = taskLink->pNext;
  46. cur->pNext = NULL;
  47. }
  48. else
  49. {
  50. prv->pNext = cur->pNext;
  51. cur->pNext = NULL;
  52. }
  53. }
  55. return cur;
  56. }
  57. //modified by whale 07/06/03
  58. //static void InserQueueNode(T_OSP_QueueInfo *node)
  59. void InserQueueNode(T_OSP_QueueInfo *node)
  60. {
  61. if(node != NULL)
  62. {
  63. node->pNext = queueLink;
  64. queueLink = node;
  65. }
  66. }
  68. static T_OSP_QueueInfo* RemoveQueueNode(message_queue_t *queueId)
  69. {
  70. T_OSP_QueueInfo *cur, *prv;
  72. cur = queueLink;
  73. prv = NULL;
  75. while((cur != NULL) && (cur->pQueueId != queueId))
  76. {
  77. prv = cur;
  78. cur = cur->pNext;
  79. }
  81. if(cur != NULL)
  82. {
  83. if(cur == queueLink)
  84. {
  85. queueLink = queueLink->pNext;
  86. cur->pNext = NULL;
  87. }
  88. else
  89. {
  90. prv->pNext = cur->pNext;
  91. cur->pNext = NULL;
  92. }
  93. }
  95. return cur;
  96. }
  98. KB_OSPRet KB_OSPInit(void)
  99. {
  100. return Ret_OK;
  101. }
  103. KB_OSPRet KB_OSPTaskInit
  104. (
  105. const char* pName, 
  106. UINT32 dStackSize, 
  107. void (*entryPoint)(void*),
  108. INT32 dPriority, 
  109. void *pPara, 
  110. UINT32 *pTaskId
  111. )
  112. {
  113. OSP_TaskInfo *pTaskInfo;
  114. int Error;
  116. pTaskInfo = (OSP_TaskInfo*)KB_OSPMalloc(sizeof(OSP_TaskInfo));
  117. if(pTaskInfo == NULL)
  118. {
  119. return Ret_Fail;
  120. }
  122. pTaskInfo->pTaskStack = (UINT8 *)KB_OSPMalloc(dStackSize);
  123. pTaskInfo->pTaskDesc = (tdesc_t *)KB_OSPMalloc(sizeof(tdesc_t));
  124. pTaskInfo->pTask = (task_t *)KB_OSPMalloc(sizeof(task_t));
  126. if( (pTaskInfo->pTaskStack == NULL) || (pTaskInfo->pTaskDesc == NULL) 
  127.    || (pTaskInfo->pTask == NULL) )
  128. {
  129. KB_OSPFree((void*)pTaskInfo->pTaskStack);
  130. KB_OSPFree((void*)pTaskInfo->pTaskDesc);
  131. KB_OSPFree((void*)pTaskInfo->pTask);
  132. KB_OSPFree((void*)pTaskInfo);
  133. return Ret_Fail;
  134. }
  136. Error = task_init((void (*)(void *))entryPoint, (void *)pPara,
  137.              (void *)pTaskInfo->pTaskStack, (size_t)dStackSize,
  138.              pTaskInfo->pTask, pTaskInfo->pTaskDesc,
  139.             (int)(dPriority * OS20_PRIORITY_LEVELS / 256),
  140.             pName, 0);
  142. if(Error != 0)
  143. {
  144. KB_OSPFree((void*)pTaskInfo->pTaskStack);
  145. KB_OSPFree((void*)pTaskInfo->pTaskDesc);
  146. KB_OSPFree((void*)pTaskInfo->pTask);
  147. KB_OSPFree((void*)pTaskInfo);
  148. return Ret_Fail;
  149. }
  151. *pTaskId = (UINT32)pTaskInfo->pTask;
  153. KD_InserTaskNode(pTaskInfo);
  155. return Ret_OK;
  156. }
  158. KB_OSPRet KB_OSPTaskSetPri(UINT32 dTaskId, INT32 dPriority)
  159. {
  160. task_priority_set((task_t*)dTaskId, (int)(dPriority * OS20_PRIORITY_LEVELS / 256));
  161. return Ret_OK;
  162. }
  164. UINT32 KB_OSPTaskGetID(void)
  165. {
  166. return (UINT32)task_id();
  167. }
  169. KB_OSPRet KB_OSPTaskDelay(UINT32 dMilliSeconds)
  170. {
  171.     task_delay((clock_t)MS_TO_TICKS(dMilliSeconds));
  173. return Ret_OK;
  174. }
  176. KB_OSPRet KB_OSPTaskSus(UINT32 dTaskId)
  177. {
  178. if(task_suspend((task_t*)dTaskId)==0)
  179. return Ret_OK;
  180. else
  181. return Ret_Fail;
  182. }
  184. KB_OSPRet KB_OSPTaskRes(UINT32 dTaskId)
  185. {
  186. if(task_resume((task_t*)dTaskId) == 0)
  187. return Ret_OK;
  188. else
  189. return Ret_Fail;
  190. }
  192. KB_OSPRet KB_OSPTaskDel(UINT32 dTaskId)
  193. {
  194. OSP_TaskInfo *pTaskInfo;
  196. task_t* task = (task_t*)dTaskId;
  198. pTaskInfo = KD_RemoveTaskNode(task);
  200. task_kill(task, 0, 0);
  202.     task_wait(&task, 1, TIMEOUT_IMMEDIATE);
  203.     
  204. task_delete(task);
  206. if(pTaskInfo != NULL)
  207. {
  208. KB_OSPFree((void*)pTaskInfo->pTaskStack);
  209. KB_OSPFree((void*)pTaskInfo->pTaskDesc);
  210. KB_OSPFree((void*)pTaskInfo->pTask);
  211. KB_OSPFree((void*)pTaskInfo);
  212. }
  214. return Ret_OK;
  215. }
  217. KB_OSPRet KB_OSPQueInit
  218. (
  219. const char* pName, 
  220. UINT32 dMaxMessages, 
  221. UINT32 *pQueueId
  222. )
  223. {
  224. T_OSP_QueueInfo *pQueueInfo;
  226. if((pQueueId == NULL) || (dMaxMessages == 0))
  227. return Ret_ParErr;
  229. pQueueInfo = (T_OSP_QueueInfo*)KB_OSPMalloc(sizeof(T_OSP_QueueInfo));
  230. if(pQueueInfo == NULL)
  231. {
  232. return Ret_Fail;
  233. }
  235. pQueueInfo->pQueueId = (message_queue_t*)KB_OSPMalloc(sizeof(message_queue_t));
  236. pQueueInfo->pQueueBuf = (void*)KB_OSPMalloc(MESSAGE_MEMSIZE_QUEUE(sizeof(KB_OSPMsgNode), dMaxMessages));
  237. if( (pQueueInfo->pQueueId == NULL)
  238. || (pQueueInfo->pQueueBuf == NULL) )
  239. {
  240. KB_OSPFree((void*)pQueueInfo->pQueueId);
  241. KB_OSPFree((void*)pQueueInfo->pQueueBuf);
  242. KB_OSPFree((void*)pQueueInfo);
  243. return Ret_Fail;
  244. }
  246. message_init_queue_timeout(pQueueInfo->pQueueId, pQueueInfo->pQueueBuf, sizeof(KB_OSPMsgNode),
  247.    (unsigned int)dMaxMessages);
  249. *pQueueId = (UINT32)pQueueInfo->pQueueId;
  251. InserQueueNode(pQueueInfo);
  253. return Ret_OK;
  254. }
  256. KB_OSPRet KB_OSPQueDel(UINT32 nQueID)
  257. {
  258. T_OSP_QueueInfo *pQueueInfo;
  260. pQueueInfo = RemoveQueueNode((message_queue_t*)nQueID);
  261. message_delete_queue((message_queue_t*)nQueID);
  263. if(pQueueInfo != NULL)
  264. {
  265. /* 回收已分配的内存 */
  266. KB_OSPFree((void*)pQueueInfo->pQueueId);
  267. KB_OSPFree((void*)pQueueInfo->pQueueBuf);
  268. KB_OSPFree((void*)pQueueInfo);
  269. }
  271. return Ret_OK;
  272. }
  274. KB_OSPRet KB_OSPMsgSend
  275. (
  276. UINT32 nQueID,
  277. KB_OSPMsgNode *pMsgNode
  278. )
  279. {
  280. KB_OSPMsgNode * PtMessage;
  282. if(pMsgNode == NULL) return Ret_ParErr;
  284.     PtMessage = (KB_OSPMsgNode *)message_claim_timeout((message_queue_t*)nQueID, (clock_t*)TIMEOUT_IMMEDIATE);
  285. if(PtMessage == NULL) return Ret_Fail;
  287.     memcpy(PtMessage, pMsgNode, sizeof(KB_OSPMsgNode));
  289. message_send((message_queue_t*)nQueID, (void*)PtMessage);
  291. return Ret_OK;
  292. }
  294. KB_OSPRet KB_OSPMsgGet
  295. (
  296. UINT32 nQueID,
  297. KB_OSPWaitMode nWaitMode,
  298. UINT32 nTime,
  299. KB_OSPMsgNode *pMsgNode
  300. )
  301. {
  302. INT32  dReturnType;
  303. void*  pMessageReceived;
  304. clock_t *dWaitTime;
  305. clock_t  time;
  307. if(pMsgNode == NULL) return Ret_ParErr;
  309. if(nWaitMode == KD_NoWait)
  310. {
  311. dWaitTime = (clock_t*)TIMEOUT_IMMEDIATE;
  312. }
  313. else if(nWaitMode == KB_Wait)
  314. {
  315. if(nTime == 0)
  316. {
  317. dWaitTime = (clock_t*)TIMEOUT_INFINITY;
  319. }
  320. else
  321. {
  322. time = time_plus(time_now(), (clock_t)MS_TO_TICKS(nTime));
  323. dWaitTime = &time;
  324. }
  325. }
  326. else
  327. {
  328. return Ret_ParErr;
  329. }
  331. pMessageReceived = message_receive_timeout((message_queue_t*)nQueID, dWaitTime);
  332. if(pMessageReceived != NULL)
  333. {
  334. memcpy(pMsgNode, pMessageReceived, sizeof(KB_OSPMsgNode));
  335. message_release((message_queue_t*)nQueID, pMessageReceived);
  336. dReturnType = Ret_OK;
  337. }
  338. else
  339. {
  340. dReturnType = Ret_Fail;
  341. }
  343. return dReturnType;
  344. }
  346. KB_OSPRet KB_OSPSemInit
  347. (
  348. const char* pName, 
  349. UINT32 nSemMax, 
  350. KB_OSPQueMode nQueMode,
  351. UINT32 *pSemID
  352. )
  353. {
  354. semaphore_t *pSemaphoreCreated;
  356. if( (nQueMode != J_OSP_WAIT_FIFO)
  357. && (nQueMode != J_OSP_WAIT_PRIO) )
  358. {
  359. return Ret_ParErr;
  360. }
  362. pSemaphoreCreated = KB_OSPMalloc(sizeof(semaphore_t));
  364. if(pSemaphoreCreated == NULL) return Ret_Fail;
  366. if(nQueMode == J_OSP_WAIT_FIFO)
  367. {
  368. semaphore_init_fifo_timeout(pSemaphoreCreated, (int)nSemMax);
  369. }
  370. else if(nQueMode == J_OSP_WAIT_PRIO)
  371. {
  372. semaphore_init_priority_timeout(pSemaphoreCreated, (int)nSemMax);
  373. }
  375. *pSemID = (UINT32)pSemaphoreCreated;
  377. return Ret_OK;
  378. }
  380. KB_OSPRet KB_OSPSemDel(UINT32 nSemId)
  381. {
  382. semaphore_delete((semaphore_t*)nSemId);
  383. KB_OSPFree((void *)nSemId);
  384. return Ret_OK;
  385. }
  387. KB_OSPRet KB_OSPSemGet
  388. (
  389. UINT32 nSemId,
  390. KB_OSPWaitMode nWaitMode,
  391. UINT32 nTime
  392. )
  393. {
  394. INT32 dReturnType;
  395. clock_t *dWaitTime;
  396. clock_t  time;
  398. if(nWaitMode == KD_NoWait)
  399. {
  400. dWaitTime = (clock_t*)TIMEOUT_IMMEDIATE;
  401. }
  402. else if(nWaitMode == KB_Wait)
  403. {
  404. if(nTime == 0)
  405. {
  406. dWaitTime = (clock_t*)TIMEOUT_INFINITY;
  407. }
  408. else
  409. {
  410. time = time_plus(time_now(), (clock_t)MS_TO_TICKS(nTime));
  411. dWaitTime = &time;
  412. }
  413. }
  414. else
  415. {
  416. return Ret_ParErr;
  417. }
  419. if(0 == semaphore_wait_timeout((semaphore_t*)nSemId, dWaitTime))
  420. {
  421. dReturnType = Ret_OK;
  422. }
  423. else
  424. {
  425. dReturnType = Ret_Timeout;
  426. }
  428. return dReturnType;
  429. }
  431. KB_OSPRet KB_OSPSemSet(UINT32 nSemId)
  432. {
  433. semaphore_signal((semaphore_t*)nSemId);
  434. return Ret_OK;
  435. }
  437. extern partition_t *SystemPartition;
  439. extern void SRCHK_RecordMemoryStatus(void);
  440. extern void SRCHK_ShowMemoryStatus(void);
  441. void* KB_OSPMalloc(UINT32 dSize)
  442. {
  443. void*p=NULL;
  445. //add byshriek
  446. if(dSize<=0)
  447. return NULL;
  448. //shriek end
  450. p = memory_allocate(SystemPartition,(size_t)dSize);
  451. if(p==NULL)
  452. printf("nmemory_allocate null size[%ld]",dSize);
  454. return p; 
  455. }
  457. KB_OSPRet KB_OSPFree(void *pFree)
  458. {
  459. if(pFree == NULL) return Ret_Fail;
  460. memory_deallocate(SystemPartition, pFree);
  461. return Ret_OK;
  462. }
  464. /* EOF */