Reduce string comparisons in ms_node_set[get]_param_value()

The param_s structure now has been changed.
 - origin_name is renamed to prop_name.
 - enumeration for the prop_name and data_type are added.

These new members are set in param_table[] in media_streamer
_node.c. These are used to remove numerous string comparisons.

[Version] 0.1.101
[Issue Type] Refactoring

Change-Id: Iaab8cb68dbf6aeb81675b70e2393cc0de8c8cbe4
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>

diff --git a/include/media_streamer_priv.h b/include/media_streamer_priv.h
index 887c249..0e843b3 100644 (file)
--- a/include/media_streamer_priv.h
+++ b/include/media_streamer_priv.h
@@ -55,12 +55,57 @@ typedef struct {
        media_streamer_callback_s decoded_ready_cb;
 } media_streamer_webrtc_callbacks_s;
 
+typedef enum {
+       PROP_NAME_CAMERA_ID,
+       PROP_NAME_CAPTURE_WIDTH,
+       PROP_NAME_CAPTURE_HEIGHT,
+       PROP_NAME_IS_LIVE,
+       PROP_NAME_LIVING,
+       PROP_NAME_URI,
+       PROP_NAME_LOCATION,
+       PROP_NAME_USER_AGENT,
+       PROP_NAME_STREAM_TYPE,
+       PROP_NAME_PORT,
+       PROP_NAME_VIDEO_IN_PORT,
+       PROP_NAME_AUDIO_IN_PORT,
+       PROP_NAME_VIDEO_OUT_PORT,
+       PROP_NAME_AUDIO_OUT_PORT,
+       PROP_NAME_ADDRESS,
+       PROP_NAME_WEBRTC_PEER_TYPE,
+       PROP_NAME_WEBRTC_STUN_SERVER,
+       PROP_NAME_WEBRTC_REMOTE_SESSION_DESCRIPTION,
+       PROP_NAME_WEBRTC_ADD_ICE_CANDIDATE,
+       PROP_NAME_AUDIO_DEVICE,
+       PROP_NAME_SYNC,
+       PROP_NAME_ROTATE,
+       PROP_NAME_FLIP,
+       PROP_NAME_DISPLAY_GEOMETRY_METHOD,
+       PROP_NAME_DISPLAY,
+       PROP_NAME_VISIBLE,
+       PROP_NAME_USE_TBM,
+       PROP_NAME_HOST,
+       PROP_NAME_SEGMENT_LOCATION,
+       PROP_NAME_PLAYLIST_LOCATION,
+       PROP_NAME_MAX
+} prop_name_e;
+
+typedef enum {
+       PARAM_DATA_TYPE_NUMBER,
+       PARAM_DATA_TYPE_BOOL,
+       PARAM_DATA_TYPE_STRING,
+       PARAM_DATA_TYPE_ENUM,
+       PARAM_DATA_TYPE_POINTER,
+       PARAM_DATA_TYPE_MAX
+} param_data_type_e;
+
 /**
  * @brief Media Streamer param type handle.
  */
 typedef struct {
        char *param_name;
-       char *origin_name;
+       char *prop_name;
+       prop_name_e prop_enum;
+       param_data_type_e data_type;
 } param_s;
 
 /**

diff --git a/packaging/capi-media-streamer.spec b/packaging/capi-media-streamer.spec
index 368d96b..b2f206e 100644 (file)
--- a/packaging/capi-media-streamer.spec
+++ b/packaging/capi-media-streamer.spec
@@ -1,6 +1,6 @@
 Name:       capi-media-streamer
 Summary:    A Media Streamer API
-Version:    0.1.100
+Version:    0.1.101
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/media_streamer_node.c b/src/media_streamer_node.c
index cb048a9..82efdb7 100644 (file)
--- a/src/media_streamer_node.c
+++ b/src/media_streamer_node.c
@@ -38,37 +38,192 @@
 #define _WEBRTC_VIDEO_CAPSFILTER         "video_capsfilter"
 
 static param_s param_table[] = {
-       {MEDIA_STREAMER_PARAM_CAMERA_ID, "camera-id"},
-       {MEDIA_STREAMER_PARAM_CAPTURE_WIDTH, "capture-width"},
-       {MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT, "capture-height"},
-       {MEDIA_STREAMER_PARAM_IS_LIVE_STREAM, "is-live"},
-       {MEDIA_STREAMER_PARAM_IS_LIVE_STREAM, "living"},
-       {MEDIA_STREAMER_PARAM_URI, "uri"},
-       {MEDIA_STREAMER_PARAM_URI, "location"},
-       {MEDIA_STREAMER_PARAM_USER_AGENT, "user-agent"},
-       {MEDIA_STREAMER_PARAM_STREAM_TYPE, "stream-type"},
-       {MEDIA_STREAMER_PARAM_PORT, "port"},
-       {MEDIA_STREAMER_PARAM_VIDEO_IN_PORT, "video_in_port"},
-       {MEDIA_STREAMER_PARAM_AUDIO_IN_PORT, "audio_in_port"},
-       {MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT, "video_out_port"},
-       {MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT, "audio_out_port"},
-       {MEDIA_STREAMER_PARAM_IP_ADDRESS, "address"},
-       {MEDIA_STREAMER_PARAM_WEBRTC_PEER_TYPE, "webrtc-peer-type"},
-       {MEDIA_STREAMER_PARAM_WEBRTC_STUN_SERVER, "webrtc-stun-server"},
-       {MEDIA_STREAMER_PARAM_WEBRTC_REMOTE_SESSION_DESCRIPTION, "webrtc-remote-session-description"},
-       {MEDIA_STREAMER_PARAM_WEBRTC_ADD_ICE_CANDIDATE, "webrtc-add-ice-candidate"},
-       {MEDIA_STREAMER_PARAM_AUDIO_DEVICE, "audio_device"},
-       {MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED, "sync"},
-       {MEDIA_STREAMER_PARAM_ROTATE, "rotate"},
-       {MEDIA_STREAMER_PARAM_FLIP, "flip"},
-       {MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD, "display-geometry-method"},
-       {MEDIA_STREAMER_PARAM_DISPLAY, "display"},
-       {MEDIA_STREAMER_PARAM_VISIBLE, "visible"},
-       {MEDIA_STREAMER_PARAM_USE_TBM, "use-tbm"},
-       {MEDIA_STREAMER_PARAM_HOST, "host"},
-       {MEDIA_STREAMER_PARAM_SEGMENT_LOCATION, "location"},
-       {MEDIA_STREAMER_PARAM_PLAYLIST_LOCATION, "playlist-location"},
-       {NULL, NULL}
+       {
+               MEDIA_STREAMER_PARAM_CAMERA_ID,
+               "camera-id",
+               PROP_NAME_CAMERA_ID,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_CAPTURE_WIDTH,
+               "capture-width",
+               PROP_NAME_CAPTURE_WIDTH,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT,
+               "capture-height",
+               PROP_NAME_CAPTURE_HEIGHT,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_IS_LIVE_STREAM,
+               "is-live",
+               PROP_NAME_IS_LIVE,
+               PARAM_DATA_TYPE_BOOL
+       },
+       {
+               MEDIA_STREAMER_PARAM_IS_LIVE_STREAM,
+               "living",
+               PROP_NAME_LIVING,
+               PARAM_DATA_TYPE_BOOL
+       },
+       {
+               MEDIA_STREAMER_PARAM_URI,
+               "uri",
+               PROP_NAME_URI,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_URI,
+               "location",
+               PROP_NAME_LOCATION,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_USER_AGENT,
+               "user-agent",
+               PROP_NAME_USER_AGENT,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_STREAM_TYPE,
+               "stream-type",
+               PROP_NAME_STREAM_TYPE,
+               PARAM_DATA_TYPE_ENUM
+       },
+       {
+               MEDIA_STREAMER_PARAM_PORT,
+               "port",
+               PROP_NAME_PORT,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_VIDEO_IN_PORT,
+               "video_in_port",
+               PROP_NAME_VIDEO_IN_PORT,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_AUDIO_IN_PORT,
+               "audio_in_port",
+               PROP_NAME_AUDIO_IN_PORT,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT,
+               "video_out_port",
+               PROP_NAME_VIDEO_OUT_PORT,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT,
+               "audio_out_port",
+               PROP_NAME_AUDIO_OUT_PORT,
+               PARAM_DATA_TYPE_NUMBER
+       },
+       {
+               MEDIA_STREAMER_PARAM_IP_ADDRESS,
+               "address",
+               PROP_NAME_ADDRESS,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_WEBRTC_PEER_TYPE,
+               "webrtc-peer-type",
+               PROP_NAME_WEBRTC_PEER_TYPE,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_WEBRTC_STUN_SERVER,
+               "webrtc-stun-server",
+               PROP_NAME_WEBRTC_STUN_SERVER,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_WEBRTC_REMOTE_SESSION_DESCRIPTION,
+               "webrtc-remote-session-description",
+               PROP_NAME_WEBRTC_REMOTE_SESSION_DESCRIPTION,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_WEBRTC_ADD_ICE_CANDIDATE,
+               "webrtc-add-ice-candidate",
+               PROP_NAME_WEBRTC_ADD_ICE_CANDIDATE,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_AUDIO_DEVICE,
+               "audio_device",
+               PROP_NAME_AUDIO_DEVICE,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED,
+               "sync",
+               PROP_NAME_SYNC,
+               PARAM_DATA_TYPE_BOOL
+       },
+       {
+               MEDIA_STREAMER_PARAM_ROTATE,
+               "rotate",
+               PROP_NAME_ROTATE,
+               PARAM_DATA_TYPE_ENUM
+       },
+       {
+               MEDIA_STREAMER_PARAM_FLIP,
+               "flip",
+               PROP_NAME_FLIP,
+               PARAM_DATA_TYPE_ENUM
+       },
+       {
+               MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD,
+               "display-geometry-method",
+               PROP_NAME_DISPLAY_GEOMETRY_METHOD,
+               PARAM_DATA_TYPE_ENUM
+       },
+       {
+               MEDIA_STREAMER_PARAM_DISPLAY,
+               "display",
+               PROP_NAME_DISPLAY,
+               PARAM_DATA_TYPE_POINTER
+       },
+       {
+               MEDIA_STREAMER_PARAM_VISIBLE,
+               "visible",
+               PROP_NAME_VISIBLE,
+               PARAM_DATA_TYPE_BOOL
+       },
+       {
+               MEDIA_STREAMER_PARAM_USE_TBM,
+               "use-tbm",
+               PROP_NAME_USE_TBM,
+               PARAM_DATA_TYPE_BOOL
+       },
+       {
+               MEDIA_STREAMER_PARAM_HOST,
+               "host",
+               PROP_NAME_HOST,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_SEGMENT_LOCATION,
+               "location",
+               PROP_NAME_SEGMENT_LOCATION,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               MEDIA_STREAMER_PARAM_PLAYLIST_LOCATION,
+               "playlist-location",
+               PROP_NAME_PLAYLIST_LOCATION,
+               PARAM_DATA_TYPE_STRING
+       },
+       {
+               NULL,
+               NULL,
+               PROP_NAME_MAX,
+               PARAM_DATA_TYPE_MAX
+       }
 };
 
 static node_info_s nodes_info[] = {
@@ -1685,9 +1840,9 @@ static int __ms_node_get_param_list(media_streamer_node_s *node, GList **param_l
        ms_retvm_if(param_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param_list is NULL");
 
        for (it_param = 0; param_table[it_param].param_name != NULL; it_param++) {
-               param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_table[it_param].origin_name);
-               if (param_spec || __ms_rtp_node_has_property(node, param_table[it_param].origin_name) ||
-                               __ms_adaptive_src_node_has_property(node, param_table[it_param].origin_name)) {
+               param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_table[it_param].prop_name);
+               if (param_spec || __ms_rtp_node_has_property(node, param_table[it_param].prop_name) ||
+                               __ms_adaptive_src_node_has_property(node, param_table[it_param].prop_name)) {
                        ms_info("Got parameter [%s] for node [%s]", param_table[it_param].param_name, node->name);
                        *param_list = g_list_append(*param_list, &(param_table[it_param]));
                }
@@ -1722,7 +1877,6 @@ static int __ms_node_set_display(media_streamer_node_s *node, const char *param_
 
 int ms_node_set_param_value(media_streamer_node_s *node, param_s *param, const char *param_value)
 {
-
        int ret = MEDIA_STREAMER_ERROR_NONE;
 
        ms_debug_fenter();
@@ -1744,48 +1898,64 @@ int ms_node_set_param_value(media_streamer_node_s *node, param_s *param, const c
        }
 
        if (node->type == MEDIA_STREAMER_NODE_TYPE_SRC &&
-                       node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE) {
+               node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE) {
                ret = __ms_adaptive_src_node_set_property(node, param, param_value);
                ms_debug_fleave();
                return ret;
        }
 
-       if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAMERA_ID)) {
+       switch (param->prop_enum) {
+       case PROP_NAME_CAMERA_ID: {
                int camera_id = (int)strtol(param_value, NULL, 10);
                ms_retvm_if(camera_id == -1, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Invalid %s value", param->param_name);
-               g_object_set(node->gst_element, param->origin_name, camera_id, NULL);
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_STREAM_TYPE) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PORT) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_ROTATE) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_FLIP) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD)) {
-               g_object_set(node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USE_TBM) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VISIBLE)) {
-               g_object_set(node->gst_element, param->origin_name, !g_ascii_strcasecmp(param_value, "true"), NULL);
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_URI)) {
+               g_object_set(node->gst_element, param->prop_name, camera_id, NULL);
+               break;
+       }
+
+       case PROP_NAME_CAPTURE_WIDTH:
+       case PROP_NAME_CAPTURE_HEIGHT:
+       case PROP_NAME_STREAM_TYPE:
+       case PROP_NAME_PORT:
+       case PROP_NAME_ROTATE:
+       case PROP_NAME_FLIP:
+       case PROP_NAME_DISPLAY_GEOMETRY_METHOD:
+               g_object_set(node->gst_element, param->prop_name, (int)strtol(param_value, NULL, 10), NULL);
+               break;
+
+       case PROP_NAME_IS_LIVE:
+       case PROP_NAME_SYNC:
+       case PROP_NAME_USE_TBM:
+       case PROP_NAME_VISIBLE:
+               g_object_set(node->gst_element, param->prop_name, !g_ascii_strcasecmp(param_value, "true"), NULL);
+               break;
+
+       case PROP_NAME_URI:
+       case PROP_NAME_LOCATION:
                if (node->type == MEDIA_STREAMER_NODE_TYPE_SRC && node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_FILE) {
                        ret = ms_util_uri_path_check(param_value);
                        if (ret != MEDIA_STREAMER_ERROR_NONE)
                                return ret;
                }
-               g_object_set(node->gst_element, param->origin_name, param_value, NULL);
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USER_AGENT) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IP_ADDRESS) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_DEVICE) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_HOST) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_SEGMENT_LOCATION) ||
-                                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PLAYLIST_LOCATION)) {
-               g_object_set(node->gst_element, param->origin_name, param_value, NULL);
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY)) {
+               g_object_set(node->gst_element, param->prop_name, param_value, NULL);
+               break;
+
+       case PROP_NAME_USER_AGENT:
+       case PROP_NAME_ADDRESS:
+       case PROP_NAME_AUDIO_DEVICE:
+       case PROP_NAME_HOST:
+       case PROP_NAME_SEGMENT_LOCATION:
+       case PROP_NAME_PLAYLIST_LOCATION:
+               g_object_set(node->gst_element, param->prop_name, param_value, NULL);
+               break;
+
+       case PROP_NAME_DISPLAY:
                ret = __ms_node_set_display(node, param_value);
-       } else {
-               ms_info("Can not set parameter [%s] in the node [%s]", param->param_name, node->name);
+               break;
+
+       default:
+               ms_info("Can not set parameter [%s, %s] in the node [%s]", param->param_name, param->prop_name, node->name);
                ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+               break;
        }
 
        ms_debug_fleave();
@@ -1879,12 +2049,12 @@ int ms_node_get_param(media_streamer_node_s *node, const char *param_name, param
 
        for (it_param = 0; param_table[it_param].param_name != NULL; it_param++) {
                if (!g_strcmp0(param_name, param_table[it_param].param_name)) {
-                       param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_table[it_param].origin_name);
-                       if (param_spec || __ms_rtp_node_has_property(node, param_table[it_param].origin_name) ||
-                                       __ms_adaptive_src_node_has_property(node, param_table[it_param].origin_name) ||
-                                       __ms_webrtc_node_has_property(node, param_table[it_param].origin_name)) {
+                       param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_table[it_param].prop_name);
+                       if (param_spec || __ms_rtp_node_has_property(node, param_table[it_param].prop_name) ||
+                                       __ms_adaptive_src_node_has_property(node, param_table[it_param].prop_name) ||
+                                       __ms_webrtc_node_has_property(node, param_table[it_param].prop_name)) {
                                *param = &(param_table[it_param]);
-                               ms_info("Got parameter [%s] for node [%s]", (*param)->param_name, node->name);
+                               ms_info("Got parameter [%s, %s] for node [%s]", (*param)->param_name, (*param)->prop_name, node->name);
                                found_param = TRUE;
                                break;
                        }
@@ -1897,81 +2067,69 @@ int ms_node_get_param(media_streamer_node_s *node, const char *param_name, param
        return MEDIA_STREAMER_ERROR_NONE;
 }
 
+static gchar *__ms_convert_prop_value_to_string(param_s *param, const GValue *value)
+{
+       ms_retvm_if(param == NULL, NULL, "param is NULL");
+       ms_retvm_if(value == NULL, NULL, "value is NULL");
+
+       switch (param->data_type) {
+       case PARAM_DATA_TYPE_NUMBER:
+               return g_strdup_printf(G_VALUE_HOLDS_INT(value) ? "%d" : "%u", g_value_get_int(value));
+
+       case PARAM_DATA_TYPE_BOOL:
+               return g_strdup(g_value_get_boolean(value) ? "true" : "false");
+
+       case PARAM_DATA_TYPE_STRING:
+               return g_value_dup_string(value);
+
+       case PARAM_DATA_TYPE_ENUM:
+               return g_strdup_printf("%d", g_value_get_enum(value));
+
+       default:
+               ms_error("should not be reached here, param[name:%s, type:%d]", param->param_name, param->data_type);
+               return NULL;
+       }
+}
+
 int ms_node_get_param_value(media_streamer_node_s *node, param_s *param, char **string_value)
 {
        int ret = MEDIA_STREAMER_ERROR_NONE;
-       char *string_val = NULL;
+       gchar *prop_val_str = NULL;
        GParamSpec *param_spec = NULL;
        GValue value = G_VALUE_INIT;
 
-       ms_debug_fenter();
-
        ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
        ms_retvm_if(param == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param is NULL");
        ms_retvm_if(string_value == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "string_value is NULL");
 
+       ms_debug("node[%s] param[%s]", node->name, param->prop_name);
+
        if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP)
                ret = __ms_rtp_node_get_property(node, param, &value);
        else if (node->type == MEDIA_STREAMER_NODE_TYPE_SRC &&
                                node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE)
                ret = __ms_adaptive_src_node_get_property(node, param, &value);
        else {
-               param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param->origin_name);
+               param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param->prop_name);
                if (param_spec) {
                        g_value_init(&value, param_spec->value_type);
-                       g_object_get_property(G_OBJECT(node->gst_element), param->origin_name, &value);
+                       g_object_get_property(G_OBJECT(node->gst_element), param->prop_name, &value);
 
                        ms_info("Got parameter [%s] for node [%s] with description [%s]", param->param_name, node->name, g_param_spec_get_blurb(param_spec));
                } else {
-                       ms_error("There is no parameter [%s] for node [%s]", param->origin_name, node->name);
+                       ms_error("There is no parameter [%s] for node [%s]", param->prop_name, node->name);
                        return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
                }
        }
 
-       if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAMERA_ID) ||
-                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH) ||
-                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT) ||
-                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PORT) ||
-                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT) ||
-                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT) ||
-                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT) ||
-                       !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT)) {
-               if (G_VALUE_HOLDS_INT(&value))
-                       string_val = g_strdup_printf("%d", g_value_get_int(&value));
-               else
-                       string_val = g_strdup_printf("%u", g_value_get_uint(&value));
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USE_TBM) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VISIBLE)) {
-               string_val = g_strdup(g_value_get_boolean(&value) ? "true" : "false");
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_URI) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USER_AGENT) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IP_ADDRESS) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_DEVICE) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_HOST) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_SEGMENT_LOCATION) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PLAYLIST_LOCATION)) {
-               string_val = g_value_dup_string(&value);
-       } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_STREAM_TYPE) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_ROTATE) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_FLIP) ||
-                               !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD)) {
-               string_val = g_strdup_printf("%d", g_value_get_enum(&value));
-       } else {
-               ms_error("should not be reached here, could not find the param name[%s] of the node[%s]", param->param_name, node->name);
-               ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
-               goto end;
-       }
-
-       *string_value = string_val ? strdup(string_val) : NULL;
-       g_free(string_val);
+       prop_val_str = __ms_convert_prop_value_to_string(param, &value);
+       *string_value = prop_val_str ? strdup(prop_val_str) : NULL;
+       g_free(prop_val_str);
 
-end:
        g_value_reset(&value);
        g_value_unset(&value);
 
-       ms_debug_fleave();
+       ms_debug("string_value[%s]", *string_value);
 
        return ret;
 }