t-head/xtensa_dsp
1
0
Fork 0
mirror of https://github.com/thead-yocto-mirror/xtensa_dsp synced 2026-06-21 17:22:27 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
develop
xtensa_dsp/test/drv_test/test_vi_enhance_process.cpp
thead_admin 0e6887d7aa Linux_SDK_V1.1.2
2023-03-05 22:30:03 +08:00

559 lines
13 KiB
C++
Raw Permalink Blame History

#include <stdio.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "csi_dsp_api.h"
#include "csi_dsp_task_defs.h"
#include "csi_dsp_post_process_defs.h"
#include "CppUTest/TestHarness.h"
#include "CppUTest/CommandLineTestRunner.h"
#ifdef __cplusplus
extern "C" {
#endif
#include "video_mem.h"
#ifdef __cplusplus
}
#endif
TEST_GROUP(DspViEnhanceProcessTest)
{
void setup()
{
instance = csi_dsp_create_instance(0);
if(!instance)
{
FAIL_TEST("create fail\n");
}
if( VMEM_create(&mem_allocor) <0)
{
FAIL_TEST("open mem_alloc_fd fail\n");
}
}
void teardown()
{
// csi_dsp_destroy_task(task);
csi_dsp_delete_instance(instance);
VMEM_destroy(mem_allocor);
}
int reqDmaBuffer(VmemParams *params)
{
if(VMEM_allocate(mem_allocor, params))
{
return -1;
}
printf("%s,alloct dma buf @ phy:%lx\n",__FUNCTION__,params->phy_address);
if(VMEM_export(mem_allocor,params))
{
return -1;
}
printf("%s,export dma buf @fd:%x\n",__FUNCTION__,params->fd);
return 0;
}
int releaseDmaBuffer(VmemParams *params)
{
VMEM_free(mem_allocor, params);
}
void *instance;
void *mem_allocor;
// void *task;
};
TEST(DspViEnhanceProcessTest,Isp2Dsp2RyProcessTestBasic)
{
void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_HW);
if(!vi_task)
{
FAIL_TEST("task create fail\n");
}
if(csi_dsp_create_reporter(instance))
{
FAIL_TEST("reporter create fail\n");
}
struct csi_dsp_task_fe_para config_params;
if(csi_dsp_task_get_frontend(vi_task,&config_params))
{
FAIL_TEST("get isp config fail\n");
}
config_params.frontend_type = CSI_DSP_FE_TYPE_ISP;
config_params.task_id = -1;
config_params.isp_param.id=0;
config_params.isp_param.hor=640;
config_params.isp_param.ver=480;
config_params.isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
config_params.isp_param.line_in_entry=640*2;
config_params.isp_param.line_stride=640*2;
config_params.isp_param.buffer_size=640*2*16*2;
config_params.isp_param.buffer_addr=0xb0000000;
if(csi_dsp_task_config_frontend(vi_task,&config_params))
{
FAIL_TEST("isp config fail\n");
}
struct csi_dsp_task_be_para post_config;
if(csi_dsp_task_get_backend(vi_task,&post_config))
{
FAIL_TEST("get post-isp config fail\n");
}
post_config.backend_type = CSI_DSP_BE_TYPE_POST_ISP;
post_config.task_id = -1;
post_config.post_isp_param.id=0;
post_config.post_isp_param.hor=640;
post_config.post_isp_param.ver=480;
post_config.post_isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
post_config.post_isp_param.line_in_entry=640*2;
post_config.post_isp_param.line_stride=640*2;
post_config.post_isp_param.buffer_size=640*2*16*2;
post_config.post_isp_param.buffer_addr=0xb0000000;
if(csi_dsp_task_config_backend(vi_task,&post_config))
{
FAIL_TEST("post-isp config fail\n");
}
struct csi_dsp_algo_config_par alog_config={
.algo_id=0,
.sett_ptr =NULL,
.sett_length =0,
};
if(csi_dsp_task_config_algo(vi_task,&alog_config))
{
FAIL_TEST("algo kernel config fail\n");
}
if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
{
FAIL_TEST("algo kernel start fail\n");
}
if(csi_dsp_task_start(vi_task))
{
FAIL_TEST("task start fail\n");
}
if(csi_dsp_task_stop(vi_task))
{
FAIL_TEST("task stop fail\n");
}
if(csi_dsp_ps_task_unregister_cb(vi_task))
{
FAIL_TEST("unregister_cb fail\n");
}
if(csi_dsp_destroy_reporter(instance))
{
FAIL_TEST("reporter destroy fail\n");
}
csi_dsp_destroy_task(vi_task);
}
TEST(DspViEnhanceProcessTest,Isp2Dsp2RyProcessTestWithPorperty)
{
void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_HW);
if(!vi_task)
{
FAIL_TEST("task create fail\n");
}
if(csi_dsp_create_reporter(instance))
{
FAIL_TEST("reporter create fail\n");
}
struct csi_dsp_task_fe_para config_params;
config_params.frontend_type = CSI_DSP_FE_TYPE_ISP;
config_params.task_id = -1;
config_params.isp_param.id=0;
config_params.isp_param.hor=640;
config_params.isp_param.ver=480;
config_params.isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
config_params.isp_param.line_in_entry=640*2;
config_params.isp_param.line_stride=640*2;
config_params.isp_param.buffer_size=640*2*16*2;
config_params.isp_param.buffer_addr=0xb0000000;
if(csi_dsp_task_config_frontend(vi_task,&config_params))
{
FAIL_TEST("isp config fail\n");
}
struct csi_dsp_task_be_para post_config;
post_config.backend_type = CSI_DSP_BE_TYPE_POST_ISP;
post_config.task_id = -1;
post_config.post_isp_param.id=0;
post_config.post_isp_param.hor=640;
post_config.post_isp_param.ver=480;
post_config.post_isp_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
post_config.post_isp_param.line_in_entry=640*2;
post_config.post_isp_param.line_stride=640*2;
post_config.post_isp_param.buffer_size=640*2*16*2;
post_config.post_isp_param.buffer_addr=0xb0000000;
if(csi_dsp_task_config_backend(vi_task,&post_config))
{
FAIL_TEST("post-isp config fail\n");
}
struct algo_property{
uint32_t width;
uint32_t height;
};
struct algo_property sett {
.width = 640,
.height = 480,
};
struct csi_dsp_algo_config_par alog_config={
.algo_id=0,
.sett_ptr =(uint64_t)&sett,
.sett_length =sizeof(struct algo_property),
};
if(csi_dsp_task_config_algo(vi_task,&alog_config))
{
FAIL_TEST("algo kernel config fail\n");
}
if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
{
FAIL_TEST("register_cb fail\n");
}
if(csi_dsp_task_start(vi_task))
{
FAIL_TEST("task start fail\n");
}
if(csi_dsp_task_stop(vi_task))
{
FAIL_TEST("task stop fail\n");
}
if(csi_dsp_ps_task_unregister_cb(vi_task))
{
FAIL_TEST("unregister_cb fail\n");
}
if(csi_dsp_destroy_reporter(instance))
{
FAIL_TEST("reporter destroy fail\n");
}
csi_dsp_destroy_task(vi_task);
}
TEST(DspViEnhanceProcessTest,Isp2Dsp2RyProcessMini)
{
void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_HW);
if(!vi_task)
{
FAIL_TEST("task create fail\n");
}
if(csi_dsp_create_reporter(instance))
{
FAIL_TEST("reporter create fail\n");
}
struct algo_property{
uint32_t width;
uint32_t height;
};
struct algo_property sett {
.width = 1280,
.height = 960,
};
struct csi_dsp_algo_config_par alog_config={
.algo_id=0,
.sett_ptr =(uint64_t)&sett,
.sett_length =sizeof(struct algo_property),
};
if(csi_dsp_task_config_algo(vi_task,&alog_config))
{
FAIL_TEST("algo kernel config fail\n");
}
if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
{
FAIL_TEST("register_cb fail\n");
}
if(csi_dsp_ps_task_unregister_cb(vi_task))
{
FAIL_TEST("unregister_cb fail\n");
}
if(csi_dsp_destroy_reporter(instance))
{
FAIL_TEST("reporter destroy fail\n");
}
csi_dsp_destroy_task(vi_task);
}
TEST(DspViEnhanceProcessTest,Vipre2Dsp2CpuProcessTestWithDmaBuf)
{
void *vi_task= csi_dsp_create_task(instance,CSI_DSP_TASK_HW_TO_SW);
if(!vi_task)
{
FAIL_TEST("task create fail\n");
}
if(csi_dsp_create_reporter(instance))
{
FAIL_TEST("reporter create fail\n");
}
struct csi_dsp_task_fe_para config_params;
config_params.frontend_type = CSI_DSP_FE_TYPE_VIPRE;
config_params.task_id = -1;
config_params.vipre_param.act_channel= 1;
config_params.vipre_param.hor=640;
config_params.vipre_param.ver=480;
config_params.vipre_param.data_fmt=CSI_DSP_IMG_FMT_RAW12_ALGIN;
config_params.vipre_param.line_num=0;
config_params.vipre_param.line_stride=640*2;
config_params.vipre_param.buffer_size=640*2*16*2;
config_params.vipre_param.buffer_num =1;
config_params.vipre_param.buffer_addr[0]=0xb0000000;
if(csi_dsp_task_config_frontend(vi_task,&config_params))
{
FAIL_TEST("vipre config fail\n");
}
int i,j;
struct csi_dsp_task_be_para * host_config;
VmemParams params;
host_config = (struct csi_dsp_task_be_para *)malloc(sizeof(struct csi_dsp_task_be_para)+3*sizeof(struct csi_dsp_buffer));
int width = 640;
int stride = 640;
int height = 1280;
host_config->backend_type = CSI_DSP_BE_TYPE_HOST;
host_config->task_id = -1;
host_config->sw_param.num_buf = 3;
for(int i=0;i<host_config->sw_param.num_buf ;i++)
{
host_config->sw_param.bufs[i].buf_id = i;
host_config->sw_param.bufs[i].dir = CSI_DSP_BUFFER_OUT;
host_config->sw_param.bufs[i].type = CSI_DSP_BUF_TYPE_DMA_BUF_IMPORT;
host_config->sw_param.bufs[i].plane_count = 1;
host_config->sw_param.bufs[i].width =width;
host_config->sw_param.bufs[i].height =height;
for(j=0;j<host_config->sw_param.bufs[i].plane_count;j++)
{
params.size = stride*height;
params.flags = VMEM_FLAG_CONTIGUOUS;
if(reqDmaBuffer(&params))
{
FAIL_TEST("req dma buf fail\n");
}
host_config->sw_param.bufs[i].planes[j].stride= stride;
host_config->sw_param.bufs[i].planes[j].size= params.size;
host_config->sw_param.bufs[i].planes[j].fd = params.fd;
}
if(csi_dsp_task_create_buffer(vi_task,&host_config->sw_param.bufs[i]))
{
FAIL_TEST("create buf fail\n");
}
}
if(csi_dsp_task_config_backend(vi_task,host_config))
{
free(host_config);
FAIL_TEST("post-isp config fail\n");
}
struct csi_dsp_algo_config_par alog_config={
.algo_id=0,
.sett_ptr =NULL,
.sett_length =0,
};
if(csi_dsp_task_config_algo(vi_task,&alog_config))
{
FAIL_TEST("algo kernel config fail\n");
}
if(csi_dsp_task_register_cb(vi_task,NULL,NULL,32))
{
FAIL_TEST("algo kernel start fail\n");
}
if(csi_dsp_task_start(vi_task))
{
FAIL_TEST("task start fail\n");
}
if(csi_dsp_task_stop(vi_task))
{
FAIL_TEST("task stop fail\n");
}
for(int i=0;i<host_config->sw_param.num_buf;i++)
{
if(csi_dsp_task_free_buffer(vi_task,&host_config->sw_param.bufs[i]))
{
FAIL_TEST("Dma buffer free fail\n");
}
params.phy_address = host_config->sw_param.bufs[i].planes[0].buf_phy;
releaseDmaBuffer(&params);
}
free(host_config);
if(csi_dsp_ps_task_unregister_cb(vi_task))
{
FAIL_TEST("unregister_cb fail\n");
}
if(csi_dsp_destroy_reporter(instance))
{
FAIL_TEST("reporter destroy fail\n");
}
csi_dsp_destroy_task(vi_task);
}
// int main(int argc, char *argv[])
// {
// printf("Dsp Post Process Test Start !\n");
// void *instance = csi_dsp_create_instance(0);
// if(!instance)
// {
// printf("create fail\n");
// return -1;
// }
// void *task= csi_dsp_create_task(instance,CSI_DSP_TASK_SW_TO_SW);
// if(!task)
// {
// printf("task create fail\n");
// return -1;
// }
// struct csi_dsp_algo_config_par alog_config={
// .algo_id=0,
// };
// if(csi_dsp_task_config_algo(task,&alog_config))
// {
// printf("algo kernel config fail\n");
// return -1;
// }
// struct csi_sw_task_req* req=NULL;
// req =csi_dsp_task_create_request(task);
// if(req==NULL)
// {
// printf("req create fail\n");
// return -1;
// }
// struct csi_dsp_buffer buf1 =
// {
// .buf_id = 0,
// .dir = CSI_DSP_BUFFER_IN,
// .type = CSI_DSP_BUF_ALLOC_DRV,
// .plane_count = 1,
// .width =640,
// .height =480,
// .planes[0].stride= 640,
// .planes[0].size= 604*480,
// };
// if(csi_dsp_request_add_buffer(req,&buf1))
// {
// printf("%s,add buffer:%d\n",__FUNCTION__,buf1.buf_id);
// csi_dsp_task_release_request(req);
// return -1;
// }
// int i=0;
// for(i=0;i<buf1.planes[0].size/4;i++)
// {
// ((int *)(buf1.planes[0].buf_vir))[i]=rand();
// }
// struct csi_dsp_buffer buf2 =
// {
// .buf_id = 1,
// .dir = CSI_DSP_BUFFER_OUT,
// .type = CSI_DSP_BUF_ALLOC_DRV,
// .plane_count = 1,
// .width =640,
// .height =480,
// .planes[0].stride= 640,
// .planes[0].size= 604*480,
// };
// if(csi_dsp_request_add_buffer(req,&buf2))
// {
// printf("%s,add buffer:%d\n",__FUNCTION__,buf1.buf_id);
// csi_dsp_task_release_request(req);
// return -1;
// }
// if(csi_dsp_request_enqueue(req))
// {
// printf("%s,req enqueu fail:%d\n",__FUNCTION__);
// csi_dsp_task_release_request(req);
// return -1;
// }
// req = csi_dsp_request_dequeue(task);
// if(req==NULL && req->status != CSI_DSP_SW_REQ_DONE)
// {
// printf("%s,req dequeue fail:%d\n",__FUNCTION__);
// return -1;
// }
// if(memcmp((void*)buf1.planes[0].buf_vir,(void *)buf2.planes[0].buf_vir,buf1.planes[0].size))
// {
// printf("%s,cmp fail\n",__FUNCTION__);
// csi_dsp_task_release_request(req);
// csi_dsp_destroy_task(task);
// csi_dsp_delete_instance(instance);
// return -1;
// }
// csi_dsp_task_release_request(req);
// csi_dsp_destroy_task(task);
// csi_dsp_delete_instance(instance);
// printf("%s,Test Pass!\n",__FUNCTION__);
// return 0;
// }
Reference in New Issue View Git Blame Copy Permalink