test_post_process.cpp 25 KB

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