#include <mmf/mm_wfd_sink.h>
#include <scmirroring_primary_sink.h>
#include <scmirroring_private.h>
+#include <scmirroring_src.h>
#define MAX_MSG_LEN 128
#define TIMEOUT_SEC 2
{
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);
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");
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;
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");
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);
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");
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);
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)) {
}
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);
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);
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;
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;
{
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;
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);
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;
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();
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;
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;
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;
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();
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;
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;
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;
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;
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;
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;
projects / platform / core / api / screen-mirroring.git / commitdiff