fifo 演示

2937阅读　0评论2011-11-03　pppStar
分类：LINUX

从dvsdk中扣出来的用于线程间传送指针

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <pthread.h>
  5. #include <errno.h>
  6. #include <string.h>

  8. #define Dmai_EINVAL -5 /**< Invalid input arguments (failure). */
  9. #define Dmai_ENOMEM -4 /**< No memory available (failure). */
  10. #define Dmai_EIO -3 /**< An IO error occured (failure). */
  11. #define Dmai_ENOTIMPL -2 /**< Functionality not implemented (failure). */
  12. #define Dmai_EFAIL -1 /**< General failure code (failure). */
  13. #define Dmai_EOK 0 /**< General success code (success). */
  14. #define Dmai_EFLUSH 1 /**< The command was flushed (success). */
  15. #define Dmai_EPRIME 2 /**< The command was primed (success). */
  16. #define Dmai_EFIRSTFIELD 3 /**< Only the first field was processed (success)*/
  17. #define Dmai_EBITERROR 4 /**< There was a non fatal bit error (success). */
  18. #define Dmai_ETIMEOUT 5 /**< The operation was timed out (success). */
  19. #define Dmai_EEOF 6 /**< The operation reached end of file */
  20. #define Dmai_EAGAIN 7 /**< The command needs to be rerun (success). */


  23. typedef void *Ptr;

  25. #if defined xdc_target__
  26. #else
  27. typedef signed char Int8 ; /* 8 bit value */
  28. #endif


  31. #if defined xdc_target__
  32. #else
  33. typedef signed short int Int16 ; /* 16 bit value */
  34. #endif
  35. #if defined xdc_target__
  36. #else
  37. typedef signed long int Int32 ; /* 32 bit value */
  38. #endif

  40. #if defined xdc_target__
  41. #else
  42. typedef unsigned char Uint8 ; /* 8 bit value */
  43. #endif
  44. #if defined xdc_target__
  45. #else
  46. typedef unsigned short int Uint16 ; /* 16 bit value */
  47. #endif
  48. #if defined xdc_target__
  49. #else
  50. typedef unsigned long int Uint32 ; /* 32 bit value */
  51. #endif

  53. typedef float Real32 ; /* 32 bit value */
  54. typedef double Real64 ; /* 64 bit value */

  56. #if defined xdc_target__
  57. #else
  58. typedef short int Bool ; /* 16 bit value */
  59. #endif

  61. typedef char Char8 ; /* 8 bit value */
  62. typedef short Char16 ; /* 16 bit value */

  64. typedef unsigned char Uchar8 ; /* 8 bit value */
  65. typedef unsigned short Uchar16 ; /* 16 bit value */

  67. /* TBD resolve this with hal_psc.c */
  68. #if defined xdc_target__
  69. #else
  70. typedef int Int ;
  71. #endif

  73. #if defined xdc_target__
  74. #else
  75. #define Void void
  76. #endif
  77. typedef void * Pvoid ;

  79. typedef Char8 * Pstr ;
  80. typedef Uchar8 * Pustr ;

  82. #define assert(h) if(!h)printf("assert fail:%d\n", __LINE__)

  84. /** ============================================================================
  85.  * @const TRUE/FALSE
  86.  *
  87.  * @desc Boolean constants
  88.  * ============================================================================
  89.  */
  90. #if !defined (FALSE)
  91. #define FALSE 0u
  92. #endif

  94. #if !defined (TRUE)
  95. #define TRUE 1u
  96. #endif

  98. typedef struct Fifo_Object {
  99.     pthread_mutex_t mutex;
  100.     Int numBufs;
  101.     Int16 flush;
  102.     Int pipes[2];
  103.     void *pUserData;
  104. } Fifo_Object;

  106. /**
  107.  * @brief Handle through which to reference a Fifo.
  108.  */
  109. typedef struct Fifo_Object *Fifo_Handle;

  111. /**
  112.  * @brief Attributes used to create a Fifo.
  113.  * @see Fifo_Attrs_DEFAULT.
  114.  */
  115. typedef struct Fifo_Attrs {
  116.     /**
  117.      * @brief Maximum elements that can be put on the Fifo at once
  118.      * @remarks For Bios only, Linux ignores this attribute
  119.      */
  120.     Int maxElems;
  121. } Fifo_Attrs;

  123. const Fifo_Attrs Fifo_Attrs_DEFAULT = {
  124.     0
  125. };

  127. /******************************************************************************
  128.  * Fifo_create
  129.  ******************************************************************************/
  130. Fifo_Handle Fifo_create(Fifo_Attrs *attrs)
  131. {
  132.     Fifo_Handle hFifo;

  134.     if (attrs == NULL) {
  135.         printf("NULL attrs not supported\n");
  136.         return NULL;
  137.     }

  139.     hFifo = calloc(1, sizeof(Fifo_Object));

  141.     if (hFifo == NULL) {
  142.         printf("Failed to allocate space for Fifo Object\n");
  143.         return NULL;
  144.     }

  146.     if (pipe(hFifo->pipes)) {
  147.         free(hFifo);
  148.         return NULL;
  149.     }
  150.     hFifo->numBufs = 0;

  152.     pthread_mutex_init(&hFifo->mutex, NULL);

  154.     return hFifo;
  155. }

  157. /******************************************************************************
  158.  * Fifo_delete
  159.  ******************************************************************************/
  160. Int Fifo_delete(Fifo_Handle hFifo)
  161. {
  162.     int ret = Dmai_EOK;

  164.     if (hFifo) {
  165.         if (close(hFifo->pipes[0])) {
  166.             ret = Dmai_EIO;
  167.         }

  169.         if (close(hFifo->pipes[1])) {
  170.             ret = Dmai_EIO;
  171.         }

  173.         pthread_mutex_destroy(&hFifo->mutex);

  175.         free(hFifo);
  176.     }

  178.     return ret;
  179. }

  181. /******************************************************************************
  182.  * Fifo_get
  183.  ******************************************************************************/
  184. Int Fifo_get(Fifo_Handle hFifo, Ptr ptrPtr)
  185. {
  186.     Int flush;
  187.     Int numBytes;

  189.     assert(hFifo);
  190.     assert(ptrPtr);

  192.     pthread_mutex_lock(&hFifo->mutex);
  193.     flush = hFifo->flush;
  194.     
  195.     /* BEGIN: Added by guojun wen, 2010/8/2 PN: */
  196.     #if 1
  197.     if (hFifo->numBufs <= 0)
  198.     {
  199.         pthread_mutex_unlock(&hFifo->mutex);
  200.         return Dmai_EIO;
  201.     }
  202.     #endif
  203.     hFifo->numBufs--;
  204.     /* END: Added by guojun wen, 2010/8/2 */
  205.     
  206.     pthread_mutex_unlock(&hFifo->mutex);

  208.     if (flush) {
  209.         return Dmai_EFLUSH;
  210.     }

  212.     numBytes = read(hFifo->pipes[0], ptrPtr, sizeof(Ptr));
  213.     if (numBytes != sizeof(Ptr)) {
  214.         printf("failed to read pipe : numBytes = %d\n",
  215.                 numBytes);
  216.         pthread_mutex_lock(&hFifo->mutex);
  217.         flush = hFifo->flush;
  218.         if (flush) {
  219.             hFifo->flush = FALSE;
  220.         }
  221.         pthread_mutex_unlock(&hFifo->mutex);

  223.         if (flush) {
  224.             return Dmai_EFLUSH;
  225.         }
  226.         return Dmai_EIO;
  227.     }

  229.     /* BEGIN: Deleted by guojun wen, 2010/8/2 PN: */
  230.     #if 0
  231.     pthread_mutex_lock(&hFifo->mutex);
  232.     hFifo->numBufs--;
  233.     pthread_mutex_unlock(&hFifo->mutex);
  234.     #endif /* #if 0 */
  235.     /* END: Deleted by guojun wen, 2010/8/2 */

  237.     return Dmai_EOK;
  238. }

  240. /******************************************************************************
  241.  * Fifo_flush
  242.  ******************************************************************************/
  243. Int Fifo_flush(Fifo_Handle hFifo)
  244. {
  245.     char ch = 0xff;

  247.     assert(hFifo);

  249.     pthread_mutex_lock(&hFifo->mutex);
  250.     hFifo->flush = TRUE;
  251.     pthread_mutex_unlock(&hFifo->mutex);

  253.     /* Make sure any Fifo_get() calls are unblocked */
  254.     if (write(hFifo->pipes[1], &ch, 1) != 1) {
  255.         return Dmai_EIO;
  256.     }

  258.     return Dmai_EOK;
  259. }

  261. /******************************************************************************
  262.  * Fifo_put
  263.  ******************************************************************************/
  264. Int Fifo_put(Fifo_Handle hFifo, Ptr ptr)
  265. {
  266.     assert(hFifo);
  267.     assert(ptr);

  269.     if (write(hFifo->pipes[1], &ptr, sizeof(Ptr)) != sizeof(Ptr)) {
  270.         return Dmai_EIO;
  271.     }
  272.     pthread_mutex_lock(&hFifo->mutex);
  273.     hFifo->numBufs++;
  274.     pthread_mutex_unlock(&hFifo->mutex);

  276.     return Dmai_EOK;
  277. }

  279. /******************************************************************************
  280.  * Fifo_getNumEntries
  281.  ******************************************************************************/
  282. Int Fifo_getNumEntries(Fifo_Handle hFifo)
  283. {
  284.     Int numEntries;

  286.     assert(hFifo);

  288.     pthread_mutex_lock(&hFifo->mutex);
  289.     numEntries = hFifo->numBufs;
  290.     pthread_mutex_unlock(&hFifo->mutex);

  292.     return numEntries;
  293. }

  295. void Fifo_setUserData(Fifo_Handle hFifo,
  296.                          void *pUserData)
  297. {
  298.     /* fifo is null */
  299.     if (NULL == hFifo)
  300.     {
  301.         return;
  302.     }
  303.     pthread_mutex_lock(&hFifo->mutex);
  304.     hFifo->pUserData = pUserData;
  305.     pthread_mutex_unlock(&hFifo->mutex);

  307.     return;
  308. }

  310. void *Fifo_getUserData(Fifo_Handle hFifo)
  311. {
  312.     /* fifo is null */
  313.     if (NULL == hFifo)
  314.     {
  315.         return NULL;
  316.     }
  317.     return hFifo->pUserData;
  318. }

  320. Fifo_Handle hCap2Play ;
  321. Fifo_Handle hPlay2Cap ;
  322.    
  323. static int CreateFifo()
  324. {
  325.     Fifo_Attrs fAttrs = Fifo_Attrs_DEFAULT;
  326.     Fifo_Handle ahFiFo[2] = {0};
  327.     long lLoop = 0;
  328.     long lCount = 0;

  330.     for (lCount = 0; lCount < 2; lCount++)
  331.     {
  332.         ahFiFo[lCount] = Fifo_create(&fAttrs);
  333.         if (NULL == ahFiFo[lCount])
  334.         {
  335.             for (lLoop = 0; lLoop < lCount; lLoop++)
  336.             {
  337.                 Fifo_delete(ahFiFo[lLoop]);
  338.             }
  339.             return -1;
  340.         }
  341.     }

  343.     hCap2Play = ahFiFo[0];
  344.     hPlay2Cap = ahFiFo[1];


  347.     return 1;
  348. }

  350. unsigned char arr[5] = {'1', '2','3','4','5'};


  353. void *paly_function( void *ptr )
  354. {
  355.      int count = 0;
  356.      int fiforet = Dmai_EOK;
  357.      
  358.      while(1)
  359.      {
  360.              char* localptr = NULL;
  361.              if(count >= sizeof(arr)/sizeof(char))
  362.              {
  363.                      break;
  364.              }
  365.              
  366.              fiforet = Fifo_get(hCap2Play, (Ptr)&localptr);
  367.              if(fiforet != Dmai_EOK )
  368.              {
  369.                      printf("play:get fail\n");
  370.                      sleep(1);
  371.                      continue;
  372.              }
  373.              
  374.              printf("play get :0x%x\n", *localptr);
  375.              count++;
  376.              
  377.              fiforet = Fifo_put(hPlay2Cap, localptr);
  378.              if(fiforet != Dmai_EOK )
  379.              {
  380.                      printf("play:put fail\n");
  381.                      sleep(1);
  382.                      continue;
  383.              }         
  384.      }
  385.      
  386.      sleep(2);
  387.      printf("play thread out\n");
  388. }

  390. int main()
  391. {
  392.         pthread_t thread1;
  393.         int ret ;
  394.         int count = 0;
  395.         ret = CreateFifo();
  396.         if(ret < 0)
  397.         {
  398.       printf("create fifo fail \n");
  399.     }
  400.     
  401.     ret = pthread_create( &thread1, NULL, paly_function, (void*) NULL);
  402.     if(ret != 0)
  403.     {
  404.         printf("creat thread fail");
  405.     }
  406.     
  407.     for(count = 0; count < sizeof(arr)/sizeof(char);count++)
  408.     {
  409.                 printf("main,put count:%d\n", count);
  410.          Fifo_put(hCap2Play, (Ptr)&arr[count]);
  411.     }
  412.     
  413.     sleep(1);
  414.     
  415.     for(count = 0; count < sizeof(arr)/sizeof(char);count++)
  416.     {
  417.             char* localptr = NULL;
  418.          ret = Fifo_get(hPlay2Cap, &localptr);
  419.          if(ret == Dmai_EOK )
  420.          {
  421.              printf("main get:%c\n", *localptr);
  422.          }
  423.     }
  424.     
  425.     Fifo_delete(hCap2Play);
  426.     Fifo_delete(hPlay2Cap);

  428.     return 0;
  429. }
上一篇：内存碎片一例
下一篇：感悟2