From: Hyunsoo Park Date: Wed, 3 Aug 2022 05:41:42 +0000 (+0900) Subject: sink : remove duplicate codes X-Git-Tag: submit/tizen/20220804.081433^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fheads%2Ftizen_7.0_hotfix;p=platform%2Fcore%2Fapi%2Fscreen-mirroring.git sink : remove duplicate codes [Version] : 0.2.33 [Issue type] : Code cleanup By applying this patch, DC score would be increased to 4.51 Change-Id: I048a02aae3f08c34391a09d233c16faf994aae10 Signed-off-by: Hyunsoo Park --- diff --git a/include/scmirroring_private.h b/include/scmirroring_private.h index ca86c25..bc3ad4e 100644 --- a/include/scmirroring_private.h +++ b/include/scmirroring_private.h @@ -231,23 +231,9 @@ typedef struct { char *ip; char *port; bool use_hdcp; - char *server_name; - int resolution; - int connected; - int sock; - int source_id; - GIOChannel *channel; - char *sock_path; - int connect_mode; - int current_state; - scmirroring_state_cb_s *scmirroring_state_cb; scmirroring_sink_state_cb_s *scmirroring_sink_state_cb; - scmirroring_multisink_e multisink; - scmirroring_direct_streaming_e direct_streaming; - char *filesrc; - scmirroring_av_transport_e av_transport; char *coupled_sink_address; - scmirroring_coupling_mode_e coupling_mode; //MAKE SERVER COUPLING MODE + scmirroring_src_h primary_src; } scmirroring_primary_sink_s; diff --git a/packaging/capi-media-screen-mirroring.spec b/packaging/capi-media-screen-mirroring.spec index d3eff1e..cc1df46 100644 --- a/packaging/capi-media-screen-mirroring.spec +++ b/packaging/capi-media-screen-mirroring.spec @@ -1,6 +1,6 @@ Name: capi-media-screen-mirroring Summary: A screen mirroring library in Tizen C API -Version: 0.2.32 +Version: 0.2.33 Release: 1 Group: Multimedia/API License: Apache-2.0 diff --git a/src/scmirroring_primary_sink.c b/src/scmirroring_primary_sink.c index 86f6542..44f5c78 100644 --- a/src/scmirroring_primary_sink.c +++ b/src/scmirroring_primary_sink.c @@ -24,6 +24,7 @@ #include #include #include +#include #define MAX_MSG_LEN 128 #define TIMEOUT_SEC 2 @@ -55,48 +56,35 @@ int scmirroring_primary_sink_create(scmirroring_primary_sink_h *scmirroring_prim { CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - int ret = SCMIRRORING_ERROR_NONE; - scmirroring_debug_fenter(); scmirroring_retvm_if(scmirroring_primary_sink == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is NULL"); - scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)calloc(1, sizeof(scmirroring_primary_sink_s)); + scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)calloc(1, sizeof(scmirroring_primary_sink_s) + sizeof(scmirroring_src_s)); scmirroring_retvm_if(handle == NULL, SCMIRRORING_ERROR_OUT_OF_MEMORY, "Fail to allocate memory for handle"); scmirroring_error("New to Create"); handle->magic_num = SCMIRRORING_MAGIC_NUMBER; - handle->mm_handle = 0; - handle->use_hdcp = TRUE; - handle->scmirroring_sink_state_cb = NULL; - handle->ip = NULL; handle->port = NULL; - handle->filesrc = NULL; - handle->connected = NOT_CONNECTED_TO_SERVER; handle->use_hdcp = TRUE; - handle->resolution = 0; - handle->connect_mode = SCMIRRORING_CONNECTION_WIFI_DIRECT; - handle->scmirroring_state_cb = NULL; - handle->sock = -1; - handle->channel = NULL; - handle->sock_path = NULL; - handle->current_state = SCMIRRORING_STATE_CREATED; - handle->server_name = g_strdup("scmirroring"); - handle->multisink = SCMIRRORING_MULTISINK_DISABLE; - handle->av_transport = SCMIRRORING_AV_TRANSPORT_UDP; - handle->coupling_mode = SCMIRRORING_COUPLING_MODE_DISABLED; - - ret = mm_wfd_sink_create_r2(&handle->mm_handle); + handle->scmirroring_sink_state_cb = NULL; + + int ret = mm_wfd_sink_create_r2(&handle->mm_handle); if (ret != MM_ERROR_NONE) { - SCMIRRORING_SAFE_FREE(handle->server_name); SCMIRRORING_SAFE_FREE(handle); scmirroring_error("Fail to Create"); return _scmirroring_error_convert(__func__, ret); } + ret = scmirroring_src_create(&handle->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to create source handle\n"); + return _scmirroring_error_convert(__func__, ret); + } + *scmirroring_primary_sink = (scmirroring_primary_sink_h)handle; ret = _scmirroring_error_convert(__func__, ret); @@ -108,10 +96,10 @@ int scmirroring_primary_sink_create(scmirroring_primary_sink_h *scmirroring_prim int scmirroring_primary_sink_set_ip_and_port(scmirroring_primary_sink_h scmirroring_primary_sink, const char *ip, const char *port) { - scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; - scmirroring_debug_fenter(); + scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; + scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid"); scmirroring_retvm_if(ip == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "ip is NULL"); scmirroring_retvm_if(port == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "port is NULL"); @@ -160,15 +148,13 @@ int scmirroring_primary_sink_unprepare(scmirroring_primary_sink_h scmirroring_pr int scmirroring_primary_sink_destroy(scmirroring_primary_sink_h scmirroring_primary_sink) { - int ret = SCMIRRORING_ERROR_NONE; + scmirroring_debug_fenter(); scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid"); - ret = mm_wfd_sink_destroy(handle->mm_handle); + int ret = mm_wfd_sink_destroy(handle->mm_handle); handle->mm_handle = 0; handle->magic_num = 0; @@ -204,10 +190,10 @@ int scmirroring_primary_sink_disconnect(scmirroring_primary_sink_h scmirroring_p int scmirroring_primary_sink_set_state_changed_cb(scmirroring_primary_sink_h scmirroring_primary_sink, scmirroring_sink_state_cb callback, void *user_data) { - scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; - scmirroring_debug_fenter(); + scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; + scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid"); scmirroring_retvm_if(callback == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "callback is NULL"); @@ -229,10 +215,10 @@ int scmirroring_primary_sink_set_state_changed_cb(scmirroring_primary_sink_h scm int scmirroring_primary_sink_unset_state_changed_cb(scmirroring_primary_sink_h scmirroring_primary_sink) { - scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; - scmirroring_debug_fenter(); + scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; + scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid"); SCMIRRORING_SAFE_FREE(handle->scmirroring_sink_state_cb); @@ -350,8 +336,8 @@ int scmirroring_primary_sink_get_current_state(scmirroring_primary_sink_h scmirr int scmirroring_primary_sink_set_coupled_sink(scmirroring_primary_sink_h scmirroring_primary_sink, gchar* address) { - int ret = SCMIRRORING_ERROR_NONE; scmirroring_debug_fenter(); + scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid"); @@ -359,7 +345,7 @@ int scmirroring_primary_sink_set_coupled_sink(scmirroring_primary_sink_h scmirro scmirroring_debug("address [%s]", address); - ret = mm_wfd_sink_set_coupled_sink(handle->mm_handle, address); + int ret = mm_wfd_sink_set_coupled_sink(handle->mm_handle, address); if (ret != MM_ERROR_NONE) { scmirroring_error("Fail to Set Coupled IP"); return _scmirroring_error_convert(__func__, ret); @@ -373,12 +359,10 @@ int scmirroring_primary_sink_set_coupled_sink(scmirroring_primary_sink_h scmirro int scmirroring_primary_sink_set_coupled_sink_status(scmirroring_primary_sink_h scmirroring_primary_sink, int status) { - int ret = SCMIRRORING_ERROR_NONE; + scmirroring_debug_fenter(); scmirroring_primary_sink_s *handle = (scmirroring_primary_sink_s *)scmirroring_primary_sink; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(handle), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring_primary_sink is invalid"); if ((status < SCMIRRORING_COUPLING_STATUS_NOT_COUPLED) || (status >= SCMIRRORING_COUPLING_STATUS_MAX)) { @@ -387,7 +371,7 @@ int scmirroring_primary_sink_set_coupled_sink_status(scmirroring_primary_sink_h } scmirroring_debug("coupled sink status(%d)", status); - ret = mm_wfd_sink_set_coupled_sink_status(handle->mm_handle, status); + int ret = mm_wfd_sink_set_coupled_sink_status(handle->mm_handle, status); if (ret != MM_ERROR_NONE) { scmirroring_error("Fail to Set status"); return _scmirroring_error_convert(__func__, ret); @@ -403,13 +387,13 @@ int scmirroring_primary_sink_set_coupled_sink_status(scmirroring_primary_sink_h static gboolean __scmirroring_primary_src_callback_call(gpointer data) { scmirroring_primary_sink_s *scmirroring = (scmirroring_primary_sink_s *) data; - + scmirroring_src_s *scmirroring_src = (scmirroring_src_s *)scmirroring->primary_src; if (scmirroring == NULL) { scmirroring_error("SCMIRRORING is NULL"); return FALSE; } - scmirroring_state_cb_s *cb_info = scmirroring->scmirroring_state_cb; + scmirroring_state_cb_s *cb_info = scmirroring_src->scmirroring_state_cb; if ((cb_info != NULL) && (cb_info->state_cb != NULL)) { scmirroring_debug("Calling user callback(error: %d, status: %d)", cb_info->error_code, cb_info->src_state); @@ -419,13 +403,13 @@ static gboolean __scmirroring_primary_src_callback_call(gpointer data) if (cb_info != NULL && cb_info->src_state == SCMIRRORING_STATE_NULL) { SCMIRRORING_SAFE_FREE(scmirroring->ip); SCMIRRORING_SAFE_FREE(scmirroring->port); - SCMIRRORING_SAFE_FREE(scmirroring->scmirroring_state_cb); + SCMIRRORING_SAFE_FREE(scmirroring_src->scmirroring_state_cb); - g_io_channel_shutdown(scmirroring->channel, FALSE, NULL); - g_io_channel_unref(scmirroring->channel); + g_io_channel_shutdown(scmirroring_src->channel, FALSE, NULL); + g_io_channel_unref(scmirroring_src->channel); - SCMIRRORING_SAFE_G_FREE(scmirroring->sock_path); - SCMIRRORING_SAFE_FREE(scmirroring); + SCMIRRORING_SAFE_G_FREE(scmirroring_src->sock_path); + SCMIRRORING_SAFE_FREE(scmirroring->primary_src); } return FALSE; @@ -468,7 +452,8 @@ static int __scmirroring_primary_src_get_messages(scmirroring_primary_sink_s *sc static void __scmirroring_primary_src_set_callback_info(scmirroring_primary_sink_s *scmirroring, int error_code, int state) { - scmirroring_state_cb_s *cb_info = scmirroring->scmirroring_state_cb; + scmirroring_src_s *scmirroring_src = (scmirroring_src_s *)scmirroring->primary_src; + scmirroring_state_cb_s *cb_info = scmirroring_src->scmirroring_state_cb; if (cb_info) { cb_info->error_code = error_code; cb_info->src_state = state; @@ -488,6 +473,7 @@ static void __scmirroring_primary_src_interpret(scmirroring_primary_sink_s *scmi { scmirroring_debug("Received : %s", buf); + scmirroring_src_s *scmirroring_src = (scmirroring_src_s *)scmirroring->primary_src; int error_code = SCMIRRORING_ERROR_INVALID_OPERATION; int src_state = SCMIRRORING_STATE_CREATED; gchar **response; @@ -500,8 +486,8 @@ static void __scmirroring_primary_src_interpret(scmirroring_primary_sink_s *scmi error_code = __scmirroring_primary_src_get_error(response[0]); src_state = _scmirroring_src_state_convert(response[1]); - if (scmirroring->current_state != src_state) { - scmirroring->current_state = src_state; + if (scmirroring_src->current_state != src_state) { + scmirroring_src->current_state = src_state; __scmirroring_primary_src_set_callback_info(scmirroring, error_code, src_state); } else { scmirroring_debug("Current state is already %d", src_state); @@ -529,9 +515,10 @@ gboolean __scmirroring_primary_src_read_cb(GIOChannel *src, GIOCondition conditi gsize read; scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)data; + scmirroring_src_s *scmirroring_src = (scmirroring_src_s *)_scmirroring->primary_src; if (condition & G_IO_IN) { - g_io_channel_read_chars(_scmirroring->channel, buf, MAX_MSG_LEN, &read, NULL); + g_io_channel_read_chars(scmirroring_src->channel, buf, MAX_MSG_LEN, &read, NULL); if (read == 0) { scmirroring_error("Read 0 bytes"); return FALSE; @@ -568,37 +555,15 @@ gboolean __scmirroring_primary_src_read_cb(GIOChannel *src, GIOCondition conditi int scmirroring_primary_src_create(scmirroring_primary_sink_h *scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); + scmirroring_debug_fenter(); - int ret = SCMIRRORING_ERROR_NONE; scmirroring_primary_sink_s *_scmirroring = NULL; - scmirroring_debug_fenter(); - - scmirroring_retvm_if(scmirroring == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL"); - - _scmirroring = (scmirroring_primary_sink_s *)calloc(1, sizeof(scmirroring_primary_sink_s)); - scmirroring_retvm_if(_scmirroring == NULL, SCMIRRORING_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY"); - - _scmirroring->magic_num = SCMIRRORING_MAGIC_NUMBER; - _scmirroring->ip = NULL; - _scmirroring->port = NULL; - _scmirroring->filesrc = NULL; - _scmirroring->connected = NOT_CONNECTED_TO_SERVER; - _scmirroring->use_hdcp = TRUE; - _scmirroring->resolution = 0; - _scmirroring->connect_mode = SCMIRRORING_CONNECTION_WIFI_DIRECT; - _scmirroring->scmirroring_state_cb = NULL; - _scmirroring->sock = -1; - _scmirroring->channel = NULL; - _scmirroring->sock_path = NULL; - _scmirroring->current_state = SCMIRRORING_STATE_CREATED; - _scmirroring->server_name = g_strdup("scmirroring"); - _scmirroring->multisink = SCMIRRORING_MULTISINK_DISABLE; - _scmirroring->av_transport = SCMIRRORING_AV_TRANSPORT_UDP; - _scmirroring->coupling_mode = SCMIRRORING_COUPLING_MODE_DISABLED; - - *scmirroring = (scmirroring_primary_sink_h)_scmirroring; + int ret = scmirroring_src_create(&_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to create source handle\n"); + return _scmirroring_error_convert(__func__, ret); + } scmirroring_debug_fleave(); @@ -607,26 +572,16 @@ int scmirroring_primary_src_create(scmirroring_primary_sink_h *scmirroring) int scmirroring_primary_src_set_connection_mode(scmirroring_primary_sink_h scmirroring, scmirroring_connection_mode_e connect_mode) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if ((connect_mode < SCMIRRORING_CONNECTION_WIFI_DIRECT) || (connect_mode >= SCMIRRORING_CONNECTION_MAX)) { - scmirroring_error("INVALID Connection mode : %d", connect_mode); - return SCMIRRORING_ERROR_INVALID_PARAMETER; + int ret = scmirroring_src_set_connection_mode(_scmirroring->primary_src, connect_mode); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set connection_mode\n"); + return _scmirroring_error_convert(__func__, ret); } - _scmirroring->connect_mode = connect_mode; - - if (_scmirroring->connected) - ret = _scmirroring_src_send_set_cm(_scmirroring->sock, _scmirroring->connect_mode); - scmirroring_debug_fleave(); return ret; @@ -634,27 +589,16 @@ int scmirroring_primary_src_set_connection_mode(scmirroring_primary_sink_h scmir int scmirroring_primary_src_set_state_changed_cb(scmirroring_primary_sink_h scmirroring, scmirroring_state_cb callback, void *user_data) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); - scmirroring_retvm_if(callback == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "callback is NULL"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if (_scmirroring->scmirroring_state_cb == NULL) { - _scmirroring->scmirroring_state_cb = (scmirroring_state_cb_s *)calloc(1, sizeof(scmirroring_state_cb_s)); - scmirroring_retvm_if(_scmirroring->scmirroring_state_cb == NULL, SCMIRRORING_ERROR_OUT_OF_MEMORY, "Error Set CB"); - } else { - memset(_scmirroring->scmirroring_state_cb, 0, sizeof(scmirroring_state_cb_s)); + int ret = scmirroring_src_set_state_changed_cb(_scmirroring->primary_src, callback, NULL); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set state changed callback\n"); + return _scmirroring_error_convert(__func__, ret); } - _scmirroring->scmirroring_state_cb->user_data = user_data; - _scmirroring->scmirroring_state_cb->state_cb = callback; - scmirroring_debug_fleave(); return ret; @@ -662,23 +606,16 @@ int scmirroring_primary_src_set_state_changed_cb(scmirroring_primary_sink_h scmi int scmirroring_primary_src_unset_state_changed_cb(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if (_scmirroring->scmirroring_state_cb != NULL) { - _scmirroring->scmirroring_state_cb->user_data = NULL; - _scmirroring->scmirroring_state_cb->state_cb = NULL; + int ret = scmirroring_src_unset_state_changed_cb(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to unset state changed callback\n"); + return _scmirroring_error_convert(__func__, ret); } - SCMIRRORING_SAFE_FREE(_scmirroring->scmirroring_state_cb); - scmirroring_debug_fleave(); return ret; @@ -686,76 +623,32 @@ int scmirroring_primary_src_unset_state_changed_cb(scmirroring_primary_sink_h sc int scmirroring_primary_src_set_ip_and_port(scmirroring_primary_sink_h scmirroring, const char *ip, const char *port) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); - scmirroring_retvm_if(!STRING_VALID(ip), SCMIRRORING_ERROR_INVALID_PARAMETER, "INVALID IP"); - scmirroring_retvm_if(!STRING_VALID(port), SCMIRRORING_ERROR_INVALID_PARAMETER, "INVALID PORT"); - - SCMIRRORING_SAFE_FREE(_scmirroring->ip); - _scmirroring->ip = strdup(ip); - scmirroring_retvm_if(_scmirroring->ip == NULL, SCMIRRORING_ERROR_OUT_OF_MEMORY, "Out of memory for IP"); - - SCMIRRORING_SAFE_FREE(_scmirroring->port); - _scmirroring->port = strdup(port); - scmirroring_retvm_if(_scmirroring->port == NULL, SCMIRRORING_ERROR_OUT_OF_MEMORY, "Out of memory for PORT"); - - if (_scmirroring->connected) - ret = _scmirroring_src_send_set_ip(_scmirroring->sock, _scmirroring->ip, _scmirroring->port); - - scmirroring_debug_fleave(); - - return ret; -} - -int scmirroring_primary_src_set_resolution(scmirroring_primary_sink_h scmirroring, scmirroring_resolution_e resolution) -{ - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); - - if ((resolution < SCMIRRORING_RESOLUTION_1920x1080_P30) || (resolution >= SCMIRRORING_RESOLUTION_MAX)) { - scmirroring_error("INVALID resolution : %d", resolution); - return SCMIRRORING_ERROR_INVALID_PARAMETER; + int ret = scmirroring_src_set_ip_and_port(_scmirroring->primary_src, ip, port); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set ip and port\n"); + return _scmirroring_error_convert(__func__, ret); } - _scmirroring->resolution = resolution; - - if (_scmirroring->connected) - ret = _scmirroring_src_send_set_reso(_scmirroring->sock, _scmirroring->resolution); - scmirroring_debug_fleave(); return ret; } -int scmirroring_primary_src_set_server_name(scmirroring_primary_sink_h scmirroring, const char *name) +int scmirroring_primary_src_set_resolution(scmirroring_primary_sink_h scmirroring, scmirroring_resolution_e resolution) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - SCMIRRORING_SAFE_G_FREE(_scmirroring->server_name); - _scmirroring->server_name = g_strdup(name); - scmirroring_retvm_if(_scmirroring->server_name == NULL, SCMIRRORING_ERROR_OUT_OF_MEMORY, "Out of memory for server name"); + int ret = scmirroring_src_set_resolution(_scmirroring->primary_src, resolution); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set resolution\n"); + return _scmirroring_error_convert(__func__, ret); + } scmirroring_debug_fleave(); @@ -764,26 +657,16 @@ int scmirroring_primary_src_set_server_name(scmirroring_primary_sink_h scmirrori int scmirroring_primary_src_set_multisink_ability(scmirroring_primary_sink_h scmirroring, scmirroring_multisink_e multisink) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if ((multisink < SCMIRRORING_MULTISINK_DISABLE) || (multisink > SCMIRRORING_MULTISINK_ENABLE)) { - scmirroring_error("INVALID multisink ability : %d", multisink); - return SCMIRRORING_ERROR_INVALID_PARAMETER; + int ret = scmirroring_src_set_multisink_ability(_scmirroring->primary_src, multisink); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set multisink\n"); + return _scmirroring_error_convert(__func__, ret); } - _scmirroring->multisink = multisink; - - if (_scmirroring->connected) - ret = _scmirroring_src_send_set_multisink(_scmirroring->sock, _scmirroring->multisink); - scmirroring_debug_fleave(); return ret; @@ -791,113 +674,16 @@ int scmirroring_primary_src_set_multisink_ability(scmirroring_primary_sink_h scm int scmirroring_primary_src_connect(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - int retry = 0; - struct sockaddr_un serv_addr; - int sock = -1; - GIOChannel *channel = NULL; - struct timeval tv_timeout = { TIMEOUT_SEC, 0 }; - char buf[255] = {0, }; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); - - scmirroring_retvm_if(_scmirroring->connected == CONNECTED_TO_SERVER, SCMIRRORING_ERROR_NONE, "already connected to server."); - - /*Create TCP Socket*/ - if ((sock = socket(PF_FILE, SOCK_STREAM, 0)) < 0) { - strerror_r(errno, buf, sizeof(buf)); - scmirroring_error("socket failed: %s", buf); - return SCMIRRORING_ERROR_INVALID_OPERATION; - } - - if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) { - strerror_r(errno, buf, sizeof(buf)); - scmirroring_error("setsockopt failed: %s", buf); - close(sock); - return SCMIRRORING_ERROR_INVALID_OPERATION; - } - - channel = g_io_channel_unix_new(sock); - if (channel == NULL) { - strerror_r(errno, buf, sizeof(buf)); - scmirroring_error("g_io_channel_unix_new failed: %s", buf); - } - - g_io_channel_set_flags(channel, G_IO_FLAG_NONBLOCK, NULL); - - _scmirroring->sock = sock; - _scmirroring->channel = channel; - SCMIRRORING_SAFE_G_FREE(_scmirroring->sock_path); - _scmirroring->sock_path = g_strdup("/tmp/.miracast_ipc_rtspserver"); - - /* Connecting to the miracast server */ - memset(&serv_addr, 0, sizeof(struct sockaddr_un)); - serv_addr.sun_family = AF_UNIX; - g_strlcpy(serv_addr.sun_path, _scmirroring->sock_path, sizeof(serv_addr.sun_path)); - -try: - scmirroring_debug("Trying to connect to the miracast server"); - if (connect(_scmirroring->sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { - /* Once failed to connect, try to launch miracast server */ - if (retry == 0) { - ret = _scmirroring_server_launch(_scmirroring->server_name); - if (ret != SCMIRRORING_ERROR_NONE) { - SCMIRRORING_SAFE_G_FREE(_scmirroring->sock_path); - scmirroring_error("_scmirroring_server_launch error : %d", ret); - return ret; - } - retry++; - goto try; - } else { - scmirroring_debug("Trying to connect failed"); - if (retry < 5) { - scmirroring_debug("Trying to connect again.."); - retry++; - usleep(10000); - goto try; - } - - strerror_r(errno, buf, sizeof(buf)); - scmirroring_error("Connect error : %s", buf); - close(_scmirroring->sock); - _scmirroring->sock = -1; - SCMIRRORING_SAFE_G_FREE(_scmirroring->sock_path); - return SCMIRRORING_ERROR_INVALID_OPERATION; - } - } else { - scmirroring_debug("Connected successfully"); - } - - /* Create new channel to watch tcp socket */ - GSource *source = NULL; - source = g_io_create_watch(_scmirroring->channel, G_IO_IN | G_IO_HUP | G_IO_ERR); - int source_id = -1; - - /* Set callback to be called when socket is readable */ - g_source_set_callback(source, G_SOURCE_FUNC(__scmirroring_primary_src_read_cb), _scmirroring, NULL); - source_id = g_source_attach(source, g_main_context_get_thread_default()); - - _scmirroring->source_id = source_id; - _scmirroring->connected = CONNECTED_TO_SERVER; - _scmirroring->current_state = SCMIRRORING_STATE_READY; - - __scmirroring_primary_src_set_callback_info(_scmirroring, SCMIRRORING_ERROR_NONE, SCMIRRORING_STATE_READY); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if ((_scmirroring->ip != NULL) || (_scmirroring->port != NULL)) { - ret = _scmirroring_src_send_set_ip(_scmirroring->sock, _scmirroring->ip, _scmirroring->port); - ret = _scmirroring_src_send_set_cm(_scmirroring->sock, _scmirroring->connect_mode); - ret = _scmirroring_src_send_set_reso(_scmirroring->sock, _scmirroring->resolution); + int ret = scmirroring_src_connect(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to connect\n"); + return _scmirroring_error_convert(__func__, ret); } - if (_scmirroring->multisink == SCMIRRORING_MULTISINK_ENABLE) - ret = _scmirroring_src_send_set_multisink(_scmirroring->sock, _scmirroring->multisink); - scmirroring_debug_fleave(); return ret; @@ -905,35 +691,16 @@ try: int scmirroring_primary_src_disconnect(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); - scmirroring_retvm_if(_scmirroring->connected == NOT_CONNECTED_TO_SERVER, SCMIRRORING_ERROR_NONE, "Already disconnected"); - - ret = _scmirroring_src_send_cmd_to_server(_scmirroring->sock, SCMIRRORING_STATE_CMD_DESTROY); - if (ret != SCMIRRORING_ERROR_NONE) - scmirroring_error("Failed to destroy miracast server [%d]", ret); - - if (_scmirroring->channel != NULL) { - g_io_channel_shutdown(_scmirroring->channel, FALSE, NULL); - g_io_channel_unref(_scmirroring->channel); - _scmirroring->channel = NULL; - } + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if (_scmirroring->sock != -1) { - close(_scmirroring->sock); - _scmirroring->sock = -1; + int ret = scmirroring_src_disconnect(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to disconnect\n"); + return _scmirroring_error_convert(__func__, ret); } - SCMIRRORING_SAFE_G_FREE(_scmirroring->sock_path); - _scmirroring->connected = NOT_CONNECTED_TO_SERVER; - scmirroring_debug_fleave(); return ret; @@ -941,94 +708,84 @@ int scmirroring_primary_src_disconnect(scmirroring_primary_sink_h scmirroring) int scmirroring_primary_src_start(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); + scmirroring_debug_fenter(); scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + int ret = scmirroring_src_start(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to start\n"); + return _scmirroring_error_convert(__func__, ret); + } - return _scmirroring_src_send_cmd_to_server(_scmirroring->sock, SCMIRRORING_STATE_CMD_START); + scmirroring_debug_fleave(); + + return ret; } int scmirroring_primary_src_pause(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); + scmirroring_debug_fenter(); scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + int ret = scmirroring_src_pause(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to pause\n"); + return _scmirroring_error_convert(__func__, ret); + } - return _scmirroring_src_send_cmd_to_server(_scmirroring->sock, SCMIRRORING_STATE_CMD_PAUSE); + scmirroring_debug_fleave(); + return ret; } int scmirroring_primary_src_resume(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); + scmirroring_debug_fenter(); scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + int ret = scmirroring_src_resume(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to resume\n"); + return _scmirroring_error_convert(__func__, ret); + } - return _scmirroring_src_send_cmd_to_server(_scmirroring->sock, SCMIRRORING_STATE_CMD_RESUME); + scmirroring_debug_fleave(); + + return ret; } -int scmirroring_primary_src_set_direct_streaming(scmirroring_primary_sink_h scmirroring_primary_src, +int scmirroring_primary_src_set_direct_streaming(scmirroring_primary_sink_h scmirroring, scmirroring_direct_streaming_e enable, const char* uri_srcname) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - int len = 0; - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring_primary_src; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); - scmirroring_retvm_if(!STRING_VALID(uri_srcname), SCMIRRORING_ERROR_INVALID_PARAMETER, "INVALID URI_SRCNAME"); - _scmirroring->direct_streaming = enable; - - len = strlen(uri_srcname); - if (_scmirroring->filesrc != NULL) { - g_free(_scmirroring->filesrc); - _scmirroring->filesrc = NULL; - } - _scmirroring->filesrc = g_strndup(uri_srcname, len); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if ((_scmirroring->filesrc == NULL)) { - scmirroring_error("OUT_OF_MEMORY"); - return SCMIRRORING_ERROR_OUT_OF_MEMORY; + int ret = scmirroring_src_set_direct_streaming(_scmirroring->primary_src, enable, uri_srcname); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set direct streaming\n"); + return _scmirroring_error_convert(__func__, ret); } - ret = _scmirroring_src_send_set_direct_streaming(_scmirroring->sock, _scmirroring->direct_streaming, _scmirroring->filesrc); - scmirroring_debug_fleave(); return ret; } - int scmirroring_primary_src_set_coupling_mode(scmirroring_primary_sink_h scmirroring, scmirroring_coupling_mode_e coupling_mode) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if ((coupling_mode < SCMIRRORING_COUPLING_MODE_DISABLED) || (coupling_mode > SCMIRRORING_COUPLING_MODE_ENABLED)) { - scmirroring_error("INVALID coupling mode : %d", coupling_mode); - return SCMIRRORING_ERROR_INVALID_PARAMETER; + int ret = scmirroring_src_set_coupling_mode(_scmirroring->primary_src, coupling_mode); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set coupling mode\n"); + return _scmirroring_error_convert(__func__, ret); } - _scmirroring->coupling_mode = coupling_mode; - - if (_scmirroring->connected) - ret = _scmirroring_src_send_set_coupling_mode(_scmirroring->sock, coupling_mode); - scmirroring_debug_fleave(); return ret; @@ -1037,24 +794,16 @@ int scmirroring_primary_src_set_coupling_mode(scmirroring_primary_sink_h scmirro int scmirroring_primary_src_AV_transport_switch(scmirroring_primary_sink_h scmirroring, scmirroring_av_transport_e transport) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if (transport < SCMIRRORING_AV_TRANSPORT_UDP || transport > SCMIRRORING_AV_TRANSPORT_TCP) { - scmirroring_error("Invalid transport"); - return SCMIRRORING_ERROR_INVALID_PARAMETER; + int ret = scmirroring_src_AV_transport_switch(_scmirroring->primary_src, SCMIRRORING_AV_TRANSPORT_UDP); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to set av transport switch\n"); + return _scmirroring_error_convert(__func__, ret); } - _scmirroring->av_transport = transport; - - ret = _scmirroring_src_send_switch_transport(_scmirroring->sock, transport); - scmirroring_debug_fleave(); return ret; @@ -1062,35 +811,33 @@ int scmirroring_primary_src_AV_transport_switch(scmirroring_primary_sink_h scmir int scmirroring_primary_src_stop(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); + scmirroring_debug_fenter(); scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + int ret = scmirroring_src_stop(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to stop\n"); + return _scmirroring_error_convert(__func__, ret); + } - return _scmirroring_src_send_cmd_to_server(_scmirroring->sock, SCMIRRORING_STATE_CMD_STOP); + scmirroring_debug_fleave(); + + return ret; } int scmirroring_primary_src_destroy(scmirroring_primary_sink_h scmirroring) { - CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE); - - int ret = SCMIRRORING_ERROR_NONE; - scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - scmirroring_debug_fenter(); - scmirroring_retvm_if(!__is_valid_handle(_scmirroring), SCMIRRORING_ERROR_INVALID_PARAMETER, "scmirroring is invalid"); + scmirroring_primary_sink_s *_scmirroring = (scmirroring_primary_sink_s *)scmirroring; - if (_scmirroring->connected == CONNECTED_TO_SERVER) { - ret = scmirroring_primary_src_disconnect(scmirroring); - if (ret != SCMIRRORING_ERROR_NONE) - scmirroring_error("Failed to disconnect server [%d]", ret); + int ret = scmirroring_src_destroy(_scmirroring->primary_src); + if (ret != SCMIRRORING_ERROR_NONE) { + scmirroring_error("Failed to destroy\n"); + return _scmirroring_error_convert(__func__, ret); } - SCMIRRORING_SAFE_FREE(_scmirroring->scmirroring_state_cb); - SCMIRRORING_SAFE_G_FREE(_scmirroring->server_name); - scmirroring_debug_fleave(); return ret; diff --git a/test_sink/scmirroring_primary_sink_test.c b/test_sink/scmirroring_primary_sink_test.c index 4285a27..b712029 100644 --- a/test_sink/scmirroring_primary_sink_test.c +++ b/test_sink/scmirroring_primary_sink_test.c @@ -1251,7 +1251,7 @@ int _scmirroring_primary_src_create(void) int ret = SCMIRRORING_ERROR_NONE; g_print("Create source handle\n"); - ret = scmirroring_primary_src_create(&scmirroring_primary_sink); + ret = scmirroring_primary_sink_create(&scmirroring_primary_sink); if (ret != SCMIRRORING_ERROR_NONE) { g_print("Failed to create source handle\n"); return ret;