test_post_process.cpp 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939
  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 "csi_dsp_api.h"
  7. #include "csi_dsp_task_defs.h"
  8. #include "csi_dsp_post_process_defs.h"
  9. #include "CppUTest/TestHarness.h"
  10. #include "CppUTest/CommandLineTestRunner.h"
  11. struct buf_param{
  12. int with;
  13. int height;
  14. int stride;
  15. int plane_num;
  16. };
  17. TEST_GROUP(DspPostProcessTestBasic)
  18. {
  19. void setup()
  20. {
  21. instance = csi_dsp_create_instance(0);
  22. if(!instance)
  23. {
  24. FAIL_TEST("create fail\n");
  25. }
  26. task= csi_dsp_create_task(instance,CSI_DSP_TASK_SW_TO_SW);
  27. if(!task)
  28. {
  29. FAIL_TEST("task create fail\n");
  30. }
  31. }
  32. void teardown()
  33. {
  34. csi_dsp_destroy_task(task);
  35. csi_dsp_delete_instance(instance);
  36. }
  37. void *instance;
  38. void *task;
  39. int oneRequsetHelper(int with,int height,int stride,int plane_num)
  40. {
  41. int i=0;
  42. int j=0;
  43. int ret =0 ;
  44. struct timeval time_enqueue;
  45. struct timeval time_dequeue;
  46. csi_dsp_algo_load_req_t alog_config={
  47. .algo_id=0,
  48. };
  49. if(csi_dsp_task_load_algo(task,&alog_config))
  50. {
  51. FAIL_TEST("algo kernel load fail\n");
  52. }
  53. struct csi_sw_task_req* req=NULL;
  54. req =csi_dsp_task_create_request(task);
  55. if(req==NULL)
  56. {
  57. FAIL_TEST("req create fail\n");
  58. }
  59. struct csi_dsp_buffer buf1;
  60. buf1.buf_id = 0;
  61. buf1.dir = CSI_DSP_BUFFER_IN;
  62. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  63. buf1.plane_count = plane_num;
  64. buf1.width =with;
  65. buf1.height =height;
  66. for(i=0;i<buf1.plane_count;i++)
  67. {
  68. buf1.planes[i].stride= stride;
  69. buf1.planes[i].size= stride*buf1.height;
  70. }
  71. if(csi_dsp_request_add_buffer(req,&buf1))
  72. {
  73. csi_dsp_task_release_request(req);
  74. FAIL_TEST("Add buffer:%d\n");
  75. }
  76. int *buf;
  77. for(j=0;j<buf1.plane_count;j++)
  78. {
  79. buf = (int *)buf1.planes[j].buf_vir;
  80. for(i=0;i<buf1.planes[j].size/4;i++)
  81. {
  82. buf[i]=rand();
  83. }
  84. printf("plane:%d, buf1 data:%d\n",j,buf[0]);
  85. }
  86. struct csi_dsp_buffer buf2;
  87. buf2.buf_id = 1;
  88. buf2.dir = CSI_DSP_BUFFER_OUT;
  89. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  90. buf2.plane_count = plane_num;
  91. buf2.width =with;
  92. buf2.height =height;
  93. for(i=0;i<buf2.plane_count;i++)
  94. {
  95. buf2.planes[i].stride= stride;
  96. buf2.planes[i].size= stride*buf2.height;
  97. }
  98. if(csi_dsp_request_add_buffer(req,&buf2))
  99. {
  100. csi_dsp_task_release_request(req);
  101. FAIL_TEST("Add buffer:%d\n");
  102. }
  103. for(j=0;j<buf2.plane_count;j++)
  104. {
  105. buf = (int *)buf2.planes[j].buf_vir;
  106. for(i=0;i<buf2.planes[0].size/4;i++)
  107. {
  108. buf[i]=rand();
  109. }
  110. printf("plane:%d, buf2 data:%d\n",j,buf[0]);
  111. }
  112. if(csi_dsp_request_enqueue(req))
  113. {
  114. csi_dsp_task_release_request(req);
  115. FAIL_TEST("Add buffer:%d\n");
  116. }
  117. gettimeofday(&time_enqueue, 0);
  118. req = csi_dsp_request_dequeue(task);
  119. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  120. {
  121. FAIL_TEST("req dequeue fail\n");
  122. }
  123. gettimeofday(&time_dequeue, 0);
  124. 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);
  125. // MEMCMP_EQUAL((void*)buf1.planes[0].buf_vir,(void *)buf2.planes[0].buf_vir,buf1.planes[0].size);
  126. for(i=0;i<buf2.plane_count;i++)
  127. {
  128. ret = memcmp((void*)buf1.planes[i].buf_vir,(void *)buf2.planes[i].buf_vir,buf2.planes[i].size);
  129. 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);
  130. CHECK_EQUAL_ZERO(ret);
  131. }
  132. // CHECK_EQUAL_ZERO(ret);
  133. csi_dsp_task_release_request(req);
  134. return 0;
  135. }
  136. // int task_thread_process(struct buf_param * param)
  137. // {
  138. // }
  139. };
  140. TEST(DspPostProcessTestBasic,oneProcessReq_640_480)
  141. {
  142. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,1));
  143. }
  144. TEST(DspPostProcessTestBasic,oneProcessReq_1920_1080)
  145. {
  146. CHECK_EQUAL_ZERO(oneRequsetHelper(1920,1080,1920,1));
  147. }
  148. TEST(DspPostProcessTestBasic,oneProcessReq_4096_2160)
  149. {
  150. CHECK_EQUAL_ZERO(oneRequsetHelper(4096,2160,4096,1));
  151. }
  152. TEST(DspPostProcessTestBasic,oneProcessReq_multi_planes)
  153. {
  154. CHECK_EQUAL_ZERO(oneRequsetHelper(640,480,640,3));
  155. }
  156. TEST(DspPostProcessTestBasic,oneProcessReq_multi_planes_1280_960)
  157. {
  158. CHECK_EQUAL_ZERO(oneRequsetHelper(1280,960,1280,3));
  159. }
  160. TEST(DspPostProcessTestBasic,oneProcessReq_multi_planes_1920_1080)
  161. {
  162. CHECK_EQUAL_ZERO(oneRequsetHelper(1920,1080,1920,3));
  163. }
  164. TEST(DspPostProcessTestBasic,MultiProcessReq)
  165. {
  166. struct csi_sw_task_req* req_list[6];
  167. int loop=0;
  168. int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  169. struct csi_sw_task_req* req=NULL;
  170. csi_dsp_algo_load_req_t alog_config={
  171. .algo_id=0,
  172. };
  173. if(csi_dsp_task_load_algo(task,&alog_config))
  174. {
  175. FAIL_TEST("algo kernel load fail\n");
  176. }
  177. for(loop =0 ;loop < req_num;loop++)
  178. {
  179. req =csi_dsp_task_create_request(task);
  180. if(req==NULL)
  181. {
  182. FAIL_TEST("req create fail\n");
  183. }
  184. req_list[loop]=req;
  185. struct csi_dsp_buffer buf1;
  186. buf1.buf_id = 0;
  187. buf1.dir = CSI_DSP_BUFFER_IN;
  188. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  189. buf1.plane_count = 1;
  190. buf1.width =640;
  191. buf1.height =480;
  192. buf1.planes[0].stride= 640;
  193. buf1.planes[0].size= 640*480;
  194. if(csi_dsp_request_add_buffer(req,&buf1))
  195. {
  196. csi_dsp_task_release_request(req);
  197. FAIL_TEST("Add buffer:%d\n");
  198. }
  199. int i=0;
  200. for(i=0;i<buf1.planes[0].size/4;i++)
  201. {
  202. ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  203. }
  204. struct csi_dsp_buffer buf2;
  205. buf2.buf_id = 1;
  206. buf2.dir = CSI_DSP_BUFFER_OUT;
  207. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  208. buf2.plane_count = 1;
  209. buf2.width =640;
  210. buf2.height =480;
  211. buf2.planes[0].stride= 640;
  212. buf2.planes[0].size= 640*480;
  213. if(csi_dsp_request_add_buffer(req,&buf2))
  214. {
  215. csi_dsp_task_release_request(req);
  216. FAIL_TEST("Add buffer:%d\n");
  217. }
  218. if(csi_dsp_request_enqueue(req))
  219. {
  220. csi_dsp_task_release_request(req);
  221. FAIL_TEST("Add buffer:%d\n");
  222. }
  223. }
  224. for(;loop>0;loop--)
  225. {
  226. req = csi_dsp_request_dequeue(task);
  227. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  228. {
  229. FAIL_TEST("req dequeue fail\n");
  230. }
  231. // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  232. int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  233. CHECK_EQUAL_ZERO(ret);
  234. csi_dsp_task_release_request(req);
  235. }
  236. }
  237. TEST(DspPostProcessTestBasic,MultiProcessReqEnqueueConcentration)
  238. {
  239. struct csi_sw_task_req* req_list[6];
  240. int loop=0;
  241. struct csi_sw_task_req* req=NULL;
  242. int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  243. csi_dsp_algo_load_req_t alog_config={
  244. .algo_id=0,
  245. };
  246. if(csi_dsp_task_load_algo(task,&alog_config))
  247. {
  248. FAIL_TEST("algo kernel load fail\n");
  249. }
  250. for(loop =0 ;loop < req_num;loop++)
  251. {
  252. req =csi_dsp_task_create_request(task);
  253. if(req==NULL)
  254. {
  255. FAIL_TEST("req create fail\n");
  256. }
  257. req_list[loop]=req;
  258. struct csi_dsp_buffer buf1;
  259. buf1.buf_id = 0;
  260. buf1.dir = CSI_DSP_BUFFER_IN;
  261. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  262. buf1.plane_count = 1;
  263. buf1.width =640;
  264. buf1.height =480;
  265. buf1.planes[0].stride= 640;
  266. buf1.planes[0].size= 640*480;
  267. if(csi_dsp_request_add_buffer(req,&buf1))
  268. {
  269. csi_dsp_task_release_request(req);
  270. FAIL_TEST("Add buffer:%d\n");
  271. }
  272. int i=0;
  273. for(i=0;i<buf1.planes[0].size/4;i++)
  274. {
  275. ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  276. }
  277. struct csi_dsp_buffer buf2;
  278. buf2.buf_id = 1;
  279. buf2.dir = CSI_DSP_BUFFER_OUT;
  280. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  281. buf2.plane_count = 1;
  282. buf2.width =640;
  283. buf2.height =480;
  284. buf2.planes[0].stride= 640;
  285. buf2.planes[0].size= 640*480;
  286. if(csi_dsp_request_add_buffer(req,&buf2))
  287. {
  288. csi_dsp_task_release_request(req);
  289. FAIL_TEST("Add buffer:%d\n");
  290. }
  291. }
  292. for(loop =0 ;loop < req_num;loop++)
  293. {
  294. if(csi_dsp_request_enqueue(req_list[loop]))
  295. {
  296. csi_dsp_task_release_request(req_list[loop]);
  297. FAIL_TEST("Add buffer:%d\n");
  298. }
  299. }
  300. for(;loop>0;loop--)
  301. {
  302. req = csi_dsp_request_dequeue(task);
  303. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  304. {
  305. FAIL_TEST("req dequeue fail\n");
  306. }
  307. // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  308. int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  309. CHECK_EQUAL_ZERO(ret);
  310. csi_dsp_task_release_request(req);
  311. }
  312. }
  313. TEST(DspPostProcessTestBasic,MultiProcessReqEnqueueConcentration_1)
  314. {
  315. struct csi_sw_task_req* req_list[6];
  316. int loop=0;
  317. struct csi_sw_task_req* req=NULL;
  318. int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  319. csi_dsp_algo_load_req_t alog_config={
  320. .algo_id=0,
  321. };
  322. if(csi_dsp_task_load_algo(task,&alog_config))
  323. {
  324. FAIL_TEST("algo kernel load fail\n");
  325. }
  326. for(loop =0 ;loop < req_num;loop++)
  327. {
  328. req =csi_dsp_task_create_request(task);
  329. if(req==NULL)
  330. {
  331. FAIL_TEST("req create fail\n");
  332. }
  333. req_list[loop]=req;
  334. struct csi_dsp_buffer buf1;
  335. buf1.buf_id = 0;
  336. buf1.dir = CSI_DSP_BUFFER_IN;
  337. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  338. buf1.plane_count = 1;
  339. buf1.width =640;
  340. buf1.height =480;
  341. buf1.planes[0].stride= 640;
  342. buf1.planes[0].size= 640*480;
  343. if(csi_dsp_request_add_buffer(req,&buf1))
  344. {
  345. csi_dsp_task_release_request(req);
  346. FAIL_TEST("Add buffer:%d\n");
  347. }
  348. int i=0;
  349. for(i=0;i<buf1.planes[0].size/4;i++)
  350. {
  351. ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  352. }
  353. struct csi_dsp_buffer buf2;
  354. buf2.buf_id = 1;
  355. buf2.dir = CSI_DSP_BUFFER_OUT;
  356. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  357. buf2.plane_count = 1;
  358. buf2.width =640;
  359. buf2.height =480;
  360. buf2.planes[0].stride= 640;
  361. buf2.planes[0].size= 640*480;
  362. if(csi_dsp_request_add_buffer(req,&buf2))
  363. {
  364. csi_dsp_task_release_request(req);
  365. FAIL_TEST("Add buffer:%d\n");
  366. }
  367. }
  368. for(loop =0 ;loop < req_num;loop++)
  369. {
  370. if(csi_dsp_request_enqueue(req_list[loop]))
  371. {
  372. csi_dsp_task_release_request(req_list[loop]);
  373. FAIL_TEST("Add buffer:%d\n");
  374. }
  375. }
  376. for(;loop>0;loop--)
  377. {
  378. req = csi_dsp_request_dequeue(task);
  379. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  380. {
  381. FAIL_TEST("req dequeue fail\n");
  382. }
  383. }
  384. for(loop =0 ;loop < req_num;loop++)
  385. {
  386. req = req_list[loop];
  387. // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  388. int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  389. CHECK_EQUAL_ZERO(ret);
  390. csi_dsp_task_release_request(req);
  391. }
  392. }
  393. TEST(DspPostProcessTestBasic,MultiProcessReqEnqueueConcentration_profile_640)
  394. {
  395. struct csi_sw_task_req* req_list[6];
  396. struct timeval cur_time_enqueue[6];
  397. struct timeval cur_time_dequeue[6];
  398. int loop=0;
  399. struct csi_sw_task_req* req=NULL;
  400. int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  401. csi_dsp_algo_load_req_t alog_config={
  402. .algo_id=0,
  403. };
  404. if(csi_dsp_task_load_algo(task,&alog_config))
  405. {
  406. FAIL_TEST("algo kernel load fail\n");
  407. }
  408. for(loop =0 ;loop < req_num;loop++)
  409. {
  410. req =csi_dsp_task_create_request(task);
  411. if(req==NULL)
  412. {
  413. FAIL_TEST("req create fail\n");
  414. }
  415. req_list[loop]=req;
  416. struct csi_dsp_buffer buf1;
  417. buf1.buf_id = 0;
  418. buf1.dir = CSI_DSP_BUFFER_IN;
  419. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  420. buf1.plane_count = 1;
  421. buf1.width =640;
  422. buf1.height =480;
  423. buf1.planes[0].stride= 640;
  424. buf1.planes[0].size= 640*480;
  425. if(csi_dsp_request_add_buffer(req,&buf1))
  426. {
  427. csi_dsp_task_release_request(req);
  428. FAIL_TEST("Add buffer:%d\n");
  429. }
  430. int i=0;
  431. for(i=0;i<buf1.planes[0].size/4;i++)
  432. {
  433. ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  434. }
  435. struct csi_dsp_buffer buf2;
  436. buf2.buf_id = 1;
  437. buf2.dir = CSI_DSP_BUFFER_OUT;
  438. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  439. buf2.plane_count = 1;
  440. buf2.width =640;
  441. buf2.height =480;
  442. buf2.planes[0].stride= 640;
  443. buf2.planes[0].size= 640*480;
  444. if(csi_dsp_request_add_buffer(req,&buf2))
  445. {
  446. csi_dsp_task_release_request(req);
  447. FAIL_TEST("Add buffer:%d\n");
  448. }
  449. }
  450. for(loop =0 ;loop < req_num;loop++)
  451. {
  452. if(csi_dsp_request_enqueue(req_list[loop]))
  453. {
  454. csi_dsp_task_release_request(req_list[loop]);
  455. FAIL_TEST("Add buffer:%d\n");
  456. }
  457. gettimeofday(&cur_time_enqueue[loop], 0);
  458. }
  459. for(;loop>0;loop--)
  460. {
  461. req = csi_dsp_request_dequeue(task);
  462. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  463. {
  464. FAIL_TEST("req dequeue fail\n");
  465. }
  466. gettimeofday(&cur_time_dequeue[loop], 0);
  467. }
  468. for(loop =0 ;loop < req_num;loop++)
  469. {
  470. printf("req:%d,start:%d,%d,end:%d,%d\n",req_list[loop]->request_id,cur_time_enqueue[loop].tv_sec,cur_time_enqueue[loop].tv_usec,
  471. cur_time_dequeue[loop].tv_sec,cur_time_dequeue[loop].tv_usec);
  472. }
  473. for(loop =0 ;loop < req_num;loop++)
  474. {
  475. req = req_list[loop];
  476. // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  477. int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  478. CHECK_EQUAL_ZERO(ret);
  479. csi_dsp_task_release_request(req);
  480. }
  481. }
  482. TEST(DspPostProcessTestBasic,MultiProcessReqEnqueueConcentration_profile_1920)
  483. {
  484. struct csi_sw_task_req* req_list[6];
  485. struct timeval cur_time_enqueue[6];
  486. struct timeval cur_time_dequeue[6];
  487. int loop=0;
  488. struct csi_sw_task_req* req=NULL;
  489. int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  490. csi_dsp_algo_load_req_t alog_config={
  491. .algo_id=0,
  492. };
  493. if(csi_dsp_task_load_algo(task,&alog_config))
  494. {
  495. FAIL_TEST("algo kernel load fail\n");
  496. }
  497. for(loop =0 ;loop < req_num;loop++)
  498. {
  499. req =csi_dsp_task_create_request(task);
  500. if(req==NULL)
  501. {
  502. FAIL_TEST("req create fail\n");
  503. }
  504. req_list[loop]=req;
  505. struct csi_dsp_buffer buf1;
  506. buf1.buf_id = 0;
  507. buf1.dir = CSI_DSP_BUFFER_IN;
  508. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  509. buf1.plane_count = 1;
  510. buf1.width =1920;
  511. buf1.height =1080;
  512. buf1.planes[0].stride= 1920;
  513. buf1.planes[0].size= 1920*1080;
  514. if(csi_dsp_request_add_buffer(req,&buf1))
  515. {
  516. csi_dsp_task_release_request(req);
  517. FAIL_TEST("Add buffer:%d\n");
  518. }
  519. int i=0;
  520. for(i=0;i<buf1.planes[0].size/4;i++)
  521. {
  522. ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  523. }
  524. struct csi_dsp_buffer buf2;
  525. buf2.buf_id = 1;
  526. buf2.dir = CSI_DSP_BUFFER_OUT;
  527. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  528. buf2.plane_count = 1;
  529. buf2.width =1920;
  530. buf2.height =1080;
  531. buf2.planes[0].stride= 1920;
  532. buf2.planes[0].size= 1920*1080;
  533. if(csi_dsp_request_add_buffer(req,&buf2))
  534. {
  535. csi_dsp_task_release_request(req);
  536. FAIL_TEST("Add buffer:%d\n");
  537. }
  538. }
  539. for(loop =0 ;loop < req_num;loop++)
  540. {
  541. if(csi_dsp_request_enqueue(req_list[loop]))
  542. {
  543. csi_dsp_task_release_request(req_list[loop]);
  544. FAIL_TEST("Add buffer:%d\n");
  545. }
  546. gettimeofday(&cur_time_enqueue[loop], 0);
  547. }
  548. for(;loop>0;loop--)
  549. {
  550. req = csi_dsp_request_dequeue(task);
  551. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  552. {
  553. FAIL_TEST("req dequeue fail\n");
  554. }
  555. gettimeofday(&cur_time_dequeue[loop], 0);
  556. }
  557. uint32_t counter;
  558. for(loop =0 ;loop < req_num;loop++)
  559. {
  560. printf("req:%d,start:%d,%d,end:%d,%d\n",req_list[loop]->request_id,cur_time_enqueue[loop].tv_sec,cur_time_enqueue[loop].tv_usec,
  561. cur_time_dequeue[loop].tv_sec,cur_time_dequeue[loop].tv_usec);
  562. }
  563. for(loop =0 ;loop < req_num;loop++)
  564. {
  565. req = req_list[loop];
  566. // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  567. int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  568. CHECK_EQUAL_ZERO(ret);
  569. csi_dsp_task_release_request(req);
  570. }
  571. }
  572. TEST(DspPostProcessTestBasic,MultiProcessReqEnqueueConcentration_profile_4096)
  573. {
  574. struct csi_sw_task_req* req_list[6];
  575. struct timeval cur_time_enqueue[6];
  576. struct timeval cur_time_dequeue[6];
  577. int loop=0;
  578. struct csi_sw_task_req* req=NULL;
  579. int req_num = sizeof(req_list)/sizeof(struct csi_sw_task_req*);
  580. csi_dsp_algo_load_req_t alog_config={
  581. .algo_id=0,
  582. };
  583. if(csi_dsp_task_load_algo(task,&alog_config))
  584. {
  585. FAIL_TEST("algo kernel load fail\n");
  586. }
  587. for(loop =0 ;loop < req_num;loop++)
  588. {
  589. req =csi_dsp_task_create_request(task);
  590. if(req==NULL)
  591. {
  592. FAIL_TEST("req create fail\n");
  593. }
  594. req_list[loop]=req;
  595. struct csi_dsp_buffer buf1;
  596. buf1.buf_id = 0;
  597. buf1.dir = CSI_DSP_BUFFER_IN;
  598. buf1.type = CSI_DSP_BUF_ALLOC_DRV;
  599. buf1.plane_count = 1;
  600. buf1.width =4096;
  601. buf1.height =2160;
  602. buf1.planes[0].stride= 4096;
  603. buf1.planes[0].size= 4096*2160;
  604. if(csi_dsp_request_add_buffer(req,&buf1))
  605. {
  606. csi_dsp_task_release_request(req);
  607. FAIL_TEST("Add buffer:%d\n");
  608. }
  609. int i=0;
  610. for(i=0;i<buf1.planes[0].size/4;i++)
  611. {
  612. ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  613. }
  614. struct csi_dsp_buffer buf2;
  615. buf2.buf_id = 1;
  616. buf2.dir = CSI_DSP_BUFFER_OUT;
  617. buf2.type = CSI_DSP_BUF_ALLOC_DRV;
  618. buf2.plane_count = 1;
  619. buf2.width =4096;
  620. buf2.height =2160;
  621. buf2.planes[0].stride= 640;
  622. buf2.planes[0].size= 4096*2160;
  623. if(csi_dsp_request_add_buffer(req,&buf2))
  624. {
  625. csi_dsp_task_release_request(req);
  626. FAIL_TEST("Add buffer:%d\n");
  627. }
  628. }
  629. for(loop =0 ;loop < req_num;loop++)
  630. {
  631. if(csi_dsp_request_enqueue(req_list[loop]))
  632. {
  633. csi_dsp_task_release_request(req_list[loop]);
  634. FAIL_TEST("Add buffer:%d\n");
  635. }
  636. gettimeofday(&cur_time_enqueue[loop], 0);
  637. }
  638. for(;loop>0;loop--)
  639. {
  640. req = csi_dsp_request_dequeue(task);
  641. if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  642. {
  643. FAIL_TEST("req dequeue fail\n");
  644. }
  645. gettimeofday(&cur_time_dequeue[loop], 0);
  646. }
  647. uint32_t counter;
  648. for(loop =0 ;loop < req_num;loop++)
  649. {
  650. printf("req:%d,start:%d,%d,end:%d,%d\n",req_list[loop]->request_id,cur_time_enqueue[loop].tv_sec,cur_time_enqueue[loop].tv_usec,
  651. cur_time_dequeue[loop].tv_sec,cur_time_dequeue[loop].tv_usec);
  652. }
  653. for(loop =0 ;loop < req_num;loop++)
  654. {
  655. req = req_list[loop];
  656. // MEMCMP_EQUAL((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  657. int ret = memcmp((void*)req->buffers[0].planes[0].buf_vir,(void *)req->buffers[1].planes[0].buf_vir,req->buffers[0].planes[0].size);
  658. CHECK_EQUAL_ZERO(ret);
  659. csi_dsp_task_release_request(req);
  660. }
  661. }
  662. int main( int argc, char **argv )
  663. {
  664. return RUN_ALL_TESTS(argc, argv);
  665. }
  666. // int main(int argc, char *argv[])
  667. // {
  668. // printf("Dsp Post Process Test Start !\n");
  669. // void *instance = csi_dsp_create_instance(0);
  670. // if(!instance)
  671. // {
  672. // printf("create fail\n");
  673. // return -1;
  674. // }
  675. // void *task= csi_dsp_create_task(instance,CSI_DSP_TASK_SW_TO_SW);
  676. // if(!task)
  677. // {
  678. // printf("task create fail\n");
  679. // return -1;
  680. // }
  681. // struct csi_dsp_algo_config_par alog_config={
  682. // .algo_id=0,
  683. // };
  684. // if(csi_dsp_task_config_algo(task,&alog_config))
  685. // {
  686. // printf("algo kernel config fail\n");
  687. // return -1;
  688. // }
  689. // struct csi_sw_task_req* req=NULL;
  690. // req =csi_dsp_task_create_request(task);
  691. // if(req==NULL)
  692. // {
  693. // printf("req create fail\n");
  694. // return -1;
  695. // }
  696. // struct csi_dsp_buffer buf1 =
  697. // {
  698. // .buf_id = 0,
  699. // .dir = CSI_DSP_BUFFER_IN,
  700. // .type = CSI_DSP_BUF_ALLOC_DRV,
  701. // .plane_count = 1,
  702. // .width =640,
  703. // .height =480,
  704. // .planes[0].stride= 640,
  705. // .planes[0].size= 604*480,
  706. // };
  707. // if(csi_dsp_request_add_buffer(req,&buf1))
  708. // {
  709. // printf("%s,add buffer:%d\n",__FUNCTION__,buf1.buf_id);
  710. // csi_dsp_task_release_request(req);
  711. // return -1;
  712. // }
  713. // int i=0;
  714. // for(i=0;i<buf1.planes[0].size/4;i++)
  715. // {
  716. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  717. // }
  718. // struct csi_dsp_buffer buf2 =
  719. // {
  720. // .buf_id = 1,
  721. // .dir = CSI_DSP_BUFFER_OUT,
  722. // .type = CSI_DSP_BUF_ALLOC_DRV,
  723. // .plane_count = 1,
  724. // .width =640,
  725. // .height =480,
  726. // .planes[0].stride= 640,
  727. // .planes[0].size= 604*480,
  728. // };
  729. // if(csi_dsp_request_add_buffer(req,&buf2))
  730. // {
  731. // printf("%s,add buffer:%d\n",__FUNCTION__,buf1.buf_id);
  732. // csi_dsp_task_release_request(req);
  733. // return -1;
  734. // }
  735. // if(csi_dsp_request_enqueue(req))
  736. // {
  737. // printf("%s,req enqueu fail:%d\n",__FUNCTION__);
  738. // csi_dsp_task_release_request(req);
  739. // return -1;
  740. // }
  741. // req = csi_dsp_request_dequeue(task);
  742. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  743. // {
  744. // printf("%s,req dequeue fail:%d\n",__FUNCTION__);
  745. // return -1;
  746. // }
  747. // if(memcmp((void*)buf1.planes[0].buf_vir,(void *)buf2.planes[0].buf_vir,buf1.planes[0].size))
  748. // {
  749. // printf("%s,cmp fail\n",__FUNCTION__);
  750. // csi_dsp_task_release_request(req);
  751. // csi_dsp_destroy_task(task);
  752. // csi_dsp_delete_instance(instance);
  753. // return -1;
  754. // }
  755. // csi_dsp_task_release_request(req);
  756. // csi_dsp_destroy_task(task);
  757. // csi_dsp_delete_instance(instance);
  758. // printf("%s,Test Pass!\n",__FUNCTION__);
  759. // return 0;
  760. // }