lai/hisi_SS524V100_SDK
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3b1e7a70826baf550be8c93a9c66a0f554d032d5
hisi_SS524V100_SDK/back/sample/hdmi/sample_hdmi_cmd.c
T

620 lines
20 KiB
C
Raw Blame History

/*
Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
*/
#include "sample_hdmi_cmd.h"
#define HDMI_MAX_ARGC 20
#define HDMI_MAX_PAMRM_SIZE 30
#define HDMI_MAX_ASPECTRATIO 2
#define HDMI_MAX_AUTHMODE 2
#define HDMI_MAX_AUDIO_FREQNCE 3
#define INDEX_720P60 4
#define INDEX_1080P60 8
#define INVAILD_IN_PARAMETERS 0xFFFFFFFF
static ot_hdmi_id g_test_hdmi_id = OT_HDMI_ID_0;
static td_bool g_vo_hdmi_rgb_mode = TD_FALSE;
static td_u8 g_args[HDMI_MAX_ARGC][HDMI_MAX_PAMRM_SIZE] = {0};
static hdmi_input_param g_hdmi_timing[] = {
{ OT_VO_OUT_1080P24, "1080P_24" },
{ OT_VO_OUT_1080P25, "1080P_25" },
{ OT_VO_OUT_1080P30, "1080P_30" },
{ OT_VO_OUT_720P50, "720P_50" },
{ OT_VO_OUT_720P60, "720P_60" },
{ OT_VO_OUT_1080I50, "1080i_50" },
{ OT_VO_OUT_1080I60, "1080i_60" },
{ OT_VO_OUT_1080P50, "1080P_50" },
{ OT_VO_OUT_1080P60, "1080P_60" },
{ OT_VO_OUT_576P50, "576P_50" },
{ OT_VO_OUT_480P60, "480P_60" },
{ OT_VO_OUT_640x480_60, "640x480p_60" },
{ OT_VO_OUT_800x600_60, "800x600" },
{ OT_VO_OUT_1024x768_60, "1024X768" },
{ OT_VO_OUT_1280x1024_60, "1280X1024" },
{ OT_VO_OUT_1366x768_60, "1366X768" },
{ OT_VO_OUT_1440x900_60, "1440X900" },
{ OT_VO_OUT_1280x800_60, "1280X800" },
{ OT_VO_OUT_1680x1050_60, "1680X1050" },
{ OT_VO_OUT_1920x2160_30, "1920X2160" },
{ OT_VO_OUT_1600x1200_60, "1600X1200" },
{ OT_VO_OUT_1920x1200_60, "1920X1200_60" },
{ OT_VO_OUT_2560x1440_30, "2560X1440_30" },
{ OT_VO_OUT_2560x1440_60, "2560X1440_60" },
{ OT_VO_OUT_2560x1600_60, "2560X1600" },
{ OT_VO_OUT_3840x2160_24, "3840X2160_24" },
{ OT_VO_OUT_3840x2160_25, "3840X2160_25" },
{ OT_VO_OUT_3840x2160_30, "3840X2160_30" },
#ifndef HDMI_SUPPORT_1_4
{ OT_VO_OUT_3840x2160_50, "3840X2160_50" },
{ OT_VO_OUT_3840x2160_60, "3840X2160_60" },
#endif
{ OT_VO_OUT_BUTT, "BUTT" }
};
static hdmi_input_param g_hdmi_v_color_mode[] = {
{ 0, "RGB" },
{ 1, "YUV422" },
{ 2, "YUV444" },
#ifndef HDMI_SUPPORT_1_4
{ 3, "YUV420" }
#endif
};
static hdmi_input_param g_hdmi_v_aspect_ratio[HDMI_MAX_ASPECTRATIO] = {
{ 0, "4:3" },
{ 1, "16:9" }
};
static hdmi_input_param g_hdmi_a_freq[HDMI_MAX_AUDIO_FREQNCE] = {
{ 0, "32000" },
{ 1, "44100" },
{ 2, "48000" }
};
static td_u32 hdmi_string_to_integer(td_u8 *ptr)
{
td_u32 index, string_len;
if (ptr == NULL) {
return INVAILD_IN_PARAMETERS;
}
string_len = strlen((char *)ptr);
if (string_len > NUM_16) {
return INVAILD_IN_PARAMETERS;
}
for (index = 0; index < string_len; index++) {
if ((ptr[index] >= '0') && (ptr[index] <= '9')) {
continue;
}
return INVAILD_IN_PARAMETERS;
}
return (atoi((char *)ptr));
}
/* adjust input parameter */
static td_u8 hdmi_adjust_string(td_char *ptr, td_u32 len)
{
td_u32 i, j;
/* search the first character char */
while (*ptr == ' ' || *ptr == '\0' || *ptr == '\t') {
ptr++;
}
/* change to little case character */
for (i = (len - 1); i > 0; i--) {
if ((*(ptr + i - 1) >= 'A') && (*(ptr + i - 1) <= 'Z')) {
*(ptr + i - 1) = 'a' + (*(ptr + i - 1) - 'A');
}
}
for (i = 0; i < HDMI_MAX_ARGC; i++) {
(td_void)memset_s(g_args[i], HDMI_MAX_PAMRM_SIZE, 0, HDMI_MAX_PAMRM_SIZE);
}
/* fill g_args[][] with input string */
for (i = 0; i < HDMI_MAX_ARGC; i++) {
j = 0;
while (*ptr == ' ' || *ptr == '\t') {
ptr++;
}
while ((*ptr != ' ') && (*ptr != '\0') && (*ptr != '\t') && j < HDMI_MAX_PAMRM_SIZE) {
if ((*ptr >= 'a' && *ptr <= 'z') || (*ptr >= '0' && *ptr <= '9') || (*ptr == '_') || (*ptr == '-')) {
g_args[i][j] = *ptr;
j++;
}
ptr++;
}
if (j >= HDMI_MAX_PAMRM_SIZE) {
printf("\033[32;1mparam err!\033[0m\n");
return 0;
}
if ((i != 0) && (j == 0)) {
printf("Invalid arg[%d]!\n", i);
return 0;
}
g_args[i][j] = '\0';
/* LF : 0xA, NL line feed, new line */
while (*ptr == ' ' || *ptr == '\t' || *ptr == 0xA) {
ptr++;
}
if (*ptr == '\0') {
i++;
break;
}
}
return i;
}
static td_void hdmi_hdmi_force(td_void)
{
td_s32 ret;
ot_hdmi_attr attr = {0};
printf("hdmi_hdmi_force with ss_mpi_hdmi_set_attr\n");
ret = ss_mpi_hdmi_stop(g_test_hdmi_id);
sample_if_failure_return_void(ret);
ret = ss_mpi_hdmi_get_attr(g_test_hdmi_id, &attr);
sample_if_failure_return_void(ret);
attr.hdmi_en = TD_TRUE;
attr.audio_en = TD_TRUE;
ret = ss_mpi_hdmi_set_attr(g_test_hdmi_id, &attr);
sample_if_failure_return_void(ret);
ret = ss_mpi_hdmi_start(g_test_hdmi_id);
sample_if_failure_return_void(ret);
return;
}
static td_void hdmi_dvi_force(td_void)
{
td_s32 ret;
ot_hdmi_attr attr = {0};
ot_vo_hdmi_param hdmi_param = {0};
printf("hdmi_dvi_force with ot_hdmi_set_attr\n");
ret = ss_mpi_hdmi_stop(g_test_hdmi_id);
ret = ss_mpi_vo_get_hdmi_param(SAMPLE_VO_DEV_DHD0, &hdmi_param);
sample_if_failure_return_void(ret);
hdmi_param.csc.csc_matrix = OT_VO_CSC_MATRIX_BT601LIMIT_TO_RGBFULL;
ret = ss_mpi_vo_set_hdmi_param(SAMPLE_VO_DEV_DHD0, &hdmi_param);
sample_if_failure_return_void(ret);
ret = ss_mpi_hdmi_get_attr(g_test_hdmi_id, &attr);
sample_if_failure_return_void(ret);
attr.hdmi_en = TD_FALSE;
attr.audio_en = TD_FALSE;
ret = ss_mpi_hdmi_set_attr(g_test_hdmi_id, &attr);
sample_if_failure_return_void(ret);
ret = ss_mpi_hdmi_start(g_test_hdmi_id);
sample_if_failure_return_void(ret);
return;
}
static td_s32 hdmi_deepcolor(td_u32 deep_color_flag)
{
td_s32 ret;
ot_hdmi_attr attr = {0};
ot_hdmi_sink_capability sink_cap = {0};
ret = ss_mpi_hdmi_get_sink_capability(g_test_hdmi_id, &sink_cap);
if (ret == TD_SUCCESS) {
if (deep_color_flag == OT_HDMI_DEEP_COLOR_30BIT) {
if (sink_cap.support_deepcolor_30bit != TD_TRUE) {
printf("OT_HDMI_DEEP_COLOR_30BIT do not support in sink device\n");
}
} else if (deep_color_flag == OT_HDMI_DEEP_COLOR_36BIT) {
if (sink_cap.support_deepcolor_36bit != TD_TRUE) {
printf("OT_HDMI_DEEP_COLOR_36BIT do not support in sink device\n");
}
} else {
printf("deep_color:0x%x do not support in current environment\n", deep_color_flag);
}
} else {
printf("can't get capability, force set attr \n");
}
printf("hdmi_deepcolor deep_color_flag:%d\n", deep_color_flag);
ret = ss_mpi_hdmi_stop(g_test_hdmi_id);
sample_if_failure_return(ret, TD_FAILURE);
ret = ss_mpi_hdmi_get_attr(g_test_hdmi_id, &attr);
sample_if_failure_return(ret, TD_FAILURE);
attr.deep_color_mode = deep_color_flag;
ret = ss_mpi_hdmi_set_attr(g_test_hdmi_id, &attr);
if (ret == OT_ERR_HDMI_FEATURE_NO_SUPPORT) {
printf("feature no support.\n");
}
printf("return :%d\n", ret);
ret = ss_mpi_hdmi_start(g_test_hdmi_id);
sample_if_failure_return(ret, TD_FAILURE);
return ret;
}
static td_void hdmi_video_timing(td_u32 index, td_u32 timing)
{
td_s32 ret;
printf("set %s, timing index(%d)\n", g_hdmi_timing[index].index_string, timing);
ret = sample_hdmi_fmt_change(timing, g_vo_hdmi_rgb_mode);
sample_if_failure_return_void(ret);
printf("hdmi_video_timing video_timing:%d\n", timing);
return;
}
static td_s32 hdmi_color_mode(td_u32 color_index)
{
td_s32 ret;
ot_vo_hdmi_param hdmi_param = {0};
printf("hdmi_color_mode color_index:%d\n", color_index);
ret = ss_mpi_vo_get_hdmi_param(SAMPLE_VO_DEV_DHD0, &hdmi_param);
sample_if_failure_return(ret, TD_FAILURE);
ret = ss_mpi_hdmi_stop(OT_HDMI_ID_0);
sample_if_failure_return(ret, TD_FAILURE);
switch (color_index) {
case NUM_1: /* ycbcr422 */
hdmi_param.csc.csc_matrix = OT_VO_CSC_MATRIX_BT709FULL_TO_BT709FULL;
ret = ss_mpi_vo_set_hdmi_param(SAMPLE_VO_DEV_DHD0, &hdmi_param);
sample_if_failure_return(ret, TD_FAILURE);
g_vo_hdmi_rgb_mode = TD_FALSE;
system("echo outclrspace 1 > /proc/umap/hdmi0;");
break;
case NUM_2: /* ycbcr444 */
hdmi_param.csc.csc_matrix = OT_VO_CSC_MATRIX_BT709FULL_TO_BT709FULL;
ret = ss_mpi_vo_set_hdmi_param(SAMPLE_VO_DEV_DHD0, &hdmi_param);
sample_if_failure_return(ret, TD_FAILURE);
g_vo_hdmi_rgb_mode = TD_FALSE;
system("echo outclrspace 2 > /proc/umap/hdmi0;");
break;
case NUM_3: /* ycbcr420 */
hdmi_param.csc.csc_matrix = OT_VO_CSC_MATRIX_BT709FULL_TO_BT709FULL;
ret = ss_mpi_vo_set_hdmi_param(SAMPLE_VO_DEV_DHD0, &hdmi_param);
sample_if_failure_return(ret, TD_FAILURE);
g_vo_hdmi_rgb_mode = TD_FALSE;
system("echo outclrspace 3 > /proc/umap/hdmi0;");
break;
default: /* rgb */
hdmi_param.csc.csc_matrix = OT_VO_CSC_MATRIX_BT709FULL_TO_RGBLIMIT;
ret = ss_mpi_vo_set_hdmi_param(SAMPLE_VO_DEV_DHD0, &hdmi_param);
sample_if_failure_return(ret, TD_FAILURE);
g_vo_hdmi_rgb_mode = TD_TRUE;
break;
}
ret = ss_mpi_hdmi_start(OT_HDMI_ID_0);
sample_if_failure_return(ret, TD_FAILURE);
return ret;
}
static td_s32 hdmi_aspectratio(td_u32 aspectratio_index)
{
td_s32 ret_error;
ot_hdmi_infoframe info_frame = {0};
ot_hdmi_avi_infoframe *vid_infoframe = TD_NULL;
ret_error = ss_mpi_hdmi_stop(g_test_hdmi_id);
sample_if_failure_return(ret_error, TD_FAILURE);
ret_error = ss_mpi_hdmi_get_infoframe(g_test_hdmi_id, OT_INFOFRAME_TYPE_AVI, &info_frame);
sample_if_failure_return(ret_error, TD_FAILURE);
vid_infoframe = &(info_frame.infoframe_unit.avi_infoframe);
switch (aspectratio_index) {
case NUM_0:
printf("4:3\n");
vid_infoframe->aspect_ratio = OT_HDMI_PIC_ASPECT_RATIO_4TO3;
vid_infoframe->active_aspect_ratio = OT_HDMI_ACTIVE_ASPECT_RATIO_SAME_PIC;
break;
case NUM_1:
printf("16:9\n");
vid_infoframe->aspect_ratio = OT_HDMI_PIC_ASPECT_RATIO_16TO9;
vid_infoframe->active_aspect_ratio = OT_HDMI_ACTIVE_ASPECT_RATIO_SAME_PIC;
break;
default:
printf("16:9\n");
vid_infoframe->aspect_ratio = OT_HDMI_PIC_ASPECT_RATIO_16TO9;
vid_infoframe->active_aspect_ratio = OT_HDMI_ACTIVE_ASPECT_RATIO_SAME_PIC;
break;
}
ret_error = ss_mpi_hdmi_set_infoframe(g_test_hdmi_id, &info_frame);
sample_if_failure_return(ret_error, TD_FAILURE);
ret_error = ss_mpi_hdmi_start(g_test_hdmi_id);
sample_if_failure_return(ret_error, TD_FAILURE);
return ret_error;
}
static td_void hdmi_authmode(td_bool bauthmode_enable)
{
td_s32 ret;
ot_hdmi_attr attr = {0};
ret = ss_mpi_hdmi_stop(g_test_hdmi_id);
sample_if_failure_return_void(ret);
ret = ss_mpi_hdmi_get_attr(g_test_hdmi_id, &attr);
sample_if_failure_return_void(ret);
attr.auth_mode_en = bauthmode_enable;
ret = ss_mpi_hdmi_set_attr(g_test_hdmi_id, &attr);
sample_if_failure_return_void(ret);
ret = ss_mpi_hdmi_start(g_test_hdmi_id);
sample_if_failure_return_void(ret);
return;
}
static td_u32 hdmi_freq(td_u32 audio_freq_index)
{
td_s32 ret;
td_u32 sample_rate = 0;
switch (audio_freq_index) {
case NUM_0:
sample_rate = OT_HDMI_SAMPLE_RATE_32K;
break;
case NUM_1:
sample_rate = OT_HDMI_SAMPLE_RATE_44K;
break;
case NUM_2:
sample_rate = OT_HDMI_SAMPLE_RATE_48K;
break;
default:
printf("wrong input audio_freq index:%d!\n", audio_freq_index);
return TD_FAILURE;
}
ret = sample_hdmi_set_audio_sample_rate(sample_rate);
sample_if_failure_return(ret, TD_FAILURE);
return TD_SUCCESS;
}
static td_void print_help_info(td_void)
{
printf("\t help list all command we provide\n");
printf("\t q quit sample test\n");
printf("\t hdmi_hdmi_force force to hdmi output\n");
printf("\t hdmi_dvi_force force to enter dvi output mode\n");
printf("\t hdmi_deepcolor set video deepcolor mode\n");
printf("\t hdmi_video_timing set video output timing format\n");
printf("\t hdmi_color_mode set video color output(RGB/ycbcr)\n");
printf("\t hdmi_aspectratio set video aspectratio\n");
printf("\t hdmi_a_freq set audio output frequence\n");
printf("\t hdmi_authmode authmode enable or disable\n");
return;
}
static td_s32 hdmi_deep_color(td_u32 argc)
{
td_s32 ret_error;
td_u32 deep_color_index;
if (argc <= 1) {
printf("usage:hdmi_deepcolor deep_colorflag\n");
printf("deep_colorflag: 0:deep color 24bit\n");
printf("deep_colorflag: 1:deep color 30bit\n");
printf("deep_colorflag: 2:deep color 36bit\n");
return TD_FAILURE;
}
deep_color_index = hdmi_string_to_integer(g_args[1]);
if (deep_color_index >= OT_HDMI_DEEP_COLOR_BUTT) {
printf("Invalid input parameters: %s\n", g_args[1]);
printf("usage:hdmi_deepcolor deep_colorflag\n");
printf("deep_colorflag: 0:deep color 24bit\n");
printf("deep_colorflag: 1:deep color 30bit\n");
printf("deep_colorflag: 2:deep color 36bit\n");
return TD_FAILURE;
}
ret_error = hdmi_deepcolor(deep_color_index);
sample_if_failure_return(ret_error, TD_FAILURE);
return ret_error;
}
static td_s32 hdmi_videotiming(td_u32 argc)
{
td_u32 index;
td_u32 timing_index, vo_timing;
td_u32 len = (sizeof(g_hdmi_timing) / sizeof(hdmi_input_param)) - 1;
if (argc < NUM_2) {
printf("usage:hdmi_video_timing timeingmode\n");
for (index = 0; index < len; index++) {
printf("timemode:%02d %s\n", index, g_hdmi_timing[index].index_string);
}
return TD_FAILURE;
}
timing_index = hdmi_string_to_integer(g_args[1]);
if (timing_index > (len - 1)) {
printf("Invalid input parameters: %s\n", g_args[1]);
printf("usage:hdmi_video_timing timeingmode\n");
for (index = 0; index < len; index++) {
printf("timemode:%02d %s\n", index, g_hdmi_timing[index].index_string);
}
return TD_FAILURE;
}
vo_timing = g_hdmi_timing[timing_index].index;
hdmi_video_timing(timing_index, vo_timing);
return TD_SUCCESS;
}
static td_s32 hdmi_colormode(td_u32 argc)
{
td_s32 ret_error;
td_u8 index, arry_size;
td_u32 color_index;
arry_size = sizeof(g_hdmi_v_color_mode) / sizeof(g_hdmi_v_color_mode[0]);
if (argc <= 1) {
printf("usage:hdmi_color_mode colormode\n");
for (index = 0; index < arry_size; index++) {
printf("colormode:%02d %s\n", index, g_hdmi_v_color_mode[index].index_string);
}
return TD_FAILURE;
}
color_index = hdmi_string_to_integer(g_args[1]);
if (color_index >= arry_size) {
printf("Invalid input parameters: %s\n", g_args[1]);
printf("usage:hdmi_color_mode colormode\n");
for (index = 0; index < arry_size; index++) {
printf("colormode:%02d %s\n", index, g_hdmi_v_color_mode[index].index_string);
}
return TD_FAILURE;
}
ret_error = hdmi_color_mode(color_index);
sample_if_failure_return(ret_error, TD_FAILURE);
return ret_error;
}
static td_s32 hdmi_aspect_ratio(td_u32 argc)
{
td_s32 ret_error;
td_u32 aspectratio_index;
td_u8 index;
if (argc <= 1) {
printf("usage:hdmi_aspectratio aspectratio\n");
for (index = 0; index < HDMI_MAX_ASPECTRATIO; index++) {
printf("apectratio_index:%02d %s\n", g_hdmi_v_aspect_ratio[index].index,
g_hdmi_v_aspect_ratio[index].index_string);
}
return TD_FAILURE;
}
aspectratio_index = hdmi_string_to_integer(g_args[1]);
if ((aspectratio_index >= HDMI_MAX_ASPECTRATIO)) {
printf("Invalid input parameters: %s\n", g_args[1]);
printf("usage:hdmi_aspectratio aspectratio\n");
for (index = 0; index < HDMI_MAX_ASPECTRATIO; index++) {
printf("apectratio_index:%02d %s\n", g_hdmi_v_aspect_ratio[index].index,
g_hdmi_v_aspect_ratio[index].index_string);
}
return TD_FAILURE;
}
ret_error = hdmi_aspectratio(aspectratio_index);
sample_if_failure_return(ret_error, TD_FAILURE);
return ret_error;
}
static td_s32 hdmi_auth_mode(td_u32 argc)
{
td_u32 authmode;
if (argc <= 1) {
printf("usage:hdmi_authmode mode\n");
printf("hdmi_authmode: 0 disable authmode\n");
printf("hdmi_authmode: 1 enable authmode\n");
return TD_FAILURE;
}
authmode = hdmi_string_to_integer(g_args[1]);
if ((authmode >= HDMI_MAX_AUTHMODE)) {
printf("Invalid input parameters: %s\n", g_args[1]);
printf("usage:hdmi_authmode mode\n");
printf("hdmi_authmode: 0 disable authmode\n");
printf("hdmi_authmode: 1 enable authmode\n");
return TD_FAILURE;
}
hdmi_authmode(authmode);
return TD_SUCCESS;
}
static td_s32 hdmi_audio_freq(td_u32 argc)
{
td_s32 ret_error;
td_u32 a_freq_index;
td_u8 index;
if (argc <= 1) {
for (index = 0; index < HDMI_MAX_AUDIO_FREQNCE; index++) {
printf("audio freq:%02d %s\n", index, g_hdmi_a_freq[index].index_string);
}
return TD_FAILURE;
}
a_freq_index = hdmi_string_to_integer(g_args[1]);
if (a_freq_index >= HDMI_MAX_AUDIO_FREQNCE) {
printf("Invalid input parameters: %s\n", g_args[1]);
printf("usage:hdmi_audio_freq mode\n");
for (index = 0; index < HDMI_MAX_AUDIO_FREQNCE; index++) {
printf("audio freq:%02d %s\n", index, g_hdmi_a_freq[index].index_string);
}
return TD_FAILURE;
}
ret_error = hdmi_freq(a_freq_index);
sample_if_failure_return(ret_error, TD_FAILURE);
return ret_error;
}
static td_s32 hdmi_parse_arg(td_u32 argc)
{
td_u32 i;
td_s32 ret_error = TD_SUCCESS;
printf("input parameter num:%d ", argc);
for (i = 0; i < argc; i++) {
printf("argv[%d]:%s, ", i, g_args[i]);
}
printf("\n");
if ((strcmp("help", (char *)g_args[0]) == 0) || (strcmp("h", (char *)g_args[0]) == 0)) {
print_help_info();
} else if (strcmp("hdmi_hdmi_force", (char *)g_args[0]) == 0) {
hdmi_hdmi_force();
} else if (strcmp("hdmi_dvi_force", (char *)g_args[0]) == 0) {
hdmi_dvi_force();
} else if (strcmp("hdmi_deepcolor", (char *)g_args[0]) == 0) {
ret_error = hdmi_deep_color(argc);
} else if (strcmp("hdmi_video_timing", (char *)g_args[0]) == 0) {
ret_error = hdmi_videotiming(argc);
} else if (strcmp("hdmi_color_mode", (char *)g_args[0]) == 0) {
ret_error = hdmi_colormode(argc);
} else if (strcmp("hdmi_aspectratio", (char *)g_args[0]) == 0) {
ret_error = hdmi_aspect_ratio(argc);
} else if (strcmp("hdmi_authmode", (char *)g_args[0]) == 0) {
ret_error = hdmi_auth_mode(argc);
} else if (strcmp("hdmi_a_freq", (char *)g_args[0]) == 0) {
ret_error = hdmi_audio_freq(argc);
}
return ret_error;
}
td_s32 hdmi_test_cmd(td_char *string, td_u32 len)
{
td_u8 argc;
if (string == NULL) {
return TD_FAILURE;
}
(td_void)memset_s(g_args, sizeof(g_args), 0, sizeof(g_args));
printf("string %s\n", string);
argc = hdmi_adjust_string(string, len);
if (argc == 0) {
return TD_FAILURE;
}
if ((strcmp("q", (char *)g_args[0]) == 0) || (strcmp("Q", (char *)g_args[0]) == 0) ||
(strcmp("quit", (char *)g_args[0]) == 0) || (strcmp("QUIT", (char *)g_args[0]) == 0)) {
printf("quit the program, use extran interface to quit\n");
return TD_FAILURE;
}
return hdmi_parse_arg(argc);
}
Reference in New Issue View Git Blame Copy Permalink