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

385 lines
14 KiB
C
Raw Permalink Blame History

/*
Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
*/
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include "ss_mpi_vo.h"
#define VO_CONFIG_ARG_NUMBER_BASE 10 /* 10:base */
#define VO_CONFIG_MAX_CSC_VAL 100
#define VO_CONFIG_MIN_CSC_VAL 0
#define VO_CONFIG_MAX_VGA_GAIN 63
#define VO_CONFIG_MIN_VGA_GAIN 0
#define VO_CONFIG_MAX_VGA_SHARPEN 255
#define VO_CONFIG_MIN_VGA_SHARPEN 0
typedef enum {
VO_CONFIG_TYPE_LAYER = 0, /* config layer csc */
VO_CONFIG_TYPE_VGA = 1, /* config vga param */
VO_CONFIG_TYPE_HDMI = 2, /* config hdmi param */
VO_CONFIG_TYPE_RGB = 3, /* config rgb param */
VO_CONFIG_TYPE_MIPI = 4, /* config mipi param */
VO_CONFIG_TYPE_HDMI1 = 5, /* config hdmi1 param */
VO_CONFIG_TYPE_BUTT,
} vo_config_type;
typedef enum {
VO_CONFIG_ARG_CMD = 0, /* config param cmd */
VO_CONFIG_ARG_TYPE = 1, /* config param type */
VO_CONFIG_ARG_ID = 2, /* config param id */
VO_CONFIG_ARG_CSC_MATRIX = 3, /* config param csc matrix */
VO_CONFIG_ARG_LUMA = 4, /* config param csc luma */
VO_CONFIG_ARG_CONTRAST = 5, /* config param csc contrast */
VO_CONFIG_ARG_HUE = 6, /* config param csc hue */
VO_CONFIG_ARG_SATURATION = 7, /* config param csc saturation */
VO_CONFIG_ARG_EX_CSC_EN = 8, /* config param csc ex_csc_en */
VO_CONFIG_ARG_GAIN = 9, /* config param vga gain */
VO_CONFIG_ARG_SHARPEN_STRENGTH = 10, /* config param vga sharpen strength */
VO_CONFIG_ARG_BUTT,
} vo_config_arg_index;
#define VO_CONFIG_DEF_ARGC_NUM (VO_CONFIG_ARG_EX_CSC_EN + 1) /* default 9 argc */
#define VO_CONFIG_VGA_ARGC_NUM (VO_CONFIG_ARG_SHARPEN_STRENGTH + 1) /* vga param have 11 argc */
#define vo_config_check_return(express, name) \
do { \
td_s32 _ret; \
_ret = express; \
if (_ret != TD_SUCCESS) { \
printf("%s failed at %s: LINE: %d with %#x!\n", name, __FUNCTION__, __LINE__, _ret); \
return _ret; \
} \
} while (0)
static td_void usage(td_void)
{
printf("notice: layer config usage: ./vo_config [0] [layer] [csc_matrix] [luma] [contrast] [hue] ");
printf("[saturation] [ex_csc_en].\n");
printf("\tsample: ./vo_config 0 0 9 50 50 50 50 0\n");
printf("\tvga config usage: ./vo_config [1] [dev] [csc_matrix] [luma] [contrast] [hue] ");
printf("[saturation] [ex_csc_en] [gain] [sharpen_strength].\n");
printf("\tsample: ./vo_config 1 0 17 50 50 50 50 0 10 128\n");
printf("\thdmi config usage: ./vo_config [2] [dev] [csc_matrix] [luma] [contrast] [hue] ");
printf("[saturation] [ex_csc_en].\n");
printf("\tsample: ./vo_config 2 0 9 50 50 50 50 0\n");
printf("\trgb config usage: ./vo_config [3] [dev] [csc_matrix] [luma] [contrast] [hue] ");
printf("[saturation] [ex_csc_en].\n");
printf("\tsample: ./vo_config 3 0 17 50 50 50 50 0\n");
printf("\tmipi config usage: ./vo_config [4] [dev] [csc_matrix] [luma] [contrast] [hue] ");
printf("[saturation] [ex_csc_en].\n");
printf("\tsample: ./vo_config 4 0 9 50 50 50 50 0\n");
printf("\thdmi1 config usage: ./vo_config [2] [dev] [csc_matrix] [luma] [contrast] [hue] ");
printf("[saturation] [ex_csc_en].\n");
printf("\tsample: ./vo_config 5 0 9 50 50 50 50 0\n");
printf("notice: video layer csc_matrix [0,15], gfx layer csc_matrix [24,27] ");
printf("vga or rgb csc_matrix [16,23], hdmi or mipi csc_matrix [0,23].\n");
printf("\tluma/contrast/hue/saturation [0,100], ex_csc_en [0,1], gain [0, 64), sharpen_strength [0, 255].\n");
}
static td_s32 vo_get_input_argc_num(vo_config_type config_type)
{
td_s32 argc = VO_CONFIG_DEF_ARGC_NUM;
if (config_type == VO_CONFIG_TYPE_VGA) {
argc = VO_CONFIG_VGA_ARGC_NUM;
}
return argc;
}
static td_s32 vo_config_get_argv_val(char *argv[], vo_config_arg_index index, td_slong *val)
{
td_char *end_ptr = TD_NULL;
td_slong result;
errno = 0;
result = strtol(argv[index], &end_ptr, VO_CONFIG_ARG_NUMBER_BASE);
if ((end_ptr == argv[index]) || (*end_ptr != '\0')) {
return TD_FAILURE;
} else if (((result == LONG_MIN) || (result == LONG_MAX)) &&
(errno == ERANGE)) {
return TD_FAILURE;
}
*val = result;
return TD_SUCCESS;
}
static const td_char *vo_config_get_argv_name(vo_config_arg_index index)
{
const td_char *argv_name[VO_CONFIG_ARG_BUTT] = {"vo_config", "config_type", "dev/layer", "csc_matrix",
"luma", "contrast", "hue", "saturation", "ex_csc_en", "gain", "sharpen_strength"};
if (index >= VO_CONFIG_ARG_BUTT) {
return "-";
}
return argv_name[index];
}
static td_s32 vo_config_get_valid_argv_val(char *argv[], vo_config_arg_index index,
td_s32 min_val, td_s32 max_val, td_s32 *val)
{
td_s32 ret;
td_slong result = 0;
ret = vo_config_get_argv_val(argv, index, &result);
if (ret != TD_SUCCESS) {
printf("Failure: input arg index(%u) name(%s) arg is invalid!\n",
index, vo_config_get_argv_name(index));
usage();
return ret;
}
if ((result < min_val) || (result > max_val)) {
printf("Failure: input arg index(%u) name(%s) arg val (%ld) is wrong. should be [%d, %d]!\n",
index, vo_config_get_argv_name(index), result, min_val, max_val);
usage();
return TD_FAILURE;
}
*val = (td_s32)result;
return TD_SUCCESS;
}
static td_s32 vo_get_input_id_arg(vo_config_type config_type, char *argv[], td_s32 *id)
{
td_s32 min_val = 0;
td_s32 max_val = (config_type == VO_CONFIG_TYPE_LAYER) ? (OT_VO_MAX_LAYER_NUM - 1) : OT_VO_MAX_DEV_NUM - 1;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_ID, min_val, max_val, id),
"vo_config_get_valid_argv_val");
return TD_SUCCESS;
}
static td_s32 vo_get_input_csc_arg(char *argv[], ot_vo_csc *csc)
{
td_s32 val = 0;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_CSC_MATRIX,
OT_VO_CSC_MATRIX_BT601LIMIT_TO_BT601LIMIT, OT_VO_CSC_MATRIX_BUTT - 1, &val), "vo_config_get_argv");
csc->csc_matrix = (ot_vo_csc_matrix)val;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_LUMA,
VO_CONFIG_MIN_CSC_VAL, VO_CONFIG_MAX_CSC_VAL, &val), "vo_config_get_argv");
csc->luma = (td_u32)val;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_CONTRAST,
VO_CONFIG_MIN_CSC_VAL, VO_CONFIG_MAX_CSC_VAL, &val), "vo_config_get_argv");
csc->contrast = (td_u32)val;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_HUE,
VO_CONFIG_MIN_CSC_VAL, VO_CONFIG_MAX_CSC_VAL, &val), "vo_config_get_argv");
csc->hue = (td_u32)val;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_SATURATION,
VO_CONFIG_MIN_CSC_VAL, VO_CONFIG_MAX_CSC_VAL, &val), "vo_config_get_argv");
csc->saturation = (td_u32)val;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_EX_CSC_EN,
TD_FALSE, TD_TRUE, &val), "vo_config_get_argv");
csc->ex_csc_en = (td_bool)val;
return TD_SUCCESS;
}
static td_void vo_print_csc_config(const ot_vo_csc *csc)
{
printf("csc_matrix %d, luma %d, contrast %d, hue %d, saturation %d, ex_csc_en %d", csc->csc_matrix, csc->luma,
csc->contrast, csc->hue, csc->saturation, csc->ex_csc_en);
}
static td_s32 vo_get_input_arg(vo_config_type config_type, char *argv[], td_s32 *id, ot_vo_csc *csc)
{
vo_config_check_return(vo_get_input_id_arg(config_type, argv, id), "vo_get_input_id_arg");
vo_config_check_return(vo_get_input_csc_arg(argv, csc), "vo_get_input_csc_arg");
return TD_SUCCESS;
}
static td_s32 vo_do_layer_config(vo_config_type config_type, char *argv[])
{
ot_vo_layer layer = 0;
ot_vo_csc csc = {0};
vo_config_check_return(vo_get_input_arg(config_type, argv, &layer, &csc), "vo_get_input_arg");
vo_config_check_return(ss_mpi_vo_set_layer_csc(layer, &csc), "ss_mpi_vo_set_layer_csc");
vo_config_check_return(ss_mpi_vo_get_layer_csc(layer, &csc), "ss_mpi_vo_get_layer_csc");
printf("layer config layer_id %d ", layer);
vo_print_csc_config(&csc);
printf("\n");
return TD_SUCCESS;
}
static td_s32 vo_get_input_vga_param(vo_config_type config_type, char *argv[], td_s32 *id, ot_vo_vga_param *vga_param)
{
td_s32 val = 0;
vo_config_check_return(vo_get_input_arg(config_type, argv, id, &(vga_param->csc)), "vo_get_input_arg");
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_GAIN,
VO_CONFIG_MIN_VGA_GAIN, VO_CONFIG_MAX_VGA_GAIN, &val), "vo_config_get_valid_argv_val");
vga_param->gain = (td_u32)val;
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_SHARPEN_STRENGTH,
VO_CONFIG_MIN_VGA_SHARPEN, VO_CONFIG_MAX_VGA_SHARPEN, &val), "vo_config_get_valid_argv_val");
vga_param->sharpen_strength = (td_u32)val;
return TD_SUCCESS;
}
static td_s32 vo_do_vga_config(vo_config_type config_type, char *argv[])
{
ot_vo_dev dev = 0;
ot_vo_vga_param vga_param = {0};
vo_config_check_return(vo_get_input_vga_param(config_type, argv, &dev, &vga_param), "vo_get_input_vga_param");
vo_config_check_return(ss_mpi_vo_set_vga_param(dev, &vga_param), "ss_mpi_vo_set_vga_param");
vo_config_check_return(ss_mpi_vo_get_vga_param(dev, &vga_param), "ss_mpi_vo_get_vga_param");
printf("vga config dev_id %d ", dev);
vo_print_csc_config(&(vga_param.csc));
printf(" gain %d, sharpen_strength %d\n", vga_param.gain, vga_param.sharpen_strength);
return TD_SUCCESS;
}
static td_s32 vo_do_hdmi_config(vo_config_type config_type, char *argv[])
{
ot_vo_dev dev = 0;
ot_vo_hdmi_param hdmi_param = {0};
vo_config_check_return(vo_get_input_arg(config_type, argv, &dev, &(hdmi_param.csc)), "vo_get_input_arg");
vo_config_check_return(ss_mpi_vo_set_hdmi_param(dev, &hdmi_param), "ss_mpi_vo_set_hdmi_param");
vo_config_check_return(ss_mpi_vo_get_hdmi_param(dev, &hdmi_param), "ss_mpi_vo_get_hdmi_param");
printf("hdmi config dev_id %d ", dev);
vo_print_csc_config(&(hdmi_param.csc));
printf("\n");
return TD_SUCCESS;
}
static td_s32 vo_do_rgb_config(vo_config_type config_type, char *argv[])
{
ot_vo_dev dev = 0;
ot_vo_rgb_param rgb_param = {0};
ot_vo_rgb_param old_rgb_param = {0};
vo_config_check_return(vo_get_input_arg(config_type, argv, &dev, &(rgb_param.csc)), "vo_get_input_arg");
vo_config_check_return(ss_mpi_vo_get_rgb_param(dev, &old_rgb_param), "ss_mpi_vo_get_rgb_param");
rgb_param.rgb_inverted_en = old_rgb_param.rgb_inverted_en;
rgb_param.bit_inverted_en = old_rgb_param.bit_inverted_en;
vo_config_check_return(ss_mpi_vo_set_rgb_param(dev, &rgb_param), "ss_mpi_vo_set_rgb_param");
vo_config_check_return(ss_mpi_vo_get_rgb_param(dev, &rgb_param), "ss_mpi_vo_get_rgb_param");
printf("rgb config dev_id %d ", dev);
vo_print_csc_config(&(rgb_param.csc));
printf("\n");
return TD_SUCCESS;
}
static td_s32 vo_do_mipi_config(vo_config_type config_type, char *argv[])
{
ot_vo_dev dev = 0;
ot_vo_mipi_param mipi_param = {0};
vo_config_check_return(vo_get_input_arg(config_type, argv, &dev, &(mipi_param.csc)), "vo_get_input_arg");
vo_config_check_return(ss_mpi_vo_set_mipi_param(dev, &mipi_param), "ss_mpi_vo_set_mipi_param");
vo_config_check_return(ss_mpi_vo_get_mipi_param(dev, &mipi_param), "ss_mpi_vo_get_mipi_param");
printf("mipi config dev_id %d ", dev);
vo_print_csc_config(&(mipi_param.csc));
printf("\n");
return TD_SUCCESS;
}
static td_s32 vo_do_hdmi1_config(vo_config_type config_type, char *argv[])
{
ot_vo_dev dev = 0;
ot_vo_hdmi_param hdmi1_param = {0};
vo_config_check_return(vo_get_input_arg(config_type, argv, &dev, &(hdmi1_param.csc)), "vo_get_input_csc_param");
vo_config_check_return(ss_mpi_vo_set_hdmi1_param(dev, &hdmi1_param), "ss_mpi_vo_set_hdmi1_param");
vo_config_check_return(ss_mpi_vo_get_hdmi1_param(dev, &hdmi1_param), "ss_mpi_vo_get_hdmi1_param");
printf("hdmi1 config dev_id %d ", dev);
vo_print_csc_config(&(hdmi1_param.csc));
printf("\n");
return TD_SUCCESS;
}
static td_s32 vo_do_config(vo_config_type config_type, char *argv[])
{
switch (config_type) {
case VO_CONFIG_TYPE_LAYER:
return vo_do_layer_config(config_type, argv);
case VO_CONFIG_TYPE_VGA:
return vo_do_vga_config(config_type, argv);
case VO_CONFIG_TYPE_HDMI:
return vo_do_hdmi_config(config_type, argv);
case VO_CONFIG_TYPE_RGB:
return vo_do_rgb_config(config_type, argv);
case VO_CONFIG_TYPE_MIPI:
return vo_do_mipi_config(config_type, argv);
case VO_CONFIG_TYPE_HDMI1:
return vo_do_hdmi1_config(config_type, argv);
default:
printf("config type %d is invalid!\n", config_type);
return OT_ERR_VO_ILLEGAL_PARAM;
}
}
#ifdef __LITEOS__
td_s32 vo_config(int argc, char *argv[])
#else
td_s32 main(int argc, char *argv[])
#endif
{
td_s32 argc_num;
td_s32 val = 0;
vo_config_type config_type;
printf("\nnotice: this tool only can be used for TESTING !!!\n");
#ifndef __LITEOS__
printf("\tTo see more usage, please enter: ./vo_config -h\n\n");
#else
printf("\tTo see more usage, please enter: vo_config -h\n\n");
#endif
if (argc <= 1) {
printf("Failure: too little parameters!\n");
usage();
return OT_ERR_VO_ILLEGAL_PARAM;
}
if ((strncmp(argv[1], "-h", 2)) == 0) { /* 2 chars */
usage();
return TD_SUCCESS;
}
vo_config_check_return(vo_config_get_valid_argv_val(argv, VO_CONFIG_ARG_TYPE,
VO_CONFIG_TYPE_LAYER, VO_CONFIG_TYPE_BUTT - 1, &val), "vo_config_get_valid_argv_val");
config_type = (vo_config_type)val;
argc_num = vo_get_input_argc_num(config_type);
if (argc != argc_num) {
printf("Failure: config type %d should have %d param, current input %d param!\n",
config_type, argc_num, argc);
usage();
return OT_ERR_VO_ILLEGAL_PARAM;
}
return vo_do_config(config_type, argv);
}
Reference in New Issue View Git Blame Copy Permalink