*/
void __ms_generate_dots(GstElement *bin, gchar *name_tag);
-/**
- * @brief Returns the string representation of GST_STATE.
- *
- * @since_tizen 3.0
- */
-const char *_ms_state_to_string(GstState state);
-
/**
* @brief Creates GstElement by plugin name.
*
* @since_tizen 3.0
*/
gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node,
- GstElement **rtp_elem, GstElement **rtcp_elem, const gchar *elem_name);
+ GstElement **rtp_elem,
+ GstElement **rtcp_elem,
+ const gchar *elem_name,
+ const gchar *direction,
+ gboolean auto_create);
/**
* @brief Converts key-value property into needed GType
*/
int __ms_element_set_state(GstElement *gst_element, GstState gst_state);
+/**
+ * @brief Iterates pas inside gst element.
+ *
+ * @since_tizen 3.0
+ */
+int __ms_iterate_pads(GstElement *gst_element, GstPadDirection pad_type, char ***pad_name_array, int *pads_count);
+
/**
* @brief Gets mediaformat from the GstElement's pad by pad name.
*
* @since_tizen 3.0
*/
-media_format_h __ms_element_get_pad_fmt(GstElement *gst_element, const char* pad_name);
+media_format_h __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad_name);
/**
* @brief Sets mediaformat into GstElement.
*
* @since_tizen 3.0
*/
-int __ms_element_set_fmt(media_streamer_node_s *node, media_format_h fmt);
+int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, media_format_h fmt);
/**
* @brief Push the media packet buffer to the source element.
*/
int __ms_node_write_params_into_bundle(media_streamer_node_s *node,
bundle *param_list);
+
+/**
+ * @brief Writes GstElement property into user's value.
+ *
+ * @since_tizen 3.0
+ */
+int __ms_node_write_param_into_value(media_streamer_node_s *node,
+ const char *param_name, char **param_value);
\ No newline at end of file
#include <media_streamer.h>
#include <media_streamer_util.h>
+struct media_streamer_node_s;
/**
* @brief Media Streamer callbacks structure.
*
} media_streamer_ini_t;
/*Test elements*/
-#define DEFAULT_VIDEO_TEST_SOURCE "videotestsrc"
-#define DEFAULT_AUDIO_TEST_SOURCE "audiotestsrc"
-#define DEFAULT_FAKE_SINK "fakesink"
-#define DEFAULT_QUEUE "queue"
+#define DEFAULT_VIDEO_TEST_SOURCE "videotestsrc"
+#define DEFAULT_AUDIO_TEST_SOURCE "audiotestsrc"
+#define DEFAULT_FAKE_SINK "fakesink"
+#define DEFAULT_QUEUE "queue"
/* setting default values if each value is not specified in .ini file */
/* general */
-#define DEFAULT_GENERATE_DOT FALSE
-#define DEFAULT_AUDIO_SOURCE "alsasrc"
-#define DEFAULT_CAMERA_SOURCE "camerasrc"
-#define DEFAULT_VIDEO_SOURCE "ximagesrc"
-#define DEFAULT_APP_SOURCE "appsrc"
-#define DEFAULT_AUDIO_SINK "pulsesink"
-#define DEFAULT_VIDEO_SINK "autovideosink"
-#define DEFAULT_VIDEO_CONVERT "videoconvert"
-#define DEFAULT_AUDIO_CONVERT "audioconvert"
-#define DEFAULT_AUDIO_RESAMPLE "audioresample"
-#define DEFAULT_APP_SINK "appsink"
+#define DEFAULT_GENERATE_DOT FALSE
+#define DEFAULT_AUDIO_SOURCE "alsasrc"
+#define DEFAULT_CAMERA_SOURCE "v4l2src"
+#define DEFAULT_VIDEO_SOURCE "ximagesrc"
+#define DEFAULT_APP_SOURCE "appsrc"
+#define DEFAULT_AUDIO_SINK "pulsesink"
+#define DEFAULT_VIDEO_SINK "autovideosink"
+#define DEFAULT_VIDEO_CONVERT "videoconvert"
+#define DEFAULT_AUDIO_CONVERT "audioconvert"
+#define DEFAULT_AUDIO_RESAMPLE "audioresample"
+#define DEFAULT_APP_SINK "appsink"
/* udp streaming */
-#define DEFAULT_UDP_SOURCE "udpsrc"
-#define DEFAULT_UDP_SINK "udpsink"
-#define DEFAULT_RTP_BIN "rtpbin"
+#define DEFAULT_UDP_SOURCE "udpsrc"
+#define DEFAULT_UDP_SINK "udpsink"
+#define DEFAULT_RTP_BIN "rtpbin"
/* video format defaults */
-#define DEFAULT_VIDEO_ENCODER "omxh264enc"
-#define DEFAULT_VIDEO_DECODER "omxh264dec"
-#define DEFAULT_VIDEO_PARSER "h263parse"
-#define DEFAULT_VIDEO_RTPPAY "rtph263pay"
-#define DEFAULT_VIDEO_RTPDEPAY "rtph263depay"
+#define DEFAULT_VIDEO_ENCODER "omxh264enc"
+#define DEFAULT_VIDEO_DECODER "omxh264dec"
+#define DEFAULT_VIDEO_PARSER "h263parse"
+#define DEFAULT_VIDEO_RTPPAY "rtph263pay"
+#define DEFAULT_VIDEO_RTPDEPAY "rtph263depay"
/* audio format defaults */
-#define DEFAULT_AUDIO_RTPPAY "rtpL16pay"
-#define DEFAULT_AUDIO_RTPDEPAY "rtpL16depay"
+#define DEFAULT_AUDIO_RTPPAY "rtpL16pay"
+#define DEFAULT_AUDIO_RTPDEPAY "rtpL16depay"
-#define MEDIA_STREAMER_DEFAULT_CAMERA_FORMAT "video/x-raw,width=320,height=240"
+#define MEDIA_STREAMER_DEFAULT_CAMERA_FORMAT "video/x-raw,width=1280,height=720"
#define MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT "audio/x-raw,channels=1,rate=44100,format=S16BE"
#define MEDIA_STREAMER_DEFAULT_ENCODER_FORMAT "video/x-h263,stream-format=byte-stream,profile=high"
-#define MS_ELEMENT_IS_SINK(el) g_str_has_suffix(el, "sink")
-#define MS_ELEMENT_IS_SOURCE(el) g_str_has_suffix(el, "source")
-#define MS_ELEMENT_IS_AUDIO(el) g_str_has_prefix(el, "audio")
-#define MS_ELEMENT_IS_VIDEO(el) g_str_has_prefix(el, "video")
+#define MS_ELEMENT_IS_OUTPUT(el) g_strrstr(el, "out")
+#define MS_ELEMENT_IS_INPUT(el) g_strrstr(el, "in")
+#define MS_ELEMENT_IS_AUDIO(el) g_strrstr(el, "audio")
+#define MS_ELEMENT_IS_VIDEO(el) g_strrstr(el, "video")
#define MEDIA_STREAMER_DEFAULT_DOT_DIR "/tmp"
#define MEDIA_STREAMER_DEFAULT_INI \
[sources] \n\
\n\
audio_source = pulsesrc \n\
-camera_source = camerasrc \n\
+camera_source = v4l2src \n\
video_source = ximagesrc \n\
udp_source = udpsrc \n\
\n\
[sinks] \n\
\n\
audio_sink = pulsesink \n\
-video_sink = autovideosink \n\
+video_sink = waylandsink \n\
udp_sink = udpsink \n\
\n\
\n\
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
+ __ms_autoplug_prepare(ms_streamer);
+
if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY) != MEDIA_STREAMER_ERROR_NONE) {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PAUSED) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
ms_retvm_if(fmt == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Format is NULL");
/* By default it sets format to object's property 'caps'*/
- return __ms_element_set_fmt(node, fmt);
+ return __ms_element_set_fmt(node, pad_name, fmt);
}
int media_streamer_node_get_pad_format(media_streamer_node_h node,
return MEDIA_STREAMER_ERROR_NONE;
}
+int media_streamer_node_get_pad_name(media_streamer_node_h node,
+ char ***src_pad_name,
+ int *src_pad_num,
+ char ***sink_pad_name,
+ int *sink_pad_num)
+{
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ media_streamer_node_s *ms_node = (media_streamer_node_s *)node;
+
+ ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ ms_retvm_if(src_pad_name == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Empty src pad name");
+ ms_retvm_if(src_pad_num == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Number of src_pads is NULL");
+ ms_retvm_if(sink_pad_name == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Empty sink pad name");
+ ms_retvm_if(sink_pad_num == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Number of sink_pads is NULL");
+ ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+
+ ret = __ms_iterate_pads(ms_node->gst_element, GST_PAD_SRC, src_pad_name, src_pad_num);
+ ms_retvm_if(ret, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error iterating src pads");
+
+ ret = __ms_iterate_pads(ms_node->gst_element, GST_PAD_SINK, sink_pad_name, sink_pad_num);
+ ms_retvm_if(ret, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error iterating sink pads");
+
+ return ret;
+}
+
int media_streamer_node_set_params(media_streamer_node_h node,
bundle *param_list)
{
ms_retvm_if(ms_params == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error creating new params object");
if (__ms_node_write_params_into_bundle(ms_node, ms_params) != MEDIA_STREAMER_ERROR_NONE) {
- ms_info("Node [%s] do not have any params.", ms_node->name);
+ ms_info("Node [%s] does not have any params.", ms_node->name);
bundle_free(ms_params);
*param_list = NULL;
ms_retvm_if(param_name == NULL || param_value == NULL,
MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Parameters name or value is NULL");
- return ms_node->set_param(ms_node, param_name, param_value);
+ return ms_node->set_param((struct media_streamer_node_s *)ms_node, param_name, param_value);
}
int media_streamer_node_get_param(media_streamer_node_h node,
media_streamer_node_s *ms_node = (media_streamer_node_s *)node;
ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ms_retvm_if(param_name == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Param name is NULL");
+ ms_retvm_if(param_value == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Param value is NULL");
- // TBD
+ char *ms_param = NULL;
+
+ if (__ms_node_write_param_into_value(ms_node, param_name,&ms_param) != MEDIA_STREAMER_ERROR_NONE) {
+ ms_info("Node [%s] does not have param [%s]", ms_node->name, param_name);
+
+ return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ }
+ *param_value = ms_param;
return MEDIA_STREAMER_ERROR_NONE;
}
MS_SAFE_GFREE(dot_name);
}
-const char *_ms_state_to_string(GstState state)
+static int __ms_add_no_target_ghostpad(GstElement *gst_bin,
+ const char *ghost_pad_name,
+ GstPadDirection pad_direction)
{
- static const char pending[] = "PENDING\0";
- static const char null_s[] = "NULL\0";
- static const char ready[] = "READY\0";
- static const char paused[] = "PAUSED\0";
- static const char playing[] = "PLAYING\0";
- switch (state) {
- case GST_STATE_VOID_PENDING:
- return pending;
- break;
- case GST_STATE_NULL:
- return null_s;
- break;
- case GST_STATE_READY:
- return ready;
- break;
- case GST_STATE_PAUSED:
- return paused;
- break;
- case GST_STATE_PLAYING:
- return playing;
- break;
- default:
- return "\0";
- break;
- };
- return 0;
-}
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ gchar *bin_name = gst_element_get_name(gst_bin);
+ GstPad *ghost_pad = gst_ghost_pad_new_no_target(ghost_pad_name, pad_direction);
+ if (gst_element_add_pad(GST_ELEMENT(gst_bin), ghost_pad)) {
+ ms_info("Added [%s] empty ghostpad into [%s]", ghost_pad_name, bin_name);
+ } else {
+ ms_info("Error: Failed to add empty [%s] ghostpad into [%s]", ghost_pad_name, bin_name);
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ }
+
+ MS_SAFE_GFREE(bin_name);
+ return ret;
+}
static int __ms_add_ghostpad(GstElement *gst_element,
const char *pad_name,
GstElement *gst_bin,
const char *ghost_pad_name)
{
- ms_retvm_if(!ghost_pad_name || !gst_bin, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ ms_retvm_if(!gst_element || !pad_name || !ghost_pad_name || !gst_bin, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
int ret = MEDIA_STREAMER_ERROR_NONE;
GstPad *ghost_pad = NULL;
gchar *bin_name = gst_element_get_name(gst_bin);
- if (!gst_element || !pad_name) {
- ghost_pad = gst_ghost_pad_new_no_target(ghost_pad_name, GST_PAD_SRC);
+ gchar *element_name = gst_element_get_name(gst_element);
+ GstPad *element_pad = gst_element_get_static_pad(gst_element, pad_name);
+ if (!element_pad) {
+ /*maybe it is request pad */
+ element_pad = gst_element_get_request_pad(gst_element, pad_name);
+ }
+ if (element_pad != NULL) {
+ ghost_pad = gst_ghost_pad_new(ghost_pad_name, element_pad);
+ gst_pad_set_active(ghost_pad, TRUE);
+
gst_element_add_pad(GST_ELEMENT(gst_bin), ghost_pad);
- ms_info("Added [%s] empty ghostpad into [%s]", ghost_pad_name, bin_name);
+ ms_info("Added %s ghostpad from [%s] into [%s]", pad_name, element_name, bin_name);
+ MS_SAFE_UNREF(element_pad);
+ MS_SAFE_GFREE(element_name);
+
ret = MEDIA_STREAMER_ERROR_NONE;
} else {
- gchar *element_name = gst_element_get_name(gst_element);
- GstPad *element_pad = gst_element_get_static_pad(gst_element, pad_name);
- if (!element_pad) {
- /*maybe it is request pad */
- element_pad = gst_element_get_request_pad(gst_element, pad_name);
- }
- if (element_pad != NULL) {
- ghost_pad = gst_ghost_pad_new(ghost_pad_name, element_pad);
- gst_pad_set_active(ghost_pad, TRUE);
-
- gst_element_add_pad(GST_ELEMENT(gst_bin), ghost_pad);
- ms_info("Added %s ghostpad from [%s] into [%s]", pad_name, element_name, bin_name);
- MS_SAFE_UNREF(element_pad);
- MS_SAFE_GFREE(element_name);
-
- ret = MEDIA_STREAMER_ERROR_NONE;
- } else {
- ms_error("Error: element [%s] does not have valid [%s] pad for adding into [%s] bin",
- element_name, pad_name, bin_name);
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
+ ms_error("Error: element [%s] does not have valid [%s] pad for adding into [%s] bin",
+ element_name, pad_name, bin_name);
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
MS_SAFE_GFREE(bin_name);
-
return ret;
}
}
g_object_set_property(obj, key, &value);
MS_SAFE_GFREE(element_name);
+
+ return TRUE;
}
gboolean __ms_element_unlink(GstElement *element)
gst_iterator_free(pad_iterator);
/*Remove node's element from bin and reference saving*/
- parent = gst_element_get_parent(element);
+ parent = (GstElement *)gst_element_get_parent(GST_OBJECT_CAST(element));
if (parent != NULL) {
gst_object_ref(element);
gboolean ret = FALSE;
GstPad *src_pad = NULL; //pad of unlinked inner element
- GValue elem = G_VALUE_INIT;
- GstIterator *bin_iterator;
-
gchar *source_pad_name = gst_pad_get_name(source_pad);
GstElement *found_element = __ms_bin_find_element_by_klass(sink_bin, "Depayloader/Network/RTP");
const gchar *src_pad_type = gst_structure_get_string(src_pad_struct, "media");
ms_debug("type is [%s]", src_pad_type);
if (MS_ELEMENT_IS_VIDEO(src_pad_type)) {
- source_pad_name = g_strdup_printf("%s_source", "video");
+ source_pad_name = g_strdup_printf("%s_out", "video");
sink_bin = ms_node->parent_streamer->sink_video_bin;
} else if (MS_ELEMENT_IS_AUDIO(src_pad_type)) {
- source_pad_name = g_strdup_printf("%s_source", "audio");
+ source_pad_name = g_strdup_printf("%s_out", "audio");
sink_bin = ms_node->parent_streamer->sink_audio_bin;
}
ret_state = gst_element_set_state(gst_element, gst_state);
if (ret_state == GST_STATE_CHANGE_FAILURE) {
- ms_error("Failed to set element [%s] into %s state", element_name, _ms_state_to_string(gst_state));
+ ms_error("Failed to set element [%s] into %s state",
+ element_name, gst_element_state_get_name(gst_state));
MS_SAFE_GFREE(element_name);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
g_object_set(G_OBJECT(decoder_parser), "config-interval", 5, NULL);
}
- is_omx = g_strrstr(format_prefix, "omx");
+ if (g_strrstr(format_prefix, "omx")) {
+ is_omx = TRUE;
+ }
+
MS_SAFE_FREE(format_prefix);
MS_SAFE_FREE(plugin_name);
}
gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node,
- GstElement **rtp_elem, GstElement **rtcp_elem, const gchar *elem_name)
+ GstElement **rtp_elem,
+ GstElement **rtcp_elem,
+ const gchar *elem_name,
+ const gchar *direction,
+ gboolean auto_create)
{
- gboolean ret = FALSE;
+ gboolean ret = TRUE;
gchar *rtp_elem_name = NULL;
gchar *rtcp_elem_name = NULL;
gchar *plugin_name = NULL;
GstElement *rtpbin = gst_bin_get_by_name(GST_BIN(ms_node->gst_element), "rtpbin");
- ms_retvm_if(!elem_name, FALSE, "Empty rtp element name.");
+ ms_retvm_if(!elem_name || !direction, FALSE, "Empty rtp element name or direction.");
- if (MS_ELEMENT_IS_SOURCE(elem_name)) {
- plugin_name = g_strdup("udpsrc");
- } else if (MS_ELEMENT_IS_SINK(elem_name)) {
- plugin_name = g_strdup("udpsink");
+ if (MS_ELEMENT_IS_INPUT(direction)) {
+ plugin_name = g_strdup(DEFAULT_UDP_SOURCE);
+ } else if (MS_ELEMENT_IS_OUTPUT(direction)) {
+ plugin_name = g_strdup(DEFAULT_UDP_SINK);
} else {
ms_error("Error: invalid parameter name [%s]", elem_name);
return FALSE;
}
- rtp_elem_name = g_strdup_printf("%s_rtp", elem_name);
- rtcp_elem_name = g_strdup_printf("%s_rtcp", elem_name);
+ rtp_elem_name = g_strdup_printf("%s_%s_rtp", elem_name, direction);
+ rtcp_elem_name = g_strdup_printf("%s_%s_rtcp", elem_name, direction);
/* Find video udp rtp/rtcp element if it present. */
*rtp_elem = gst_bin_get_by_name(GST_BIN(ms_node->gst_element), rtp_elem_name);
*rtcp_elem = gst_bin_get_by_name(GST_BIN(ms_node->gst_element), rtcp_elem_name);
/* Create new udp element if it did not found. */
- if ((NULL == *rtp_elem) && (NULL == *rtcp_elem)) {
+ if ((NULL == *rtp_elem) && (NULL == *rtcp_elem) && auto_create) {
*rtp_elem = __ms_element_create(plugin_name, rtp_elem_name);
*rtcp_elem = __ms_element_create(plugin_name, rtcp_elem_name);
+ gst_bin_add_many(GST_BIN(ms_node->gst_element),
+ *rtp_elem, *rtcp_elem, NULL);
} else {
/*rtp/rtcp elements already into rtp bin. */
MS_SAFE_GFREE(rtp_elem_name);
return TRUE;
}
- gst_bin_add_many(GST_BIN(ms_node->gst_element),
- *rtp_elem, *rtcp_elem, NULL);
-
- if (MS_ELEMENT_IS_SINK(elem_name)) {
+ if (MS_ELEMENT_IS_OUTPUT(direction)) {
g_object_set(GST_OBJECT(*rtcp_elem), "sync", FALSE, NULL);
g_object_set(GST_OBJECT(*rtcp_elem), "async", FALSE, NULL);
if (MS_ELEMENT_IS_VIDEO(elem_name)) {
- __ms_add_ghostpad(rtpbin, "send_rtp_sink_0", ms_node->gst_element, "video_sink");
+ __ms_add_ghostpad(rtpbin, "send_rtp_sink_0", ms_node->gst_element, "video_in");
ret = gst_element_link_pads(rtpbin, "send_rtp_src_0", *rtp_elem, "sink") &&
gst_element_link_pads(rtpbin, "send_rtcp_src_0", *rtcp_elem, "sink");
} else {
- __ms_add_ghostpad(rtpbin, "send_rtp_sink_1", ms_node->gst_element, "audio_sink");
+ __ms_add_ghostpad(rtpbin, "send_rtp_sink_1", ms_node->gst_element, "audio_in");
ret = gst_element_link_pads(rtpbin, "send_rtp_src_1", *rtp_elem, "sink") &&
gst_element_link_pads(rtpbin, "send_rtcp_src_1", *rtcp_elem, "sink");
}
if (MS_ELEMENT_IS_VIDEO(elem_name)) {
ret = gst_element_link_pads(*rtp_elem, "src", rtpbin, "recv_rtp_sink_0") &&
gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_0");
- __ms_add_ghostpad(NULL, NULL, ms_node->gst_element, "video_source");
+ __ms_add_no_target_ghostpad(ms_node->gst_element, "video_out", GST_PAD_SRC);
+ __ms_add_no_target_ghostpad(ms_node->gst_element, "video_in_rtp", GST_PAD_SINK);
} else {
ret = gst_element_link_pads(*rtp_elem, "src", rtpbin, "recv_rtp_sink_1") &&
gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_1");
- __ms_add_ghostpad(NULL, NULL, ms_node->gst_element, "audio_source");
+ __ms_add_no_target_ghostpad(ms_node->gst_element, "audio_out", GST_PAD_SRC);
+ __ms_add_no_target_ghostpad(ms_node->gst_element, "audio_in_rtp", GST_PAD_SINK);
}
}
if (!ret) {
- ms_error("Can not link [rtpbin] pad to [%s] pad, ret code [%d] ", rtp_elem, ret);
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ ms_error("Can not link [rtpbin] pad to [%s] pad", rtp_elem_name);
+ ret = FALSE;
}
__ms_generate_dots(ms_node->gst_element, "rtp");
if (message != NULL) {
switch (GST_MESSAGE_TYPE(message)) {
case GST_MESSAGE_ERROR: {
- GError *err;
- gchar *debug;
+ GError *err = NULL;
+ gchar *debug = NULL;
gst_message_parse_error(message, &err, &debug);
ms_error("[Source: %s] Error: %s", GST_OBJECT_NAME(GST_OBJECT_CAST(GST_ELEMENT(GST_MESSAGE_SRC(message)))), err->message);
- MS_SAFE_FREE(err);
+ g_error_free(err);
MS_SAFE_FREE(debug);
break;
}
gchar *state_transition_name;
gst_message_parse_state_changed(message, &state_old, &state_new, &state_pending);
- ms_info("GST_MESSAGE_STATE_CHANGED: [%s] %s -> %s\n",
- gst_object_get_name(GST_MESSAGE_SRC(message)),
- _ms_state_to_string(state_old),
- _ms_state_to_string(state_new));
-
state_transition_name = g_strdup_printf("%s_%s",
gst_element_state_get_name(state_old),
gst_element_state_get_name(state_new));
-
+ ms_info("GST_MESSAGE_STATE_CHANGED: [%s] %s",
+ gst_object_get_name(GST_MESSAGE_SRC(message)),
+ state_transition_name);
__ms_generate_dots(ms_streamer->pipeline, state_transition_name);
MS_SAFE_GFREE(state_transition_name);
-
- if (state_old == GST_STATE_NULL && state_new == GST_STATE_READY) {
- ms_info("[Success] GST_STATE_NULL => GST_STATE_READY");
-
- /* Pause Media_Streamer */
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
- if (ret != MEDIA_STREAMER_ERROR_NONE) {
- ms_error("ERROR - Pause pipeline");
- return FALSE;
- }
- }
-
- if (state_old == GST_STATE_READY && state_new == GST_STATE_PAUSED) {
- ms_info("[Success] GST_STATE_READY => GST_STATE_PAUSED");
-
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING);
- if (ret != MEDIA_STREAMER_ERROR_NONE) {
- ms_error("ERROR - Play Pipeline");
- return FALSE;
- }
- }
}
break;
}
if (mime & MEDIA_FORMAT_RAW) {
format_name = g_strdup(__ms_convert_mime_to_string(mime));
caps = gst_caps_new_simple("video/x-raw",
- /*"framerate", GST_TYPE_FRACTION, max_bps, avg_bps, */
+ "framerate", GST_TYPE_FRACTION, max_bps, avg_bps,
"format", G_TYPE_STRING, format_name,
"width", G_TYPE_INT, width,
"height", G_TYPE_INT, height, NULL);
ms_debug("Pad type is [%s], format: [%s]", pad_type, pad_format);
if (MS_ELEMENT_IS_VIDEO(pad_type)) {
- int width, height;
- media_format_set_video_mime(fmt, __ms_convert_string_format_to_mime(pad_format));
- gst_structure_get_int(pad_struct, "width", &width);
- media_format_set_video_width(fmt, width);
+ int width, height, avg_bps, max_bps;
+ gst_structure_get_int(pad_struct, "width", &width);
+ gst_structure_get_fraction(pad_struct, "framerate", &max_bps, &avg_bps);
gst_structure_get_int(pad_struct, "height", &height);
+
+ media_format_set_video_mime(fmt, __ms_convert_string_format_to_mime(pad_format));
+ media_format_set_video_width(fmt, width);
media_format_set_video_height(fmt, height);
+ media_format_set_video_avg_bps(fmt, avg_bps);
+ media_format_set_video_max_bps(fmt, max_bps);
} else if (MS_ELEMENT_IS_AUDIO(pad_type)) {
int channels, bps;
media_format_set_audio_mime(fmt, __ms_convert_string_format_to_mime(pad_format));
return fmt;
}
+int __ms_iterate_pads(GstElement *gst_element, GstPadDirection pad_type, char ***pad_name_array, int *pads_count)
+{
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+ int pad_number = 0;
+ GValue elem = G_VALUE_INIT;
+ GstPad *pad = NULL;
+ char **pad_names = NULL;
+ GstIterator *pad_iterator = NULL;
+
+ if(pad_type == GST_PAD_SRC) {
+ pad_iterator = gst_element_iterate_src_pads(gst_element);
+ } else if(pad_type == GST_PAD_SINK) {
+ pad_iterator = gst_element_iterate_sink_pads(gst_element);
+ } else {
+ pad_iterator = gst_element_iterate_pads(gst_element);
+ ms_info("Iterating all pads of the Gst element");
+ }
+
+ while (GST_ITERATOR_OK == gst_iterator_next(pad_iterator, &elem)) {
+ pad = (GstPad *)g_value_get_object(&elem);
+
+ pad_names = (char **)realloc(pad_names, sizeof(char *) * (pad_number + 1));
+ if(!pad_names){
+ ms_error("Error allocation memory");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ pad_number = 0;
+ MS_SAFE_FREE(pad_names);
+ break;
+ }
+
+ pad_names[pad_number] = gst_pad_get_name(pad);
+ ++pad_number;
+
+ g_value_reset(&elem);
+ }
+
+ g_value_unset(&elem);
+ gst_iterator_free(pad_iterator);
+
+ *pad_name_array = pad_names;
+ *pads_count = pad_number;
+
+ return ret;
+}
+
media_format_h __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad_name)
{
media_format_h fmt;
return fmt;
}
-int __ms_element_set_fmt(media_streamer_node_s *node, media_format_h fmt)
+int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, media_format_h fmt)
{
GstCaps *caps = NULL;
GObject *obj = NULL;
GValue value = G_VALUE_INIT;
- caps = __ms_create_caps_from_fmt(fmt);
- ms_retvm_if(caps == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail creating caps from fmt.");
- obj = __ms_get_property_owner(node->gst_element, "caps", &value);
+ if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP) {
+ /* It is needed to set 'application/x-rtp' for audio and video udpsrc*/
+ media_format_mimetype_e mime;
+ GstElement *rtp_elem, *rtcp_elem;
+
+ /*Check if it is a valid pad*/
+ GstPad *pad = gst_element_get_static_pad(node->gst_element, pad_name);
+ if (!pad) {
+ ms_error("Error: Failed set format to pad [%s].[%s].", node->name, pad_name);
+ return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (MEDIA_FORMAT_ERROR_NONE == media_format_get_video_info(fmt, &mime, NULL, NULL, NULL, NULL)) {
+ __ms_get_rtp_elements(node, &rtp_elem, &rtcp_elem, "video", "in", FALSE);
+
+ caps = gst_caps_from_string("application/x-rtp,media=video,clock-rate=90000,encoding-name=H264");
+ ms_retvm_if(caps == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail creating caps from fmt.");
+
+ obj = __ms_get_property_owner(rtp_elem, "caps", &value);
+ } else if (MEDIA_FORMAT_ERROR_NONE == media_format_get_audio_info(fmt, &mime, NULL, NULL, NULL, NULL)) {
+ __ms_get_rtp_elements(node, &rtp_elem, &rtcp_elem, "audio", "in", FALSE);
+
+ caps = gst_caps_from_string("application/x-rtp,media=audio,clock-rate=44100,encoding-name=L16,"
+ "encoding-params=1,channels=1,payload=96");
+ ms_retvm_if(caps == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail creating caps from fmt.");
+
+ obj = __ms_get_property_owner(rtp_elem, "caps", &value);
+ } else {
+ ms_error("Failed getting media info from fmt.");
+ return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ }
+
+ MS_SAFE_UNREF(pad);
+ } else {
+ caps = __ms_create_caps_from_fmt(fmt);
+ ms_retvm_if(caps == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail creating caps from fmt.");
+
+ obj = __ms_get_property_owner(node->gst_element, "caps", &value);
+ }
+
gst_value_set_caps(&value, caps);
g_object_set_property(obj, "caps", &value);
gst_caps_unref(caps);
}
media_packet_get_buffer_size(packet, &size);
- media_packet_get_buffer_data_ptr(packet, &buffer_data);
+ media_packet_get_buffer_data_ptr(packet, (void **)&buffer_data);
media_packet_get_pts(packet, &pts);
media_packet_get_duration(packet, &duration);
int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet)
{
GstBuffer *buffer = NULL;
- GstFlowReturn gst_ret = GST_FLOW_OK;
GstSample *sample = NULL;
GstMapInfo map;
ms_retvm_if(fmt == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION,
"Error while getting media format from sink pad");
- media_packet_create_from_external_memory(&fmt, (void *)map.data, map.size, NULL, NULL, packet);
+ media_packet_create_from_external_memory(fmt, (void *)map.data, map.size, NULL, NULL, packet);
media_packet_set_pts(*packet, GST_BUFFER_PTS(buffer));
media_packet_set_dts(*packet, GST_BUFFER_DTS(buffer));
media_packet_set_pts(*packet, GST_BUFFER_DURATION(buffer));
ms_retvm_if(!ms_node && !ms_node->gst_element, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error: empty node");
gchar **tokens = NULL;
- gchar *elem_name = NULL;
- guint i = 0;
GstElement *rtp_elem = NULL;
GstElement *rtcp_elem = NULL;
- tokens = g_strsplit(param_key, ",", 3);
- ms_retvm_if(tokens == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Invalid rtp parameter line.");
- elem_name = tokens[0];
+ gchar *elem_name, *direction, *param;
+
+ tokens = g_strsplit(param_key, "_", 3);
+ if (tokens && tokens[0] && !tokens[1]) {
+ /*In this case can be param names without direction description
+ * parameter 'host' will be set to all udpsink
+ * parameter 'format' will be set all udpsrc
+ */
+
+ param = tokens[0];
+ if (!g_strcmp0(param, MEDIA_STREAMER_PARAM_HOST)) {
+ __ms_get_rtp_elements(ms_node, &rtp_elem, &rtcp_elem, "audio", "out", FALSE);
+ if (rtp_elem && rtcp_elem) {
+ __ms_element_set_property(rtp_elem, param, param_value);
+ __ms_element_set_property(rtcp_elem, param, param_value);
+ }
+
+ __ms_get_rtp_elements(ms_node, &rtp_elem, &rtcp_elem, "video", "out", FALSE);
+ if (rtp_elem && rtcp_elem) {
+ __ms_element_set_property(rtp_elem, param, param_value);
+ __ms_element_set_property(rtcp_elem, param, param_value);
+ }
+ } else {
+ ms_error("Error: Unsupported parameter [%s] for rtp node.");
+ }
- if (FALSE == __ms_get_rtp_elements(ms_node, &rtp_elem, &rtcp_elem, elem_name)) {
- ms_error("Error: invalid parameter [%s]", param_key);
g_strfreev(tokens);
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
-
- for (i = 1; (tokens && tokens[i]); i++) {
- ms_retvm_if(!rtp_elem || !rtcp_elem,
- MEDIA_STREAMER_ERROR_INVALID_OPERATION,
- "Error: [%s] did not found or created into streamer", tokens[i]);
+ return MEDIA_STREAMER_ERROR_NONE;
+ } else if (tokens || tokens[0] || tokens[1] || tokens[2]) {
+
+ /*
+ * Rtp node parameter name consist of three fields separated with symbol '_':
+ * <video/audio>_<in/out>_<param_key>
+ */
+
+ elem_name = tokens[0];
+ direction = tokens[1];
+ param = tokens[2];
+ if (FALSE == __ms_get_rtp_elements(ms_node, &rtp_elem, &rtcp_elem, elem_name, direction, TRUE)) {
+ ms_error("Error: invalid parameter [%s]", param_key);
+ g_strfreev(tokens);
+ return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ }
- if (!g_strcmp0(tokens[i], "port")) {
- __ms_element_set_property(rtp_elem, tokens[i], param_value);
+ if (!g_strcmp0(param, MEDIA_STREAMER_PARAM_PORT)) {
+ __ms_element_set_property(rtp_elem, param, param_value);
gchar *next_port = g_strdup(param_value);
next_port[strlen(next_port) - 1] += 1;
- __ms_element_set_property(rtcp_elem, tokens[i], next_port);
+ __ms_element_set_property(rtcp_elem, param, next_port);
MS_SAFE_GFREE(next_port);
- } else if (!g_strcmp0(tokens[i], "host") && MS_ELEMENT_IS_SINK(elem_name)) {
- __ms_element_set_property(rtp_elem, tokens[i], param_value);
- __ms_element_set_property(rtcp_elem, tokens[i], param_value);
- } else if (!g_strcmp0(tokens[i], "format") && MS_ELEMENT_IS_SOURCE(elem_name)) {
- __ms_element_set_property(rtp_elem, "caps", param_value);
}
+ g_strfreev(tokens);
+ return MEDIA_STREAMER_ERROR_NONE;
+ } else {
+ ms_error("Invalid rtp parameter name.");
}
+
g_strfreev(tokens);
- return MEDIA_STREAMER_ERROR_NONE;
+ return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
}
int __ms_node_create(media_streamer_node_s *node,
ms_info("Read param value[%s] with size [%d].", (gchar *)basic_val, basic_size);
if (ms_node->set_param != NULL) {
- ret = ms_node->set_param(ms_node, (gchar *)key, (gchar *)basic_val);
+ ret = ms_node->set_param((struct media_streamer_node_s *)ms_node, (char *)key, (char *)basic_val);
} else {
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
return ret;
}
+static void __ms_node_get_param_value(GParamSpec *param, GValue value,char **string_value)
+{
+ char *value_in_string = NULL;
+
+ ms_info("%-20s: %s\n", g_param_spec_get_name(param), g_param_spec_get_blurb(param));
+
+ switch (G_VALUE_TYPE(&value)) {
+ case G_TYPE_STRING:
+ ms_info("Got string value: [%s]", g_value_get_string(&value));
+ break;
+
+ case G_TYPE_BOOLEAN:
+ value_in_string = g_strdup_printf("%s", g_value_get_boolean(&value) ? "true" : "false");
+ ms_info("Got boolean value: [%s]", value_in_string);
+ break;
+
+ case G_TYPE_ULONG: {
+ GParamSpecULong *pulong = G_PARAM_SPEC_ULONG(param);
+ value_in_string = g_strdup_printf("%lu", g_value_get_ulong(&value));
+ ms_info("Got ulong value: [%s], range: %lu - %lu (default %s)",
+ value_in_string, pulong->minimum, pulong->maximum);
+ break;
+ }
+
+ case G_TYPE_LONG: {
+ GParamSpecLong *plong = G_PARAM_SPEC_LONG(param);
+ value_in_string = g_strdup_printf("%ld", g_value_get_long(&value));
+ ms_info("Got long value: [%s], range: %ld - %ld (default %s)",
+ value_in_string, plong->minimum, plong->maximum);
+ break;
+ }
+
+ case G_TYPE_UINT: {
+ GParamSpecUInt *puint = G_PARAM_SPEC_UINT(param);
+ value_in_string = g_strdup_printf("%u", g_value_get_uint(&value));
+ ms_info("Got uint value: [%s], range: %u - %u",
+ value_in_string, puint->minimum, puint->maximum);
+ break;
+ }
+
+ case G_TYPE_INT: {
+ GParamSpecInt *pint = G_PARAM_SPEC_INT(param);
+ value_in_string = g_strdup_printf("%d", g_value_get_int(&value));
+ ms_info("Got int value: [%s], range: %d - %d",
+ value_in_string, pint->minimum, pint->maximum);
+ break;
+ }
+
+ case G_TYPE_UINT64: {
+ GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64(param);
+ value_in_string = g_strdup_printf("%" G_GUINT64_FORMAT, g_value_get_uint64(&value));
+ ms_info("Got uint64 value: [%s], range: %" G_GUINT64_FORMAT "- %" G_GUINT64_FORMAT,
+ value_in_string, puint64->minimum, puint64->maximum);
+ break;
+ }
+
+ case G_TYPE_INT64: {
+ GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64(param);
+ value_in_string = g_strdup_printf("%" G_GINT64_FORMAT, g_value_get_int64(&value));
+ ms_info("Got uint64 value: [%s], range: %" G_GINT64_FORMAT "- %" G_GINT64_FORMAT,
+ value_in_string, pint64->minimum, pint64->maximum);
+ break;
+ }
+
+ case G_TYPE_FLOAT: {
+ GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT(param);
+ value_in_string = g_strdup_printf("%15.7g", g_value_get_float(&value));
+ ms_info("Got float value: [%s], range:%15.7g -%15.7g",
+ value_in_string, pfloat->minimum, pfloat->maximum);
+ break;
+ }
+
+ case G_TYPE_DOUBLE: {
+ GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE(param);
+ value_in_string = g_strdup_printf("%15.7g", g_value_get_double(&value));
+ ms_info("Got double value: [%s], range:%15.7g -%15.7g",
+ value_in_string, pdouble->minimum, pdouble->maximum);
+ break;
+ }
+
+ default:
+ ms_info("Got unknown type with param->value_type [%d]", param->value_type);
+ break;
+ }
+
+ *string_value = value_in_string;
+}
+
int __ms_node_write_params_into_bundle(media_streamer_node_s *node,
bundle *param_list)
{
guint num_properties, i;
char *string_val = NULL;
- property_specs = g_object_class_list_properties
- (G_OBJECT_GET_CLASS(node->gst_element), &num_properties);
+ property_specs = g_object_class_list_properties(G_OBJECT_GET_CLASS(node->gst_element),
+ &num_properties);
if (num_properties <= 0) {
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
continue;
}
- ms_info("%-20s: %s\n", g_param_spec_get_name(param), g_param_spec_get_blurb(param));
-
- switch (G_VALUE_TYPE(&value)) {
- case G_TYPE_STRING:
- bundle_add_str(param_list, g_param_spec_get_name(param), g_value_get_string(&value));
- ms_info("Got string value: [%s]", g_value_get_string(&value));
- break;
-
- case G_TYPE_BOOLEAN:
- string_val = g_strdup_printf("%s", g_value_get_boolean(&value) ? "true" : "false");
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got boolean value: [%s]", string_val);
- break;
-
- case G_TYPE_ULONG: {
- GParamSpecULong *pulong = G_PARAM_SPEC_ULONG(param);
- string_val = g_strdup_printf("%lu", g_value_get_ulong(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got ulong value: [%s], range: %lu - %lu (default %s)",
- string_val, pulong->minimum, pulong->maximum);
- break;
- }
-
- case G_TYPE_LONG: {
- GParamSpecLong *plong = G_PARAM_SPEC_LONG(param);
- string_val = g_strdup_printf("%ld", g_value_get_long(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got long value: [%s], range: %ld - %ld (default %s)",
- string_val, plong->minimum, plong->maximum);
- break;
- }
-
- case G_TYPE_UINT: {
- GParamSpecUInt *puint = G_PARAM_SPEC_UINT(param);
- string_val = g_strdup_printf("%u", g_value_get_uint(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got uint value: [%s], range: %u - %u",
- string_val, puint->minimum, puint->maximum);
- break;
- }
-
- case G_TYPE_INT: {
- GParamSpecInt *pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got int value: [%s], range: %d - %d",
- string_val, pint->minimum, pint->maximum);
- break;
- }
-
- case G_TYPE_UINT64: {
- GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64(param);
- string_val = g_strdup_printf("%" G_GUINT64_FORMAT, g_value_get_uint64(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got uint64 value: [%s], range: %" G_GUINT64_FORMAT "- %" G_GUINT64_FORMAT,
- string_val, puint64->minimum, puint64->maximum);
- break;
- }
-
- case G_TYPE_INT64: {
- GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64(param);
- string_val = g_strdup_printf("%" G_GINT64_FORMAT, g_value_get_int64(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got uint64 value: [%s], range: %" G_GINT64_FORMAT "- %" G_GINT64_FORMAT,
- string_val, pint64->minimum, pint64->maximum);
- break;
- }
-
- case G_TYPE_FLOAT: {
- GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT(param);
- string_val = g_strdup_printf("%15.7g", g_value_get_float(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got float value: [%s], range:%15.7g -%15.7g",
- string_val, pfloat->minimum, pfloat->maximum);
- break;
- }
-
- case G_TYPE_DOUBLE: {
- GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE(param);
- string_val = g_strdup_printf("%15.7g", g_value_get_double(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got double value: [%s], range:%15.7g -%15.7g",
- string_val, pdouble->minimum, pdouble->maximum);
- break;
- }
-
- default:
- ms_info("Got unknown type with param->value_type [%d]", param->value_type);
- break;
-
- MS_SAFE_FREE(string_val);
- }
+ __ms_node_get_param_value(param, value, &string_val);
+
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ }
+
+ return MEDIA_STREAMER_ERROR_NONE;
+}
+
+int __ms_node_write_param_into_value(media_streamer_node_s *node,
+ const char *param_name, char **param_value)
+{
+ GParamSpec *property_specs;
+ char *string_val = NULL;
+
+ property_specs = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element),
+ param_name);
+
+ ms_info("Getting parameter of the Node [%s]", node->name);
+
+ GValue value = { 0, };
+ GParamSpec *param = property_specs;
+
+ g_value_init(&value, param->value_type);
+ if (param->flags & G_PARAM_READWRITE) {
+ g_object_get_property(G_OBJECT(node->gst_element), param->name, &value);
}
+
+ __ms_node_get_param_value(param, value, &string_val);
+
+ *param_value = string_val;
+
return MEDIA_STREAMER_ERROR_NONE;
}
}
break;
case MEDIA_STREAMER_STATE_READY:
- ret = __ms_autoplug_prepare(ms_streamer);
+ ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_READY);
break;
case MEDIA_STREAMER_STATE_PLAYING:
ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING);
MS_TABLE_SAFE_UNREF(ms_streamer->nodes_table);
if (ms_streamer->sink_video_bin &&
- GST_OBJECT_PARENT(ms_streamer->sink_video_bin) != ms_streamer->pipeline) {
+ GST_OBJECT_PARENT(ms_streamer->sink_video_bin) != GST_OBJECT(ms_streamer->pipeline)) {
MS_SAFE_UNREF(ms_streamer->sink_video_bin);
ms_info("sink_video_bin removed from pipeline");
}
if (ms_streamer->sink_audio_bin &&
- GST_OBJECT_PARENT(ms_streamer->sink_audio_bin) != ms_streamer->pipeline) {
+ GST_OBJECT_PARENT(ms_streamer->sink_audio_bin) != GST_OBJECT(ms_streamer->pipeline)) {
MS_SAFE_UNREF(ms_streamer->sink_audio_bin);
ms_info("sink_audio_bin removed from pipeline");
}
#define VIDEO_PORT 5000
#define AUDIO_PORT 6000
-/*#define DISABLE_AUDIO */
+#define DISABLE_AUDIO
/*#define DISABLE_VIDEO */
/*---------------------------------------------------------------------------
return TRUE;
}
+static gboolean _pause()
+{
+ g_print("== pause \n");
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+ ret = media_streamer_pause(current_media_streamer);
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
+ g_print("Fail to pause media streamer");
+ return FALSE;
+ }
+ g_print("== success pause \n");
+
+ return TRUE;
+}
+
+static gboolean _stop()
+{
+ g_print("== stop \n");
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+ ret = media_streamer_stop(current_media_streamer);
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
+ g_print("Fail to stop media streamer");
+ return FALSE;
+ }
+ g_print("== success stop \n");
+
+ return TRUE;
+}
+
static gboolean _destroy(media_streamer_h streamer)
{
g_print("== destroy \n");
return FALSE;
}
-
if (current_media_streamer == g_media_streamer) {
g_media_streamer = NULL;
} else {
gchar *audio_sink_port = g_strdup_printf("%d", port_reverse ? audio_port : (audio_port + 5));
if (g_menu_preset & PRESET_RTP_STREAMER) {
- bundle_add_str(params, "audio_sink,port", audio_sink_port);
- bundle_add_str(params, "audio_sink,host", ip);
+ bundle_add_str(params, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT, audio_sink_port);
}
if (g_menu_preset & PRESET_RTP_CLIENT) {
- bundle_add_str(params, "audio_source,port", audio_src_port);
- bundle_add_str(params, "audio_source,format",
- "application/x-rtp,media=audio,clock-rate=44100,encoding-name=L16,"
- "encoding-params=1,channels=1,payload=96");
+ bundle_add_str(params, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT, audio_src_port);
}
g_free(audio_src_port);
char *video_sink_port = g_strdup_printf("%d", port_reverse ? video_port : (video_port + 5));
if (g_menu_preset & PRESET_RTP_STREAMER) {
- bundle_add_str(params, "video_sink,port", video_sink_port);
- bundle_add_str(params, "video_sink,host", ip);
+ bundle_add_str(params, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT, video_sink_port);
}
if (g_menu_preset & PRESET_RTP_CLIENT) {
- bundle_add_str(params, "video_source,port", video_src_port);
- bundle_add_str(params, "video_source,format",
- "application/x-rtp,media=video,clock-rate=90000,encoding-name=H264");
+ bundle_add_str(params, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT, video_src_port);
}
g_free(video_src_port);
g_free(video_sink_port);
#endif
+ bundle_add_str(params, MEDIA_STREAMER_PARAM_HOST, ip);
media_streamer_node_set_params(rtp_node, params);
+ media_streamer_node_set_pad_format(rtp_node, "video_in_rtp", vfmt_encoded);
+ media_streamer_node_set_pad_format(rtp_node, "audio_in_rtp", afmt_raw);
+
bundle_free(params);
params = NULL;
}
#ifdef ONE_DEVICE_TEST
if (g_menu_preset & SECOND_VOIP_MASK) {
media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST, &video_src);
- media_streamer_node_set_param(video_src, "is-live", "true");
+ media_streamer_node_set_param(video_src, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM, "true");
} else {
media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA, &video_src);
}
/*====================Linking Video Streamer=========================== */
media_streamer_node_link(video_src, "src", video_enc, "sink");
media_streamer_node_link(video_enc, "src", video_pay, "sink");
- media_streamer_node_link(video_pay, "src", rtp_bin, "video_sink");
+ media_streamer_node_link(video_pay, "src", rtp_bin, "video_in");
/*====================================================================== */
g_print("== success streamer video part \n");
/*====================Linking Audio Streamer========================== */
media_streamer_node_link(audio_src, "src", audio_enc, "sink");
media_streamer_node_link(audio_enc, "src", audio_pay, "sink");
- media_streamer_node_link(audio_pay, "src", rtp_bin, "audio_sink");
+ media_streamer_node_link(audio_pay, "src", rtp_bin, "audio_in");
/*====================================================================== */
g_print("== success streamer audio part \n");
media_streamer_node_h video_src = NULL;
#ifdef ONE_DEVICE_TEST
if (g_menu_preset & SECOND_VOIP_MASK) {
- media_streamer_node_create_src(MEDIA_STREAMER_SRC_TYPE_VIDEO_TEST, &video_src);
- media_streamer_node_set_single_param(video_src, "is-live", "true");
+ media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST, &video_src);
+ media_streamer_node_set_param(video_src, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM, "true");
} else {
- media_streamer_node_create_src(MEDIA_STREAMER_SRC_TYPE_CAMERA, &video_src);
+ media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA, &video_src);
}
#else
media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA, &video_src);
/*====================Linking Video Client=========================== */
media_streamer_node_link(video_depay, "src", video_dec, "sink");
media_streamer_node_link(video_dec, "src", video_sink, "sink");
- /* media_streamer_node_link(rtp_bin, "video_source", video_depay,"sink"); */
+ /* media_streamer_node_link(rtp_bin, "video_out", video_depay,"sink"); */
g_print("== success client video part \n");
#endif
media_streamer_node_link(audio_depay, "src", audio_converter, "sink");
media_streamer_node_link(audio_converter, "src", audio_res, "sink");
media_streamer_node_link(audio_res, "src", audio_sink, "sink");
- /*media_streamer_node_link(rtp_bin, "audio_source", audio_depay,"sink"); */
+ /*media_streamer_node_link(rtp_bin, "audio_out", audio_depay,"sink"); */
/*====================================================================== */
g_print("== success client audio part \n");
}
-static media_streamer_node_h _create_rtp(
- int video_port,
- int audio_port,
- gboolean second_client)
+static media_streamer_node_h _create_rtp(int video_port,
+ int audio_port,
+ gboolean second_client)
{
g_print("== create rtp node for current preset \n");
return rtp_bin;
}
+#if 0
/* Application source callback */
static void buffer_status_cb(media_streamer_node_h node,
media_streamer_custom_buffer_status_e status,
guint64 size = strlen(test);
media_packet_h packet;
- media_packet_create_from_external_memory(&vfmt_encoded,
+ media_packet_create_from_external_memory(vfmt_encoded,
(void *)test, size, NULL, NULL, &packet);
media_streamer_node_push_packet(node, packet);
count++;
media_packet_h packet;
media_streamer_node_pull_packet(node, &packet);
- media_packet_get_buffer_data_ptr(packet, &received_data);
+ media_packet_get_buffer_data_ptr(packet, (void **)&received_data);
g_print("Received new packet from appsink with data [%s]\n", received_data);
media_packet_destroy(packet);
return TRUE;
}
+#endif
/***************************************************************/
/** Testsuite */
/***************************************************************/
-void quit()
-{
- reset_current_menu_state();
- g_main_loop_quit(g_loop);
-}
-
/*
* Function resets menu state to the main menu state
* and cleans media streamer handle.
}
}
+void quit()
+{
+ reset_current_menu_state();
+ g_main_loop_quit(g_loop);
+}
+
static void display_getting_ip_menu(void)
{
g_print("\n");
g_print("4. prepare \n");
g_print("5. unprepare \n");
g_print("6. play \n");
- g_print("7. destroy media streamer \n\n");
+ g_print("7. pause \n");
+ g_print("8. stop \n");
+ g_print("9. destroy media streamer \n\n");
g_print("b. back \n");
g_print("----------------------------------------------------\n");
g_print("====================================================\n");
}
}
-/*=====================Broadcast Menu============================// */
void _interpret_broadcast_menu(char *cmd)
{
int len = strlen(cmd);
if (cmd_len > min_len) {
g_broadcast_address = g_strdup(cmd);
- g_print("== IP address setted to [%s]\n", g_broadcast_address);
+ g_print("== IP address set to [%s]\n", g_broadcast_address);
} else {
g_broadcast_address = g_strdup(DEFAULT_IP_ADDR);
g_print("Invalid IP. Default address will be used [%s]\n", DEFAULT_IP_ADDR);
void _interpret_autoplug_menu(char *cmd)
{
-
int cmd_number = atoi(cmd) - 1;
-
if (cmd_number == 1 || cmd_number == 0) {
g_autoplug_mode = cmd_number;
} else {
} else if (!strncmp(cmd, "6", len)) {
_play(g_media_streamer);
} else if (!strncmp(cmd, "7", len)) {
+ _pause(g_media_streamer);
+ } else if (!strncmp(cmd, "8", len)) {
+ _stop(g_media_streamer);
+ } else if (!strncmp(cmd, "9", len)) {
_destroy(current_media_streamer);
} else if (!strncmp(cmd, "b", len)) {
if (g_menu_preset & DOUBLE_STREAMER_MASK) {
interpret_cmd(buf);
return TRUE;
-
}
int main(int argc, char **argv)
projects / platform / core / api / mediastreamer.git / commitdiff