Direct streaming initial version

Signed-off-by: SeokHoon Lee <andy.shlee@samsung.com>
Change-Id: I4aa06c52ef06aaffe34334b0006b7c0dc69b5e65

diff --git a/include/scmirroring_private.h b/include/scmirroring_private.h
index 9449fb24932138902faba8a9547c78eedaa55298..f3dee22e915584cd43074b4489e20481e986a970 100644 (file)
--- a/include/scmirroring_private.h
+++ b/include/scmirroring_private.h
@@ -130,6 +130,8 @@ typedef struct {
        int current_state;
        scmirroring_state_cb_s *scmirroring_state_cb;
        scmirroring_multisink_e multisink;
+       scmirroring_direct_streaming_e direct_streaming;
+       char *filesrc;
        scmirroring_av_transport_e av_transport;
 } scmirroring_src_s;
 

diff --git a/include/scmirroring_src.h b/include/scmirroring_src.h
index c6e9dff9f26d88c6b0b22394e2e467e2aaabee74..fa1dc0463bac8a13062248e5f95e21c0d47c87af 100644 (file)
--- a/include/scmirroring_src.h
+++ b/include/scmirroring_src.h
@@ -265,6 +265,31 @@ int scmirroring_src_pause(scmirroring_src_h scmirroring_src);
  */
 int scmirroring_src_resume(scmirroring_src_h scmirroring_src);
 
+/**
+ * @brief Enable streaming without reencoding for screen mirroring.
+ * @details This function enable streaming without reencoding for screen mirroring, which means files that encoded with supported formats will be streamed without decoding and reencoding.
+ *
+ * @param[in] scmirroring_src The handle to screen mirroring source
+ * @param[in] enable Ability to stream file directly
+ * @param[in] uri_srcname File name to stream directly
+ *
+ * @return @c 0 on success,
+ *         otherwise a negative error value
+ *
+ * @retval #SCMIRRORING_ERROR_NONE Successful
+ * @retval #SCMIRRORING_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #SCMIRRORING_ERROR_OUT_OF_MEMORY Not enough memory to allocate new object
+ * @retval #SCMIRRORING_ERROR_INVALID_OPERATION External function not implemented
+ *
+ * @pre The screen mirroring state should be SCMIRRORING_STATE_PLAYING
+ *
+ * @see scmirroring_src_create()
+ * @see scmirroring_src_set_state_changed_cb()
+ * @see scmirroring_src_connect()
+ * @see scmirroring_src_start()
+ */
+int scmirroring_src_set_direct_streaming(scmirroring_src_h scmirroring_src, scmirroring_direct_streaming_e enable, const char *uri_srcname);
+
 /**
  * @brief Change transport for AV streaming.
  * @details This function changes transport for AV streaming. Default transport is UDP.

diff --git a/include/scmirroring_type.h b/include/scmirroring_type.h
index 162ef729560ee200604470e18ed6edbce8acbffa..a934efb9670522427eeae3a2c9ae1899c9f0594c 100644 (file)
--- a/include/scmirroring_type.h
+++ b/include/scmirroring_type.h
@@ -124,6 +124,15 @@ typedef enum {
        SCMIRRORING_VIDEO_CODEC_H264         /**< H.264 codec for video */
 } scmirroring_video_codec_e;
 
+/**
+ * @brief Enumeration for screen mirroring direct streaming mode.
+ * @since_tizen 3.0
+ */
+typedef enum {
+       SCMIRRORING_DIRECT_STREAMING_DISABLED = 0,    /**< Disable screen mirroring direct streaming mode */
+       SCMIRRORING_DIRECT_STREAMING_ENABLED          /**< Enable direct streaming for files */
+} scmirroring_direct_streaming_e;
+
 /**
  * @brief Enumeration for screen mirroring AV streaming transport.
  * @since_tizen 3.0
@@ -133,7 +142,7 @@ typedef enum {
        SCMIRRORING_AV_TRANSPORT_TCP         /**< TCP transport for AV streaming data */
 } scmirroring_av_transport_e;
 
