test_post_process_dma_buf.cpp 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284
  1. #include <stdio.h>
  2. #include <sys/mman.h>
  3. #include <sys/stat.h>
  4. #include <sys/types.h>
  5. #include <sys/time.h>
  6. #include <unistd.h>
  7. #include "csi_dsp_api.h"
  8. #include "csi_dsp_task_defs.h"
  9. #include "csi_dsp_post_process_defs.h"
  10. #include "CppUTest/TestHarness.h"
  11. #include "CppUTest/CommandLineTestRunner.h"
  12. #ifdef __cplusplus
  13. extern "C" {
  14. #endif
  15. #include "video_mem.h"
  16. #ifdef __cplusplus
  17. }
  18. #endif
  19. struct buf_param{
  20. int with;
  21. int height;
  22. int stride;
  23. int plane_num;
  24. };
  25. TEST_GROUP(DspPostProcessTestDmaBuf)
  26. {
  27. void setup()
  28. {
  29. instance = csi_dsp_create_instance(0);
  30. if(!instance)
  31. {
  32. FAIL_TEST("create fail\n");
  33. }
  34. task= csi_dsp_create_task(instance,CSI_DSP_TASK_SW_TO_SW);
  35. if(!task)
  36. {
  37. FAIL_TEST("task create fail\n");
  38. }
  39. if( VMEM_create(&mem_allocor) <0)
  40. {
  41. FAIL_TEST("open mem_alloc_fd fail\n");
  42. }
  43. }
  44. void teardown()
  45. {
  46. csi_dsp_destroy_task(task);
  47. csi_dsp_delete_instance(instance);
  48. VMEM_destroy(mem_allocor);
  49. }
  50. void *instance;
  51. void *mem_allocor;
  52. void *task;
  53. int reqDmaBuffer(VmemParams *params)
  54. {
  55. int pgsize = getpagesize();
  56. params->size = ((params->size+pgsize-1)/pgsize)*pgsize;
  57. if(VMEM_allocate(mem_allocor, params))
  58. {
  59. return -1;
  60. }
  61. printf("%s,alloct dma buf @ phy:%lx\n",__FUNCTION__,params->phy_address);
  62. if(VMEM_export(mem_allocor,params))
  63. {
  64. return -1;
  65. }
  66. printf("%s,export dma buf @fd:%x\n",__FUNCTION__,params->fd);
  67. // if(VMEM_mmap(mem_allocor,params))
  68. // {
  69. // return -1;
  70. // }
  71. // printf("%s,mmap dma buf addr:%lx\n",__FUNCTION__,params->vir_address);
  72. return 0;
  73. }
  74. int releaseDmaBuffer(VmemParams *params)
  75. {
  76. VMEM_free(mem_allocor, params);
  77. }
  78. int oneRequsetHelper(int with,int height,int stride,int plane_num,char *name)
  79. {
  80. int i=0;
  81. int j=0;
  82. int ret =0 ;
  83. struct timeval time_enqueue;
  84. struct timeval time_dequeue;
  85. VmemParams params_in[3];
  86. VmemParams params_out[3];
  87. csi_dsp_algo_load_req_t alog_config={
  88. .algo_id=0,
  89. };
  90. if(name != NULL)
  91. {
  92. if(csi_dsp_task_acquire_algo(task,name))
  93. {
  94. FAIL_TEST("algo kernel load fail\n");
  95. }
  96. }
  97. else
  98. {
  99. if(csi_dsp_task_load_algo(task,&alog_config))
  100. {
  101. FAIL_TEST("algo kernel load fail\n");
  102. }
  103. }
  104. struct csi_sw_task_req* req=NULL;
  105. req =csi_dsp_task_create_request(task);
  106. if(req==NULL)
  107. {
  108. FAIL_TEST("req create fail\n");
  109. }
  110. for(i=0;i<plane_num;i++)
  111. {
  112. params_in[i].size = stride*height;
  113. params_in[i].flags = VMEM_FLAG_CONTIGUOUS;
  114. if(reqDmaBuffer(&params_in[i]))
  115. {
  116. FAIL_TEST("req dma buf fail\n");
  117. }
  118. }
  119. struct csi_dsp_buffer buf1;
  120. buf1.buf_id = 0;
  121. buf1.dir = CSI_DSP_BUFFER_IN;
  122. buf1.type = CSI_DSP_BUF_TYPE_DMA_BUF_IMPORT;
  123. buf1.plane_count = plane_num;
  124. buf1.width =with;
  125. buf1.height =height;
  126. for(i=0;i<buf1.plane_count;i++)
  127. {
  128. buf1.planes[i].stride= stride;
  129. buf1.planes[i].size= params_in[i].size;
  130. buf1.planes[i].fd = params_in[i].fd;
  131. }
  132. if(csi_dsp_request_add_buffer(req,&buf1))
  133. {
  134. csi_dsp_task_release_request(req);
  135. FAIL_TEST("Add buffer:%d\n");
  136. }
  137. int *buf;
  138. for(j=0;j<buf1.plane_count;j++)
  139. {
  140. buf = (int *)buf1.planes[j].buf_vir;
  141. for(i=0;i<buf1.planes[j].size/4;i++)
  142. {
  143. buf[i]=rand();
  144. }
  145. printf("plane:%d, buf1 data:%d\n",j,buf[0]);
  146. }
  147. for(i=0;i<plane_num;i++)
  148. {
  149. params_out[i].size = stride*height;
  150. params_out[i].flags = VMEM_FLAG_CONTIGUOUS;
  151. if(reqDmaBuffer(&params_out[i]))
  152. {
  153. FAIL_TEST("req dma buf fail\n");
  154. }
  155. }
  156. struct csi_dsp_buffer buf2;
  157. buf2.buf_id = 1;
  158. buf2.dir = CSI_DSP_BUFFER_OUT;
  159. buf2.type = CSI_DSP_BUF_TYPE_DMA_BUF_IMPORT;
  160. buf2.plane_count = plane_num;
  161. buf2.width =with;
  162. buf2.height =height;
  163. for(i=0;i<buf2.plane_count;i++)
  164. {
  165. buf2.planes[i].stride= stride;
  166. buf2.planes[i].size= params_out[i].size;
  167. buf2.planes[i].fd = params_out[i].fd;
  168. }
  169. if(csi_dsp_request_add_buffer(req,&buf2))
  170. {
  171. csi_dsp_task_release_request(req);
  172. FAIL_TEST("Add buffer:%d\n");
  173. }
  174. for(j=0;j<buf2.plane_count;j++)
  175. {
  176. buf = (int *)buf2.planes[j].buf_vir;
  177. for(i=0;i<buf2.planes[0].size/4;i++)
  178. {
  179. buf[i]=rand();
  180. }
  181. printf("plane:%d, buf2 data:%d\n",j,buf[0]);
  182. }
  183. if(csi_dsp_request_enqueue(req))
  184. {
  185. csi_dsp_task_release_request(req);
  186. FAIL_TEST("Add buffer:%d\n");
  187. }
  188. gettimeofday(&time_enqueue, 0);
  189. req = csi_dsp_request_dequeue(task);
  190. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  191. {
  192. FAIL_TEST("req dequeue fail\n");
  193. }
  194. gettimeofday(&time_dequeue, 0);
  195. printf("req:%d,start:%d,%d,end:%d,%d\n",req->request_id,time_enqueue.tv_sec,time_enqueue.tv_usec,time_dequeue.tv_sec,time_dequeue.tv_usec);
  196. // MEMCMP_EQUAL((void*)buf1.planes[0].buf_vir,(void *)buf2.planes[0].buf_vir,buf1.planes[0].size);
  197. // memset((void *)buf2.planes[0].buf_vir,0xff,16);
  198. for(i=0;i<buf2.plane_count;i++)
  199. {
  200. ret |= memcmp((void*)buf1.planes[i].buf_vir,(void *)buf2.planes[i].buf_vir,buf2.planes[i].size);
  201. printf("compare plane:%d, buf1:%d,buf2:%d,size:%d\n",i,((int*)buf1.planes[i].buf_vir)[0],((int*)buf2.planes[i].buf_vir)[0],buf2.planes[i].size);
  202. }
  203. CHECK_EQUAL_ZERO(ret);
  204. csi_dsp_task_release_request(req);
  205. for(i=0;i<plane_num;i++)
  206. {
  207. releaseDmaBuffer(&params_in[i]);
  208. releaseDmaBuffer(&params_out[i]);
  209. }
  210. return 0;
  211. }
  212. };
  213. TEST(DspPostProcessTestDmaBuf,oneProcessReq_640_480_fl_lib)
  214. {
  215. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,1,"dsp_dummy_algo_flo"));
  216. }
  217. TEST(DspPostProcessTestDmaBuf,oneProcessReq_640_480_pi_lib)
  218. {
  219. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,1,"dsp_dummy_algo_pisl"));
  220. }
  221. TEST(DspPostProcessTestDmaBuf,oneProcessReq_1920_1080_fl_lib)
  222. {
  223. CHECK_EQUAL_ZERO(oneRequsetHelper(1920,1080,1920,1,"dsp_dummy_algo_flo"));
  224. }
  225. TEST(DspPostProcessTestDmaBuf,oneProcessReq_4096_2160)
  226. {
  227. CHECK_EQUAL_ZERO(oneRequsetHelper(4096,2160,4096,1,NULL));
  228. }
  229. TEST(DspPostProcessTestDmaBuf,oneProcessReq_640_480)
  230. {
  231. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,1,NULL));
  232. }
  233. TEST(DspPostProcessTestDmaBuf,oneProcessReq_multi_planes)
  234. {
  235. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,3,NULL));
  236. }