test_vi_enhance_process.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546
  1. #include <stdio.h>
  2. #include <sys/mman.h>
  3. #include <sys/stat.h>
  4. #include <sys/types.h>
  5. #include "csi_dsp_api.h"
  6. #include "csi_dsp_task_defs.h"
  7. #include "csi_dsp_post_process_defs.h"
  8. #include "CppUTest/TestHarness.h"
  9. #include "CppUTest/CommandLineTestRunner.h"
  10. #ifdef __cplusplus
  11. extern "C" {
  12. #endif
  13. #include "video_mem.h"
  14. #ifdef __cplusplus
  15. }
  16. #endif
  17. TEST_GROUP(DspViEnhanceProcessTest)
  18. {
  19. void setup()
  20. {
  21. instance = csi_dsp_create_instance(0);
  22. if(!instance)
  23. {
  24. FAIL_TEST("create fail\n");
  25. }
  26. if( VMEM_create(&mem_allocor) <0)
  27. {
  28. FAIL_TEST("open mem_alloc_fd fail\n");
  29. }
  30. }
  31. void teardown()
  32. {
  33. // csi_dsp_destroy_task(task);
  34. csi_dsp_delete_instance(instance);
  35. VMEM_destroy(mem_allocor);
  36. }
  37. int reqDmaBuffer(VmemParams *params)
  38. {
  39. if(VMEM_allocate(mem_allocor, params))
  40. {
  41. return -1;
  42. }
  43. printf("%s,alloct dma buf @ phy:%lx\n",__FUNCTION__,params->phy_address);
  44. if(VMEM_export(mem_allocor,params))
  45. {
  46. return -1;
  47. }
  48. printf("%s,export dma buf @fd:%x\n",__FUNCTION__,params->fd);
  49. return 0;
  50. }
  51. int releaseDmaBuffer(VmemParams *params)
  52. {
  53. VMEM_free(mem_allocor, params);
  54. }
  55. void *instance;
  56. void *mem_allocor;
  57. // void *task;
  58. };
  59. TEST(DspViEnhanceProcessTest,Isp2Dsp2RyProcessTestBasic)
  60. {
  61. void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_HW);
  62. if(!vi_task)
  63. {
  64. FAIL_TEST("task create fail\n");
  65. }
  66. if(csi_dsp_create_reporter(instance))
  67. {
  68. FAIL_TEST("reporter create fail\n");
  69. }
  70. struct csi_dsp_task_fe_para config_params;
  71. config_params.frontend_type = CSI_DSP_FE_TYPE_ISP;
  72. config_params.task_id = -1;
  73. config_params.isp_param.id=0;
  74. config_params.isp_param.hor=640;
  75. config_params.isp_param.ver=480;
  76. config_params.isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
  77. config_params.isp_param.line_in_entry=640*2;
  78. config_params.isp_param.line_stride=640*2;
  79. config_params.isp_param.buffer_size=640*2*16*2;
  80. config_params.isp_param.buffer_addr=0xb0000000;
  81. if(csi_dsp_task_config_frontend(vi_task,&config_params))
  82. {
  83. FAIL_TEST("isp config fail\n");
  84. }
  85. struct csi_dsp_task_be_para post_config;
  86. post_config.backend_type = CSI_DSP_BE_TYPE_POST_ISP;
  87. post_config.task_id = -1;
  88. post_config.post_isp_param.id=0;
  89. post_config.post_isp_param.hor=640;
  90. post_config.post_isp_param.ver=480;
  91. post_config.post_isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
  92. post_config.post_isp_param.line_in_entry=640*2;
  93. post_config.post_isp_param.line_stride=640*2;
  94. post_config.post_isp_param.buffer_size=640*2*16*2;
  95. post_config.post_isp_param.buffer_addr=0xb0000000;
  96. if(csi_dsp_task_config_backend(vi_task,&post_config))
  97. {
  98. FAIL_TEST("post-isp config fail\n");
  99. }
  100. struct csi_dsp_algo_config_par alog_config={
  101. .algo_id=0,
  102. .sett_ptr =NULL,
  103. .sett_length =0,
  104. };
  105. if(csi_dsp_task_config_algo(vi_task,&alog_config))
  106. {
  107. FAIL_TEST("algo kernel config fail\n");
  108. }
  109. if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
  110. {
  111. FAIL_TEST("algo kernel start fail\n");
  112. }
  113. if(csi_dsp_task_start(vi_task))
  114. {
  115. FAIL_TEST("task start fail\n");
  116. }
  117. if(csi_dsp_task_stop(vi_task))
  118. {
  119. FAIL_TEST("task stop fail\n");
  120. }
  121. if(csi_dsp_ps_task_unregister_cb(vi_task))
  122. {
  123. FAIL_TEST("unregister_cb fail\n");
  124. }
  125. if(csi_dsp_destroy_reporter(instance))
  126. {
  127. FAIL_TEST("reporter destroy fail\n");
  128. }
  129. csi_dsp_destroy_task(vi_task);
  130. }
  131. TEST(DspViEnhanceProcessTest,Isp2Dsp2RyProcessTestWithPorperty)
  132. {
  133. void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_HW);
  134. if(!vi_task)
  135. {
  136. FAIL_TEST("task create fail\n");
  137. }
  138. if(csi_dsp_create_reporter(instance))
  139. {
  140. FAIL_TEST("reporter create fail\n");
  141. }
  142. struct csi_dsp_task_fe_para config_params;
  143. config_params.frontend_type = CSI_DSP_FE_TYPE_ISP;
  144. config_params.task_id = -1;
  145. config_params.isp_param.id=0;
  146. config_params.isp_param.hor=640;
  147. config_params.isp_param.ver=480;
  148. config_params.isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
  149. config_params.isp_param.line_in_entry=640*2;
  150. config_params.isp_param.line_stride=640*2;
  151. config_params.isp_param.buffer_size=640*2*16*2;
  152. config_params.isp_param.buffer_addr=0xb0000000;
  153. if(csi_dsp_task_config_frontend(vi_task,&config_params))
  154. {
  155. FAIL_TEST("isp config fail\n");
  156. }
  157. struct csi_dsp_task_be_para post_config;
  158. post_config.backend_type = CSI_DSP_BE_TYPE_POST_ISP;
  159. post_config.task_id = -1;
  160. post_config.post_isp_param.id=0;
  161. post_config.post_isp_param.hor=640;
  162. post_config.post_isp_param.ver=480;
  163. post_config.post_isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
  164. post_config.post_isp_param.line_in_entry=640*2;
  165. post_config.post_isp_param.line_stride=640*2;
  166. post_config.post_isp_param.buffer_size=640*2*16*2;
  167. post_config.post_isp_param.buffer_addr=0xb0000000;
  168. if(csi_dsp_task_config_backend(vi_task,&post_config))
  169. {
  170. FAIL_TEST("post-isp config fail\n");
  171. }
  172. struct algo_property{
  173. uint32_t width;
  174. uint32_t height;
  175. };
  176. struct algo_property sett {
  177. .width = 640,
  178. .height = 480,
  179. };
  180. struct csi_dsp_algo_config_par alog_config={
  181. .algo_id=0,
  182. .sett_ptr =(uint64_t)&sett,
  183. .sett_length =sizeof(struct algo_property),
  184. };
  185. if(csi_dsp_task_config_algo(vi_task,&alog_config))
  186. {
  187. FAIL_TEST("algo kernel config fail\n");
  188. }
  189. if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
  190. {
  191. FAIL_TEST("register_cb fail\n");
  192. }
  193. if(csi_dsp_task_start(vi_task))
  194. {
  195. FAIL_TEST("task start fail\n");
  196. }
  197. if(csi_dsp_task_stop(vi_task))
  198. {
  199. FAIL_TEST("task stop fail\n");
  200. }
  201. if(csi_dsp_ps_task_unregister_cb(vi_task))
  202. {
  203. FAIL_TEST("unregister_cb fail\n");
  204. }
  205. if(csi_dsp_destroy_reporter(instance))
  206. {
  207. FAIL_TEST("reporter destroy fail\n");
  208. }
  209. csi_dsp_destroy_task(vi_task);
  210. }
  211. TEST(DspViEnhanceProcessTest,Isp2Dsp2RyProcessMini)
  212. {
  213. void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_HW);
  214. if(!vi_task)
  215. {
  216. FAIL_TEST("task create fail\n");
  217. }
  218. if(csi_dsp_create_reporter(instance))
  219. {
  220. FAIL_TEST("reporter create fail\n");
  221. }
  222. struct algo_property{
  223. uint32_t width;
  224. uint32_t height;
  225. };
  226. struct algo_property sett {
  227. .width = 1280,
  228. .height = 960,
  229. };
  230. struct csi_dsp_algo_config_par alog_config={
  231. .algo_id=0,
  232. .sett_ptr =(uint64_t)&sett,
  233. .sett_length =sizeof(struct algo_property),
  234. };
  235. if(csi_dsp_task_config_algo(vi_task,&alog_config))
  236. {
  237. FAIL_TEST("algo kernel config fail\n");
  238. }
  239. if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
  240. {
  241. FAIL_TEST("register_cb fail\n");
  242. }
  243. if(csi_dsp_ps_task_unregister_cb(vi_task))
  244. {
  245. FAIL_TEST("unregister_cb fail\n");
  246. }
  247. if(csi_dsp_destroy_reporter(instance))
  248. {
  249. FAIL_TEST("reporter destroy fail\n");
  250. }
  251. csi_dsp_destroy_task(vi_task);
  252. }
  253. TEST(DspViEnhanceProcessTest,Vipre2Dsp2CpuProcessTestWithDmaBuf)
  254. {
  255. void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_SW);
  256. if(!vi_task)
  257. {
  258. FAIL_TEST("task create fail\n");
  259. }
  260. if(csi_dsp_create_reporter(instance))
  261. {
  262. FAIL_TEST("reporter create fail\n");
  263. }
  264. struct csi_dsp_task_fe_para config_params;
  265. config_params.frontend_type = CSI_DSP_FE_TYPE_VIPRE;
  266. config_params.task_id = -1;
  267. config_params.vipre_param.act_channel= 1;
  268. config_params.vipre_param.hor=640;
  269. config_params.vipre_param.ver=480;
  270. config_params.vipre_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
  271. config_params.vipre_param.line_num=0;
  272. config_params.vipre_param.line_stride=640*2;
  273. config_params.vipre_param.buffer_size=640*2*16*2;
  274. config_params.vipre_param.buffer_num =1;
  275. config_params.vipre_param.buffer_addr[0]=0xb0000000;
  276. if(csi_dsp_task_config_frontend(vi_task,&config_params))
  277. {
  278. FAIL_TEST("vipre config fail\n");
  279. }
  280. int i,j;
  281. struct csi_dsp_task_be_para * host_config;
  282. VmemParams params;
  283. host_config = (struct csi_dsp_task_be_para *)malloc(sizeof(struct csi_dsp_task_be_para)+3*sizeof(struct csi_dsp_buffer));
  284. int width = 640;
  285. int stride = 640;
  286. int height = 1280;
  287. host_config->backend_type = CSI_DSP_BE_TYPE_HOST;
  288. host_config->task_id = -1;
  289. host_config->sw_param.num_buf = 3;
  290. for(int i=0;i<host_config->sw_param.num_buf ;i++)
  291. {
  292. host_config->sw_param.bufs[i].buf_id = i;
  293. host_config->sw_param.bufs[i].dir = CSI_DSP_BUFFER_OUT;
  294. host_config->sw_param.bufs[i].type = CSI_DSP_BUF_TYPE_DMA_BUF_IMPORT;
  295. host_config->sw_param.bufs[i].plane_count = 1;
  296. host_config->sw_param.bufs[i].width =width;
  297. host_config->sw_param.bufs[i].height =height;
  298. for(j=0;j<host_config->sw_param.bufs[i].plane_count;j++)
  299. {
  300. params.size = stride*height;
  301. params.flags = VMEM_FLAG_CONTIGUOUS;
  302. if(reqDmaBuffer(&params))
  303. {
  304. FAIL_TEST("req dma buf fail\n");
  305. }
  306. host_config->sw_param.bufs[i].planes[j].stride= stride;
  307. host_config->sw_param.bufs[i].planes[j].size= params.size;
  308. host_config->sw_param.bufs[i].planes[j].fd = params.fd;
  309. }
  310. if(csi_dsp_task_create_buffer(vi_task,&host_config->sw_param.bufs[i]))
  311. {
  312. FAIL_TEST("create buf fail\n");
  313. }
  314. }
  315. if(csi_dsp_task_config_backend(vi_task,host_config))
  316. {
  317. free(host_config);
  318. FAIL_TEST("post-isp config fail\n");
  319. }
  320. struct csi_dsp_algo_config_par alog_config={
  321. .algo_id=0,
  322. .sett_ptr =NULL,
  323. .sett_length =0,
  324. };
  325. if(csi_dsp_task_config_algo(vi_task,&alog_config))
  326. {
  327. FAIL_TEST("algo kernel config fail\n");
  328. }
  329. if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
  330. {
  331. FAIL_TEST("algo kernel start fail\n");
  332. }
  333. if(csi_dsp_task_start(vi_task))
  334. {
  335. FAIL_TEST("task start fail\n");
  336. }
  337. if(csi_dsp_task_stop(vi_task))
  338. {
  339. FAIL_TEST("task stop fail\n");
  340. }
  341. for(int i=0;i<host_config->sw_param.num_buf;i++)
  342. {
  343. if(csi_dsp_task_free_buffer(vi_task,&host_config->sw_param.bufs[i]))
  344. {
  345. FAIL_TEST("Dma buffer free fail\n");
  346. }
  347. params.phy_address = host_config->sw_param.bufs[i].planes[0].buf_phy;
  348. releaseDmaBuffer(&params);
  349. }
  350. free(host_config);
  351. if(csi_dsp_ps_task_unregister_cb(vi_task))
  352. {
  353. FAIL_TEST("unregister_cb fail\n");
  354. }
  355. if(csi_dsp_destroy_reporter(instance))
  356. {
  357. FAIL_TEST("reporter destroy fail\n");
  358. }
  359. csi_dsp_destroy_task(vi_task);
  360. }
  361. // int main(int argc, char *argv[])
  362. // {
  363. // printf("Dsp Post Process Test Start !\n");
  364. // void *instance = csi_dsp_create_instance(0);
  365. // if(!instance)
  366. // {
  367. // printf("create fail\n");
  368. // return -1;
  369. // }
  370. // void *task= csi_dsp_create_task(instance,CSI_DSP_TASK_SW_TO_SW);
  371. // if(!task)
  372. // {
  373. // printf("task create fail\n");
  374. // return -1;
  375. // }
  376. // struct csi_dsp_algo_config_par alog_config={
  377. // .algo_id=0,
  378. // };
  379. // if(csi_dsp_task_config_algo(task,&alog_config))
  380. // {
  381. // printf("algo kernel config fail\n");
  382. // return -1;
  383. // }
  384. // struct csi_sw_task_req* req=NULL;
  385. // req =csi_dsp_task_create_request(task);
  386. // if(req==NULL)
  387. // {
  388. // printf("req create fail\n");
  389. // return -1;
  390. // }
  391. // struct csi_dsp_buffer buf1 =
  392. // {
  393. // .buf_id = 0,
  394. // .dir = CSI_DSP_BUFFER_IN,
  395. // .type = CSI_DSP_BUF_ALLOC_DRV,
  396. // .plane_count = 1,
  397. // .width =640,
  398. // .height =480,
  399. // .planes[0].stride= 640,
  400. // .planes[0].size= 604*480,
  401. // };
  402. // if(csi_dsp_request_add_buffer(req,&buf1))
  403. // {
  404. // printf("%s,add buffer:%d\n",__FUNCTION__,buf1.buf_id);
  405. // csi_dsp_task_release_request(req);
  406. // return -1;
  407. // }
  408. // int i=0;
  409. // for(i=0;i<buf1.planes[0].size/4;i++)
  410. // {
  411. // ((int *)(buf1.planes[0].buf_vir))[i]=rand();
  412. // }
  413. // struct csi_dsp_buffer buf2 =
  414. // {
  415. // .buf_id = 1,
  416. // .dir = CSI_DSP_BUFFER_OUT,
  417. // .type = CSI_DSP_BUF_ALLOC_DRV,
  418. // .plane_count = 1,
  419. // .width =640,
  420. // .height =480,
  421. // .planes[0].stride= 640,
  422. // .planes[0].size= 604*480,
  423. // };
  424. // if(csi_dsp_request_add_buffer(req,&buf2))
  425. // {
  426. // printf("%s,add buffer:%d\n",__FUNCTION__,buf1.buf_id);
  427. // csi_dsp_task_release_request(req);
  428. // return -1;
  429. // }
  430. // if(csi_dsp_request_enqueue(req))
  431. // {
  432. // printf("%s,req enqueu fail:%d\n",__FUNCTION__);
  433. // csi_dsp_task_release_request(req);
  434. // return -1;
  435. // }
  436. // req = csi_dsp_request_dequeue(task);
  437. // if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
  438. // {
  439. // printf("%s,req dequeue fail:%d\n",__FUNCTION__);
  440. // return -1;
  441. // }
  442. // if(memcmp((void*)buf1.planes[0].buf_vir,(void *)buf2.planes[0].buf_vir,buf1.planes[0].size))
  443. // {
  444. // printf("%s,cmp fail\n",__FUNCTION__);
  445. // csi_dsp_task_release_request(req);
  446. // csi_dsp_destroy_task(task);
  447. // csi_dsp_delete_instance(instance);
  448. // return -1;
  449. // }
  450. // csi_dsp_task_release_request(req);
  451. // csi_dsp_destroy_task(task);
  452. // csi_dsp_delete_instance(instance);
  453. // printf("%s,Test Pass!\n",__FUNCTION__);
  454. // return 0;
  455. // }