- /**
+/**
  * @brief Called when each status is changed.
  * @since_tizen 2.4
  *

diff --git a/miracast_server/miracast_server_impl.c b/miracast_server/miracast_server_impl.c
index dbf37b1c9c0fdb779195b1d051a6dffeb75e7b80..91400f994c731f6512b58aaac198b25fe2ccb52a 100644 (file)
--- a/miracast_server/miracast_server_impl.c
+++ b/miracast_server/miracast_server_impl.c
@@ -715,6 +715,27 @@ failed:
        return SCMIRRORING_ERROR_INVALID_OPERATION;
 }
 
+static int __miracast_server_set_direct_streaming(MiracastServer *server_obj, gint direct_streaming,
+               gchar *filesrc)
+{
+       GstRTSPWFDServer *server = NULL;
+       server = (GstRTSPWFDServer *)server_obj->server;
+       if (server == NULL) {
+               scmirroring_error("No server object");
+               goto failed;
+       }
+
+       if (gst_rtsp_wfd_server_set_direct_streaming(server, direct_streaming, filesrc) != ERROR_NONE) {
+               scmirroring_error("Failed to set direct streaming to server object");
+               goto failed;
+       }
+
+       return SCMIRRORING_ERROR_NONE;
+failed:
+       scmirroring_error("Failed to start direct streaming");
+       return SCMIRRORING_ERROR_INVALID_OPERATION;
+}
+
 static int __miracast_server_switch_transport(MiracastServer *server_obj, gint transport)
 {
        GstRTSPWFDServer *server = NULL;
@@ -825,6 +846,27 @@ void __miracast_server_interpret(MiracastServer *server, gchar *buf)
                g_strfreev(multisink_info);
 
                klass->send_response(server, "OK:SET");
+       } else if (g_strrstr(buf, "SET STREAMING")) {
+               gchar **streaming_info = NULL;
+
+               streaming_info = g_strsplit(buf, " ", 0);
+               if (streaming_info == NULL || streaming_info[2] == NULL || streaming_info[3] == NULL) {
+                       klass->send_response(server, "FAIL:SET");
+                       g_strfreev(streaming_info);
+                       return;
+               }
+
+               scmirroring_debug("Streming command: %d, Filesrc: %s", atoi(streaming_info[2]), streaming_info[3]);
+
+               ret = __miracast_server_set_direct_streaming(server, atoi(streaming_info[2]), streaming_info[3]);
+
+               if (ret == SCMIRRORING_ERROR_NONE)
+                       klass->send_response(server, "OK:SET");
+               else
+                       klass->send_response(server, "FAIL:SET");
+
+               g_strfreev(streaming_info);
+
        } else if (g_strrstr(buf, "SWITCH UDP")) {
                scmirroring_debug("Swithc AV streaming transport to UDP");
 

diff --git a/packaging/capi-media-screen-mirroring.spec b/packaging/capi-media-screen-mirroring.spec
index c3f7aaf465174d2b584cf3825c1e6a349fcb2504..1f5f3713371c53f4a6db50ab7fb9286a3f7ff207 100644 (file)
--- 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.1.82
+Version:    0.1.83
 Release:    0
 Group:      Multimedia/API
 License:    Apache-2.0

diff --git a/src/scmirroring_src.c b/src/scmirroring_src.c
index d2189efe9d9842596c9d99c9de0671535eb25033..b771e0cb0acea9080cfed82abb3249f78c433349 100644 (file)
--- a/src/scmirroring_src.c
+++ b/src/scmirroring_src.c
@@ -376,6 +376,28 @@ static int __scmirroring_src_send_set_multisink(scmirroring_src_h scmirroring)
        return ret;
 }
 
+static int __scmirroring_src_send_set_direct_streaming(scmirroring_src_h scmirroring)
+{
+       /* Set resolution to miracast server */
+       char *cmd = NULL;
+       int ret = SCMIRRORING_ERROR_NONE;
+       scmirroring_src_s *_scmirroring = (scmirroring_src_s *)scmirroring;
+
+       scmirroring_retvm_if(_scmirroring == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+       cmd = g_strdup_printf("SET STREAMING %d %s", _scmirroring->direct_streaming, _scmirroring->filesrc);
+       ret = __scmirroring_src_send_cmd_to_server(_scmirroring, cmd);
+       if (ret != SCMIRRORING_ERROR_NONE) {
+               SCMIRRORING_SAFE_FREE(cmd);
+               scmirroring_error("Failed to enable direct streaming [%d]", ret);
+               return SCMIRRORING_ERROR_INVALID_OPERATION;
+       }
+
+       SCMIRRORING_SAFE_FREE(cmd);
+
+       return ret;
+}
+
 static int __scmirroring_src_send_switch_transport(scmirroring_src_h scmirroring)
 {
        /* Set tranport protocol to miracast server */
@@ -414,6 +436,7 @@ int scmirroring_src_create(scmirroring_src_h *scmirroring)
        _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;
@@ -841,6 +864,41 @@ int scmirroring_src_resume(scmirroring_src_h scmirroring)
        return ret;
 }
 
