test_vi_enhance_process.cpp 13 KB

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