GstElement *__ms_rtp_element_create(media_streamer_node_s *ms_node);
/**
- * @brief Find Udp elements into rtp container by name.
- * It returns elements with increased ref count.
+ * @brief Prepares rtp container according to parameters data.
* @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, const gchar *direction, gboolean auto_create);
-
-/**
- * @brief Converts key-value property into needed GType
- * and sets this property into GstElement.
- *
- * @since_tizen 3.0
- */
-gboolean __ms_element_set_property(GstElement *src_element, const char *key, const gchar *param_value);
+gboolean __ms_rtp_element_prepare(media_streamer_node_s *ms_node);
/**
* @brief Unlink all pads into GstElement.
*
* @since_tizen 3.0
*/
-const gchar * __ms_get_pad_type(GstPad *element_pad);
+const gchar *__ms_get_pad_type(GstPad *element_pad);
/**
* @brief Creates decodebin to link with sink part.
*
*
* @since_tizen 3.0
*/
-int __ms_element_get_pad_fmt(GstElement * gst_element, const char *pad_name, media_format_h *fmt);
+int __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad_name, media_format_h *fmt);
/**
- * @brief Sets mediaformat into GstElement.
+ * @brief Sets mediaformat into Node's pad.
*
* @since_tizen 3.0
*/
*
* @since_tizen 3.0
*/
-int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet);
\ No newline at end of file
+int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet);
#include <media_streamer_priv.h>
-/**
- * @brief Sets property to media streamer node with key and value.
- *
- * @since_tizen 3.0
- */
-int __ms_node_set_property(media_streamer_node_s *ms_node, const gchar *param_key, const gchar *param_value);
/**
* @brief Creates media streamer node using input and output format.
*
* @since_tizen 3.0
*/
-int __ms_node_read_params_from_bundle(media_streamer_node_s *node, bundle *param_list);
+int __ms_node_set_params_from_bundle(media_streamer_node_s *node, bundle *param_list);
/**
* @brief Writes GstElement properties into user's bundle object.
int __ms_node_write_params_into_bundle(media_streamer_node_s *node, bundle *param_list);
/**
- * @brief Writes GstElement property into user's value.
+ * @brief Gets node's parameter by param_name.
+ *
+ * @since_tizen 3.0
+ */
+int __ms_node_get_param(media_streamer_node_s *node, const char *param_name, param_s **param);
+
+/**
+ * @brief Gets list of all node's parameters.
+ *
+ * @since_tizen 3.0
+ */
+int __ms_node_get_param_list(media_streamer_node_s *node, GList **param_list);
+
+/**
+ * @brief Gets string value of node's parameter.
+ *
+ * @since_tizen 3.0
+ */
+int __ms_node_get_param_value(media_streamer_node_s *node, param_s *param, char **string_value);
+
+/**
+ * @brief Sets parameter value into node's parameter.
+ *
+ * @since_tizen 3.0
+ */
+int __ms_node_set_param_value(media_streamer_node_s *ms_node, param_s *param, const gchar *param_value);
+
+/**
+ * @brief Sets media format value into node's pad.
*
* @since_tizen 3.0
*/
-int __ms_node_write_param_into_value(media_streamer_node_s *node, const char *param_name, char **param_value);
+int __ms_node_set_pad_format(media_streamer_node_s *node, const char *pad_name, media_format_h fmt);
#include <media_streamer_util.h>
struct media_streamer_node_s;
+
/**
* @brief Media Streamer callbacks structure.
*
} media_streamer_sink_callbacks_s;
/**
+ * @brief Media Streamer param type handle.
+ *
+ * @since_tizen 3.0
+ */
+typedef struct {
+ char *param_name;
+ char *origin_name;
+} param_s;
+
+/**
* @brief Media Streamer type handle.
*
* @since_tizen 3.0
*
* @since_tizen 3.0
*/
-typedef int (*ms_node_set_param)(struct media_streamer_node_s *node, const char *param_key, const char *param_value);
-
-/**
- * @brief Media Streamer node type handle.
- *
- * @since_tizen 3.0
- */
typedef struct {
GstElement *gst_element;
media_streamer_s *parent_streamer;
GList *sig_list;
- ms_node_set_param set_param;
void *callbacks_structure;
} media_streamer_node_s;
*/
int __ms_state_change(media_streamer_s *ms_streamer, media_streamer_state_e state);
-/**
- * @brief Returns initial parameter name among defined parameter values.
- *
- * @since_tizen 3.0
- */
-void __ms_node_check_param_name(GstElement *element, gboolean name_is_known,
- const char *param_name, char **init_param_name);
-
#ifdef __cplusplus
}
#define FONT_COLOR_CYAN "\033[36m"
#define FONT_COLOR_GRAY "\033[37m"
-#define ms_debug(fmt, arg...) do { \
- LOGD(FONT_COLOR_RESET""fmt"", ##arg); \
+#define ms_debug(fmt, arg...) \
+ do { \
+ LOGD(FONT_COLOR_RESET""fmt"", ##arg); \
} while (0)
-#define ms_info(fmt, arg...) do { \
- LOGI(FONT_COLOR_GREEN""fmt"", ##arg); \
+#define ms_info(fmt, arg...) \
+ do { \
+ LOGI(FONT_COLOR_GREEN""fmt"", ##arg); \
} while (0)
-#define ms_error(fmt, arg...) do { \
- LOGE(FONT_COLOR_RED""fmt"", ##arg); \
+#define ms_error(fmt, arg...) \
+ do { \
+ LOGE(FONT_COLOR_RED""fmt"", ##arg); \
} while (0)
-#define ms_debug_fenter() do { \
- LOGD(FONT_COLOR_YELLOW"<Enter>"); \
+#define ms_debug_fenter() \
+ do { \
+ LOGD(FONT_COLOR_YELLOW"<Enter>"); \
} while (0)
-#define ms_debug_fleave() do { \
- LOGD(FONT_COLOR_PURPLE"<Leave>"); \
+#define ms_debug_fleave() \
+ do { \
+ LOGD(FONT_COLOR_PURPLE"<Leave>"); \
} while (0)
-#define ms_retm_if(expr, fmt, arg...) do { \
- if (expr) { \
- LOGE(FONT_COLOR_RED""fmt"", ##arg); \
- return; \
- } \
+#define ms_retm_if(expr, fmt, arg...) \
+ do { \
+ if (expr) { \
+ LOGE(FONT_COLOR_RED""fmt"", ##arg); \
+ return; \
+ } \
} while (0)
-#define ms_retvm_if(expr, val, fmt, arg...) do { \
- if (expr) { \
- LOGE(FONT_COLOR_RED""fmt"", ##arg); \
- return(val); \
- } \
+#define ms_retvm_if(expr, val, fmt, arg...) \
+ do { \
+ if (expr) { \
+ LOGE(FONT_COLOR_RED""fmt"", ##arg); \
+ return(val); \
+ } \
} while (0)
#define MS_SAFE_FREE(src) {if (src) { free(src); src = NULL; } }
#endif
#define MEDIA_STREAMER_INI_MAX_STRLEN 100
+#define RTP_STREAM_DISABLED (0)
/**
* @brief Media Streamer ini settings structure.
* @since_tizen 3.0
*/
typedef struct {
- GObject* obj;
+ GObject *obj;
gulong signal_id;
} media_streamer_signal_s;
#define MS_ELEMENT_IS_AUDIO(el) g_strrstr(el, "audio")
#define MS_ELEMENT_IS_VIDEO(el) g_strrstr(el, "video")
#define MS_ELEMENT_IS_IMAGE(el) g_strrstr(el, "image")
+
#define MS_RTP_PAD_VIDEO_IN "video_in"
#define MS_RTP_PAD_AUDIO_IN "audio_in"
+#define MS_RTP_PAD_VIDEO_OUT "video_out"
+#define MS_RTP_PAD_AUDIO_OUT "audio_out"
+#define MEDIA_STREAMER_PARAM_VIDEO_IN_FORMAT MS_RTP_PAD_VIDEO_IN"_format"
+#define MEDIA_STREAMER_PARAM_AUDIO_IN_FORMAT MS_RTP_PAD_AUDIO_IN"_format"
+
#define MS_ELEMENT_IS_RTP(el) g_strrstr(el, "rtp_container")
#define MS_ELEMENT_IS_TEXT(el) g_strrstr(el, "text")
#define MS_ELEMENT_IS_ENCODER(el) g_strrstr(el, "encoder")
#define MS_ELEMENT_IS_DECODER(el) g_strrstr(el, "decoder")
+#define MEDIA_STREAMER_DEFAULT_DOT_DIR "/tmp"
+
#define MS_BIN_FOREACH_ELEMENTS(bin, fn, streamer) \
-{ \
- GstIterator *iter = gst_bin_iterate_elements(GST_BIN(bin)); \
- if (gst_iterator_foreach(iter, fn, streamer) != GST_ITERATOR_DONE) { \
- ms_error("Error while iterating elements in bin [%s]!", GST_ELEMENT_NAME(bin)); \
- } \
- gst_iterator_free(iter); \
-}
+ do { \
+ GstIterator *iter = gst_bin_iterate_elements(GST_BIN(bin)); \
+ if (gst_iterator_foreach(iter, fn, streamer) != GST_ITERATOR_DONE) \
+ ms_error("Error while iterating elements in bin [%s]!", GST_ELEMENT_NAME(bin)); \
+ gst_iterator_free(iter); \
+ } while (0)
-#define MEDIA_STREAMER_DEFAULT_DOT_DIR "/tmp"
+#define MS_BIN_UNPREPARE(bin) \
+ if (!__ms_bin_remove_elements(ms_streamer, bin)) {\
+ ms_debug("Got a few errors during unprepare [%s] bin.", GST_ELEMENT_NAME(bin));\
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;\
+ }
+
+#define MS_SET_INT_RTP_PARAM(obj, key, value) \
+ do { \
+ GValue *val = g_malloc0(sizeof(GValue)); \
+ g_value_init(val, G_TYPE_INT); \
+ g_value_set_int(val, value); \
+ g_object_set_data_full(G_OBJECT(obj), key, (gpointer)val, __ms_rtp_param_value_destroy); \
+ } while (0)
+
+#define MS_SET_INT_STATIC_STRING_PARAM(obj, key, value) \
+ do { \
+ GValue *val = g_malloc0(sizeof(GValue)); \
+ g_value_init(val, G_TYPE_STRING); \
+ g_value_set_static_string(val, value); \
+ g_object_set_data_full(G_OBJECT(obj), key, (gpointer)val, __ms_rtp_param_value_destroy); \
+ } while (0)
+
+#define MS_SET_INT_CAPS_PARAM(obj, key, value) \
+ do { \
+ GValue *val = g_malloc0(sizeof(GValue)); \
+ g_value_init(val, GST_TYPE_CAPS); \
+ gst_value_set_caps(val, value); \
+ g_object_set_data_full(G_OBJECT(obj), key, (gpointer)val, __ms_rtp_param_value_destroy); \
+ } while (0)
/**
* @brief Loads media streamer settings from ini file.
*/
void __ms_signal_destroy(void *data);
+/**
+ * @brief Destroys the which set as rtp node parameter.
+ *
+ * @since_tizen 3.0
+ */
+void __ms_rtp_param_value_destroy(gpointer data);
+
#ifdef __cplusplus
}
#endif
* Public Implementation
*/
-int media_streamer_node_create_src(media_streamer_node_src_type_e type, media_streamer_node_h * src)
+int media_streamer_node_create_src(media_streamer_node_src_type_e type, media_streamer_node_h *src)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, media_streamer_node_h * sink)
+int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, media_streamer_node_h *sink)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-int media_streamer_node_create(media_streamer_node_type_e type, media_format_h in_fmt, media_format_h out_fmt, media_streamer_node_h * node)
+int media_streamer_node_create(media_streamer_node_type_e type, media_format_h in_fmt, media_format_h out_fmt, media_streamer_node_h *node)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-int media_streamer_create(media_streamer_h * streamer)
+int media_streamer_create(media_streamer_h *streamer)
{
ms_retvm_if(streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return ret;
}
-int media_streamer_get_state(media_streamer_h streamer, media_streamer_state_e * state)
+int media_streamer_get_state(media_streamer_h streamer, media_streamer_state_e *state)
{
media_streamer_s *ms_streamer = (media_streamer_s *) streamer;
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return __ms_element_push_packet(ms_node->gst_element, packet);
}
-int media_streamer_node_pull_packet(media_streamer_node_h sink, media_packet_h * packet)
+int media_streamer_node_pull_packet(media_streamer_node_h sink, media_packet_h *packet)
{
media_streamer_node_s *ms_node = (media_streamer_node_s *) sink;
ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
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, pad_name, fmt);
+ return __ms_node_set_pad_format(node, pad_name, fmt);
}
int media_streamer_node_get_pad_format(media_streamer_node_h node, const char *pad_name, media_format_h *fmt)
return ret;
}
-int media_streamer_node_set_params(media_streamer_node_h node, bundle * param_list)
+int media_streamer_node_set_params(media_streamer_node_h node, bundle *param_list)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ms_retvm_if(param_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Parameters list is NULL");
- ret = __ms_node_read_params_from_bundle(ms_node, param_list);
+ ret = __ms_node_set_params_from_bundle(ms_node, param_list);
ms_retvm_if(ret != MEDIA_STREAMER_ERROR_NONE, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Parameters list is NULL");
return ret;
}
-int media_streamer_node_get_params(media_streamer_node_h node, bundle ** param_list)
+int media_streamer_node_get_params(media_streamer_node_h node, bundle **param_list)
{
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_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Param list pionter is NULL");
- bundle *ms_params = NULL;
- ms_params = bundle_create();
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+ bundle *ms_params = bundle_create();
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] does not have any params.", ms_node->name);
+ ret = __ms_node_write_params_into_bundle(ms_node, ms_params);
+ if (ret == MEDIA_STREAMER_ERROR_NONE)
+ *param_list = ms_params;
+ else
bundle_free(ms_params);
- *param_list = NULL;
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
-
- *param_list = ms_params;
- return MEDIA_STREAMER_ERROR_NONE;
+ return ret;
}
int media_streamer_node_set_param(media_streamer_node_h node, const char *param_name, const char *param_value)
{
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(ms_node->gst_element == NULL && ms_node->set_param, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is 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((struct media_streamer_node_s *)ms_node, param_name, param_value);
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ param_s *param = NULL;
+
+ ret = __ms_node_get_param(node, param_name, ¶m);
+ if (ret == MEDIA_STREAMER_ERROR_NONE)
+ ret = __ms_node_set_param_value(node, param, param_value);
+
+ return ret;
}
int media_streamer_node_get_param(media_streamer_node_h node, const char *param_name, char **param_value)
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");
- 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);
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ param_s *param = NULL;
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
+ ret = __ms_node_get_param(ms_node, param_name, ¶m);
+ if (ret == MEDIA_STREAMER_ERROR_NONE)
+ ret = __ms_node_get_param_value(ms_node, param, param_value);
- *param_value = ms_param;
- return MEDIA_STREAMER_ERROR_NONE;
+ return ret;
}
gst_pad_unlink(peer, pad)
#define H264_PARSER_CONFIG_INTERVAL 5
-void __ms_generate_dots(GstElement * bin, gchar * name_tag)
+void __ms_generate_dots(GstElement *bin, gchar *name_tag)
{
gchar *dot_name;
ms_retm_if(bin == NULL, "Handle is NULL");
MS_SAFE_GFREE(dot_name);
}
-static int __ms_add_no_target_ghostpad(GstElement * gst_bin, const char *ghost_pad_name, GstPadDirection pad_direction)
+static int __ms_add_no_target_ghostpad(GstElement *gst_bin, const char *ghost_pad_name, GstPadDirection pad_direction)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-static gboolean __ms_add_ghostpad(GstElement * gst_element, const char *pad_name, GstElement * gst_bin, const char *ghost_pad_name)
+static gboolean __ms_add_ghostpad(GstElement *gst_element, const char *pad_name, GstElement *gst_bin, const char *ghost_pad_name)
{
ms_retvm_if(!gst_element || !pad_name || !ghost_pad_name || !gst_bin, FALSE, "Handle is NULL");
return ret;
}
-static GObject *__ms_get_property_owner(GstElement * element, const gchar * key, GValue * value)
+static GObject *__ms_get_property_owner(GstElement *element, const gchar *key, GValue *value)
{
GParamSpec *param = NULL;
GObject *obj = NULL;
return obj;
}
-gboolean __ms_element_set_property(GstElement * element, const char *key, const gchar * param_value)
-{
- char *init_name = NULL;
- int pint = 0;
- gboolean bool_val = FALSE;
- gboolean ret = FALSE;
-
- __ms_node_check_param_name(element, TRUE, key, &init_name);
-
- if (init_name) {
- GValue value = G_VALUE_INIT;
- GObject *obj = __ms_get_property_owner(element, init_name, &value);
-
- if (obj == NULL) {
- ms_debug("Element [%s] does not have property [%s].", GST_ELEMENT_NAME(element), init_name);
- return FALSE;
- }
-
- if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_CAMERA_ID)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM)) {
- bool_val = !g_strcmp0(param_value, "true") ? TRUE : FALSE;
- g_value_set_boolean(&value, bool_val);
- g_object_set(obj, init_name, bool_val, NULL);
- ms_info("Set boolean value: [%d]", g_value_get_boolean(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_URI)) {
- g_value_set_string(&value, param_value);
- g_object_set(obj, init_name, param_value, NULL);
- ms_info("Set string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_USER_AGENT)) {
- g_value_set_string(&value, param_value);
- g_object_set(obj, init_name, param_value, NULL);
- ms_info("Set string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_STREAM_TYPE)) {
- pint = atoi(param_value);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d] ", pint);
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_PORT)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT)) {
- pint = atoi(param_value);
- g_value_set_int(&value, pint);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_IP_ADDRESS)) {
- g_value_set_string(&value, param_value);
- g_object_set(obj, init_name, param_value, NULL);
- ms_info("Set string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_AUDIO_DEVICE)) {
- g_value_set_string(&value, param_value);
- g_object_set(obj, init_name, param_value, NULL);
- ms_info("Set string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED)) {
- bool_val = !g_strcmp0(param_value, "true") ? TRUE : FALSE;
- g_value_set_boolean(&value, bool_val);
- g_object_set(obj, init_name, bool_val, NULL);
- ms_info("Set boolean value: [%d]", g_value_get_boolean(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_ROTATE)) {
- pint = atoi(param_value);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d] ", pint);
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_FLIP)) {
- pint = atoi(param_value);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d] ", pint);
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD)) {
- pint = atoi(param_value);
- g_object_set(obj, init_name, pint, NULL);
- ms_info("Set int value: [%d] ", pint);
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_EVAS_OBJECT)) {
- g_value_set_pointer(&value, (gpointer)param_value);
- g_object_set(obj, init_name, (gpointer)param_value, NULL);
- ms_info("Set pointer: [%p]", g_value_get_pointer(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_VISIBLE)) {
- bool_val = !g_strcmp0(param_value, "true") ? TRUE : FALSE;
- g_value_set_boolean(&value, bool_val);
- g_object_set(obj, init_name, bool_val, NULL);
- ms_info("Set boolean value: [%d]", g_value_get_boolean(&value));
- } else if (!g_strcmp0(key, MEDIA_STREAMER_PARAM_HOST)) {
- g_value_set_string(&value, param_value);
- g_object_set(obj, init_name, param_value, NULL);
- ms_info("Set string value: [%s]", g_value_get_string(&value));
- } else {
- ms_info("Got unknown type with param->value_type [%lu]", G_VALUE_TYPE(&value));
- ret = FALSE;
- }
- g_value_unset(&value);
- } else {
- ms_info("Can not set parameter [%s] in the node [%s]", key, GST_ELEMENT_NAME(element));
- }
-
- return ret;
-}
-
/* This unlinks from its peer and ghostpads on its way */
-static gboolean __ms_pad_peer_unlink(GstPad * pad)
+static gboolean __ms_pad_peer_unlink(GstPad *pad)
{
if (!gst_pad_is_linked(pad))
return TRUE;
return ret;
}
-static GstElement *__ms_pad_get_peer_element(GstPad * pad)
+static GstElement *__ms_pad_get_peer_element(GstPad *pad)
{
if (!gst_pad_is_linked(pad)) {
ms_info("Pad [%s:%s] is not linked yet", GST_DEBUG_PAD_NAME(pad));
if (GST_GHOST_PAD(target_pad)) {
GstPad *element_pad = gst_ghost_pad_get_target(GST_GHOST_PAD(target_pad));
ret = gst_pad_get_parent_element(element_pad);
- g_assert(ret);
MS_SAFE_UNREF(element_pad);
} else {
/* This is a usual static pad */
ret = gst_pad_get_parent_element(target_pad);
- g_assert(ret);
}
MS_SAFE_UNREF(target_pad);
} else if (GST_IS_GHOST_PAD(peer_pad)) {
GstPad *element_pad = gst_ghost_pad_get_target(GST_GHOST_PAD(peer_pad));
ret = gst_pad_get_parent_element(element_pad);
- g_assert(ret);
MS_SAFE_UNREF(element_pad);
} else {
/* This is a usual static pad */
return ret;
}
-gboolean __ms_element_unlink(GstElement * element)
+gboolean __ms_element_unlink(GstElement *element)
{
gboolean ret = TRUE;
GstPad *pad = NULL;
return ret;
}
-gboolean __ms_bin_remove_element(GstElement * element)
+gboolean __ms_bin_remove_element(GstElement *element)
{
GstElement *parent = (GstElement *) gst_element_get_parent(element);
gboolean ret = FALSE;
return ret;
}
-gboolean __ms_bin_add_element(GstElement * bin, GstElement * element, gboolean do_ref)
+gboolean __ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ref)
{
GstElement *parent = (GstElement *) gst_element_get_parent(element);
gboolean ret = FALSE;
return ret;
}
-static gboolean __ms_get_peer_element(GstPad * source_pad, GstElement * found_element)
+static gboolean __ms_get_peer_element(GstPad *source_pad, GstElement *found_element)
{
GstElement *peer_element = NULL;
return FALSE;
}
-const gchar *__ms_get_pad_type(GstPad * element_pad)
+const gchar *__ms_get_pad_type(GstPad *element_pad)
{
const gchar *element_pad_type = NULL;
GstCaps *element_pad_caps = gst_pad_query_caps(element_pad, 0);
return element_pad_type;
}
-static gboolean __ms_intersect_pads(GstPad * src_pad, GstPad * sink_pad)
+static gboolean __ms_intersect_pads(GstPad *src_pad, GstPad *sink_pad)
{
GstCaps *src_pad_caps = NULL;
const gchar *src_pad_type = NULL;
return intersect_res;
}
-static gboolean __ms_check_unlinked_element(GstElement * previous_elem, GstPad * prev_elem_src_pad, GstPad * found_elem_sink_pad)
+static gboolean __ms_check_unlinked_element(GstElement *previous_elem,
+ GstPad *prev_elem_src_pad, GstPad *found_elem_sink_pad)
{
gboolean intersect_res = FALSE;
GstIterator *src_pad_iterator = NULL;
return ret;
}
-static gboolean __ms_check_peer_element(GstElement * previous_elem, GstPad * prev_elem_src_pad, GstElement * found_element)
+static gboolean __ms_check_peer_element(GstElement *previous_elem, GstPad *prev_elem_src_pad, GstElement *found_element)
{
gboolean peer_element_found = FALSE;
GstIterator *src_pad_iterator = NULL;
return ret;
}
-GstElement *__ms_bin_find_element_by_klass(GstElement * sink_bin, GstElement * previous_elem, GstPad * source_pad, const gchar * klass_name, const gchar * bin_name)
+GstElement *__ms_bin_find_element_by_klass(GstElement *sink_bin, GstElement *previous_elem, GstPad *source_pad, const gchar *klass_name, const gchar *bin_name)
{
GValue element_value = G_VALUE_INIT;
GstElement *found_element = NULL;
if (MS_ELEMENT_IS_AUDIO(pad_type)) {
found_element = __ms_combine_next_element(parent_decodebin, src_pad, ms_streamer->topology_bin, MEDIA_STREAMER_CONVERTER_KLASS, NULL, DEFAULT_AUDIO_CONVERT);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_QUEUE_KLASS, NULL, DEFAULT_QUEUE);
+ found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, NULL, NULL, DEFAULT_QUEUE);
found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_SINK_KLASS, NULL, NULL);
} else if (MS_ELEMENT_IS_VIDEO(pad_type)) {
if (subtitles_exist) {
found_element = __ms_combine_next_element(parent_decodebin, src_pad, ms_streamer->topology_bin, MEDIA_STREAMER_OVERLAY_KLASS, NULL, DEFAULT_TEXT_OVERLAY);
found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->topology_bin, MEDIA_STREAMER_CONVERTER_KLASS, NULL, DEFAULT_VIDEO_CONVERT);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_QUEUE_KLASS, NULL, DEFAULT_QUEUE);
+ found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, NULL, NULL, DEFAULT_QUEUE);
found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_SINK_KLASS, NULL, NULL);
} else {
found_element = __ms_combine_next_element(parent_decodebin, src_pad, ms_streamer->topology_bin, MEDIA_STREAMER_CONVERTER_KLASS, NULL, DEFAULT_VIDEO_CONVERT);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_QUEUE_KLASS, NULL, DEFAULT_QUEUE);
+ found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, NULL, NULL, DEFAULT_QUEUE);
found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_SINK_KLASS, NULL, NULL);
}
} else if (MS_ELEMENT_IS_TEXT(pad_type)) {
}
} else {
previous_element = __ms_link_with_new_element(previous_element, src_pad, found_element);
- previous_element = __ms_combine_next_element(previous_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_QUEUE_KLASS, NULL, DEFAULT_QUEUE);
- previous_element = __ms_combine_next_element(previous_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_SINK_KLASS, NULL, NULL);
}
} else if (MS_ELEMENT_IS_AUDIO(src_pad_type)) {
previous_element = __ms_combine_next_element(previous_element, NULL, ms_streamer->topology_bin, MEDIA_STREAMER_CONVERTER_KLASS, NULL, DEFAULT_AUDIO_CONVERT);
ms_retvm_if(ms_node == NULL, (GstElement *) NULL, "Error empty rtp node Handle");
GstElement *rtp_container = gst_bin_new("rtp_container");
- GstElement *rtp_elem = __ms_element_create("rtpbin", "rtpbin");
- ms_retvm_if(!rtp_container || !rtp_elem, (GstElement *) NULL, "Error: creating elements for rtp container");
+ ms_retvm_if(!rtp_container, (GstElement *) NULL, "Error: creating elements for rtp container");
- if (!gst_bin_add(GST_BIN(rtp_container), rtp_elem)) {
- MS_SAFE_UNREF(rtp_container);
- MS_SAFE_UNREF(rtp_elem);
- return NULL;
- }
+ __ms_add_no_target_ghostpad(rtp_container, MS_RTP_PAD_VIDEO_OUT, GST_PAD_SRC);
+ __ms_add_no_target_ghostpad(rtp_container, MS_RTP_PAD_AUDIO_OUT, GST_PAD_SRC);
+ __ms_add_no_target_ghostpad(rtp_container, MS_RTP_PAD_VIDEO_IN, GST_PAD_SINK);
+ __ms_add_no_target_ghostpad(rtp_container, MS_RTP_PAD_AUDIO_IN, GST_PAD_SINK);
+
+ __ms_add_no_target_ghostpad(rtp_container, MS_RTP_PAD_VIDEO_IN"_rtp", GST_PAD_SINK);
+ __ms_add_no_target_ghostpad(rtp_container, MS_RTP_PAD_AUDIO_IN"_rtp", GST_PAD_SINK);
+
+ /* Add RTP node parameters as GObject data with destroy function */
+ MS_SET_INT_RTP_PARAM(rtp_container, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT, RTP_STREAM_DISABLED);
+ MS_SET_INT_RTP_PARAM(rtp_container, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT, RTP_STREAM_DISABLED);
+ MS_SET_INT_RTP_PARAM(rtp_container, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT, RTP_STREAM_DISABLED);
+ MS_SET_INT_RTP_PARAM(rtp_container, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT, RTP_STREAM_DISABLED);
+ MS_SET_INT_STATIC_STRING_PARAM(rtp_container, MEDIA_STREAMER_PARAM_HOST, "localhost");
+ MS_SET_INT_CAPS_PARAM(rtp_container, MEDIA_STREAMER_PARAM_VIDEO_IN_FORMAT, gst_caps_new_any());
+ MS_SET_INT_CAPS_PARAM(rtp_container, MEDIA_STREAMER_PARAM_AUDIO_IN_FORMAT, gst_caps_new_any());
- __ms_signal_create(&ms_node->sig_list, rtp_elem, "pad-added", G_CALLBACK(__ms_rtpbin_pad_added_cb), ms_node);
return rtp_container;
}
-gboolean __ms_get_rtp_elements(media_streamer_node_s * ms_node, GstElement ** rtp_elem, GstElement ** rtcp_elem, const gchar * elem_name, const gchar * direction, gboolean auto_create)
+gboolean __ms_rtp_element_prepare(media_streamer_node_s *ms_node)
{
- ms_retvm_if(!elem_name || !direction, FALSE, "Empty rtp element name or direction.");
+ ms_retvm_if(!ms_node, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL");
- GstElement *rtpbin = gst_bin_get_by_name(GST_BIN(ms_node->gst_element), "rtpbin");
+ GstElement *rtpbin = __ms_element_create("rtpbin", "rtpbin");
+ ms_retvm_if(!rtpbin, FALSE, "Error: creating elements for rtp container");
- gboolean ret = TRUE;
- gchar *plugin_name = NULL;
- 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 RTP pad direction [%s]", direction);
+ if (!__ms_bin_add_element(ms_node->gst_element, rtpbin, FALSE)) {
MS_SAFE_UNREF(rtpbin);
return FALSE;
}
+ __ms_signal_create(&ms_node->sig_list, rtpbin, "pad-added", G_CALLBACK(__ms_rtpbin_pad_added_cb), ms_node);
- gchar *rtp_elem_name = g_strdup_printf("%s_%s_rtp", elem_name, direction);
- gchar *rtcp_elem_name = g_strdup_printf("%s_%s_rtcp", elem_name, direction);
+ gboolean ret = TRUE;
+ GstElement *rtp_el = NULL;
+ GstElement *rtcp_el = NULL;
- /* 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);
+ GValue *val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_HOST);
+ const gchar *host = g_value_get_string(val);
- /* Create new udp element if it did not found. */
- 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);
- gst_object_ref(*rtp_elem);
- gst_object_ref(*rtcp_elem);
- } else {
+ val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_VIDEO_IN_PORT);
+ if (g_value_get_int(val) > RTP_STREAM_DISABLED) {
+ rtp_el = __ms_element_create("udpsrc", MS_RTP_PAD_VIDEO_IN"_rtp");
+ __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE);
+ rtcp_el = __ms_element_create("udpsrc", MS_RTP_PAD_VIDEO_IN"_rctp");
+ __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE);
- /*rtp/rtcp elements already into rtp bin. */
- MS_SAFE_UNREF(rtpbin);
- MS_SAFE_GFREE(rtp_elem_name);
- MS_SAFE_GFREE(rtcp_elem_name);
- MS_SAFE_GFREE(plugin_name);
- return TRUE;
+ ret = ret && gst_element_link_pads(rtp_el, "src", rtpbin, "recv_rtp_sink_0");
+ ret = ret && gst_element_link_pads(rtcp_el, "src", rtpbin, "recv_rtcp_sink_0");
+
+ g_object_set_property(G_OBJECT(rtp_el), MEDIA_STREAMER_PARAM_PORT, val);
+ g_object_set(G_OBJECT(rtcp_el), MEDIA_STREAMER_PARAM_PORT, (g_value_get_int(val) + 1), NULL);
+
+ val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_VIDEO_IN_FORMAT);
+ g_object_set_property(G_OBJECT(rtp_el), "caps", val);
}
- 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);
+ val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_AUDIO_IN_PORT);
+ if (g_value_get_int(val) > RTP_STREAM_DISABLED) {
+ rtp_el = __ms_element_create("udpsrc", MS_RTP_PAD_AUDIO_IN"_rtp");
+ __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE);
+ rtcp_el = __ms_element_create("udpsrc", MS_RTP_PAD_AUDIO_IN"_rctp");
+ __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE);
- if (MS_ELEMENT_IS_VIDEO(elem_name)) {
- __ms_add_ghostpad(rtpbin, "send_rtp_sink_0", ms_node->gst_element, MS_RTP_PAD_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, MS_RTP_PAD_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");
- }
- } else {
- 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_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_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);
- }
+ ret = ret && gst_element_link_pads(rtp_el, "src", rtpbin, "recv_rtp_sink_1");
+ ret = ret && gst_element_link_pads(rtcp_el, "src", rtpbin, "recv_rtcp_sink_1");
+
+ g_object_set_property(G_OBJECT(rtp_el), MEDIA_STREAMER_PARAM_PORT, val);
+ g_object_set(G_OBJECT(rtcp_el), MEDIA_STREAMER_PARAM_PORT, (g_value_get_int(val) + 1), NULL);
+
+ val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_AUDIO_IN_FORMAT);
+ g_object_set_property(G_OBJECT(rtp_el), "caps", val);
}
- if (!ret) {
- ms_error("Can not link [rtpbin] pad to [%s] pad", rtp_elem_name);
- MS_SAFE_UNREF(*rtp_elem);
- MS_SAFE_UNREF(*rtcp_elem);
- ret = FALSE;
- __ms_generate_dots(ms_node->gst_element, "rtp_fail");
+ val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT);
+ if (g_value_get_int(val) > RTP_STREAM_DISABLED) {
+ rtp_el = __ms_element_create("udpsink", MS_RTP_PAD_VIDEO_OUT"_rtp");
+ __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE);
+ rtcp_el = __ms_element_create("udpsink", MS_RTP_PAD_VIDEO_OUT"_rctp");
+ __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE);
+
+ GstPad *rtp_sink = gst_element_get_request_pad(rtpbin, "send_rtp_sink_0");
+ GstPad *ghost_sink = gst_element_get_static_pad(ms_node->gst_element, MS_RTP_PAD_VIDEO_IN);
+ gst_ghost_pad_set_target(GST_GHOST_PAD(ghost_sink), rtp_sink);
+ MS_SAFE_UNREF(rtp_sink);
+ MS_SAFE_UNREF(ghost_sink);
+
+ ret = ret && gst_element_link_pads(rtpbin, "send_rtp_src_0", rtp_el, "sink");
+ ret = ret && gst_element_link_pads(rtpbin, "send_rtcp_src_0", rtcp_el, "sink");
+
+ g_object_set_property(G_OBJECT(rtp_el), MEDIA_STREAMER_PARAM_PORT, val);
+ g_object_set(GST_OBJECT(rtp_el), "sync", FALSE, NULL);
+ g_object_set(GST_OBJECT(rtp_el), MEDIA_STREAMER_PARAM_HOST, host, NULL);
+ g_object_set(G_OBJECT(rtcp_el), MEDIA_STREAMER_PARAM_PORT, (g_value_get_int(val) + 1), NULL);
+ g_object_set(GST_OBJECT(rtcp_el), "async", FALSE, NULL);
+ g_object_set(GST_OBJECT(rtcp_el), MEDIA_STREAMER_PARAM_HOST, host, NULL);
}
- __ms_generate_dots(ms_node->gst_element, "rtp");
- MS_SAFE_UNREF(rtpbin);
- MS_SAFE_GFREE(rtp_elem_name);
- MS_SAFE_GFREE(rtcp_elem_name);
- MS_SAFE_GFREE(plugin_name);
+ val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT);
+ if (g_value_get_int(val) > RTP_STREAM_DISABLED) {
+ rtp_el = __ms_element_create("udpsink", MS_RTP_PAD_AUDIO_OUT"_rtp");
+ __ms_bin_add_element(ms_node->gst_element, rtp_el, FALSE);
+ rtcp_el = __ms_element_create("udpsink", MS_RTP_PAD_AUDIO_OUT"_rctp");
+ __ms_bin_add_element(ms_node->gst_element, rtcp_el, FALSE);
+
+ GstPad *rtp_sink = gst_element_get_request_pad(rtpbin, "send_rtp_sink_1");
+ GstPad *ghost_sink = gst_element_get_static_pad(ms_node->gst_element, MS_RTP_PAD_AUDIO_IN);
+ gst_ghost_pad_set_target(GST_GHOST_PAD(ghost_sink), rtp_sink);
+ MS_SAFE_UNREF(rtp_sink);
+ MS_SAFE_UNREF(ghost_sink);
+
+ ret = ret && gst_element_link_pads(rtpbin, "send_rtp_src_1", rtp_el, "sink");
+ ret = ret && gst_element_link_pads(rtpbin, "send_rtcp_src_1", rtcp_el, "sink");
+
+ g_object_set_property(G_OBJECT(rtp_el), MEDIA_STREAMER_PARAM_PORT, val);
+ g_object_set(GST_OBJECT(rtp_el), "sync", FALSE, NULL);
+ g_object_set(GST_OBJECT(rtp_el), MEDIA_STREAMER_PARAM_HOST, host, NULL);
+ g_object_set(G_OBJECT(rtcp_el), MEDIA_STREAMER_PARAM_PORT, (g_value_get_int(val) + 1), NULL);
+ g_object_set(GST_OBJECT(rtcp_el), "async", FALSE, NULL);
+ g_object_set(GST_OBJECT(rtcp_el), MEDIA_STREAMER_PARAM_HOST, host, NULL);
+ }
+ __ms_generate_dots(ms_node->gst_element, "rtp_prepared");
return ret;
}
-int __ms_add_node_into_bin(media_streamer_s * ms_streamer, media_streamer_node_s * ms_node)
+int __ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s *ms_node)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL");
return ret;
}
-static gboolean __ms_parse_gst_error(media_streamer_s * ms_streamer, GstMessage * message, GError * error)
+static gboolean __ms_parse_gst_error(media_streamer_s *ms_streamer, GstMessage *message, GError *error)
{
ms_retvm_if(!ms_streamer, FALSE, "Error: invalid Media Streamer handle.");
ms_retvm_if(!error, FALSE, "Error: invalid error handle.");
return TRUE;
}
-static gboolean __ms_bus_cb(GstBus * bus, GstMessage * message, gpointer userdata)
+static gboolean __ms_bus_cb(GstBus *bus, GstMessage *message, gpointer userdata)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
media_streamer_s *ms_streamer = (media_streamer_s *) userdata;
return TRUE;
}
-int __ms_pipeline_create(media_streamer_s * ms_streamer)
+int __ms_pipeline_create(media_streamer_s *ms_streamer)
{
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return caps;
}
-static media_format_h __ms_create_fmt_from_caps(GstCaps * caps)
+static media_format_h __ms_create_fmt_from_caps(GstCaps *caps)
{
media_format_h fmt;
GstStructure *pad_struct;
return fmt;
}
-int __ms_element_pad_names(GstElement * gst_element, GstPadDirection pad_type, char ***pad_name_array, int *pads_count)
+int __ms_element_pad_names(GstElement *gst_element, GstPadDirection pad_type, char ***pad_name_array, int *pads_count)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-int __ms_element_get_pad_fmt(GstElement * gst_element, const char *pad_name, media_format_h *fmt)
+int __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad_name, media_format_h *fmt)
{
GstCaps *allowed_caps = NULL;
GstCaps *property_caps = NULL;
g_value_init(&value, param->value_type);
if (param->flags & G_PARAM_READWRITE) {
g_object_get_property(G_OBJECT(gst_element), "caps", &value);
- property_caps = gst_value_get_caps(&value);
+ property_caps = GST_CAPS(gst_value_get_caps(&value));
}
g_value_unset(&value);
}
return ret;
}
-int __ms_element_set_fmt(media_streamer_node_s * node, const char *pad_name, 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;
+ ms_retvm_if(!node || !pad_name || !fmt, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP) {
- /* Check if it is a valid pad */
- GstPad *pad = gst_element_get_static_pad(node->gst_element, pad_name);
- ms_retvm_if(!pad, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error: Failed set format to pad [%s].[%s].", node->name, pad_name);
- MS_SAFE_UNREF(pad);
-
- /* It is needed to set 'application/x-rtp' for audio and video udpsrc */
- media_format_mimetype_e mime;
- int audio_channels, audio_samplerate;
- GstElement *rtp_elem, *rtcp_elem;
- gchar *rtp_caps_str = NULL;
-
- if (MEDIA_FORMAT_ERROR_NONE == media_format_get_video_info(fmt, &mime, NULL, NULL, NULL, NULL)) {
- rtp_caps_str = g_strdup_printf("application/x-rtp,media=video,clock-rate=90000,encoding-name=%s", __ms_convert_mime_to_rtp_format(mime));
- __ms_get_rtp_elements(node, &rtp_elem, &rtcp_elem, "video", "in", FALSE);
-
- } else if (MEDIA_FORMAT_ERROR_NONE == media_format_get_audio_info(fmt, &mime, &audio_channels, &audio_samplerate, NULL, NULL)) {
- rtp_caps_str = g_strdup_printf("application/x-rtp,media=audio,clock-rate=%d,encoding-name=%s,channels=%d,payload=96", audio_samplerate, __ms_convert_mime_to_rtp_format(mime), audio_channels);
- __ms_get_rtp_elements(node, &rtp_elem, &rtcp_elem, "audio", "in", FALSE);
- } else {
- ms_error("Failed getting media info from fmt.");
- return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
- }
- caps = gst_caps_from_string(rtp_caps_str);
- obj = __ms_get_property_owner(rtp_elem, "caps", &value);
-
- MS_SAFE_UNREF(rtp_elem);
- MS_SAFE_UNREF(rtcp_elem);
- MS_SAFE_GFREE(rtp_caps_str);
- } else {
- caps = __ms_create_caps_from_fmt(fmt);
- ms_retvm_if(caps == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail creating caps from fmt.");
+ GValue value = G_VALUE_INIT;
+ GObject *obj = __ms_get_property_owner(node->gst_element, "caps", &value);
+ ms_retvm_if(!obj, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Can't find object");
- obj = __ms_get_property_owner(node->gst_element, "caps", &value);
- }
+ GstCaps *caps = __ms_create_caps_from_fmt(fmt);
+ ms_retvm_if(!caps, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Can't convert fmt into Caps");
gst_value_set_caps(&value, caps);
g_object_set_property(obj, "caps", &value);
return MEDIA_STREAMER_ERROR_NONE;
}
-gboolean __ms_gst_seek(GstElement * element, gint64 g_time, GstSeekFlags seek_flag)
+gboolean __ms_gst_seek(GstElement *element, gint64 g_time, GstSeekFlags seek_flag)
{
gboolean result = FALSE;
return result;
}
-int __ms_element_push_packet(GstElement * src_element, media_packet_h packet)
+int __ms_element_push_packet(GstElement *src_element, media_packet_h packet)
{
GstBuffer *buffer = NULL;
GstFlowReturn gst_ret = GST_FLOW_OK;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_element_pull_packet(GstElement * sink_element, media_packet_h * packet)
+int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet)
{
GstSample *sample = NULL;
media_format_h fmt = NULL;
#include <media_streamer_util.h>
#include <media_streamer_gst.h>
-char *param_table[][2] = {
+param_s param_table[] = {
{MEDIA_STREAMER_PARAM_CAMERA_ID, "camera-id"},
- {MEDIA_STREAMER_PARAM_CAMERA_ID, "camera"},
- {MEDIA_STREAMER_PARAM_CAMERA_ID, "device-name"},
+ {MEDIA_STREAMER_PARAM_CAMERA_ID, "device"},
{MEDIA_STREAMER_PARAM_CAPTURE_WIDTH, "capture-width"},
{MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT, "capture-height"},
{MEDIA_STREAMER_PARAM_IS_LIVE_STREAM, "is-live"},
{NULL, NULL}
};
-int __ms_node_set_property(media_streamer_node_s * ms_node, const gchar * param_key, const gchar * param_value)
+static gboolean __ms_rtp_node_has_property(media_streamer_node_s *ms_node, const gchar *param_name)
{
- ms_retvm_if(!ms_node || !ms_node->gst_element, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error: empty node");
- ms_retvm_if(!param_key || !param_value, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error: invalid property parameter");
+ ms_retvm_if(!ms_node || !ms_node->gst_element, FALSE, "Error: empty node");
+ ms_retvm_if(!param_name, FALSE, "Error: invalid property parameter");
- __ms_element_set_property(ms_node->gst_element, param_key, param_value);
+ if (ms_node->type != MEDIA_STREAMER_NODE_TYPE_RTP)
+ return FALSE;
- return MEDIA_STREAMER_ERROR_NONE;
+ GValue *val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), param_name);
+ return val ? TRUE : FALSE;
}
-static int __ms_rtp_node_set_property(media_streamer_node_s * ms_node, const char *param_key, const char *param_value)
+static int __ms_rtp_node_get_property(media_streamer_node_s *ms_node, param_s *param, GValue *value)
{
- ms_retvm_if(!ms_node || !ms_node->gst_element, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error: empty node");
+ ms_retvm_if(!ms_node || !ms_node->gst_element, FALSE, "Error: empty node");
+ ms_retvm_if(ms_node->type != MEDIA_STREAMER_NODE_TYPE_RTP, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Invalid node type");
+ ms_retvm_if(!param, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error: invalid property parameter");
- gchar **tokens = NULL;
- GstElement *rtp_elem = NULL;
- GstElement *rtcp_elem = NULL;
-
- 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_SAFE_UNREF(rtp_elem);
- MS_SAFE_UNREF(rtcp_elem);
- }
-
- __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);
- MS_SAFE_UNREF(rtp_elem);
- MS_SAFE_UNREF(rtcp_elem);
- }
- } else {
- ms_error("Error: Unsupported parameter [%s] for rtp node.", param);
- }
+ int ret = MEDIA_STREAMER_ERROR_NONE;
- g_strfreev(tokens);
- 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;
- }
+ GValue *val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), param->param_name);
+ if (!strcmp(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT) ||
+ !strcmp(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT) ||
+ !strcmp(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT) ||
+ !strcmp(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT)) {
+ g_value_init(value, G_TYPE_INT);
+ } else if (!strcmp(param->param_name, MEDIA_STREAMER_PARAM_HOST)) {
+ g_value_init(value, G_TYPE_STRING);
+ } else
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+
+ g_value_copy(val, value);
+ return ret;
+}
- 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, param, next_port);
- MS_SAFE_GFREE(next_port);
- }
+static int __ms_rtp_node_set_property(media_streamer_node_s *ms_node, param_s *param, const char *param_value)
+{
+ ms_retvm_if(!ms_node || !ms_node->gst_element, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error: empty node");
+ ms_retvm_if(ms_node->type != MEDIA_STREAMER_NODE_TYPE_RTP, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Invalid node type");
+ ms_retvm_if(!param, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error: invalid property parameter");
- g_strfreev(tokens);
- MS_SAFE_UNREF(rtp_elem);
- MS_SAFE_UNREF(rtcp_elem);
- return MEDIA_STREAMER_ERROR_NONE;
- } else {
- ms_error("Invalid rtp parameter name.");
- }
+ int ret = MEDIA_STREAMER_ERROR_NONE;
- g_strfreev(tokens);
+ GValue *val = (GValue *)g_object_get_data(G_OBJECT(ms_node->gst_element), param->param_name);
+ if (!val)
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+
+ if (!strcmp(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT) ||
+ !strcmp(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT) ||
+ !strcmp(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT) ||
+ !strcmp(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT)) {
+ g_value_unset(val);
+ g_value_init(val, G_TYPE_INT);
+ g_value_set_int(val, (int)strtol(param_value, NULL, 10));
+ } else if (!strcmp(param->param_name, MEDIA_STREAMER_PARAM_HOST)) {
+ g_value_unset(val);
+ g_value_init(val, G_TYPE_STRING);
+ g_value_take_string(val, g_strdup(param_value));
+ } else if (!strcmp(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_IN_FORMAT) ||
+ !strcmp(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_IN_FORMAT)) {
+ GstCaps *caps = gst_caps_from_string(param_value);
+ if (caps) {
+ g_value_unset(val);
+ g_value_init(val, GST_TYPE_CAPS);
+ gst_value_set_caps(val, caps);
+ } else
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ } else
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
- return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ return ret;
}
-int __ms_node_create(media_streamer_node_s * node, media_format_h in_fmt, media_format_h out_fmt)
+int __ms_node_create(media_streamer_node_s *node, media_format_h in_fmt, media_format_h out_fmt)
{
ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
__ms_load_ini_dictionary(&dict);
- node->set_param = (ms_node_set_param) __ms_node_set_property;
-
switch (node->type) {
case MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER:
format_prefix = g_strdup_printf("%s:encoder", __ms_convert_mime_to_string(mime));
break;
case MEDIA_STREAMER_NODE_TYPE_RTP:
node->gst_element = __ms_rtp_element_create(node);
- node->set_param = (ms_node_set_param) __ms_rtp_node_set_property;
break;
case MEDIA_STREAMER_NODE_TYPE_QUEUE:
node->gst_element = __ms_element_create(DEFAULT_QUEUE, NULL);
/* This signal callback is called when appsrc needs data, we add an idle handler
* to the mainloop to start pushing data into the appsrc */
-static void __ms_src_start_feed_cb(GstElement * pipeline, guint size, gpointer data)
+static void __ms_src_start_feed_cb(GstElement *pipeline, guint size, gpointer data)
{
media_streamer_node_s *ms_src = (media_streamer_node_s *) data;
ms_retm_if(ms_src == NULL, "Handle is NULL");
/* This callback is called when appsrc has enough data and we can stop sending.
* We remove the idle handler from the mainloop */
-static void __ms_src_stop_feed_cb(GstElement * pipeline, gpointer data)
+static void __ms_src_stop_feed_cb(GstElement *pipeline, gpointer data)
{
media_streamer_node_s *ms_src = (media_streamer_node_s *) data;
ms_retm_if(ms_src == NULL, "Handle is NULL");
}
}
-int __ms_src_node_create(media_streamer_node_s * node)
+int __ms_src_node_create(media_streamer_node_s *node)
{
ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
__ms_load_ini_dictionary(&dict);
- node->set_param = (ms_node_set_param) __ms_node_set_property;
-
switch (node->subtype) {
case MEDIA_STREAMER_NODE_SRC_TYPE_FILE:
node->gst_element = __ms_element_create(DEFAULT_FILE_SOURCE, NULL);
}
/* The appsink has received a buffer */
-static void __ms_sink_new_buffer_cb(GstElement * sink, gpointer * data)
+static void __ms_sink_new_buffer_cb(GstElement *sink, gpointer *data)
{
media_streamer_node_s *ms_sink = (media_streamer_node_s *) data;
ms_retm_if(ms_sink == NULL, "Handle is NULL");
}
/* The appsink has got eos */
-static void sink_eos(GstElement * sink, gpointer * data)
+static void sink_eos(GstElement *sink, gpointer *data)
{
media_streamer_node_s *ms_sink = (media_streamer_node_s *) data;
ms_retm_if(ms_sink == NULL, "Handle is NULL");
}
}
-int __ms_sink_node_create(media_streamer_node_s * node)
+int __ms_sink_node_create(media_streamer_node_s *node)
{
ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
__ms_load_ini_dictionary(&dict);
- node->set_param = (ms_node_set_param) __ms_node_set_property;
-
switch (node->subtype) {
case MEDIA_STREAMER_NODE_SINK_TYPE_FILE:
ms_error("Error: not implemented yet");
return ret;
}
-void __ms_node_destroy(media_streamer_node_s * node)
+void __ms_node_destroy(media_streamer_node_s *node)
{
gchar *node_name = g_strdup(node->name);
MS_SAFE_GFREE(node_name);
}
-int __ms_node_insert_into_table(GHashTable * nodes_table, media_streamer_node_s * ms_node)
+int __ms_node_insert_into_table(GHashTable *nodes_table, media_streamer_node_s *ms_node)
{
if (g_hash_table_contains(nodes_table, ms_node->name)) {
ms_debug("Current Node [%s] already added into Media Streamer", ms_node->name);
}
}
-static gboolean __ms_src_need_typefind(media_streamer_s *ms_streamer, GstPad * src_pad)
+static gboolean __ms_src_need_typefind(GstPad *src_pad)
{
gboolean ret = FALSE;
return FALSE;
GstCaps *src_caps = gst_pad_query_caps(src_pad, NULL);
- if (gst_caps_is_any(src_caps) ||
- !__ms_bin_find_element_by_klass(ms_streamer->topology_bin, NULL, NULL, MEDIA_STREAMER_BIN_KLASS, "rtp_container"))
+ if (gst_caps_is_any(src_caps))
ret = TRUE;
gst_caps_unref(src_caps);
return ret;
}
-static void _sink_node_lock_state(const GValue * item, gpointer user_data)
+static void _sink_node_lock_state(const GValue *item, gpointer user_data)
{
GstElement *sink_element = GST_ELEMENT(g_value_get_object(item));
ms_retm_if(!sink_element, "Handle is NULL");
}
}
-static void _src_node_prepare(const GValue * item, gpointer user_data)
+static void _src_node_prepare(const GValue *item, gpointer user_data)
{
media_streamer_s *ms_streamer = (media_streamer_s *) user_data;
GstElement *src_element = GST_ELEMENT(g_value_get_object(item));
GstPad *src_pad = gst_element_get_static_pad(src_element, "src");
GstElement *found_element = NULL;
- if (__ms_src_need_typefind(ms_streamer, src_pad)) {
+ if (__ms_src_need_typefind(src_pad)) {
found_element = __ms_decodebin_create(ms_streamer);
found_element = __ms_link_with_new_element(src_element, src_pad, found_element);
} else {
MS_SAFE_UNREF(src_pad);
}
-int __ms_pipeline_prepare(media_streamer_s * ms_streamer)
+int __ms_pipeline_prepare(media_streamer_s *ms_streamer)
{
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ media_streamer_node_s *rtp_node = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "rtp_container");
+ if (rtp_node)
+ __ms_rtp_element_prepare(rtp_node);
+
MS_BIN_FOREACH_ELEMENTS(ms_streamer->sink_bin, _sink_node_lock_state, NULL);
MS_BIN_FOREACH_ELEMENTS(ms_streamer->src_bin, _src_node_prepare, ms_streamer);
return MEDIA_STREAMER_ERROR_NONE;
}
-static gboolean __ms_bin_remove_elements(media_streamer_s * ms_streamer, GstElement * bin)
+static gboolean __ms_bin_remove_elements(media_streamer_s *ms_streamer, GstElement *bin)
{
GValue element = G_VALUE_INIT;
GstIterator *bin_iterator = gst_bin_iterate_elements(GST_BIN(bin));
MS_SAFE_UNREF(pad);
}
-int __ms_pipeline_unprepare(media_streamer_s * ms_streamer)
+int __ms_pipeline_unprepare(media_streamer_s *ms_streamer)
{
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
int ret = MEDIA_STREAMER_ERROR_NONE;
-#define MS_BIN_UNPREPARE(bin) \
- if (!__ms_bin_remove_elements(ms_streamer, bin)) {\
- ms_debug("Got a few errors during unprepare [%s] bin.", GST_ELEMENT_NAME(bin));\
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;\
- }
/* Disconnects and clean all autoplug signals */
g_list_free_full(ms_streamer->autoplug_sig_list, __ms_signal_destroy);
ms_streamer->autoplug_sig_list = NULL;
g_list_free_full(ms_streamer->pads_types_list, __ms_pending_pads_remove);
ms_streamer->pads_types_list = NULL;
+ media_streamer_node_s *rtp_node = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "rtp_container");
+ if (rtp_node) {
+ g_list_free_full(rtp_node->sig_list, __ms_signal_destroy);
+ rtp_node->sig_list = NULL;
+ MS_BIN_UNPREPARE(rtp_node->gst_element);
+ }
+
MS_BIN_UNPREPARE(ms_streamer->src_bin);
MS_BIN_UNPREPARE(ms_streamer->topology_bin);
MS_BIN_UNPREPARE(ms_streamer->sink_bin);
-#undef MS_BIN_UNPREPARE
return ret;
}
-static void __params_foreach_cb(const char *key, const int type, const bundle_keyval_t * kv, void *user_data)
+int __ms_node_set_params_from_bundle(media_streamer_node_s *node, bundle *param_list)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
- media_streamer_node_s *ms_node = (media_streamer_node_s *) user_data;
- ms_retm_if(ms_node == NULL, "Handle is NULL");
-
- void *basic_val = NULL;
- size_t basic_size = 0;
-
- ms_info("Try to add parameter [%s] with type [%d] to the node [%s].", key, type, ms_node->name);
-
- if (!bundle_keyval_type_is_array((bundle_keyval_t *) kv)) {
- bundle_keyval_get_basic_val((bundle_keyval_t *) kv, &basic_val, &basic_size);
- ms_info("Read param value[%s] with size [%lu].", (gchar *) basic_val, (unsigned long)basic_size);
-
- if (ms_node->set_param != NULL)
- ret = ms_node->set_param((struct media_streamer_node_s *)ms_node, (char *)key, (char *)basic_val);
- else
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- } else {
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ GList *p_list = NULL;
+ int written_count = 0;
+
+ ret = __ms_node_get_param_list(node, &p_list);
+ if (ret == MEDIA_STREAMER_ERROR_NONE) {
+ param_s *param = NULL;
+ GList *list_iter = NULL;
+ char *string_val = NULL;
+ for (list_iter = p_list; list_iter != NULL; list_iter = list_iter->next) {
+ param = (param_s *)list_iter->data;
+ if (bundle_get_str(param_list, param->param_name, &string_val) != BUNDLE_ERROR_KEY_NOT_AVAILABLE
+ && __ms_node_set_param_value(node, param, string_val) == MEDIA_STREAMER_ERROR_NONE)
+ written_count++;
+ }
}
- ms_retm_if(ret != MEDIA_STREAMER_ERROR_NONE, "Error while adding param [%s,%d] to the node [%s]", key, type, ms_node->name);
+ ms_info("Set [%d] parameters of [%d]", written_count, bundle_get_count(param_list));
+ if (written_count == 0)
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+
+ return ret;
}
-int __ms_node_read_params_from_bundle(media_streamer_node_s * node, bundle * param_list)
+int __ms_node_write_params_into_bundle(media_streamer_node_s *node, bundle *param_list)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
- bundle_foreach(param_list, __params_foreach_cb, (void *)node);
+ GList *p_list = NULL;
+
+ ret = __ms_node_get_param_list(node, &p_list);
+ if (ret == MEDIA_STREAMER_ERROR_NONE) {
+ param_s *param = NULL;
+ GList *list_iter = NULL;
+ char *string_val = NULL;
+ for (list_iter = p_list; list_iter != NULL; list_iter = list_iter->next) {
+ param = (param_s *)list_iter->data;
+
+ if (__ms_node_get_param_value(node, param, &string_val) == MEDIA_STREAMER_ERROR_NONE)
+ bundle_add_str(param_list, param->param_name, string_val);
+ }
+ }
return ret;
}
-static void __ms_node_get_param_value(GParamSpec * param, GValue value, char **string_value)
+int __ms_node_get_param(media_streamer_node_s *node, const char *param_name, param_s **param)
{
- char *string_val = NULL;
- GParamSpecInt *pint = NULL;
-
- if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_CAMERA_ID)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM)) {
- string_val = g_strdup_printf("%s", g_value_get_boolean(&value) ? "true" : "false");
- ms_info("Got boolean value: [%s]", string_val);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_URI)) {
- string_val = g_strdup_printf("%s", g_value_get_string(&value));
- ms_info("Got string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_USER_AGENT)) {
- string_val = g_strdup_printf("%s", g_value_get_string(&value));
- ms_info("Got string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_STREAM_TYPE)) {
- string_val = g_strdup_printf("%d", g_value_get_enum(&value));
- ms_info("Got int value: [%s] ", string_val);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_PORT)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT)) {
- pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_IP_ADDRESS)) {
- string_val = g_strdup_printf("%s", g_value_get_string(&value));
- ms_info("Got string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_AUDIO_DEVICE)) {
- string_val = g_strdup_printf("%s", g_value_get_string(&value));
- ms_info("Got string value: [%s]", g_value_get_string(&value));
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED)) {
- string_val = g_strdup_printf("%s", g_value_get_boolean(&value) ? "true" : "false");
- ms_info("Got boolean value: [%s]", string_val);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_ROTATE)) {
- string_val = g_strdup_printf("%d", g_value_get_enum(&value));
- ms_info("Got enum value: [%s] ", string_val);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_FLIP)) {
- string_val = g_strdup_printf("%d", g_value_get_enum(&value));
- ms_info("Got enum value: [%s] ", string_val);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD)) {
- string_val = g_strdup_printf("%d", g_value_get_enum(&value));
- ms_info("Got enum value: [%s] ", string_val);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_VISIBLE)) {
- string_val = g_strdup_printf("%s", g_value_get_boolean(&value) ? "true" : "false");
- ms_info("Got boolean value: [%s]", string_val);
- } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_HOST)) {
- string_val = g_strdup_printf("%s", g_value_get_string(&value));
- ms_info("Got string value: [%s]", g_value_get_string(&value));
+ GParamSpec *param_spec;
+ gboolean found_param = FALSE;
+ int it_param;
+
+ for (it_param = 0; param_table[it_param].param_name != NULL; it_param++) {
+ if (!g_strcmp0(param_name, param_table[it_param].param_name)) {
+ param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_table[it_param].origin_name);
+ if (param_spec || __ms_rtp_node_has_property(node, param_name)) {
+ *param = &(param_table[it_param]);
+ ms_info("Got parameter [%s] for node [%s]", (*param)->param_name, node->name);
+ found_param = TRUE;
+ break;
+ }
+ }
}
-
- *string_value = string_val;
+ ms_retvm_if(!found_param, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Node [%s] doesn't have param [%s].", node->name, param_name);
+ return MEDIA_STREAMER_ERROR_NONE;
}
-void __ms_node_check_param_name(GstElement * element, gboolean name_is_known, const char *param_name, char **init_param_name)
+int __ms_node_get_param_list(media_streamer_node_s *node, GList **param_list)
{
- char *set_param_name = NULL;
- char *orig_param_name = NULL;
- int it_param = 0;
-
- GParamSpec *param;
-
- for (it_param = 0; param_table[it_param][0] != NULL; it_param++) {
- set_param_name = param_table[it_param][0];
- orig_param_name = param_table[it_param][1];
- param = g_object_class_find_property(G_OBJECT_GET_CLASS(element), orig_param_name);
-
- if (name_is_known) {
- if (!g_strcmp0(param_name, set_param_name)) {
- if (param) {
- *init_param_name = orig_param_name;
- break;
- }
- }
- } else {
- if (!g_strcmp0(param_name, orig_param_name)) {
- if (param) {
- *init_param_name = set_param_name;
- break;
- }
- }
+ GParamSpec *param_spec;
+ int it_param;
+
+ for (it_param = 0; param_table[it_param].param_name != NULL; it_param++) {
+ param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_table[it_param].origin_name);
+ if (param_spec || __ms_rtp_node_has_property(node, param_table[it_param].param_name)) {
+ ms_info("Got parameter [%s] for node [%s]", param_table[it_param].param_name, node->name);
+ *param_list = g_list_append(*param_list, &(param_table[it_param]));
}
}
+ ms_retvm_if(!(*param_list), MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Node [%s] doesn't have any params.", node->name);
+ return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_node_write_params_into_bundle(media_streamer_node_s * node, bundle * param_list)
+int __ms_node_get_param_value(media_streamer_node_s *node, param_s *param, char **string_value)
{
- GParamSpec **property_specs;
- guint num_properties, i;
char *string_val = NULL;
- char *param_init_name = NULL;
-
- 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;
+ GParamSpec *param_spec;
+ GValue value = G_VALUE_INIT;
- ms_info("Getting parameter of the Node [%s]", node->name);
+ int ret = MEDIA_STREAMER_ERROR_NONE;
- for (i = 0; i < num_properties; i++) {
- GValue value = { 0, };
- GParamSpec *param = property_specs[i];
+ if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP)
+ ret = __ms_rtp_node_get_property(node, param, &value);
+ else {
+ param_spec = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param->origin_name);
- __ms_node_check_param_name(node->gst_element, FALSE, param->name, ¶m_init_name);
+ g_value_init(&value, param_spec->value_type);
+ g_object_get_property(G_OBJECT(node->gst_element), param->origin_name, &value);
- if (param_init_name) {
- g_value_init(&value, param->value_type);
+ ms_info("Got parameter [%s] for node [%s] with description [%s]", param->param_name, node->name, g_param_spec_get_blurb(param_spec));
+ }
- if (param->flags & G_PARAM_READWRITE) {
- g_object_get_property(G_OBJECT(node->gst_element), param->name, &value);
+ if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAMERA_ID))
+ if (G_VALUE_HOLDS_STRING(&value)) {
+ /* v4l2src have string property 'device' with value /dev/video[0-n].
+ * Try to get index from it. */
+ const char *str_val = g_value_get_string(&value);
+ if (str_val && g_str_has_prefix(str_val, "/dev/video")) {
+ string_val = g_strdup(str_val + strlen("/dev/video"));
} else {
-
- /* Skip properties which user can not change. */
- continue;
+ ms_info("Parameter [%s] was got not for MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA type of nodes", param->param_name);
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
}
-
- ms_info("%-20s: %s\n", param_init_name, g_param_spec_get_blurb(param));
- __ms_node_get_param_value(param, value, &string_val);
-
- bundle_add_str(param_list, param_init_name, string_val);
- param_init_name = NULL;
+ } else {
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
}
- }
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH))
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT))
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM))
+ string_val = g_strdup(g_value_get_boolean(&value) ? "true" : "false");
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_URI))
+ string_val = g_value_dup_string(&value);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USER_AGENT))
+ string_val = g_value_dup_string(&value);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_STREAM_TYPE))
+ string_val = g_strdup_printf("%d", g_value_get_enum(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PORT))
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT))
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT))
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT))
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT))
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IP_ADDRESS))
+ string_val = g_value_dup_string(&value);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_DEVICE))
+ string_val = g_value_dup_string(&value);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED))
+ string_val = g_strdup(g_value_get_boolean(&value) ? "true" : "false");
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_ROTATE))
+ string_val = g_strdup_printf("%d", g_value_get_enum(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_FLIP))
+ string_val = g_strdup_printf("%d", g_value_get_enum(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD))
+ string_val = g_strdup_printf("%d", g_value_get_enum(&value));
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VISIBLE))
+ string_val = g_strdup(g_value_get_boolean(&value) ? "true" : "false");
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_HOST))
+ string_val = g_value_dup_string(&value);
- return MEDIA_STREAMER_ERROR_NONE;
+ *string_value = string_val;
+ g_value_unset(&value);
+ return ret;
}
-int __ms_node_write_param_into_value(media_streamer_node_s * node, const char *param_name, char **param_value)
+int __ms_node_set_param_value(media_streamer_node_s *ms_node, param_s *param, const char *param_value)
{
- char *string_val = NULL;
- char *param_init_name = NULL;
+ ms_retvm_if(!ms_node || !param || !param_value, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- GValue value = { 0, };
- GParamSpec *param;
+ int ret = MEDIA_STREAMER_ERROR_NONE;
- __ms_node_check_param_name(node->gst_element, TRUE, param_name, ¶m_init_name);
+ if (ms_node->type == MEDIA_STREAMER_NODE_TYPE_RTP) {
+ ret = __ms_rtp_node_set_property(ms_node, param, param_value);
+ return ret;
+ }
- if (param_init_name) {
- param = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_init_name);
+ if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAMERA_ID)) {
+ int camera_id = (int)strtol(param_value, NULL, 10);
+ ms_retvm_if(camera_id == -1, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Invalid %s value", param->param_name);
+ if (g_str_has_prefix(ms_node->name, "v4l2src")) {
+ /* v4l2src have string property 'device' with value /dev/video[0-n]. */
+ gchar *camera_device_str = g_strdup_printf("/dev/video%d", camera_id);
+ g_object_set(ms_node->gst_element, param->origin_name, camera_device_str, NULL);
+ MS_SAFE_FREE(camera_device_str);
+ } else
+ g_object_set(ms_node->gst_element, param->origin_name, camera_id, NULL);
+ } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH))
+ g_object_set(ms_node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT))
+ g_object_set(ms_node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM))
+ g_object_set(ms_node->gst_element, param->origin_name, !g_ascii_strcasecmp(param_value, "true"), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_URI))
+ g_object_set(ms_node->gst_element, param->origin_name, param_value, NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USER_AGENT))
+ g_object_set(ms_node->gst_element, param->origin_name, param_value, NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_STREAM_TYPE))
+ g_object_set(ms_node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PORT))
+ g_object_set(ms_node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IP_ADDRESS))
+ g_object_set(ms_node->gst_element, param->origin_name, param_value, NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_DEVICE))
+ g_object_set(ms_node->gst_element, param->origin_name, param_value, NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED))
+ g_object_set(ms_node->gst_element, param->origin_name, !g_ascii_strcasecmp(param_value, "true"), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_ROTATE))
+ g_object_set(ms_node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_FLIP))
+ g_object_set(ms_node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD))
+ g_object_set(ms_node->gst_element, param->origin_name, (int)strtol(param_value, NULL, 10), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_EVAS_OBJECT))
+ g_object_set(ms_node->gst_element, param->origin_name, (gpointer)param_value, NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VISIBLE))
+ g_object_set(ms_node->gst_element, param->origin_name, !g_ascii_strcasecmp(param_value, "true"), NULL);
+ else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_HOST))
+ g_object_set(ms_node->gst_element, param->origin_name, param_value, NULL);
+ else {
+ ms_info("Can not set parameter [%s] in the node [%s]", param->param_name, ms_node->name);
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ }
- ms_info("Getting parameter of the Node [%s]", node->name);
+ return ret;
+}
- g_value_init(&value, param->value_type);
+int __ms_node_set_pad_format(media_streamer_node_s *node, const char *pad_name, media_format_h fmt)
+{
+ ms_retvm_if(!node || !pad_name || !fmt, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- if (param->flags & G_PARAM_READWRITE)
- g_object_get_property(G_OBJECT(node->gst_element), param_init_name, &value);
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP) {
+ media_format_mimetype_e mime;
+ gchar *rtp_caps_str = NULL;
+
+ /* It is needed to set 'application/x-rtp' for audio and video udpsrc */
+ if (!strcmp(pad_name, MS_RTP_PAD_VIDEO_IN"_rtp")) {
+ ret = media_format_get_video_info(fmt, &mime, NULL, NULL, NULL, NULL);
+ if (MEDIA_FORMAT_ERROR_NONE == ret) {
+ rtp_caps_str = g_strdup_printf("application/x-rtp,media=video,clock-rate=90000,encoding-name=%s", __ms_convert_mime_to_rtp_format(mime));
+ param_s param = {MEDIA_STREAMER_PARAM_VIDEO_IN_FORMAT, MEDIA_STREAMER_PARAM_VIDEO_IN_FORMAT};
+ ret = __ms_node_set_param_value(node, ¶m, rtp_caps_str);
+ }
+ } else if (!strcmp(pad_name, MS_RTP_PAD_AUDIO_IN"_rtp")) {
+ int audio_channels, audio_samplerate;
+ ret = media_format_get_audio_info(fmt, &mime, &audio_channels, &audio_samplerate, NULL, NULL);
+ if (MEDIA_FORMAT_ERROR_NONE == ret) {
+ rtp_caps_str = g_strdup_printf("application/x-rtp,media=audio,clock-rate=%d,encoding-name=%s,channels=%d,payload=96", audio_samplerate, __ms_convert_mime_to_rtp_format(mime), audio_channels);
+ param_s param = {MEDIA_STREAMER_PARAM_AUDIO_IN_FORMAT, MEDIA_STREAMER_PARAM_AUDIO_IN_FORMAT};
+ ret = __ms_node_set_param_value(node, ¶m, rtp_caps_str);
+ }
+ }
- ms_info("%-20s: %s\n", param_name, g_param_spec_get_blurb(param));
- __ms_node_get_param_value(param, value, &string_val);
+ MS_SAFE_GFREE(rtp_caps_str);
+ } else {
+ ret = __ms_element_set_fmt(node, pad_name, fmt);
}
- if (!string_val)
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
-
- *param_value = string_val;
-
- return MEDIA_STREAMER_ERROR_NONE;
+ return ret;
}
#define GST_TIME_TO_MSEC(t) (t == GST_CLOCK_TIME_NONE ? t : (int)(((GstClockTime)(t)) / GST_MSECOND))
-int __ms_state_change(media_streamer_s * ms_streamer, media_streamer_state_e state)
+int __ms_state_change(media_streamer_s *ms_streamer, media_streamer_state_e state)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-int __ms_create(media_streamer_s * ms_streamer)
+int __ms_create(media_streamer_s *ms_streamer)
{
__ms_load_ini_settings(&ms_streamer->ini);
return __ms_pipeline_create(ms_streamer);
}
-int __ms_get_position(media_streamer_s * ms_streamer, int *time)
+int __ms_get_position(media_streamer_s *ms_streamer, int *time)
{
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ms_retvm_if(time == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Return value is NULL");
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_streamer_seek(media_streamer_s * ms_streamer, int g_time, bool flag)
+int __ms_streamer_seek(media_streamer_s *ms_streamer, int g_time, bool flag)
{
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_streamer_destroy(media_streamer_s * ms_streamer)
+int __ms_streamer_destroy(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
static void __ms_check_ini_status(void);
-gchar *__ms_ini_get_string(dictionary * dict, const char *ini_path, char *default_str)
+gchar *__ms_ini_get_string(dictionary *dict, const char *ini_path, char *default_str)
{
gchar *result_str = NULL;
return result_str;
}
-gboolean __ms_load_ini_dictionary(dictionary ** dict)
+gboolean __ms_load_ini_dictionary(dictionary **dict)
{
ms_retvm_if(dict == NULL, FALSE, "Handle is NULL");
return TRUE;
}
-gboolean __ms_destroy_ini_dictionary(dictionary * dict)
+gboolean __ms_destroy_ini_dictionary(dictionary *dict)
{
ms_retvm_if(dict == NULL, FALSE, "Handle is null");
return TRUE;
}
-void __ms_load_ini_settings(media_streamer_ini_t * ini)
+void __ms_load_ini_settings(media_streamer_ini_t *ini)
{
dictionary *dict = NULL;
}
}
-void __ms_signal_create(GList ** sig_list, GstElement * obj, const char *sig_name, GCallback cb, gpointer user_data)
+void __ms_signal_create(GList **sig_list, GstElement *obj, const char *sig_name, GCallback cb, gpointer user_data)
{
ms_retm_if(!sig_list || !obj || !sig_name, "Empty signal data!");
}
MS_SAFE_GFREE(sig_data);
}
+
+void __ms_rtp_param_value_destroy(gpointer data)
+{
+ GValue *val = (GValue *)data;
+ ms_retm_if(!data, "Empty object data!");
+
+ if (GST_VALUE_HOLDS_CAPS(val))
+ gst_caps_unref(GST_CAPS(gst_value_get_caps(val)));
+
+ g_value_unset(val);
+ MS_SAFE_GFREE(val);
+}
g_print("Current play position [%02d:%02d:%03d] \n", current_time / (1000 * 60), (current_time / 1000) % 60, current_time % 1000);
}
-static void _create(media_streamer_h * streamer)
+static void _create(media_streamer_h *streamer)
{
g_print("== create \n");
int ret = MEDIA_STREAMER_ERROR_NONE;
display_menu();
}
-gboolean input(GIOChannel * channel)
+gboolean input(GIOChannel *channel)
{
gchar buf[MAX_STRING_LEN];
gsize read;
projects / platform / core / api / mediastreamer.git / commitdiff