+int scmirroring_src_set_direct_streaming(scmirroring_src_h scmirroring_src,
+               scmirroring_direct_streaming_e enable, const char* uri_srcname)
+{
+       CHECK_FEATURE_SUPPORTED(WIFIDIRECT_DISPLAY_FEATURE);
+
+       int ret = SCMIRRORING_ERROR_NONE;
+       int len = 0;
+       scmirroring_src_s *_scmirroring = (scmirroring_src_s *)scmirroring_src;
+
+       scmirroring_debug_fenter();
+
+       scmirroring_retvm_if(_scmirroring == NULL, SCMIRRORING_ERROR_INVALID_PARAMETER, "Handle is NULL");
+       scmirroring_retvm_if(_scmirroring->magic_num != SCMIRRORING_MAGIC_NUMBER, SCMIRRORING_ERROR_INVALID_PARAMETER, "Invalid handle");
+       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);
+
+       if ((_scmirroring->filesrc == NULL)) {
+               scmirroring_error("OUT_OF_MEMORY");
+               return SCMIRRORING_ERROR_OUT_OF_MEMORY;
+       }
+
+       ret = __scmirroring_src_send_set_direct_streaming(_scmirroring);
+
+       scmirroring_debug_fleave();
+
+       return ret;
+}
+
 int scmirroring_src_AV_transport_switch(scmirroring_src_h scmirroring,
                scmirroring_av_transport_e transport)
 {

diff --git a/test/scmirroring_test.c b/test/scmirroring_test.c
index be49f3c09aeb3f0fb7fe26bba362543f0edecba1..65f440ed6296c5cfce51288e52a8652b14ec13ba 100644 (file)
--- a/test/scmirroring_test.c
+++ b/test/scmirroring_test.c
@@ -54,6 +54,7 @@ static void __displaymenu(void)
        g_print("S : Start  \n");
        g_print("P : Pause \n");
        g_print("R : Resume \n");
+       g_print("s : Direct Streaming (ex. s 1 file:///tmp/file.mp4 (0:disable, 1:enable))\n");
        g_print("u : Switch to UDP\n");
        g_print("t : Switch ti TCP\n");
        g_print("T : sTop\n");
@@ -126,6 +127,9 @@ static void __interpret(char *cmd)
        } else if (strncmp(cmd, "t", 1) == 0) {
                g_print("Switch to TCP\n");
                ret = scmirroring_src_AV_transport_switch(g_scmirroring, SCMIRRORING_AV_TRANSPORT_TCP);
+       } else if (strncmp(cmd, "s", 1) == 0) {
+               ret = scmirroring_src_set_direct_streaming(g_scmirroring, atoi(value[1]), value[2]);
+               g_print("Direct streaming state - [%d] Source - [%s]\n", atoi(value[1]), value[2]);
        } else if (strncmp(cmd, "T", 1) == 0) {
                g_print("Stop\n");
                ret = scmirroring_src_stop(g_scmirroring);