lai/hisi_SS524V100_SDK
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
fdff2918c316fe57c85696a22fd60f629ed798f8
hisi_SS524V100_SDK/mpp/tools/vpss_chn_dump.c
T

815 lines
25 KiB
C
Raw Blame History

/*
Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
*/
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include "ot_math.h"
#include "ot_buffer.h"
#include "securec.h"
#include "ot_common.h"
#include "ot_common_video.h"
#include "ot_common_sys.h"
#include "ot_common_vb.h"
#include "ss_mpi_sys.h"
#include "ss_mpi_vb.h"
#include "ss_mpi_vgs.h"
#include "ot_common_vpss.h"
#include "ss_mpi_vpss.h"
#define MAX_FRM_WIDTH 20480
#define FILE_NAME_LENGTH 128
#define PIXEL_FORMAT_STRING_LEN 10
#define GET_CHN_FRAME_TIMEOUT 50000
/* set VPSS_GET_CHN_FRAME_CONTINUOUSLY to 1 to get continuous frame */
#define VPSS_GET_CHN_FRAME_CONTINUOUSLY 0
/* set the value of VPSS_GET_CHN_FRAME_NUM according to how many frames you need to dump */
#define VPSS_GET_CHN_FRAME_NUM 40
typedef struct {
ot_vb_blk vb_blk;
ot_vb_pool vb_pool;
td_phys_addr_t phys_addr;
td_void *virt_addr;
} vpss_dump_mem;
static td_u32 g_vpss_depth_flag = 0;
static td_u32 g_signal_flag = 0;
static ot_vpss_grp g_vpss_grp = 0;
static ot_vpss_chn g_vpss_chn = 0;
static td_u32 g_orig_depth = 0;
static ot_vpss_chn_mode g_orig_chn_mode = OT_VPSS_CHN_MODE_AUTO;
static ot_video_frame_info g_frame;
static ot_video_frame_info g_multi_frame[VPSS_GET_CHN_FRAME_NUM];
static ot_vb_pool g_pool = OT_VB_INVALID_POOL_ID;
static vpss_dump_mem g_dump_mem = { 0 };
static ot_vgs_handle g_handle = -1;
static td_u32 g_blk_size = 0;
static td_char *g_user_page_addr[2] = { TD_NULL, TD_NULL }; /* 2 Y and C */
static td_u32 g_size = 0;
static td_u32 g_c_size = 0;
static FILE *g_pfd = TD_NULL;
static td_void vpss_chn_dump_covert_chroma_sp42x_to_planar(const ot_video_frame *frame, FILE *fd,
td_u32 uv_height, td_bool is_uv_invert)
{
/* If this value is too small and the image is big, this memory may not be enough */
static unsigned char tmp_buf[MAX_FRM_WIDTH];
char *mem_content = TD_NULL;
char *virt_addr_c = TD_NULL;
td_u32 w, h;
td_phys_addr_t phys_addr;
phys_addr = frame->phys_addr[1];
g_user_page_addr[1] = (td_char *)ss_mpi_sys_mmap(phys_addr, g_c_size);
if (g_user_page_addr[1] == TD_NULL) {
printf("mmap chroma data error!!!\n");
return;
}
virt_addr_c = g_user_page_addr[1];
fflush(fd);
/* save U */
fprintf(stderr, "U......");
fflush(stderr);
for (h = 0; h < uv_height; h++) {
mem_content = virt_addr_c + h * frame->stride[1];
if (!is_uv_invert) {
mem_content += 1;
}
for (w = 0; w < frame->width / 2; w++) { /* 2 chroma width */
tmp_buf[w] = *mem_content;
mem_content += 2; /* 2 semiplanar steps */
}
fwrite(tmp_buf, frame->width / 2, 1, fd); /* 2 chroma width */
}
fflush(fd);
/* save V */
fprintf(stderr, "V......");
fflush(stderr);
for (h = 0; h < uv_height; h++) {
mem_content = virt_addr_c + h * frame->stride[1];
if (is_uv_invert) {
mem_content += 1;
}
for (w = 0; w < frame->width / 2; w++) { /* 2 chroma width */
tmp_buf[w] = *mem_content;
mem_content += 2; /* 2 semiplanar steps */
}
fwrite(tmp_buf, frame->width / 2, 1, fd); /* 2 chroma width */
}
fflush(fd);
if (g_user_page_addr[1] != TD_NULL) {
ss_mpi_sys_munmap(g_user_page_addr[1], g_c_size);
g_user_page_addr[1] = TD_NULL;
}
}
/* When saving a file, sp420 will be denoted by p420 and sp422 will be denoted by p422 in the name of the file */
static td_void sample_yuv_8bit_dump(const ot_video_frame *frame, FILE *fd)
{
unsigned int h;
char *virt_addr_y = TD_NULL;
char *mem_content = TD_NULL;
td_phys_addr_t phys_addr;
ot_pixel_format pixel_format = frame->pixel_format;
/* When the storage format is a planar format, this variable is used to keep the height of the UV component */
td_u32 uv_height = 0;
td_bool is_uv_invert = (pixel_format == OT_PIXEL_FORMAT_YUV_SEMIPLANAR_420 ||
pixel_format == OT_PIXEL_FORMAT_YUV_SEMIPLANAR_422) ? TD_TRUE : TD_FALSE;
g_size = (frame->stride[0]) * (frame->height);
if (pixel_format == OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420 || pixel_format == OT_PIXEL_FORMAT_YUV_SEMIPLANAR_420) {
g_c_size = (frame->stride[1]) * (frame->height) / 2; /* 2 uv height */
uv_height = frame->height / 2; /* 2 uv height */
} else if (pixel_format == OT_PIXEL_FORMAT_YVU_SEMIPLANAR_422 ||
pixel_format == OT_PIXEL_FORMAT_YUV_SEMIPLANAR_422) {
g_c_size = (frame->stride[1]) * (frame->height);
uv_height = frame->height;
} else if (pixel_format == OT_PIXEL_FORMAT_YUV_400) {
g_c_size = 0;
uv_height = frame->height;
}
phys_addr = frame->phys_addr[0];
g_user_page_addr[0] = (td_char *)ss_mpi_sys_mmap(phys_addr, g_size);
if (g_user_page_addr[0] == TD_NULL) {
return;
}
virt_addr_y = g_user_page_addr[0];
/* save Y */
fprintf(stderr, "saving......Y......");
fflush(stderr);
for (h = 0; h < frame->height; h++) {
mem_content = virt_addr_y + h * frame->stride[0];
fwrite(mem_content, frame->width, 1, fd);
}
fflush(fd);
if (pixel_format != OT_PIXEL_FORMAT_YUV_400) {
vpss_chn_dump_covert_chroma_sp42x_to_planar(frame, fd, uv_height, is_uv_invert);
}
fprintf(stderr, "done %d!\n", frame->time_ref);
fflush(stderr);
ss_mpi_sys_munmap(g_user_page_addr[0], g_size);
g_user_page_addr[0] = NULL;
}
static td_void vpss_restore_depth(ot_vpss_grp vpss_grp, ot_vpss_chn vpss_chn)
{
td_s32 ret;
ot_vpss_chn_attr chn_attr;
ot_vpss_ext_chn_attr ext_chn_attr;
if (vpss_chn >= OT_VPSS_MAX_PHYS_CHN_NUM) {
ret = ss_mpi_vpss_get_ext_chn_attr(vpss_grp, vpss_chn, &ext_chn_attr);
if (ret != TD_SUCCESS) {
printf("get ext chn attr error!!!\n");
}
ext_chn_attr.depth = g_orig_depth;
ret = ss_mpi_vpss_set_ext_chn_attr(vpss_grp, vpss_chn, &ext_chn_attr);
if (ret != TD_SUCCESS) {
printf("set ext chn attr error!!!\n");
}
} else {
ret = ss_mpi_vpss_get_chn_attr(vpss_grp, vpss_chn, &chn_attr);
if (ret != TD_SUCCESS) {
printf("get chn attr error!!!\n");
}
chn_attr.depth = g_orig_depth;
chn_attr.chn_mode = g_orig_chn_mode;
ret = ss_mpi_vpss_set_chn_attr(vpss_grp, vpss_chn, &chn_attr);
if (ret != TD_SUCCESS) {
printf("set chn attr error!!!\n");
}
}
}
static td_void vpss_restore(ot_vpss_grp vpss_grp, ot_vpss_chn vpss_chn)
{
td_s32 ret;
if (g_frame.pool_id != OT_VB_INVALID_POOL_ID) {
ret = ss_mpi_vpss_release_chn_frame(vpss_grp, vpss_chn, &g_frame);
if (ret != TD_SUCCESS) {
printf("Release Chn Frame error!!!\n");
}
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
}
if (g_handle != -1) {
ss_mpi_vgs_cancel_job(g_handle);
g_handle = -1;
}
if (g_dump_mem.vb_pool != OT_VB_INVALID_POOL_ID) {
ss_mpi_vb_release_blk(g_dump_mem.vb_blk);
g_dump_mem.vb_pool = OT_VB_INVALID_POOL_ID;
}
if (g_pool != OT_VB_INVALID_POOL_ID) {
ss_mpi_vb_destroy_pool(g_pool);
g_pool = OT_VB_INVALID_POOL_ID;
}
if (g_user_page_addr[0] != TD_NULL) {
ss_mpi_sys_munmap(g_user_page_addr[0], g_size);
g_user_page_addr[0] = TD_NULL;
}
if (g_user_page_addr[1] != TD_NULL) {
ss_mpi_sys_munmap(g_user_page_addr[1], g_size);
g_user_page_addr[1] = TD_NULL;
}
if (g_pfd != TD_NULL) {
fclose(g_pfd);
g_pfd = TD_NULL;
}
if (g_vpss_depth_flag) {
vpss_restore_depth(vpss_grp, vpss_chn);
g_vpss_depth_flag = 0;
}
return;
}
static void vpss_chn_dump_handle_sig(int signo)
{
if (g_signal_flag) {
return;
}
if (signo == SIGINT || signo == SIGTERM) {
g_signal_flag = 1;
}
return;
}
static td_s32 vpss_chn_dump_make_yuv_file_name(ot_vpss_grp grp, ot_vpss_chn chn, td_u32 frame_cnt)
{
td_char yuv_name[FILE_NAME_LENGTH];
td_char pixel_str[PIXEL_FORMAT_STRING_LEN];
switch (g_frame.video_frame.pixel_format) {
case OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420:
case OT_PIXEL_FORMAT_YUV_SEMIPLANAR_420:
if (snprintf_s(pixel_str, PIXEL_FORMAT_STRING_LEN, PIXEL_FORMAT_STRING_LEN - 1, "P420") == -1) {
printf("set pixel name fail!\n");
return TD_FAILURE;
}
break;
case OT_PIXEL_FORMAT_YVU_SEMIPLANAR_422:
case OT_PIXEL_FORMAT_YUV_SEMIPLANAR_422:
if (snprintf_s(pixel_str, PIXEL_FORMAT_STRING_LEN, PIXEL_FORMAT_STRING_LEN - 1, "P422") == -1) {
printf("set pixel name fail!\n");
return TD_FAILURE;
}
break;
default:
if (snprintf_s(pixel_str, PIXEL_FORMAT_STRING_LEN, PIXEL_FORMAT_STRING_LEN - 1, "P400") == -1) {
printf("set pixel name fail!\n");
return TD_FAILURE;
}
break;
}
/* make file name */
if (snprintf_s(yuv_name, FILE_NAME_LENGTH, FILE_NAME_LENGTH - 1, "./vpss_grp%d_chn%d_%dx%d_%s_%d.yuv",
grp, chn, g_frame.video_frame.width,
g_frame.video_frame.height, pixel_str, frame_cnt) == -1) {
printf("set out put file name fail!\n");
return TD_FAILURE;
}
printf("Dump YUV frame of vpss chn %d to file: \"%s\"\n", chn, yuv_name);
/* open file */
g_pfd = fopen(yuv_name, "wb");
if (g_pfd == TD_NULL) {
printf("open file failed, errno %d!\n", errno);
return TD_FAILURE;
}
fflush(stdout);
return TD_SUCCESS;
}
static td_void vpss_chn_dump_set_vgs_frame_info(ot_video_frame_info *vgs_frame_info, const vpss_dump_mem *dump_mem,
const ot_vb_calc_cfg *vb_calc_cfg, const ot_video_frame_info *vpss_frame_info)
{
vgs_frame_info->video_frame.phys_addr[0] = dump_mem->phys_addr;
vgs_frame_info->video_frame.phys_addr[1] = vgs_frame_info->video_frame.phys_addr[0] + vb_calc_cfg->main_y_size;
vgs_frame_info->video_frame.width = vpss_frame_info->video_frame.width;
vgs_frame_info->video_frame.height = vpss_frame_info->video_frame.height;
vgs_frame_info->video_frame.stride[0] = vb_calc_cfg->main_stride;
vgs_frame_info->video_frame.stride[1] = vb_calc_cfg->main_stride;
vgs_frame_info->video_frame.compress_mode = OT_COMPRESS_MODE_NONE;
vgs_frame_info->video_frame.pixel_format = vpss_frame_info->video_frame.pixel_format;
vgs_frame_info->video_frame.video_format = OT_VIDEO_FORMAT_LINEAR;
vgs_frame_info->video_frame.dynamic_range = vpss_frame_info->video_frame.dynamic_range;
vgs_frame_info->video_frame.pts = 0;
vgs_frame_info->video_frame.time_ref = 0;
vgs_frame_info->pool_id = dump_mem->vb_pool;
vgs_frame_info->mod_id = OT_ID_VGS;
}
static td_s32 vpss_chn_dump_init_vgs_pool(vpss_dump_mem *dump_mem, ot_vb_calc_cfg *vb_calc_cfg)
{
td_u32 width = g_frame.video_frame.width;
td_u32 height = g_frame.video_frame.height;
ot_pixel_format pixel_format = g_frame.video_frame.pixel_format;
ot_pic_buf_attr buf_attr = {0};
ot_vb_pool_cfg vb_pool_cfg = {0};
buf_attr.width = width;
buf_attr.height = height;
buf_attr.pixel_format = pixel_format;
buf_attr.bit_width = OT_DATA_BIT_WIDTH_8;
buf_attr.compress_mode = OT_COMPRESS_MODE_NONE;
buf_attr.align = 0;
ot_common_get_pic_buf_cfg(&buf_attr, vb_calc_cfg);
g_blk_size = vb_calc_cfg->vb_size;
vb_pool_cfg.blk_size = g_blk_size;
vb_pool_cfg.blk_cnt = 1;
vb_pool_cfg.remap_mode = OT_VB_REMAP_MODE_NONE;
g_pool = ss_mpi_vb_create_pool(&vb_pool_cfg);
if (g_pool == OT_VB_INVALID_POOL_ID) {
printf("OT_MPI_VB_CreatePool failed! \n");
return TD_FAILURE;
}
dump_mem->vb_pool = g_pool;
dump_mem->vb_blk = ss_mpi_vb_get_blk(dump_mem->vb_pool, g_blk_size, TD_NULL);
if (dump_mem->vb_blk == OT_VB_INVALID_HANDLE) {
printf("get vb blk failed!\n");
return TD_FAILURE;
}
dump_mem->phys_addr = ss_mpi_vb_handle_to_phys_addr(dump_mem->vb_blk);
return TD_SUCCESS;
}
static td_s32 vpss_chn_dump_send_vgs_and_dump(const ot_video_frame_info *vpss_frame_info)
{
ot_video_frame_info vgs_frame_info = {0};
ot_vgs_task_attr vgs_task_attr;
ot_vb_calc_cfg vb_calc_cfg = {0};
if (vpss_chn_dump_init_vgs_pool(&g_dump_mem, &vb_calc_cfg) != TD_SUCCESS) {
printf("init vgs pool failed\n");
return TD_FAILURE;
}
vpss_chn_dump_set_vgs_frame_info(&vgs_frame_info, &g_dump_mem, &vb_calc_cfg, vpss_frame_info);
if (ss_mpi_vgs_begin_job(&g_handle) != TD_SUCCESS) {
printf("ss_mpi_vgs_begin_job failed\n");
return TD_FAILURE;
}
if (memcpy_s(&vgs_task_attr.img_in, sizeof(ot_video_frame_info),
vpss_frame_info, sizeof(ot_video_frame_info)) != EOK) {
printf("memcpy_s img_in failed\n");
goto err_exit;
}
if (memcpy_s(&vgs_task_attr.img_out, sizeof(ot_video_frame_info),
&vgs_frame_info, sizeof(ot_video_frame_info)) != EOK) {
printf("memcpy_s img_out failed\n");
goto err_exit;
}
if (ss_mpi_vgs_add_scale_task(g_handle, &vgs_task_attr, OT_VGS_SCALE_COEF_NORM) != TD_SUCCESS) {
printf("ss_mpi_vgs_add_scale_task failed\n");
goto err_exit;
}
if (ss_mpi_vgs_end_job(g_handle) != TD_SUCCESS) {
printf("ss_mpi_vgs_end_job failed\n");
goto err_exit;
}
/* save frame to file */
if (vgs_frame_info.video_frame.dynamic_range == OT_DYNAMIC_RANGE_SDR8) {
sample_yuv_8bit_dump(&vgs_frame_info.video_frame, g_pfd);
} else {
printf("Only support dump 8-bit data!\n");
}
ss_mpi_vb_release_blk(g_dump_mem.vb_blk);
g_dump_mem.vb_pool = OT_VB_INVALID_POOL_ID;
if (g_pool != OT_VB_INVALID_POOL_ID) {
ss_mpi_vb_destroy_pool(g_pool);
g_pool = OT_VB_INVALID_POOL_ID;
}
g_handle = -1;
return TD_SUCCESS;
err_exit:
ss_mpi_vgs_cancel_job(g_handle);
g_handle = -1;
return TD_FAILURE;
}
static td_bool vpss_chn_dump_is_vgs_required(ot_vpss_grp grp, ot_vpss_chn chn)
{
td_s32 ret;
ot_vpss_chn_attr chn_attr;
ot_vpss_ext_chn_attr ext_chn_attr;
if (chn >= OT_VPSS_MAX_PHYS_CHN_NUM) {
/* please don't change vpss ext chn attr when dump frame */
ret = ss_mpi_vpss_get_ext_chn_attr(grp, chn, &ext_chn_attr);
if (ret != TD_SUCCESS) {
printf("get vpss ext chn attr failed!\n");
return TD_FALSE;
}
if ((ext_chn_attr.compress_mode != OT_COMPRESS_MODE_NONE) ||
(ext_chn_attr.video_format != OT_VIDEO_FORMAT_LINEAR)) {
return TD_TRUE;
} else {
return TD_FALSE;
}
} else {
/* please don't change vpss chn attr when dump frame */
ret = ss_mpi_vpss_get_chn_attr(grp, chn, &chn_attr);
if (ret != TD_SUCCESS) {
printf("get vpss chn attr failed!\n");
return TD_FALSE;
}
if ((chn_attr.compress_mode != OT_COMPRESS_MODE_NONE) || (chn_attr.video_format != OT_VIDEO_FORMAT_LINEAR)) {
return TD_TRUE;
} else {
return TD_FALSE;
}
}
}
static td_bool vpss_chn_dump_is_frame_continuous(td_u32 frame_cnt, td_bool send_to_vgs)
{
if (send_to_vgs == TD_TRUE) {
return TD_FALSE;
}
if (VPSS_GET_CHN_FRAME_CONTINUOUSLY == 0) {
return TD_FALSE;
}
if (frame_cnt > VPSS_GET_CHN_FRAME_NUM) {
printf("VPSS_GET_CHN_FRAME_NUM(%d) is small than frame_cnt(%d), "
"please edit the value of this macro if you want to get frame continuously!\n",
VPSS_GET_CHN_FRAME_NUM, frame_cnt);
return TD_FALSE;
}
return TD_TRUE;
}
static td_s32 vpss_chn_dump_noncontinuous_frame(ot_vpss_grp grp, ot_vpss_chn chn, td_u32 frame_cnt, td_bool send_to_vgs)
{
td_u32 cnt = frame_cnt;
const td_s32 milli_sec = GET_CHN_FRAME_TIMEOUT;
td_s32 ret;
/* get frame */
while (cnt--) {
if (g_signal_flag == 1) {
printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
return TD_FAILURE;
}
if (ss_mpi_vpss_get_chn_frame(grp, chn, &g_frame, milli_sec) != TD_SUCCESS) {
printf("Get frame failed!\n");
usleep(1000); /* 1000 sleep */
continue;
}
if (send_to_vgs) {
if (vpss_chn_dump_send_vgs_and_dump(&g_frame) != TD_SUCCESS) {
ss_mpi_vpss_release_chn_frame(grp, chn, &g_frame);
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
return TD_FAILURE;
}
} else {
if (OT_DYNAMIC_RANGE_SDR8 == g_frame.video_frame.dynamic_range) {
sample_yuv_8bit_dump(&g_frame.video_frame, g_pfd);
} else {
printf("Only support dump 8-bit data!\n");
}
}
printf("Get frame %d\n", cnt);
/* release frame after using */
ret = ss_mpi_vpss_release_chn_frame(grp, chn, &g_frame);
if (ret != TD_SUCCESS) {
printf("Release frame failed, now exit!\n");
return ret;
}
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
}
return TD_SUCCESS;
}
static td_s32 vpss_chn_dump_continuous_frame(ot_vpss_grp grp, ot_vpss_chn chn, td_u32 frame_cnt)
{
td_u32 cnt = frame_cnt;
td_u32 get_frame_cnt = 0;
const td_s32 milli_sec = GET_CHN_FRAME_TIMEOUT;
td_s32 ret;
/* get frame */
while (cnt--) {
if (g_signal_flag == 1) {
printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
return TD_FAILURE;
}
if (ss_mpi_vpss_get_chn_frame(grp, chn, &g_multi_frame[get_frame_cnt], milli_sec) != TD_SUCCESS) {
printf("Get frame failed!\n");
usleep(1000); /* 1000 sleep */
continue;
}
get_frame_cnt++;
}
cnt = 0;
while (cnt < get_frame_cnt) {
if (g_signal_flag == 1) {
printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
return TD_FAILURE;
}
if (OT_DYNAMIC_RANGE_SDR8 == g_multi_frame[cnt].video_frame.dynamic_range) {
sample_yuv_8bit_dump(&g_multi_frame[cnt].video_frame, g_pfd);
} else {
printf("Only support dump 8-bit data!\n");
}
printf("Get frame %d\n", cnt);
/* release frame after using */
ret = ss_mpi_vpss_release_chn_frame(grp, chn, &g_multi_frame[cnt]);
if (ret != TD_SUCCESS) {
printf("Release frame failed, now exit!\n");
return ret;
}
g_multi_frame[cnt].pool_id = OT_VB_INVALID_POOL_ID;
cnt++;
}
return TD_SUCCESS;
}
static td_void vpss_chn_dump_release_multi_frame(ot_vpss_grp grp, ot_vpss_chn chn, td_u32 frame_cnt)
{
td_u32 i;
for (i = 0; i < frame_cnt; i++) {
if (g_multi_frame[i].pool_id != OT_VB_INVALID_POOL_ID) {
(td_void)ss_mpi_vpss_release_chn_frame(grp, chn, &g_multi_frame[i]);
}
}
}
static td_s32 vpss_chn_dump_get_frame(ot_vpss_grp grp, ot_vpss_chn chn, td_u32 frame_cnt)
{
td_s32 ret;
td_bool send_to_vgs = vpss_chn_dump_is_vgs_required(grp, chn);
td_bool get_continuous_frame = vpss_chn_dump_is_frame_continuous(frame_cnt, send_to_vgs);
if (get_continuous_frame == TD_TRUE) {
ret = vpss_chn_dump_continuous_frame(grp, chn, frame_cnt);
if (ret != TD_SUCCESS) {
vpss_chn_dump_release_multi_frame(grp, chn, frame_cnt);
}
} else {
ret = vpss_chn_dump_noncontinuous_frame(grp, chn, frame_cnt, send_to_vgs);
}
return ret;
}
static td_s32 vpss_chn_dump_try_get_frame(ot_vpss_grp grp, ot_vpss_chn chn, td_u32 frame_cnt)
{
const td_s32 milli_sec = GET_CHN_FRAME_TIMEOUT;
td_s32 try_times = 10;
td_s32 ret;
while (ss_mpi_vpss_get_chn_frame(grp, chn, &g_frame, milli_sec) != TD_SUCCESS) {
if (g_signal_flag == 1) {
printf("\033[0;31mprogram termination abnormally!\033[0;39m\n");
return TD_FAILURE;
}
try_times--;
if (try_times <= 0) {
printf("get frame error for 10 times,now exit !!!\n");
return TD_FAILURE;
}
usleep(40000); /* 40000 sleep */
}
if (g_frame.video_frame.video_format != OT_VIDEO_FORMAT_LINEAR) {
printf("only support linear frame dump!\n");
ss_mpi_vpss_release_chn_frame(grp, chn, &g_frame);
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
return TD_FAILURE;
}
if (vpss_chn_dump_make_yuv_file_name(grp, chn, frame_cnt) != TD_SUCCESS) {
ss_mpi_vpss_release_chn_frame(grp, chn, &g_frame);
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
return TD_FAILURE;
}
ret = ss_mpi_vpss_release_chn_frame(grp, chn, &g_frame);
if (ret != TD_SUCCESS) {
printf("Release frame error ,now exit !!!\n");
return TD_FAILURE;
}
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
return TD_SUCCESS;
}
static td_void sample_misc_vpss_dump(ot_vpss_grp grp, ot_vpss_chn chn, td_u32 frame_cnt)
{
const td_u32 depth = 2;
td_s32 ret;
ot_vpss_chn_attr chn_attr;
ot_vpss_ext_chn_attr ext_chn_attr;
if (chn >= OT_VPSS_MAX_PHYS_CHN_NUM) {
ret = ss_mpi_vpss_get_ext_chn_attr(grp, chn, &ext_chn_attr);
if (ret != TD_SUCCESS) {
printf("get ext chn attr error!!!\n");
return;
}
g_orig_depth = ext_chn_attr.depth;
ext_chn_attr.depth = depth;
if (ss_mpi_vpss_set_ext_chn_attr(grp, chn, &ext_chn_attr) != TD_SUCCESS) {
printf("set ext chn attr error!!!\n");
goto exit;
}
} else {
ret = ss_mpi_vpss_get_chn_attr(grp, chn, &chn_attr);
if (ret != TD_SUCCESS) {
printf("get chn attr error!!!\n");
return;
}
g_orig_depth = chn_attr.depth;
g_orig_chn_mode = chn_attr.chn_mode;
chn_attr.depth = depth;
chn_attr.chn_mode = OT_VPSS_CHN_MODE_USER;
if (ss_mpi_vpss_set_chn_attr(grp, chn, &chn_attr) != TD_SUCCESS) {
printf("set chn attr error!!!\n");
goto exit;
}
}
g_vpss_depth_flag = 1;
if (memset_s(&g_frame, sizeof(ot_video_frame_info), 0, sizeof(ot_video_frame_info)) != EOK) {
printf("memset_s frame error!!!\n");
goto exit;
}
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
if (vpss_chn_dump_try_get_frame(grp, chn, frame_cnt) != TD_SUCCESS) {
goto exit;
}
if (vpss_chn_dump_get_frame(grp, chn, frame_cnt) != TD_SUCCESS) {
goto exit;
}
exit:
vpss_restore(grp, chn);
return;
}
static td_void usage(td_void)
{
printf("\n"
"*************************************************\n"
"Usage: ./vpss_chn_dump [VpssGrp] [VpssChn] [FrmCnt]\n"
"1)VpssGrp: \n"
" Vpss group id\n"
"2)VpssChn: \n"
" vpss chn id\n"
"3)FrmCnt: \n"
" the count of frame to be dumped\n"
"*)Example:\n"
" e.g : ./vpss_chn_dump 0 0 1\n"
" e.g : ./vpss_chn_dump 1 4 2\n"
"*)set VPSS_GET_CHN_FRAME_CONTINUOUSLY to 1 to get continuous frame\n"
"*************************************************\n"
"\n");
}
static td_void vpss_chn_dump_init_global_params()
{
g_vpss_depth_flag = 0;
g_signal_flag = 0;
g_user_page_addr[0] = TD_NULL;
g_user_page_addr[1] = TD_NULL;
g_dump_mem.vb_blk = -1;
g_dump_mem.vb_pool = OT_VB_INVALID_POOL_ID;
g_dump_mem.phys_addr = 0;
g_dump_mem.virt_addr = TD_NULL;
g_frame.pool_id = OT_VB_INVALID_POOL_ID;
g_orig_depth = 0;
g_pool = OT_VB_INVALID_POOL_ID;
g_handle = -1;
g_blk_size = 0;
g_size = 0;
g_pfd = TD_NULL;
}
#ifdef __LITEOS__
td_s32 vpss_chn_dump(int argc, char *argv[])
#else
td_s32 main(int argc, char *argv[])
#endif
{
td_s32 frame_cnt;
const td_s32 base = 10;
td_char *end_ptr = TD_NULL;
printf("\nNOTICE: This tool only can be used for TESTING !!!\n");
printf("\tTo see more usage, please enter: ./vpss_chn_dump -h\n\n");
if (((argc > 1) && (strncmp(argv[1], "-h", 2) == 0)) || (argc != 4)) { /* 2: help, 4: args */
goto print_usage;
}
errno = 0;
g_vpss_grp = (td_s32)strtol(argv[1], &end_ptr, base);
if ((errno != 0) || (*end_ptr != '\0')) {
goto print_usage;
}
if (!value_between(g_vpss_grp, 0, OT_VPSS_MAX_GRP_NUM - 1)) {
printf("grp id must be [0,%d]!!!!\n\n", OT_VPSS_MAX_GRP_NUM - 1);
return TD_FAILURE;
}
errno = 0;
g_vpss_chn = (td_s32)strtol(argv[2], &end_ptr, base); /* 2: chn id */
if ((errno != 0) || (*end_ptr != '\0')) {
goto print_usage;
}
if (!value_between(g_vpss_chn, 0, OT_VPSS_MAX_CHN_NUM - 1)) {
printf("chn id must be [0,%d]!!!!\n\n", OT_VPSS_MAX_CHN_NUM - 1);
return TD_FAILURE;
}
errno = 0;
frame_cnt = (td_s32)strtol(argv[3], &end_ptr, base); /* 3: frame count */
if ((errno != 0) || (*end_ptr != '\0')) {
goto print_usage;
}
if (frame_cnt <= 0) {
printf("the frame cnt(%d) is wrong!\n", frame_cnt);
return TD_FAILURE;
}
vpss_chn_dump_init_global_params();
#ifndef __LITEOS__
signal(SIGINT, vpss_chn_dump_handle_sig);
signal(SIGTERM, vpss_chn_dump_handle_sig);
#endif
sample_misc_vpss_dump(g_vpss_grp, g_vpss_chn, (td_u32)frame_cnt);
return TD_SUCCESS;
print_usage:
usage();
return TD_SUCCESS;
}
Reference in New Issue View Git Blame Copy Permalink