505 lines
16 KiB
C
Executable File
505 lines
16 KiB
C
Executable File
/*
|
|
* Copyright (c) XMEDIA. All rights reserved.
|
|
*/
|
|
#include <sys/mman.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <sys/ioctl.h>
|
|
#include <errno.h>
|
|
|
|
#include "xmedia_vi.h"
|
|
#include "xmedia_mmz.h"
|
|
#include "xmedia_video_common.h"
|
|
|
|
#define MAX_FRAME_CNT 100
|
|
#define MAX_FRAME_WIDTH 3840
|
|
|
|
#define MAX_WAIT_TIME 1000 // 获取帧最长等待时间，单位ms
|
|
|
|
#define RAW_DUMP_DEPTH 2
|
|
|
|
#define FILE_NAME_LEN 256
|
|
|
|
#define r_printf(fmt, ...) \
|
|
do { \
|
|
printf("\e[31m\e[1m [%s]-%d: " fmt "\e[0m", __FUNCTION__, __LINE__, ##__VA_ARGS__); \
|
|
} while (0)
|
|
|
|
xmedia_void vi_bayer_dump_usage(xmedia_void)
|
|
{
|
|
printf("\n"
|
|
"***************************************************************\n"
|
|
"Usage: ./vi_bayer_dump [pipe] [frame_cnt] [ratio_show]\n"
|
|
"pipe: \n"
|
|
" 0 ~ 7: Vi pipe 0 ~ 7, default is 0\n"
|
|
"frame_cnt: \n"
|
|
" The count of frame to be dump, default is 1\n"
|
|
"ratio_show: \n"
|
|
" Whether the file name of raw show ratio info, default is 0\n"
|
|
"e.g: ./vi_bayer_dump 0 1 1\n"
|
|
"***************************************************************\n"
|
|
"\n");
|
|
exit(1);
|
|
}
|
|
|
|
xmedia_s32 get_dump_pipe(xmedia_s32 pipe, xmedia_vi_dev_bind_pipe_attr *dev_bind_pipe)
|
|
{
|
|
xmedia_s32 ret;
|
|
xmedia_s32 dev;
|
|
xmedia_s32 i, j;
|
|
xmedia_bool is_get_dev = XMEDIA_FALSE;
|
|
xmedia_vi_grp_config grp_config;
|
|
xmedia_bool is_wdr_pipe = XMEDIA_FALSE;
|
|
xmedia_vi_dev_bind_pipe_attr dev_bind_pipe_tmp;
|
|
|
|
for (i = 0; i < VI_MAX_DEV_NUM; i++) {
|
|
ret = xmedia_vi_get_pipe_by_dev(i, &dev_bind_pipe_tmp);
|
|
if (ret == XMEDIA_SUCCESS) {
|
|
for (j = 0; j < dev_bind_pipe_tmp.pipe_num; j++) {
|
|
if (pipe == dev_bind_pipe_tmp.pipe_id[j]) {
|
|
dev = i;
|
|
is_get_dev = XMEDIA_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (is_get_dev == XMEDIA_FALSE) {
|
|
r_printf("pipe %d get bind dev failed\n", pipe);
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
memset(dev_bind_pipe, 0, sizeof(xmedia_vi_dev_bind_pipe_attr));
|
|
|
|
ret = xmedia_vi_get_pipe_by_dev(dev, dev_bind_pipe);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
r_printf("xmedia_vi_get_pipe_by_dev failed with 0x%x\n", ret);
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
for (i = 0; i < VI_MAX_GRP_NUM; i++) {
|
|
ret = xmedia_vi_get_grp_config(i, &grp_config);
|
|
if (ret == XMEDIA_SUCCESS) {
|
|
if (grp_config.grp_type == XMEDIA_VI_GRP_TYPE_WDR) {
|
|
for (j = 0; j < VI_MAX_WDR_NUM; j++) {
|
|
if (grp_config.wdr_grp_config.pipe_id[j] == pipe) {
|
|
is_wdr_pipe = XMEDIA_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (is_wdr_pipe == XMEDIA_FALSE) {
|
|
dev_bind_pipe->pipe_num = 1;
|
|
dev_bind_pipe->pipe_id[0] = pipe;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_char *compress_mode_to_string(xmedia_video_compress_mode compress_mode)
|
|
{
|
|
if (compress_mode == XMEDIA_VIDEO_COMPRESS_MODE_NONE) {
|
|
return "cmp_none";
|
|
} else if (compress_mode == XMEDIA_VIDEO_COMPRESS_MODE_LINE) {
|
|
return "cmp_line";
|
|
} else if (compress_mode == XMEDIA_VIDEO_COMPRESS_MODE_SEG) {
|
|
return "cmp_seg";
|
|
} else {
|
|
return "cmp_xxx";
|
|
}
|
|
}
|
|
|
|
xmedia_u32 data_width_to_num(xmedia_video_data_width data_width)
|
|
{
|
|
if (data_width == XMEDIA_VIDEO_DATA_WIDTH_8) {
|
|
return 8;
|
|
} else if (data_width == XMEDIA_VIDEO_DATA_WIDTH_10) {
|
|
return 10;
|
|
} else if (data_width == XMEDIA_VIDEO_DATA_WIDTH_12) {
|
|
return 12;
|
|
} else if (data_width == XMEDIA_VIDEO_DATA_WIDTH_14) {
|
|
return 14;
|
|
} else if (data_width == XMEDIA_VIDEO_DATA_WIDTH_16) {
|
|
return 16;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
xmedia_s32 save_uncompress_raw_to_file(xmedia_video_frame *frame, FILE *fd)
|
|
{
|
|
xmedia_s32 i;
|
|
xmedia_u32 row;
|
|
xmedia_u32 stride;
|
|
xmedia_u64 phy_addr, size;
|
|
xmedia_u8 *data = XMEDIA_NULL;
|
|
xmedia_u8 *data_tmp = XMEDIA_NULL;
|
|
xmedia_u8 *usr_page_addr = XMEDIA_NULL;
|
|
xmedia_u16 *buf_tmp = XMEDIA_NULL;
|
|
xmedia_u32 tmp;
|
|
xmedia_u64 value;
|
|
xmedia_u32 out_cnt;
|
|
|
|
stride = frame->stride.y_stride;
|
|
|
|
size = stride * frame->height;
|
|
|
|
phy_addr = frame->addr.y_phy_addr;
|
|
|
|
usr_page_addr = xmedia_mmz_map(phy_addr, size, XMEDIA_FALSE);
|
|
if (usr_page_addr == XMEDIA_NULL) {
|
|
r_printf("mmz map phy 0x%llx size %llu failed\n", phy_addr, size);
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
if (frame->bit_width != XMEDIA_VIDEO_DATA_WIDTH_8 && frame->bit_width != XMEDIA_VIDEO_DATA_WIDTH_16) {
|
|
buf_tmp = (xmedia_u16 *)malloc(frame->width * 2); // 文件非紧凑排布，10,12,14bits不超两倍
|
|
if (buf_tmp == XMEDIA_NULL) {
|
|
r_printf("malloc failed\n");
|
|
xmedia_mmz_unmap(usr_page_addr);
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
}
|
|
|
|
data = usr_page_addr;
|
|
|
|
printf("saving Y............\n");
|
|
|
|
for (row = 0; row < frame->height; row++) {
|
|
out_cnt = 0;
|
|
if (frame->bit_width == XMEDIA_VIDEO_DATA_WIDTH_8) {
|
|
fwrite(data, frame->width, 1, fd);
|
|
} else if (frame->bit_width == XMEDIA_VIDEO_DATA_WIDTH_16) {
|
|
fwrite(data, frame->width, 2, fd);
|
|
} else if (frame->bit_width == XMEDIA_VIDEO_DATA_WIDTH_10) {
|
|
// 4 pixels consist of 5 bytes
|
|
tmp = frame->width / 4;
|
|
for (i = 0; i < tmp; i++) {
|
|
// byte4 byte3 byte2 byte1 byte0
|
|
data_tmp = data + 5 * i;
|
|
value = data_tmp[0] + ((xmedia_u32)data_tmp[1] << 8) + ((xmedia_u32)data_tmp[2] << 16) +
|
|
((xmedia_u32)data_tmp[3] << 24) + ((xmedia_u64)data_tmp[4] << 32);
|
|
buf_tmp[out_cnt++] = value & 0x3ff;
|
|
buf_tmp[out_cnt++] = (value >> 10) & 0x3ff;
|
|
buf_tmp[out_cnt++] = (value >> 20) & 0x3ff;
|
|
buf_tmp[out_cnt++] = (value >> 30) & 0x3ff;
|
|
}
|
|
fwrite(buf_tmp, frame->width, 2, fd);
|
|
} else if (frame->bit_width == XMEDIA_VIDEO_DATA_WIDTH_12) {
|
|
// 2 pixels consist of 3 bytes
|
|
tmp = frame->width / 2;
|
|
for (i = 0; i < tmp; i++) {
|
|
// byte2 byte1 byte0
|
|
data_tmp = data + 3 * i;
|
|
value = data_tmp[0] + ((xmedia_u32)data_tmp[1] << 8) + ((xmedia_u32)data_tmp[2] << 16);
|
|
buf_tmp[out_cnt++] = value & 0xfff;
|
|
buf_tmp[out_cnt++] = (value >> 12) & 0xfff;
|
|
}
|
|
fwrite(buf_tmp, frame->width, 2, fd);
|
|
} else if (frame->bit_width == XMEDIA_VIDEO_DATA_WIDTH_14) {
|
|
// 4 pixels consist of 7 bytes
|
|
tmp = frame->width / 4;
|
|
for (i = 0; i < tmp; i++) {
|
|
// byte6 byte5 byte4 byte3 byte2 byte1 byte0
|
|
data_tmp = data + 7 * i;
|
|
value = data_tmp[0] + ((xmedia_u32)data_tmp[1] << 8) + ((xmedia_u32)data_tmp[2] << 16) +
|
|
((xmedia_u32)data_tmp[3] << 24) + ((xmedia_u64)data_tmp[4] << 32) +
|
|
((xmedia_u64)data_tmp[5] << 40) + ((xmedia_u64)data_tmp[6] << 48);
|
|
buf_tmp[out_cnt++] = value & 0x3fff;
|
|
buf_tmp[out_cnt++] = (value >> 14) & 0x3fff;
|
|
buf_tmp[out_cnt++] = (value >> 28) & 0x3fff;
|
|
buf_tmp[out_cnt++] = (value >> 42) & 0x3fff;
|
|
}
|
|
fwrite(buf_tmp, frame->width, 2, fd);
|
|
}
|
|
data += frame->stride.y_stride;
|
|
}
|
|
|
|
if (frame->bit_width != XMEDIA_VIDEO_DATA_WIDTH_8 && frame->bit_width != XMEDIA_VIDEO_DATA_WIDTH_16) {
|
|
free(buf_tmp);
|
|
}
|
|
|
|
xmedia_mmz_unmap(usr_page_addr);
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_s32 save_compress_raw_to_file(xmedia_video_frame *frame, FILE *fd)
|
|
{
|
|
// todo
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_s32 save_raw_to_file(xmedia_video_frame *frame, FILE *fd)
|
|
{
|
|
if (frame->compress_mode == XMEDIA_VIDEO_COMPRESS_MODE_NONE) {
|
|
return save_uncompress_raw_to_file(frame, fd);
|
|
} else {
|
|
return save_compress_raw_to_file(frame, fd);
|
|
}
|
|
}
|
|
|
|
xmedia_s32 dump_linear_bayer(xmedia_s32 pipe, xmedia_u32 cnt, xmedia_u32 ratio_show)
|
|
{
|
|
xmedia_s32 i, j;
|
|
xmedia_s32 ret;
|
|
FILE *fd = NULL;
|
|
xmedia_char file_name[FILE_NAME_LEN] = { 0 };
|
|
xmedia_video_frame_info *frame_info = XMEDIA_NULL;
|
|
|
|
frame_info = malloc(sizeof(xmedia_video_frame_info) * cnt);
|
|
if (frame_info == XMEDIA_NULL) {
|
|
r_printf("malloc failed\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
ret = xmedia_vi_acquire_pipe_frame(pipe, &frame_info[i], MAX_WAIT_TIME);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
r_printf("linear: get pipe %d frame failed with 0x%x", pipe, ret);
|
|
r_printf("only get %d frames\n", i);
|
|
break;
|
|
}
|
|
|
|
printf("linear: get pipe %d frame %d ok\n", pipe, i);
|
|
}
|
|
|
|
if (i == 0) {
|
|
free(frame_info);
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
// make file name
|
|
if (ratio_show == 0) {
|
|
snprintf(file_name, FILE_NAME_LEN, "./vi_pipe_%d_%ux%u_%d_%dbits_%s_%d.raw", pipe, frame_info[0].frame.width,
|
|
frame_info[0].frame.height, cnt, data_width_to_num(frame_info[0].frame.bit_width),
|
|
compress_mode_to_string(frame_info[0].frame.compress_mode), ratio_show);
|
|
} else {
|
|
// todo
|
|
snprintf(file_name, FILE_NAME_LEN, "./vi_pipe_%d_%ux%u_%d_%dbits_%s_%d.raw", pipe, frame_info[0].frame.width,
|
|
frame_info[0].frame.height, cnt, data_width_to_num(frame_info[0].frame.bit_width),
|
|
compress_mode_to_string(frame_info[0].frame.compress_mode), ratio_show);
|
|
}
|
|
|
|
fd = fopen(file_name, "wb");
|
|
if (fd == NULL) {
|
|
r_printf("open file faied\n");
|
|
goto failed;
|
|
}
|
|
|
|
// todo，压缩文件，先保存压缩param
|
|
|
|
for (j = 0; j < i; j++) {
|
|
printf("frame %d save start\n", j);
|
|
save_raw_to_file(&frame_info[j].frame, fd);
|
|
printf("frame %d save completed\n", j);
|
|
xmedia_vi_release_pipe_frame(pipe, &frame_info[j]);
|
|
}
|
|
|
|
fclose(fd);
|
|
|
|
free(frame_info);
|
|
|
|
return XMEDIA_SUCCESS;
|
|
|
|
failed:
|
|
for (j = 0; j < i; j++) {
|
|
xmedia_vi_release_pipe_frame(pipe, &frame_info[j]);
|
|
}
|
|
|
|
free(frame_info);
|
|
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
xmedia_s32 dump_wdr_bayer(xmedia_vi_dev_bind_pipe_attr *bind_attr, xmedia_u32 cnt, xmedia_u32 ratio_show)
|
|
{
|
|
xmedia_s32 i, j, k;
|
|
xmedia_s32 ret;
|
|
FILE *fd = NULL;
|
|
xmedia_u32 frame_cnt = 0;
|
|
xmedia_char file_name[FILE_NAME_LEN] = { 0 };
|
|
xmedia_video_frame_info *frame_info[VI_MAX_WDR_FRAME_NUM] = { XMEDIA_NULL };
|
|
|
|
for (i = 0; i < bind_attr->pipe_num; i++) {
|
|
frame_info[i] = malloc(sizeof(xmedia_video_frame_info) * cnt);
|
|
if (frame_info[i] == XMEDIA_NULL) {
|
|
r_printf("pipe %d malloc frame info failed\n", bind_attr->pipe_id[i]);
|
|
for (j = 0; j < i; j++) {
|
|
free(frame_info[j]);
|
|
}
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < cnt; i++) {
|
|
for (j = 0; j < bind_attr->pipe_num; j++) {
|
|
ret = xmedia_vi_acquire_pipe_frame(bind_attr->pipe_id[j], &frame_info[j][i], MAX_WAIT_TIME);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
r_printf("wdr: get pipe %d frame failed with 0x%x", bind_attr->pipe_id[j], ret);
|
|
r_printf("only get %d frames\n", i);
|
|
frame_cnt = i;
|
|
for (k = 0; k < bind_attr->pipe_num; k++) {
|
|
xmedia_vi_release_pipe_frame(bind_attr->pipe_id[k], &frame_info[k][i]);
|
|
goto save_frame;
|
|
}
|
|
} else {
|
|
printf("wdr: get pipe %d frame %d ok\n", bind_attr->pipe_id[j], i);
|
|
}
|
|
}
|
|
}
|
|
|
|
frame_cnt = i;
|
|
|
|
// make file name
|
|
if (ratio_show == 0) {
|
|
snprintf(file_name, FILE_NAME_LEN, "./vi_pipe_%d_%ux%u_%d_%dbits_%s_%d_wdr.raw", bind_attr->pipe_id[0],
|
|
frame_info[0][0].frame.width, frame_info[0][0].frame.height, cnt * bind_attr->pipe_num,
|
|
data_width_to_num(frame_info[0][0].frame.bit_width),
|
|
compress_mode_to_string(frame_info[0][0].frame.compress_mode), ratio_show);
|
|
} else {
|
|
// todo
|
|
snprintf(file_name, FILE_NAME_LEN, "./vi_pipe_%d_%ux%u_%d_%dbits_%s_%d_wdr.raw", bind_attr->pipe_id[0],
|
|
frame_info[0][0].frame.width, frame_info[0][0].frame.height, cnt * bind_attr->pipe_num,
|
|
data_width_to_num(frame_info[0][0].frame.bit_width),
|
|
compress_mode_to_string(frame_info[0][0].frame.compress_mode), ratio_show);
|
|
}
|
|
|
|
fd = fopen(file_name, "wb");
|
|
if (fd == NULL) {
|
|
r_printf("open file faied\n");
|
|
goto end;
|
|
}
|
|
|
|
save_frame:
|
|
if (frame_cnt == 0) {
|
|
for (i = 0; i < bind_attr->pipe_num; i++) {
|
|
free(frame_info[i]);
|
|
}
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
for (i = 0; i < frame_cnt; i++) {
|
|
for (j = 0; j < bind_attr->pipe_num; j++) {
|
|
printf("pipe %d frame %d save start\n", bind_attr->pipe_id[j], i);
|
|
save_raw_to_file(&frame_info[j][i].frame, fd);
|
|
printf("pipe %d frame %d save completed\n", bind_attr->pipe_id[j], i);
|
|
}
|
|
}
|
|
|
|
end:
|
|
if (fd != XMEDIA_NULL) {
|
|
fclose(fd);
|
|
}
|
|
|
|
for (i = 0; i < frame_cnt; i++) {
|
|
for (j = 0; j < bind_attr->pipe_num; j++) {
|
|
xmedia_vi_release_pipe_frame(bind_attr->pipe_id[j], &frame_info[j][i]);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < bind_attr->pipe_num; i++) {
|
|
free(frame_info[i]);
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_s32 main(xmedia_s32 argc, xmedia_char *argv[])
|
|
{
|
|
xmedia_s32 i;
|
|
xmedia_s32 ret;
|
|
xmedia_s32 pipe = 0;
|
|
xmedia_u32 frame_cnt = 1;
|
|
xmedia_u32 ratio_show = 0;
|
|
xmedia_vi_dev_bind_pipe_attr dev_bind_pipe;
|
|
xmedia_vi_frame_dump_attr dump_attr;
|
|
xmedia_vi_frame_dump_attr dump_attr_tmp;
|
|
|
|
printf("\nNOTIC: this tool only can be used for TESTING !!!\n");
|
|
printf("\n To see more usage, please enter: ./vi_bayer_dump -h\n\n");
|
|
|
|
if (argc > 1) {
|
|
if (strncmp(argv[1], "-h", 2) == 0) {
|
|
vi_bayer_dump_usage();
|
|
exit(XMEDIA_SUCCESS);
|
|
} else {
|
|
pipe = atoi(argv[1]); // pipe
|
|
}
|
|
}
|
|
|
|
if (argc > 2) {
|
|
frame_cnt = atoi(argv[2]); // the frame number
|
|
if (frame_cnt < 1 || frame_cnt > MAX_FRAME_CNT) {
|
|
r_printf("invalid frame cnt %u, range [1, %d]\n", frame_cnt, MAX_FRAME_CNT);
|
|
exit(XMEDIA_FAILURE);
|
|
}
|
|
}
|
|
|
|
if (argc > 3) {
|
|
if (atoi(argv[3]) > 0) {
|
|
ratio_show = 1;
|
|
} else {
|
|
ratio_show = 0;
|
|
}
|
|
}
|
|
|
|
ret = xmedia_vi_init();
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
r_printf("vi init failed !\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = get_dump_pipe(pipe, &dev_bind_pipe);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
xmedia_vi_exit();
|
|
r_printf("get_dump_pipe failed !\n");
|
|
return ret;
|
|
}
|
|
|
|
for (i = 0; i < dev_bind_pipe.pipe_num; i++) {
|
|
ret = xmedia_vi_get_pipe_frame_dump_attr(dev_bind_pipe.pipe_id[i], &dump_attr_tmp);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
xmedia_vi_exit();
|
|
r_printf("get pipe %d dump attr failed with 0x%x\n", dev_bind_pipe.pipe_id[i], ret);
|
|
return ret;
|
|
}
|
|
|
|
dump_attr.enable = XMEDIA_TRUE;
|
|
dump_attr.depth = RAW_DUMP_DEPTH;
|
|
ret = xmedia_vi_set_pipe_frame_dump_attr(dev_bind_pipe.pipe_id[i], &dump_attr);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
r_printf("set pipe %d dump attr failed with 0x%x\n", dev_bind_pipe.pipe_id[i], ret);
|
|
xmedia_vi_exit();
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if (dev_bind_pipe.pipe_num == 1) {
|
|
dump_linear_bayer(pipe, frame_cnt, ratio_show);
|
|
} else {
|
|
dump_wdr_bayer(&dev_bind_pipe, frame_cnt, ratio_show);
|
|
}
|
|
|
|
for (i = 0; i < dev_bind_pipe.pipe_num; i++) {
|
|
ret = xmedia_vi_set_pipe_frame_dump_attr(dev_bind_pipe.pipe_id[i], &dump_attr_tmp);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
r_printf("set pipe %d dump attr failed with 0x%x\n", dev_bind_pipe.pipe_id[i], ret);
|
|
xmedia_vi_exit();
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
xmedia_vi_exit();
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|