Some functions are moved to the proper file.
[Version] 0.1.40
[Issue Type] Naming convention
Change-Id: I1bc0d028ede29369b256cb323b6c926a12a73252
Signed-off-by: Sangchul Lee <sc11.lee@samsung.com>
/**
* @brief Generates dot files for GStreamer pipeline.
*/
-void __ms_generate_dots(GstElement *bin, gchar *name_tag);
+void ms_generate_dots(GstElement *bin, gchar *name_tag);
/**
* @brief Creates GstElement by plugin name.
*/
-GstElement *__ms_element_create(const char *plugin_name, const char *name);
+GstElement *ms_element_create(const char *plugin_name, const char *name);
/**
* @brief Creates GstBin name for adaptive streaming.
*/
-GstElement *__ms_adaptive_element_create(void);
+GstElement *ms_adaptive_element_create(void);
/**
* @brief Creates GstElement from specified node_plug_s structure.
*/
-GstElement *__ms_node_element_create(node_plug_s *plug_info, media_streamer_node_type_e type);
+GstElement *ms_node_element_create(node_plug_s *plug_info, media_streamer_node_type_e type);
/**
* @brief Creates rtp container GstElement.
*/
-GstElement *__ms_rtp_element_create(void);
+GstElement *ms_rtp_element_create(void);
/**
* @brief Unlink all pads into GstElement.
*/
-gboolean __ms_element_unlink(GstElement *element);
+gboolean ms_element_unlink(GstElement *element);
/**
* @brief Remove GstElement from bin.
*/
-gboolean __ms_bin_remove_element(GstElement *element);
+gboolean ms_bin_remove_element(GstElement *element);
/**
* @brief Add GstElement into bin if not added before and refs it.
*/
-gboolean __ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ref);
+gboolean ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ref);
/**
* @brief Gets pad type of element pad.
*/
-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.
*/
-GstElement *__ms_decodebin_create(media_streamer_s *ms_streamer, char *name);
+GstElement *ms_decodebin_create(media_streamer_s *ms_streamer, char *name);
/**
* @brief Creates next element by klass or by properties and links with the previous one.
*/
-GstElement *__ms_combine_next_element(GstElement *previous_element, GstPad *prev_elem_src_pad, GstElement *bin_to_find_in, media_streamer_node_type_e node_type);
+GstElement *ms_combine_next_element(GstElement *previous_element, GstPad *prev_elem_src_pad, GstElement *bin_to_find_in, media_streamer_node_type_e node_type);
/**
* @brief Locks gst_element being contained in GValue data.
*/
-gboolean __ms_element_lock_state(const GValue *item, GValue *ret, gpointer user_data);
+gboolean ms_element_lock_state(const GValue *item, GValue *ret, gpointer user_data);
/**
* @brief Unlocks gst_element being contained in GValue data.
*/
-gboolean __ms_element_unlock_state(const GValue *item, GValue *ret, gpointer user_data);
-
-/**
- * @brief Gets state of media streamer.
- */
-void __ms_get_state(media_streamer_s *ms_streamer);
+gboolean ms_element_unlock_state(const GValue *item, GValue *ret, gpointer user_data);
/**
* @brief Creates pipeline, bus and src/sink/transform bins.
*/
-int __ms_pipeline_create(media_streamer_s *ms_streamer);
+int ms_pipeline_create(media_streamer_s *ms_streamer);
/**
* @brief Prepares Media Streamer pipeline and autoplug nodes if needed.
*
*/
-int __ms_pipeline_prepare(media_streamer_s *ms_streamer);
+int ms_pipeline_prepare(media_streamer_s *ms_streamer);
/**
* @brief Unprepares Media Streamer pipeline and unlink nodes
* which user didn't link before.
*/
-int __ms_pipeline_unprepare(media_streamer_s *ms_streamer);
+int ms_pipeline_unprepare(media_streamer_s *ms_streamer);
+
+/**
+ * @brief Gets pipeline state of media streamer.
+ */
+void ms_pipeline_get_state(media_streamer_s *ms_streamer);
/**
* @brief Sets GstElement into state.
*/
-int __ms_element_set_state(GstElement *element, GstState state);
+int ms_element_set_state(GstElement *element, GstState state);
/**
* @brief Iterates pas inside gst element.
*/
-int __ms_element_pad_names(GstElement *element, GstPadDirection pad_type, char ***pad_name_array, int *pads_count);
+int ms_element_pad_names(GstElement *element, GstPadDirection pad_type, char ***pad_name_array, int *pads_count);
/**
* @brief Gets mediaformat from the GstElement's pad by pad name.
*/
-int __ms_element_get_pad_fmt(GstElement *element, const char *pad_name, media_format_h *fmt);
+int ms_element_get_pad_fmt(GstElement *element, const char *pad_name, media_format_h *fmt);
/**
* @brief Sets mediaformat to the GstElement's pad.
*/
-int __ms_element_set_fmt(GstElement *element, const char *pad_name, media_format_h fmt);
+int ms_element_set_fmt(GstElement *element, const char *pad_name, media_format_h fmt);
/**
* @brief Creates GstCap's from mediaformat.
*/
-GstCaps *__ms_create_caps_from_fmt(media_format_h fmt);
+GstCaps *ms_create_caps_from_fmt(media_format_h fmt);
/**
* @brief Seeks GstElement to according time value.
*/
-gboolean __ms_gst_seek(GstElement *element, gint64 g_time, GstSeekFlags seek_flag);
+gboolean ms_gst_seek(GstElement *element, gint64 g_time, GstSeekFlags seek_flag);
/**
* @brief Push the media packet buffer to the source element.
*/
-int __ms_element_push_packet(GstElement *src_element, media_packet_h packet);
+int ms_element_push_packet(GstElement *src_element, media_packet_h packet);
/**
* @brief Pull the media packet buffer from sink element.
*/
-int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet);
+int ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet);
/**
* @brief Finds type of media
*/
-int __ms_find_type(media_streamer_s *ms_streamer, GstElement *element);
+int ms_find_type(media_streamer_s *ms_streamer, GstElement *element);
-void __ms_rtpbin_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data);
+void ms_rtpbin_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data);
-void __ms_demux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data);
+void ms_demux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data);
-void __ms_hlsdemux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data);
+void ms_hlsdemux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data);
-void __ms_demux_nomore_pads_cb(GstElement *element, gpointer user_data);
+void ms_demux_nomore_pads_cb(GstElement *element, gpointer user_data);
#ifdef __cplusplus
typedef void *media_streamer_http_server_h;
-int __ms_http_server_create(media_streamer_http_server_h *server);
-int __ms_http_server_destroy(media_streamer_http_server_h server);
+int ms_http_server_create(media_streamer_http_server_h *server);
+int ms_http_server_destroy(media_streamer_http_server_h server);
-int __ms_http_server_start(media_streamer_http_server_h server, int port);
-int __ms_http_server_stop(media_streamer_http_server_h server);
+int ms_http_server_start(media_streamer_http_server_h server, int port);
+int ms_http_server_stop(media_streamer_http_server_h server);
-int __ms_http_server_register_uri(media_streamer_http_server_h server, char *uri, char *file_path);
-int __ms_http_server_unregister_uri(media_streamer_http_server_h server, char *uri);
+int ms_http_server_register_uri(media_streamer_http_server_h server, char *uri, char *file_path);
+int ms_http_server_unregister_uri(media_streamer_http_server_h server, char *uri);
#ifdef __cplusplus
}
/**
* @brief Gets Node's information by its type.
*/
-node_info_s *__ms_node_get_klass_by_its_type(media_streamer_node_type_e element_type);
+node_info_s *ms_node_get_klass_by_its_type(media_streamer_node_type_e element_type);
/**
* @brief Creates media streamer node using input and output format.
*/
-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);
/**
* @brief Creates media streamer source node.
*/
-int __ms_src_node_create(media_streamer_node_s *node);
+int ms_src_node_create(media_streamer_node_s *node);
/**
* @brief Creates media streamer sink node.
*/
-int __ms_sink_node_create(media_streamer_node_s *node);
+int ms_sink_node_create(media_streamer_node_s *node);
/**
* @brief Destroys media streamer node.
*/
-void __ms_node_destroy(media_streamer_node_s *node);
+void ms_node_destroy(media_streamer_node_s *node);
/**
* @brief Adds node to bin
*/
-int __ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s *node);
+int ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s *node);
/**
* @brief Prepares source node for adaptive streaming.
*/
-int __ms_adaptive_src_node_prepare(media_streamer_node_s *node, bool auto_plug);
+int ms_adaptive_src_node_prepare(media_streamer_node_s *node, bool auto_plug);
/**
* @brief Prepares sink node for adaptive streaming.
*/
-int __ms_adaptive_sink_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node);
+int ms_adaptive_sink_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node);
/**
* @brief Prepares rtp node.
*/
-gboolean __ms_rtp_node_prepare(media_streamer_node_s *node);
+gboolean ms_rtp_node_prepare(media_streamer_node_s *node);
/**
* @brief Prepares demux node.
*/
-int __ms_demux_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node);
+int ms_demux_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node);
/**
* @brief Inserts media streamer node into nodes table.
*/
-int __ms_node_insert_into_table(GHashTable *nodes_table, media_streamer_node_s *node);
+int ms_node_insert_into_table(GHashTable *nodes_table, media_streamer_node_s *node);
/**
* @brief Removes media streamer node from nodes table.
*/
-void __ms_node_remove_from_table(void *data);
+void ms_node_remove_from_table(void *data);
/**
* @brief Reads node parameters from user's bundle object.
*/
-int __ms_node_set_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);
+int ms_node_write_params_into_bundle(media_streamer_node_s *node, bundle *param_list);
/**
* @brief Gets node's parameter by param_name.
*/
-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.
- */
-int __ms_node_get_param_list(media_streamer_node_s *node, GList **param_list);
+int ms_node_get_param(media_streamer_node_s *node, const char *param_name, param_s **param);
/**
* @brief Gets string value of node's parameter.
*/
-int __ms_node_get_param_value(media_streamer_node_s *node, param_s *param, char **string_value);
+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.
*/
-int __ms_node_set_param_value(media_streamer_node_s *node, param_s *param, const gchar *param_value);
+int ms_node_set_param_value(media_streamer_node_s *node, param_s *param, const gchar *param_value);
/**
* @brief Sets media format value into node's pad.
*/
-int __ms_node_set_pad_format(media_streamer_node_s *node, const char *pad_name, media_format_h fmt);
+int ms_node_set_pad_format(media_streamer_node_s *node, const char *pad_name, media_format_h fmt);
-gboolean _ms_sink_node_prepare_iter(const GValue *item, GValue *g_ret, gpointer user_data);
-gboolean _ms_src_node_prepare_iter(const GValue *item, GValue *g_ret, gpointer user_data);
-gboolean _ms_node_resources_acquire_iter(const GValue *item, GValue *ret, gpointer user_data);
-gboolean _ms_node_resources_release_iter(const GValue *item, GValue *ret, gpointer user_data);
-gboolean _ms_node_policy_check_iter(const GValue *item, GValue *ret, gpointer user_data);
+gboolean ms_sink_node_prepare_iter(const GValue *item, GValue *g_ret, gpointer user_data);
+gboolean ms_src_node_prepare_iter(const GValue *item, GValue *g_ret, gpointer user_data);
+gboolean ms_node_resources_acquire_iter(const GValue *item, GValue *ret, gpointer user_data);
+gboolean ms_node_resources_release_iter(const GValue *item, GValue *ret, gpointer user_data);
+gboolean ms_node_policy_check_iter(const GValue *item, GValue *ret, gpointer user_data);
#ifdef __cplusplus
}
POLICY_TYPE_MIC,
} media_streamer_policy_type_e;
-int __ms_node_policy_init(media_streamer_node_s *node);
-int __ms_node_policy_deinit(media_streamer_node_s *node);
-int _ms_node_policy_check(media_streamer_node_s *node);
+int ms_node_policy_init(media_streamer_node_s *node);
+int ms_node_policy_deinit(media_streamer_node_s *node);
+int ms_node_policy_check(media_streamer_node_s *node);
#ifdef __cplusplus
}
extern "C" {
#endif
-int _ms_node_resource_acquire(media_streamer_node_s *node);
-int _ms_node_resource_release(media_streamer_node_s *node);
+int ms_node_resource_acquire(media_streamer_node_s *node);
+int ms_node_resource_release(media_streamer_node_s *node);
#ifdef __cplusplus
}
int policy_changed_cb_id;
} media_streamer_node_s;
-typedef struct _media_streamer_wl_info_s {
- gint parent_id;
-} media_streamer_wl_info_s;
-
/**
* @brief Gets the play position of Media streamer element.
*/
-int __ms_get_position(media_streamer_s *ms_streamer, int *time);
+int ms_get_position(media_streamer_s *ms_streamer, int *time);
/**
* @brief Gets the duration of Media streamer element.
*/
-int __ms_get_duration(media_streamer_s *ms_streamer, int *time);
+int ms_get_duration(media_streamer_s *ms_streamer, int *time);
/**
* @brief Seeks Media streamer element to the pointed position.
*/
-int __ms_seek(media_streamer_s *ms_streamer, int time, bool flag);
+int ms_seek(media_streamer_s *ms_streamer, int time, bool flag);
/**
* @brief Destroys media streamer structure.
*/
-int __ms_destroy(media_streamer_s *ms_streamer);
+int ms_destroy(media_streamer_s *ms_streamer);
/**
* @brief Creates media streamer structure.
*/
-int __ms_create(media_streamer_s *ms_streamer);
+int ms_create(media_streamer_s *ms_streamer);
/**
* @brief Changes state of media streamer.
*/
-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 __ms_release_resources(media_streamer_s *ms_streamer);
+int ms_release_resources(media_streamer_s *ms_streamer);
#ifdef __cplusplus
}
#include <gst/gst.h>
#include <dlog.h>
#include <iniparser.h>
+#include <Evas.h>
#ifdef __cplusplus
extern "C" {
gulong signal_id;
} media_streamer_signal_s;
+typedef struct _media_streamer_wl_info_s {
+ gint parent_id;
+} media_streamer_wl_info_s;
+
/*Test elements*/
#define DEFAULT_VIDEO_TEST_SOURCE "videotestsrc"
#define DEFAULT_AUDIO_TEST_SOURCE "audiotestsrc"
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_param_value_destroy); \
+ g_object_set_data_full(G_OBJECT(obj), key, (gpointer)val, ms_param_value_destroy); \
} while (0)
#define MS_SET_INT_STATIC_STRING_PARAM(obj, key, value) \
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_param_value_destroy); \
+ g_object_set_data_full(G_OBJECT(obj), key, (gpointer)val, ms_param_value_destroy); \
} while (0)
#define MS_SET_INT_CAPS_PARAM(obj, key, value) \
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_param_value_destroy); \
+ g_object_set_data_full(G_OBJECT(obj), key, (gpointer)val, ms_param_value_destroy); \
} while (0)
#define MS_GET_CAPS_TYPE(caps, type) \
* @brief Loads media streamer settings from ini file.
* The default values will be used if error has occurred.
*/
-void __ms_load_ini_settings(media_streamer_ini_t *ini);
+void ms_load_ini_settings(media_streamer_ini_t *ini);
/**
* @brief Read and copy string reading from ini file.
*/
-gchar *__ms_ini_get_string(const char *ini_path, const char *default_str);
+gchar *ms_ini_get_string(const char *ini_path, const char *default_str);
/**
* @brief Reads comma-separated string list from ini file.
*/
-void __ms_ini_read_list(const char *key, gchar ***list);
+void ms_ini_read_list(const char *key, gchar ***list);
/**
* @brief Converts Media Format mime type into Caps media format string.
*/
-const gchar *__ms_convert_mime_to_string_format(media_format_mimetype_e mime);
+const gchar *ms_convert_mime_to_string_format(media_format_mimetype_e mime);
/**
* @brief Converts Media Format mime type into rtp media type.
*/
-const gchar *__ms_convert_mime_to_rtp_format(media_format_mimetype_e mime);
+const gchar *ms_convert_mime_to_rtp_format(media_format_mimetype_e mime);
/**
* @brief Converts Caps stream format into Media Format mime type.
*/
-media_format_mimetype_e __ms_convert_string_format_to_media_format(const char *format_type);
+media_format_mimetype_e ms_convert_string_format_to_media_format(const char *format_type);
/**
* @brief Creates Media streamer signal structure,
* connects it to object and appends it to signal list.
*/
-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);
/**
* @brief Disconnects signal from object and
* destroys Media streamer signal object.
*/
-void __ms_signal_destroy(void *data);
+void ms_signal_destroy(void *data);
/**
* @brief Destroys the which set as rtp node parameter.
*/
-void __ms_param_value_destroy(gpointer data);
+void ms_param_value_destroy(gpointer data);
/**
* @brief Check URI is valid file
*/
-int __ms_util_uri_path_check(const char *file_uri);
+int ms_util_uri_path_check(const char *file_uri);
/**
* @brief Iterates func over all elements contained within a bin.
*/
-int __ms_bin_foreach_elements(GstBin *bin, GstIteratorFoldFunction func, void *user_data);
+int ms_bin_foreach_elements(GstBin *bin, GstIteratorFoldFunction func, void *user_data);
+
+int ms_get_wl_info(Evas_Object *obj, media_streamer_wl_info_s *wl_info);
#ifdef __cplusplus
}
Name: capi-media-streamer
Summary: A Media Streamer API
-Version: 0.1.39
-Release: 1
+Version: 0.1.40
+Release: 0
Group: Multimedia/API
License: Apache-2.0
URL: http://source.tizen.org
ms_src->type = MEDIA_STREAMER_NODE_TYPE_SRC;
ms_src->subtype = (media_streamer_node_src_type_e) type;
- ret = __ms_src_node_create(ms_src);
+ ret = ms_src_node_create(ms_src);
if (ret != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error creating Src node [%d]", ret);
- __ms_node_destroy(ms_src);
+ ms_node_destroy(ms_src);
return ret;
}
ms_sink->type = MEDIA_STREAMER_NODE_TYPE_SINK;
ms_sink->subtype = (media_streamer_node_sink_type_e) type;
- ret = __ms_sink_node_create(ms_sink);
+ ret = ms_sink_node_create(ms_sink);
if (ret != MEDIA_STREAMER_ERROR_NONE) {
- __ms_node_destroy(ms_sink);
+ ms_node_destroy(ms_sink);
ms_error("Error creating Sink node [%d]", ret);
return ret;
}
ms_node->type = type;
ms_node->subtype = 0;
- ret = __ms_node_create(ms_node, in_fmt, out_fmt);
+ ret = ms_node_create(ms_node, in_fmt, out_fmt);
if (ret != MEDIA_STREAMER_ERROR_NONE) {
- __ms_node_destroy(ms_node);
+ ms_node_destroy(ms_node);
ms_error("Error creating Node [%d]", ret);
return ret;
} else {
if (ms_node->parent_streamer == NULL) {
/* This node was not added into any media streamer */
- __ms_node_destroy(ms_node);
+ ms_node_destroy(ms_node);
} else {
ms_error("Node destroy error: needed to remove node from media streamer before destroying.");
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_node_insert_into_table(ms_streamer->nodes_table, ms_node);
+ ret = ms_node_insert_into_table(ms_streamer->nodes_table, ms_node);
if (ret == MEDIA_STREAMER_ERROR_NONE) {
ms_node->parent_streamer = ms_streamer;
- ret = __ms_add_node_into_bin(ms_streamer, ms_node);
+ ret = ms_add_node_into_bin(ms_streamer, ms_node);
}
g_mutex_unlock(&ms_streamer->mutex_lock);
g_mutex_lock(&ms_streamer->mutex_lock);
- __ms_generate_dots(ms_streamer->pipeline, "before_prepare");
+ ms_generate_dots(ms_streamer->pipeline, "before_prepare");
- ret = __ms_pipeline_prepare(ms_streamer);
+ ret = ms_pipeline_prepare(ms_streamer);
- __ms_generate_dots(ms_streamer->pipeline, "after_prepare");
+ ms_generate_dots(ms_streamer->pipeline, "after_prepare");
g_mutex_unlock(&ms_streamer->mutex_lock);
- __ms_get_state(ms_streamer);
+ ms_pipeline_get_state(ms_streamer);
ms_debug_fleave();
g_mutex_lock(&ms_streamer->mutex_lock);
- __ms_generate_dots(ms_streamer->pipeline, "before_unprepare");
+ ms_generate_dots(ms_streamer->pipeline, "before_unprepare");
- ret = __ms_pipeline_unprepare(ms_streamer);
+ ret = ms_pipeline_unprepare(ms_streamer);
- __ms_http_server_destroy(ms_streamer->http_server);
+ ms_http_server_destroy(ms_streamer->http_server);
- __ms_generate_dots(ms_streamer->pipeline, "after_unprepare");
+ ms_generate_dots(ms_streamer->pipeline, "after_unprepare");
g_mutex_unlock(&ms_streamer->mutex_lock);
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PLAYING);
+ ret = ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PLAYING);
g_mutex_unlock(&ms_streamer->mutex_lock);
- __ms_get_state(ms_streamer);
+ ms_pipeline_get_state(ms_streamer);
ms_debug_fleave();
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_create(ms_streamer);
+ ret = ms_create(ms_streamer);
if (ret != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error creating Media Streamer");
g_mutex_unlock(&ms_streamer->mutex_lock);
- __ms_destroy(ms_streamer);
+ ms_destroy(ms_streamer);
return ret;
}
ms_streamer->pend_state = MEDIA_STREAMER_STATE_NONE;
- ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE);
+ ret = ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE);
*streamer = ms_streamer;
g_mutex_unlock(&ms_streamer->mutex_lock);
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "streamer is NULL");
ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be unprepared before destroying!");
- ret = __ms_destroy(ms_streamer);
+ ret = ms_destroy(ms_streamer);
ms_debug_fleave();
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PAUSED);
+ ret = ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PAUSED);
g_mutex_unlock(&ms_streamer->mutex_lock);
- __ms_get_state(ms_streamer);
+ ms_pipeline_get_state(ms_streamer);
ms_debug_fleave();
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_seek(streamer, 0, FALSE);
+ ret = ms_seek(streamer, 0, FALSE);
if (ret != MEDIA_STREAMER_ERROR_NONE)
ms_error("Error while putting media streamer to zero playing position");
else
- ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PAUSED);
+ ret = ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PAUSED);
- __ms_http_server_stop(ms_streamer->http_server);
+ ms_http_server_stop(ms_streamer->http_server);
g_mutex_unlock(&ms_streamer->mutex_lock);
- __ms_get_state(ms_streamer);
+ ms_pipeline_get_state(ms_streamer);
ms_debug_fleave();
/* if query duration failed or returns duration value MS_TIME_NONE,
* we suppose that pipeline does not support seek. */
- ret = __ms_get_duration(ms_streamer, &duration);
+ ret = ms_get_duration(ms_streamer, &duration);
if (ret == MEDIA_STREAMER_ERROR_NONE && duration != MS_TIME_NONE) {
ms_streamer->seek_done_cb.callback = callback;
ms_streamer->seek_done_cb.user_data = user_data;
- ret = __ms_seek(streamer, time, accurate);
+ ret = ms_seek(streamer, time, accurate);
} else
ret = MEDIA_STREAMER_ERROR_NOT_SUPPORTED;
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_get_position(streamer, time);
+ ret = ms_get_position(streamer, time);
g_mutex_unlock(&ms_streamer->mutex_lock);
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_get_duration(streamer, duration);
+ ret = ms_get_duration(streamer, duration);
g_mutex_unlock(&ms_streamer->mutex_lock);
ms_debug_fleave();
- return __ms_element_push_packet(ms_node->gst_element, packet);
+ 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)
ms_debug_fleave();
- return __ms_element_pull_packet(ms_node->gst_element, packet);
+ return ms_element_pull_packet(ms_node->gst_element, packet);
}
int media_streamer_node_link(media_streamer_node_h src_node, const char *src_pad_name, media_streamer_node_h dest_node, const char *sink_pad_name)
ms_debug_fleave();
/* By default it sets format to object's property 'caps' */
- return __ms_node_set_pad_format(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)
ms_debug_fleave();
- return __ms_element_get_pad_fmt(ms_node->gst_element, pad_name, fmt);
+ return ms_element_get_pad_fmt(ms_node->gst_element, pad_name, fmt);
}
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)
ms_retvm_if(sink_pad_num == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "sink_pad_num is NULL");
ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "gst_element is NULL");
- ret = __ms_element_pad_names(ms_node->gst_element, GST_PAD_SRC, src_pad_name, src_pad_num);
+ ret = ms_element_pad_names(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_element_pad_names(ms_node->gst_element, GST_PAD_SINK, sink_pad_name, sink_pad_num);
+ ret = ms_element_pad_names(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");
ms_debug_fleave();
ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "gst_element is NULL");
ms_retvm_if(param_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param_list is NULL");
- ret = __ms_node_set_params_from_bundle(ms_node, param_list);
+ ret = ms_node_set_params_from_bundle(ms_node, param_list);
ms_debug_fleave();
ms_params = bundle_create();
ms_retvm_if(ms_params == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating new params object");
- ret = __ms_node_write_params_into_bundle(ms_node, ms_params);
+ ret = ms_node_write_params_into_bundle(ms_node, ms_params);
if (ret == MEDIA_STREAMER_ERROR_NONE)
*param_list = ms_params;
else
ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "gst_element is NULL");
ms_retvm_if(param_name == NULL || param_value == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Parameters name or value is NULL");
- ret = __ms_node_get_param(node, param_name, ¶m);
+ 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);
+ ret = ms_node_set_param_value(node, param, param_value);
ms_debug_fleave();
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");
- ret = __ms_node_get_param(ms_node, param_name, ¶m);
+ 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);
+ ret = ms_node_get_param_value(ms_node, param, param_value);
ms_debug_fleave();
static int __ms_adaptive_sink_prepare(media_streamer_s *ms_streamer);
-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, "bin is NULL");
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 = NULL;
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 = NULL;
gboolean ret = FALSE;
return ret;
}
-const gchar *__ms_get_pad_type(GstPad *element_pad)
+const gchar *ms_get_pad_type(GstPad *element_pad)
{
const gchar *pad_type = NULL;
GstCaps *pad_caps = NULL;
return elements_linked ? found_element : NULL;
}
-int __ms_factory_rank_compare(GstPluginFeature *first_feature, GstPluginFeature *second_feature)
+static int __ms_factory_rank_compare(GstPluginFeature *first_feature, GstPluginFeature *second_feature)
{
ms_debug_fenter();
guint first_rank = 0, second_rank = 0;
return second_rank - first_rank;
}
-GstElement *__ms_combine_next_element(GstElement *previous_element, GstPad *prev_elem_src_pad, GstElement *bin_to_find_in, media_streamer_node_type_e node_type)
+GstElement *ms_combine_next_element(GstElement *previous_element, GstPad *prev_elem_src_pad, GstElement *bin_to_find_in, media_streamer_node_type_e node_type)
{
GstCaps *prev_caps = NULL;
GstElement *found_element = NULL;
ms_debug_fenter();
- node_klass_type = __ms_node_get_klass_by_its_type(node_type);
+ node_klass_type = ms_node_get_klass_by_its_type(node_type);
/* - 1 - If previous element is linked - check for peer element */
found_element = __ms_find_peer_element_by_type(GST_ELEMENT(previous_element), prev_elem_src_pad, node_klass_type);
node_plug_s plug_info = {node_klass_type, NULL, prev_caps, NULL};
/* Create Node by ini or registry */
- found_element = __ms_node_element_create(&plug_info, node_type);
+ found_element = ms_node_element_create(&plug_info, node_type);
if (found_element) {
ms_info("New Element [%s] is created ", GST_ELEMENT_NAME(found_element));
/* Add created element */
- if (__ms_bin_add_element(bin_to_find_in, found_element, TRUE)) {
+ if (ms_bin_add_element(bin_to_find_in, found_element, TRUE)) {
gst_element_sync_state_with_parent(found_element);
__ms_link_two_elements(previous_element, prev_elem_src_pad, found_element);
- __ms_generate_dots(bin_to_find_in, GST_ELEMENT_NAME(found_element));
+ ms_generate_dots(bin_to_find_in, GST_ELEMENT_NAME(found_element));
} else {
ms_error("Element [%s] was not added into [%s] bin", GST_ELEMENT_NAME(found_element), GST_ELEMENT_NAME(bin_to_find_in));
MS_SAFE_UNREF(found_element);
a_pad = GST_PAD(a);
b_pad = GST_PAD(b);
- a_pad_type = __ms_get_pad_type(a_pad);
- b_pad_type = __ms_get_pad_type(b_pad);
+ a_pad_type = ms_get_pad_type(a_pad);
+ b_pad_type = ms_get_pad_type(b_pad);
ms_debug_fleave();
ms_retm_if(ms_streamer == NULL, "ms_streamer is NULL");
found_element = gst_pad_get_parent_element(src_pad);
- new_pad_type = __ms_get_pad_type(src_pad);
+ new_pad_type = ms_get_pad_type(src_pad);
if (MS_ELEMENT_IS_VIDEO(new_pad_type)) {
- if (__ms_bin_find_element_by_type(found_element, src_pad, ms_streamer->transform_bin, __ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY))) {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY);
+ if (__ms_bin_find_element_by_type(found_element, src_pad, ms_streamer->transform_bin, ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY))) {
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY);
src_pad = NULL;
}
if (sink_bin_type == MEDIA_STREAMER_SINK_BIN_RTP_SERVER) {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
} else if (sink_bin_type == MEDIA_STREAMER_SINK_BIN_ADAPTIVE) {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_MUXER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_MUXER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
} else {
caps = gst_pad_query_caps(src_pad, NULL);
caps_str = gst_caps_to_string(caps);
if (caps_str && (g_strrstr(caps_str, "ST12") || g_strrstr(caps_str, "SN12") ||
g_strrstr(caps_str, "SN21") || g_strrstr(caps_str, "S420") || g_strrstr(caps_str, "SR32"))) {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
} else {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
}
MS_SAFE_GFREE(caps_str);
gst_caps_unref(caps);
}
} else if (MS_ELEMENT_IS_AUDIO(new_pad_type)) {
if (sink_bin_type == MEDIA_STREAMER_SINK_BIN_RTP_SERVER) {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
} else if (sink_bin_type == MEDIA_STREAMER_SINK_BIN_ADAPTIVE) {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_MUXER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_MUXER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
} else {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
}
} else if (MS_ELEMENT_IS_TEXT(new_pad_type)) {
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY);
} else {
ms_error("Unsupported pad type [%s]!", new_pad_type);
}
- __ms_generate_dots(ms_streamer->pipeline, "after_sink_linked");
+ ms_generate_dots(ms_streamer->pipeline, "after_sink_linked");
gst_object_unref(found_element);
ms_debug_fleave();
ms_debug_fleave();
}
-GstElement *__ms_decodebin_create(media_streamer_s *ms_streamer, char *name)
+static GstElement *__ms_decodebin_create(media_streamer_s *ms_streamer, char *name)
{
GstElement *decodebin = NULL;
ms_retvm_if(!ms_streamer, NULL, "ms_streamer is NULL");
- decodebin = __ms_element_create(DEFAULT_DECODEBIN, name);
- __ms_bin_add_element(ms_streamer->transform_bin, decodebin, TRUE);
+ decodebin = ms_element_create(DEFAULT_DECODEBIN, name);
+ ms_bin_add_element(ms_streamer->transform_bin, decodebin, TRUE);
gst_element_sync_state_with_parent(decodebin);
- __ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "pad-added", G_CALLBACK(__decodebin_pad_added_cb), ms_streamer);
- __ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "autoplug-select", G_CALLBACK(__decodebin_autoplug_select_cb), ms_streamer);
- __ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "no-more-pads", G_CALLBACK(__decodebin_nomore_pads_cb), ms_streamer);
+ ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "pad-added", G_CALLBACK(__decodebin_pad_added_cb), ms_streamer);
+ ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "autoplug-select", G_CALLBACK(__decodebin_autoplug_select_cb), ms_streamer);
+ ms_signal_create(&ms_streamer->autoplug_sig_list, decodebin, "no-more-pads", G_CALLBACK(__decodebin_nomore_pads_cb), ms_streamer);
ms_debug_fleave();
if (MS_ELEMENT_IS_VIDEO(src_pad_type)) {
gst_object_ref(parent_rtp_element);
- found_element = __ms_combine_next_element(parent_rtp_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY);
- decoder_element = __ms_bin_find_element_by_type(found_element, NULL, ms_streamer->transform_bin, __ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER));
+ found_element = ms_combine_next_element(parent_rtp_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY);
+ decoder_element = __ms_bin_find_element_by_type(found_element, NULL, ms_streamer->transform_bin, ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER));
if (!decoder_element) {
if (ms_streamer->ini.use_decodebin) {
return TRUE;
} else {
gst_object_ref(found_element);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
}
} else {
__ms_link_two_elements(found_element, NULL, decoder_element);
- found_element = __ms_combine_next_element(decoder_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(decoder_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
}
} else if (MS_ELEMENT_IS_AUDIO(src_pad_type)) {
gst_object_ref(parent_rtp_element);
- found_element = __ms_combine_next_element(parent_rtp_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
+ found_element = ms_combine_next_element(parent_rtp_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->sink_bin, MEDIA_STREAMER_NODE_TYPE_SINK);
} else {
ms_info("Unknown media type received from rtp element!");
}
return TRUE;
}
-void __ms_rtpbin_pad_added_cb(GstElement *src, GstPad *new_pad, gpointer user_data)
+void ms_rtpbin_pad_added_cb(GstElement *src, GstPad *new_pad, gpointer user_data)
{
media_streamer_s *ms_streamer = NULL;
GstPad *target_pad = NULL;
gst_ghost_pad_set_target(GST_GHOST_PAD(src_pad), new_pad);
if (src_pad && __ms_sink_bin_prepare(ms_streamer, src_pad, src_pad_type)) {
- __ms_element_set_state(ms_node->gst_element, GST_STATE_PLAYING);
- __ms_generate_dots(ms_streamer->pipeline, "rtpbin_playing");
+ ms_element_set_state(ms_node->gst_element, GST_STATE_PLAYING);
+ ms_generate_dots(ms_streamer->pipeline, "rtpbin_playing");
} else {
ms_error("Failed to prepare sink_bin for pad type [%s]", src_pad_type);
}
}
//LCOV_EXCL_STOP
-void __ms_demux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data)
+void ms_demux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data)
{
media_streamer_s *ms_streamer = (media_streamer_s *) user_data;
ms_debug_fleave();
}
-void __ms_hlsdemux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data)
+void ms_hlsdemux_pad_added_cb(GstElement *element, GstPad *new_pad, gpointer user_data)
{
GstPad *gp = NULL;
ms_debug_fenter();
found_element = gst_pad_get_parent_element(src_pad);
- new_pad_type = __ms_get_pad_type(src_pad);
+ new_pad_type = ms_get_pad_type(src_pad);
if (MS_ELEMENT_IS_VIDEO(new_pad_type))
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
else if (MS_ELEMENT_IS_AUDIO(new_pad_type))
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
else if (MS_ELEMENT_IS_TEXT(new_pad_type))
- found_element = __ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY);
+ found_element = ms_combine_next_element(found_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_TEXT_OVERLAY);
else
ms_error("Unsupported pad type [%s]!", new_pad_type);
- __ms_generate_dots(ms_streamer->pipeline, "after_demux_linked");
+ ms_generate_dots(ms_streamer->pipeline, "after_demux_linked");
gst_object_unref(found_element);
ms_debug_fleave();
}
-void __ms_demux_nomore_pads_cb(GstElement *element, gpointer user_data)
+void ms_demux_nomore_pads_cb(GstElement *element, gpointer user_data)
{
media_streamer_s *ms_streamer = (media_streamer_s *) user_data;
GList *iterator = NULL;
ms_debug_fleave();
}
-int __ms_element_set_state(GstElement *element, GstState state)
+int ms_element_set_state(GstElement *element, GstState state)
{
GstStateChangeReturn ret_state;
return MEDIA_STREAMER_ERROR_NONE;
}
-GstElement *__ms_element_create(const char *plugin_name, const char *name)
+GstElement *ms_element_create(const char *plugin_name, const char *name)
{
GstElement *plugin_elem = NULL;
video_enc_plug_info.info = &(nodes_info[0]);
video_enc_plug_info.src_caps = video_enc_src_caps;
video_enc_plug_info.sink_caps = video_enc_sink_caps;
- video_enc = __ms_node_element_create(&video_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
+ video_enc = ms_node_element_create(&video_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
audio_enc_src_caps = gst_caps_new_simple("audio/mpeg", "mpegversion", G_TYPE_INT, 4, NULL);
audio_enc_sink_caps = gst_caps_new_empty_simple("audio/x-raw");
audio_enc_plug_info.info = &(nodes_info[1]);
audio_enc_plug_info.src_caps = audio_enc_src_caps;
audio_enc_plug_info.sink_caps = audio_enc_sink_caps;
- audio_enc = __ms_node_element_create(&audio_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
+ audio_enc = ms_node_element_create(&audio_enc_plug_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
muxer_src_caps = gst_caps_new_empty_simple("video/mpegts");
mux_plug_info.info = &(nodes_info[2]);
mux_plug_info.src_caps = muxer_src_caps;
- muxer = __ms_node_element_create(&mux_plug_info, MEDIA_STREAMER_NODE_TYPE_MUXER);
+ muxer = ms_node_element_create(&mux_plug_info, MEDIA_STREAMER_NODE_TYPE_MUXER);
- __ms_bin_add_element(ms_streamer->transform_bin, muxer, FALSE);
+ ms_bin_add_element(ms_streamer->transform_bin, muxer, FALSE);
gst_element_sync_state_with_parent(muxer);
- __ms_bin_add_element(ms_streamer->transform_bin, video_enc, FALSE);
+ ms_bin_add_element(ms_streamer->transform_bin, video_enc, FALSE);
gst_element_sync_state_with_parent(video_enc);
- __ms_bin_add_element(ms_streamer->transform_bin, audio_enc, FALSE);
+ ms_bin_add_element(ms_streamer->transform_bin, audio_enc, FALSE);
gst_element_sync_state_with_parent(audio_enc);
ms_debug_fleave();
return MEDIA_STREAMER_ERROR_NONE;
}
-GstElement *__ms_adaptive_element_create(void)
+GstElement *ms_adaptive_element_create(void)
{
GstElement *adaptive_bin = NULL;
return FALSE;
}
-static GstElement *__ms_element_create_from_ini(node_plug_s *plug_info, media_streamer_node_type_e type)
+static GstElement *ms_element_create_from_ini(node_plug_s *plug_info, media_streamer_node_type_e type)
{
const gchar *src_type, *sink_type;
const gchar *format_type;
return NULL;
}
- plugin_name = __ms_ini_get_string(conf_key, NULL);
+ plugin_name = ms_ini_get_string(conf_key, NULL);
if (plugin_name) {
- gst_element = __ms_element_create(plugin_name, NULL);
+ gst_element = ms_element_create(plugin_name, NULL);
MS_SAFE_GFREE(plugin_name);
}
return gst_element;
}
-static GstElement *__ms_element_create_by_registry(node_plug_s *plug_info, media_streamer_node_type_e type)
+static GstElement *ms_element_create_by_registry(node_plug_s *plug_info, media_streamer_node_type_e type)
{
GstElement *gst_element = NULL;
const gchar *src_type = NULL;
MS_GET_CAPS_TYPE(plug_info->src_caps, src_type);
MS_GET_CAPS_TYPE(plug_info->sink_caps, sink_type);
- __ms_ini_read_list("general:exclude elements", &plug_info->exclude_names);
+ ms_ini_read_list("general:exclude elements", &plug_info->exclude_names);
factories = gst_registry_feature_filter(gst_registry_get(),
__ms_feature_node_filter, FALSE, plug_info);
if (factories) {
factory = GST_ELEMENT_FACTORY(factories->data);
ms_info("Sorted result element is [%s]", GST_OBJECT_NAME(factory));
- gst_element = __ms_element_create(GST_OBJECT_NAME(factory), NULL);
+ gst_element = ms_element_create(GST_OBJECT_NAME(factory), NULL);
} else {
ms_debug("Could not find any compatible element for node [%d]: in[%s] - out[%s]",
type, sink_type, src_type);
}
/* Creating Scaler, Converter */
- video_scale = __ms_element_create(DEFAULT_VIDEO_SCALE, NULL);
- video_convert = __ms_element_create(DEFAULT_VIDEO_CONVERT, NULL);
+ video_scale = ms_element_create(DEFAULT_VIDEO_SCALE, NULL);
+ video_convert = ms_element_create(DEFAULT_VIDEO_CONVERT, NULL);
/* Creating Video Encoder */
- encoder_info.info = __ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
+ encoder_info.info = ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
encoder_info.src_caps = enc_caps;
encoder_info.sink_caps = plug_info->sink_caps;
encoder_info.exclude_names = NULL;
- encoder_elem = __ms_element_create_from_ini(&encoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
+ encoder_elem = ms_element_create_from_ini(&encoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
if (!encoder_elem)
- encoder_elem = __ms_element_create_by_registry(&encoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
+ encoder_elem = ms_element_create_by_registry(&encoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
/* Creating Video Parser */
parser_info.info = &node_info;
parser_info.sink_caps = enc_caps;
parser_info.exclude_names = NULL;
- encoder_parser = __ms_element_create_from_ini(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
+ encoder_parser = ms_element_create_from_ini(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
if (!encoder_parser)
- encoder_parser = __ms_element_create_by_registry(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
+ encoder_parser = ms_element_create_by_registry(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
/* Creating bin - Video Encoder */
encoder_bin = gst_bin_new("video_encoder");
/* Settings if H264 format is set*/
MS_GET_CAPS_TYPE(enc_caps, src_type);
- encoder_type = __ms_convert_string_format_to_media_format(src_type);
+ encoder_type = ms_convert_string_format_to_media_format(src_type);
if (encoder_type == MEDIA_FORMAT_H264_SP) {
g_object_set(GST_OBJECT(encoder_parser), "config-interval", H264_PARSER_CONFIG_INTERVAL, NULL);
g_object_set(G_OBJECT(encoder_elem), "tune", H264_ENCODER_ZEROLATENCY, NULL);
}
/* Creating Video Decoder */
- decoder_info.info = __ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
+ decoder_info.info = ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
decoder_info.src_caps = plug_info->src_caps;
decoder_info.sink_caps = dec_caps;
decoder_info.exclude_names = NULL;
- decoder_elem = __ms_element_create_from_ini(&decoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
+ decoder_elem = ms_element_create_from_ini(&decoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
if (!decoder_elem)
- decoder_elem = __ms_element_create_by_registry(&decoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
+ decoder_elem = ms_element_create_by_registry(&decoder_info, MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER);
/* Creating Video Parser */
parser_info.info = &nodes_info;
parser_info.sink_caps = dec_caps;
parser_info.exclude_names = NULL;
- decoder_parser = __ms_element_create_from_ini(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
+ decoder_parser = ms_element_create_from_ini(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
if (!decoder_parser)
- decoder_parser = __ms_element_create_by_registry(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
+ decoder_parser = ms_element_create_by_registry(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
/* Settings if H264 format is set*/
MS_GET_CAPS_TYPE(dec_caps, sink_type);
- decoder_type = __ms_convert_string_format_to_media_format(sink_type);
+ decoder_type = ms_convert_string_format_to_media_format(sink_type);
if (decoder_type == MEDIA_FORMAT_H264_SP)
g_object_set(G_OBJECT(decoder_parser), "config-interval", H264_PARSER_CONFIG_INTERVAL, NULL);
/* Creating bin - Video Decoder */
- decoder_queue = __ms_element_create("queue", NULL);
+ decoder_queue = ms_element_create("queue", NULL);
decoder_bin = gst_bin_new("video_decoder");
if (!decoder_elem || !decoder_queue || !decoder_parser || !decoder_bin) {
last_elem = decoder_elem;
if (!is_hw_codec) {
- video_conv = __ms_element_create("videoconvert", NULL);
- video_scale = __ms_element_create("videoscale", NULL);
+ video_conv = ms_element_create("videoconvert", NULL);
+ video_scale = ms_element_create("videoscale", NULL);
if (!video_conv || !video_scale) {
ms_error("Error: creating elements for video decoder bin");
goto ERROR;
}
/* Creating Converter, Resampler, Filter */
- audio_convert = __ms_element_create(DEFAULT_AUDIO_CONVERT, NULL);
- audio_resample = __ms_element_create(DEFAULT_AUDIO_RESAMPLE, NULL);
- audio_filter = __ms_element_create(DEFAULT_FILTER, NULL);
- audio_postenc_convert = __ms_element_create(DEFAULT_AUDIO_CONVERT, NULL);
+ audio_convert = ms_element_create(DEFAULT_AUDIO_CONVERT, NULL);
+ audio_resample = ms_element_create(DEFAULT_AUDIO_RESAMPLE, NULL);
+ audio_filter = ms_element_create(DEFAULT_FILTER, NULL);
+ audio_postenc_convert = ms_element_create(DEFAULT_AUDIO_CONVERT, NULL);
/* Creating Audio Encoder */
- plug_info_encoder.info = __ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
+ plug_info_encoder.info = ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
plug_info_encoder.src_caps = enc_caps;
plug_info_encoder.sink_caps = plug_info->sink_caps;
plug_info_encoder.exclude_names = NULL;
- audio_encoder = __ms_element_create_from_ini(&plug_info_encoder, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
+ audio_encoder = ms_element_create_from_ini(&plug_info_encoder, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
if (!audio_encoder)
- audio_encoder = __ms_element_create_by_registry(&plug_info_encoder, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
+ audio_encoder = ms_element_create_by_registry(&plug_info_encoder, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
encoder_name = gst_element_get_name(audio_encoder);
if (encoder_name && g_strrstr(encoder_name, "aac"))
}
/* Creating Audio Decoder */
- decoder_info.info = __ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
+ decoder_info.info = ms_node_get_klass_by_its_type(MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
decoder_info.src_caps = plug_info->src_caps;
decoder_info.sink_caps = dec_caps;
decoder_info.exclude_names = NULL;
- decoder_elem = __ms_element_create_from_ini(&decoder_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
+ decoder_elem = ms_element_create_from_ini(&decoder_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
if (!decoder_elem)
- decoder_elem = __ms_element_create_by_registry(&decoder_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
+ decoder_elem = ms_element_create_by_registry(&decoder_info, MEDIA_STREAMER_NODE_TYPE_AUDIO_DECODER);
/* Creating Audio Parser */
parser_info.info = &nodes_info;
parser_info.sink_caps = dec_caps;
parser_info.exclude_names = NULL;
- decoder_parser = __ms_element_create_from_ini(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
+ decoder_parser = ms_element_create_from_ini(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
if (!decoder_parser)
- decoder_parser = __ms_element_create_by_registry(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
+ decoder_parser = ms_element_create_by_registry(&parser_info, MEDIA_STREAMER_NODE_TYPE_PARSER);
/* Creating bin - Audio Decoder */
decoder_bin = gst_bin_new("audio_decoder");
- decoder_queue = __ms_element_create("queue", NULL);
+ decoder_queue = ms_element_create("queue", NULL);
if (!decoder_elem || !decoder_queue || !decoder_parser || !decoder_bin) {
ms_error("Error: creating elements for audio decoder bin");
goto ERROR;
return NULL;
}
- audio_conv = __ms_element_create("audioconvert", NULL);
- audio_resample = __ms_element_create("audioresample", NULL);
+ audio_conv = ms_element_create("audioconvert", NULL);
+ audio_resample = ms_element_create("audioresample", NULL);
if (!audio_conv || !audio_resample) {
ms_error("Error: creating elements for audio decoder bin");
goto ERROR;
return NULL;
}
-GstElement *__ms_node_element_create(node_plug_s *plug_info, media_streamer_node_type_e type)
+GstElement *ms_node_element_create(node_plug_s *plug_info, media_streamer_node_type_e type)
{
GstElement *gst_element = NULL;
const gchar *src_type = NULL;
else if (type == MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER)
gst_element = __ms_video_decoder_element_create(plug_info);
else if (type == MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER || type == MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER)
- gst_element = __ms_element_create(plug_info->info->default_name, NULL);
+ gst_element = ms_element_create(plug_info->info->default_name, NULL);
else if (g_strrstr(MEDIA_STREAMER_STRICT, plug_info->info->klass_name) || (!src_type && !sink_type)) {
if (type == MEDIA_STREAMER_NODE_TYPE_RTP)
- gst_element = __ms_rtp_element_create();
+ gst_element = ms_rtp_element_create();
else
- gst_element = __ms_element_create(plug_info->info->default_name, NULL);
+ gst_element = ms_element_create(plug_info->info->default_name, NULL);
} else {
/* 2. Second priority:
* Try to get plugin name that defined in ini file
* according with node type and specified format. */
- gst_element = __ms_element_create_from_ini(plug_info, type);
+ gst_element = ms_element_create_from_ini(plug_info, type);
}
/* 3. Third priority:
* Elements that are compatible but defined as excluded will be skipped*/
if (!gst_element) {
/* Read exclude elements list */
- gst_element = __ms_element_create_by_registry(plug_info, type);
+ gst_element = ms_element_create_by_registry(plug_info, type);
}
if (type == MEDIA_STREAMER_NODE_TYPE_FILTER) {
return gst_element;
}
-GstElement *__ms_rtp_element_create(void)
+GstElement *ms_rtp_element_create(void)
{
GstElement *rtp_container = NULL;
return GST_PAD_PROBE_PASS;
}
-gboolean __ms_element_lock_state(const GValue *item, GValue *ret, gpointer user_data)
+gboolean ms_element_lock_state(const GValue *item, GValue *ret, gpointer user_data)
{
GstElement *sink_element = NULL;
GstPad *sink_pad = NULL;
return TRUE;
}
-gboolean __ms_element_unlock_state(const GValue *item, GValue *ret, gpointer user_data)
+gboolean ms_element_unlock_state(const GValue *item, GValue *ret, gpointer user_data)
{
GstElement *sink_element = NULL;
GValue *val = NULL;
state_transition_name = g_strdup_printf("Old_[%s]_New_[%s]_Pending_[%s]", gst_element_state_get_name(state_old),
gst_element_state_get_name(state_new), gst_element_state_get_name(state_pending));
ms_info("GST_MESSAGE_STATE_CHANGED: [%s] %s. ", GST_OBJECT_NAME(GST_MESSAGE_SRC(message)), state_transition_name);
- __ms_generate_dots(ms_streamer->pipeline, state_transition_name);
+ ms_generate_dots(ms_streamer->pipeline, state_transition_name);
MS_SAFE_GFREE(state_transition_name);
media_streamer_state_e old_state = ms_streamer->state;
}
case GST_MESSAGE_EOS:{
ms_info("GST_MESSAGE_EOS end-of-stream");
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
+ ret = ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
if (ret != MEDIA_STREAMER_ERROR_NONE) {
ms_error("ERROR - Pause Pipeline");
return FALSE;
return ret;
}
-int __ms_pipeline_create(media_streamer_s *ms_streamer)
+int ms_pipeline_create(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-static gboolean demux_find(gpointer key, gpointer value, gpointer user_data)
+static gboolean __demux_find(gpointer key, gpointer value, gpointer user_data)
{
return g_strrstr((char *)key, "demux") != NULL;
}
found_node = (media_streamer_node_s *) g_hash_table_lookup(ms_streamer->nodes_table, GST_ELEMENT_NAME(found_element));
if (found_node) {
if (!found_node->linked_by_user)
- ret = ret && __ms_element_unlink(found_element);
+ ret = ret && ms_element_unlink(found_element);
else
ms_info("Unprepare skipped user-linked node [%s]", found_node->name);
- __ms_generate_dots(ms_streamer->pipeline, GST_ELEMENT_NAME(found_element));
+ ms_generate_dots(ms_streamer->pipeline, GST_ELEMENT_NAME(found_element));
} else {
- ret = ret && __ms_bin_remove_element(found_element);
+ ret = ret && ms_bin_remove_element(found_element);
}
g_value_reset(&element);
return ret;
}
-int __ms_pipeline_prepare(media_streamer_s *ms_streamer)
+int ms_pipeline_prepare(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
media_streamer_node_s *rtp = NULL;
ms_retvm_if(ms_streamer->transform_bin == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "ms_streamer->transform_bin is NULL");
rtp = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "rtp_container");
- demux = (media_streamer_node_s *)g_hash_table_find(ms_streamer->nodes_table, (GHRFunc)demux_find, NULL);
+ demux = (media_streamer_node_s *)g_hash_table_find(ms_streamer->nodes_table, (GHRFunc)__demux_find, NULL);
adaptive_src = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "adaptive_src");
adaptive_sink = (media_streamer_node_s *)g_hash_table_lookup(ms_streamer->nodes_table, "adaptive_sink");
if (rtp) {
- ret = __ms_rtp_node_prepare(rtp) ? MEDIA_STREAMER_ERROR_NONE : MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ ret = ms_rtp_node_prepare(rtp) ? MEDIA_STREAMER_ERROR_NONE : MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
} else if (demux) {
- ret = __ms_demux_node_prepare(ms_streamer, demux);
+ ret = ms_demux_node_prepare(ms_streamer, demux);
if (MEDIA_STREAMER_ERROR_NONE != ret)
ms_error("Failed to prepare demux element");
} else {
if (adaptive_src) {
if (GST_BIN(ms_streamer->transform_bin)->numchildren == 0)
- ret = __ms_adaptive_src_node_prepare(adaptive_src, true);
+ ret = ms_adaptive_src_node_prepare(adaptive_src, true);
else
- ret = __ms_adaptive_src_node_prepare(adaptive_src, false);
+ ret = ms_adaptive_src_node_prepare(adaptive_src, false);
}
if (adaptive_sink)
- ret = __ms_adaptive_sink_node_prepare(ms_streamer, adaptive_sink);
+ ret = ms_adaptive_sink_node_prepare(ms_streamer, adaptive_sink);
if (ret != MEDIA_STREAMER_ERROR_NONE)
goto prepare_fail;
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin), _ms_sink_node_prepare_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin), ms_sink_node_prepare_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to prepare nodes within sink bin");
goto prepare_fail;
}
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin), _ms_src_node_prepare_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin), ms_src_node_prepare_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to prepare nodes within src bin");
goto prepare_fail;
}
- ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY);
+ ret = ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY);
if (ret != MEDIA_STREAMER_ERROR_NONE)
goto prepare_fail;
return ret;
prepare_fail:
- __ms_pipeline_unprepare(ms_streamer);
+ ms_pipeline_unprepare(ms_streamer);
return ret;
}
-int __ms_pipeline_unprepare(media_streamer_s *ms_streamer)
+int ms_pipeline_unprepare(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ms_retvm_if(ms_streamer->nodes_table == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "ms_streamer->nodes_table is NULL");
- ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE);
+ ret = ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE);
if (ret != MEDIA_STREAMER_ERROR_NONE)
ms_error("Failed to unprepare pipeline");
if (!ms_streamer->is_interrupted) {
/* Unprepare resources in case of failure */
- __ms_release_resources(ms_streamer);
+ ms_release_resources(ms_streamer);
if (ms_streamer->video_decoder_resource != NULL) {
ret = mm_resource_manager_mark_for_release(ms_streamer->resource_manager,
}
/* Disconnects and clean all autoplug signals */
- g_list_free_full(ms_streamer->autoplug_sig_list, __ms_signal_destroy);
+ g_list_free_full(ms_streamer->autoplug_sig_list, ms_signal_destroy);
ms_streamer->autoplug_sig_list = NULL;
/* Removes all pending pads according to list */
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);
+ g_list_free_full(rtp_node->sig_list, ms_signal_destroy);
rtp_node->sig_list = NULL;
__ms_bin_unprepare(ms_streamer, rtp_node->gst_element);
}
return ret;
}
-GstCaps *__ms_create_caps_from_fmt(media_format_h fmt)
+void ms_pipeline_get_state(media_streamer_s *ms_streamer)
+{
+ GstState state_old = GST_STATE_NULL, state_new = GST_STATE_NULL;
+ GstStateChangeReturn ret_state = -1;
+
+ ms_debug_fenter();
+
+ ms_retm_if(ms_streamer == NULL, "ms_streamer is NULL");
+ ms_retm_if(ms_streamer->pipeline == NULL, "ms_streamer->pipeline is NULL");
+
+ ret_state = gst_element_get_state(ms_streamer->pipeline, &state_old, &state_new, GST_CLOCK_TIME_NONE);
+ if (ret_state == GST_STATE_CHANGE_SUCCESS)
+ ms_info("Got state for [%s]: old [%s], new [%s]", GST_ELEMENT_NAME(ms_streamer->pipeline), gst_element_state_get_name(state_old), gst_element_state_get_name(state_new));
+ else
+ ms_error("Couldn`t get state for [%s]", GST_ELEMENT_NAME(ms_streamer->pipeline));
+
+ ms_debug_fleave();
+}
+
+GstCaps *ms_create_caps_from_fmt(media_format_h fmt)
{
GstCaps *caps = NULL;
gchar *caps_name = NULL;
if (!media_format_get_audio_info(fmt, &mime, &channel, &samplerate, &bit, &avg_bps)) {
if (MEDIA_FORMAT_RAW == (mime & MEDIA_FORMAT_RAW)) {
- caps = gst_caps_new_simple("audio/x-raw", "format", G_TYPE_STRING, __ms_convert_mime_to_string_format(mime), NULL);
+ caps = gst_caps_new_simple("audio/x-raw", "format", G_TYPE_STRING, ms_convert_mime_to_string_format(mime), NULL);
} else if (MEDIA_FORMAT_ENCODED == (mime & MEDIA_FORMAT_ENCODED)) {
if (mime == MEDIA_FORMAT_AAC)
- caps = gst_caps_new_simple(__ms_convert_mime_to_string_format(mime), "mpegversion", G_TYPE_INT, 4, NULL);
+ caps = gst_caps_new_simple(ms_convert_mime_to_string_format(mime), "mpegversion", G_TYPE_INT, 4, NULL);
else if (mime == MEDIA_FORMAT_MP3)
- caps = gst_caps_new_simple(__ms_convert_mime_to_string_format(mime), "mpegversion", G_TYPE_INT, 1, NULL);
+ caps = gst_caps_new_simple(ms_convert_mime_to_string_format(mime), "mpegversion", G_TYPE_INT, 1, NULL);
else
- caps = gst_caps_new_simple(__ms_convert_mime_to_string_format(mime), "channels", G_TYPE_INT, channel, "rate", G_TYPE_INT, samplerate, NULL);
+ caps = gst_caps_new_simple(ms_convert_mime_to_string_format(mime), "channels", G_TYPE_INT, channel, "rate", G_TYPE_INT, samplerate, NULL);
}
caps_name = gst_caps_to_string(caps);
ms_info("Creating Audio Caps from media format [%s]", caps_name);
} else if (!media_format_get_video_info(fmt, &mime, &width, &height, &avg_bps, &max_bps)) {
if (MEDIA_FORMAT_RAW == (mime & MEDIA_FORMAT_RAW))
caps = gst_caps_new_simple("video/x-raw", "framerate", GST_TYPE_FRACTION, max_bps,
- avg_bps, "format", G_TYPE_STRING, __ms_convert_mime_to_string_format(mime), "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL);
+ avg_bps, "format", G_TYPE_STRING, ms_convert_mime_to_string_format(mime), "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL);
else if (MEDIA_FORMAT_ENCODED == (mime & MEDIA_FORMAT_ENCODED))
- caps = gst_caps_new_simple(__ms_convert_mime_to_string_format(mime), "framerate", GST_TYPE_FRACTION, max_bps,
+ caps = gst_caps_new_simple(ms_convert_mime_to_string_format(mime), "framerate", GST_TYPE_FRACTION, max_bps,
avg_bps, "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL);
caps_name = gst_caps_to_string(caps);
ms_info("Creating Video Caps from media format [%s]", caps_name);
} else if (!media_format_get_container_mime(fmt, &mime)) {
- caps = gst_caps_new_empty_simple(__ms_convert_mime_to_string_format(mime));
+ caps = gst_caps_new_empty_simple(ms_convert_mime_to_string_format(mime));
caps_name = gst_caps_to_string(caps);
ms_info("Creating Video Caps from media format [%s]", caps_name);
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_media_format(pad_format));
+ media_format_set_video_mime(fmt, ms_convert_string_format_to_media_format(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)) {
- media_format_set_audio_mime(fmt, __ms_convert_string_format_to_media_format(pad_format));
+ media_format_set_audio_mime(fmt, ms_convert_string_format_to_media_format(pad_format));
gst_structure_get_int(pad_struct, "channels", &channels);
media_format_set_audio_channel(fmt, channels);
gst_structure_get_int(pad_struct, "rate", &bps);
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;
int pad_number = 0;
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)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
GstCaps *allowed_caps = NULL;
return ret;
}
-int __ms_element_set_fmt(GstElement *gst_element, const char *pad_name, media_format_h fmt)
+int ms_element_set_fmt(GstElement *element, const char *pad_name, media_format_h fmt)
{
gboolean can_accept = FALSE;
GstCaps *fmt_caps = NULL;
ms_debug_fenter();
- ms_retvm_if(!gst_element || !pad_name || !fmt, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
+ ms_retvm_if(!element || !pad_name || !fmt, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- fmt_caps = __ms_create_caps_from_fmt(fmt);
+ fmt_caps = ms_create_caps_from_fmt(fmt);
ms_retvm_if(!fmt_caps, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Can't convert fmt into Caps");
- factory = gst_element_get_factory(gst_element);
- node_pad = gst_element_get_static_pad(gst_element, pad_name);
+ factory = gst_element_get_factory(element);
+ node_pad = gst_element_get_static_pad(element, pad_name);
if (node_pad && GST_PAD_IS_SRC(node_pad))
can_accept = gst_element_factory_can_src_any_caps(factory, fmt_caps);
else if (node_pad && GST_PAD_IS_SINK(node_pad))
can_accept = gst_element_factory_can_sink_any_caps(factory, fmt_caps);
else
- ms_error("[%s] doesn`t have valid pad [%s]", GST_ELEMENT_NAME(gst_element), pad_name);
+ ms_error("[%s] doesn`t have valid pad [%s]", GST_ELEMENT_NAME(element), pad_name);
if (!can_accept) {
if (fmt_caps)
gst_caps_unref(fmt_caps);
- ms_error("[%s]'s pad [%s] can`t be set with the given format", GST_ELEMENT_NAME(gst_element), pad_name);
+ ms_error("[%s]'s pad [%s] can`t be set with the given format", GST_ELEMENT_NAME(element), pad_name);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
} else {
- MS_SET_INT_CAPS_PARAM(gst_element, pad_name, fmt_caps);
- ms_info("[%s]'s pad [%s] was set with given format", GST_ELEMENT_NAME(gst_element), pad_name);
+ MS_SET_INT_CAPS_PARAM(element, pad_name, fmt_caps);
+ ms_info("[%s]'s pad [%s] was set with given format", GST_ELEMENT_NAME(element), pad_name);
}
MS_SAFE_UNREF(node_pad);
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;
GstEvent *event = NULL;
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)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
GstSample *sample = NULL;
g_signal_emit_by_name(sink_element, "pull-sample", &sample, NULL);
ms_retvm_if(sample == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Pull sample failed!");
- ret = __ms_element_get_pad_fmt(sink_element, "sink", &fmt);
+ ret = ms_element_get_pad_fmt(sink_element, "sink", &fmt);
if (ret == MEDIA_STREAMER_ERROR_NONE) {
buffer = gst_sample_get_buffer(sample);
if (!buffer) {
ms_debug_fleave();
}
-int __ms_find_type(media_streamer_s *ms_streamer, GstElement *src_element)
+int ms_find_type(media_streamer_s *ms_streamer, GstElement *src_element)
{
GstElement *typefind = NULL;
GstPad *src_pad = NULL;
ms_retvm_if(typefind == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION,
"Error creating element [typefind]");
- __ms_bin_add_element(ms_streamer->transform_bin, typefind, TRUE);
+ ms_bin_add_element(ms_streamer->transform_bin, typefind, TRUE);
gst_element_sync_state_with_parent(typefind);
GHashTable *uri_table;
} _ms_http_server_s;
-static int __ms_http_server_file_read_contents(const char *file_path, char **content, gsize *size);
+//LCOV_EXCL_START
+static const char *get_filename_ext(const char *file_path)
+{
+ const char *dot = strrchr(file_path, '.');
+
+ if (!dot || dot == file_path) return "";
+ return dot + 1;
+}
+
+static int __ms_http_server_file_read_contents(const char *file_path, char **content, gsize *size)
+{
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ struct stat stat_results = {0, };
+ int file_open = 0;
+
+ ms_debug_fenter();
+
+ ms_retvm_if(content == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "content is NULL");
+ ms_retvm_if(size == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "size is NULL");
+
+ if (!file_path || !strlen(file_path))
+ return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+
+ ret = ms_util_uri_path_check(file_path);
+ if (MEDIA_STREAMER_ERROR_NONE != ret)
+ return ret;
+
+ file_open = open(file_path, O_RDONLY);
+ if (file_open < 0) {
+ char mes_error[256];
+ strerror_r(errno, mes_error, sizeof(mes_error));
+ ms_error("Couldn`t open file [%s] according to [%s]. Error N [%d]", file_path, mes_error, errno);
+
+ return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ }
+
+ if (fstat(file_open, &stat_results) < 0) {
+ ms_error("Couldn`t get status of the file [%s]", file_path);
+ } else if (stat_results.st_size == 0) {
+ ms_error("The size of file is 0");
+ close(file_open);
+ return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ } else {
+ ms_debug("Size of file [%lld] bytes", (long long)stat_results.st_size);
+ }
+
+ *content = malloc((size_t)stat_results.st_size);
+ if (read(file_open, *content, (size_t)stat_results.st_size) < (size_t)stat_results.st_size) {
+ close(file_open);
+ return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ }
+ *size = (gsize)stat_results.st_size;
+
+ close(file_open);
+
+ ms_debug_fleave();
+
+ return MEDIA_STREAMER_ERROR_NONE;
+}
+
static void __ms_http_server_connection_handle_cb(SoupServer *server, SoupMessage *msg,
- const char *path, GHashTable *query, SoupClientContext *client, gpointer user_data);
+ const char *path, GHashTable *query, SoupClientContext *client, gpointer user_data)
+{
+ _ms_http_server_s *hserver = (_ms_http_server_s *) user_data;
+ SoupMessageHeadersIter iter;
+ const char *name, *value;
+ char *content = NULL;
+ gsize size = 0;
+ char *mime_type = NULL;
+ char *fs_dir = NULL;
+ char *file_path = NULL;
+ const char *extension = NULL;
+
+ /* Close connection if handle is NULL */
+ ms_retm_if(hserver == NULL, "server is NULL");
+ ms_retm_if(msg == NULL || msg->method == NULL || msg->request_headers == NULL, "msg is NULL");
+ ms_retm_if(path == NULL, "path is NULL");
-int __ms_http_server_create(media_streamer_http_server_h *server)
+ ms_debug("%s %s HTTP/1.%d", msg->method, path,
+ soup_message_get_http_version(msg));
+ soup_message_headers_iter_init(&iter, msg->request_headers);
+ while (soup_message_headers_iter_next(&iter, &name, &value))
+ ms_debug("%s: %s", name, value);
+ if (msg->request_body->length && msg->request_body->data)
+ ms_debug("%s", msg->request_body->data);
+
+ if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD) {
+ ms_info("Received read event");
+
+ /* Extract file path with URI. First symbol is '/' */
+ fs_dir = (char *)g_hash_table_lookup(hserver->uri_table, "adaptive_path");
+ file_path = g_strjoin(NULL, fs_dir, path+1, NULL);
+ extension = get_filename_ext(path+1);
+
+ mime_type_get_mime_type(extension, &mime_type);
+
+ ms_info("Received URI %s", path + 1);
+ ms_info("mime-type: %s", mime_type);
+
+ if (MEDIA_STREAMER_ERROR_NONE !=
+ __ms_http_server_file_read_contents(file_path, &content, &size)) {
+
+ soup_message_set_status(msg, SOUP_STATUS_BAD_REQUEST);
+ } else {
+ ms_info("Sending response");
+ soup_message_set_response(msg, mime_type, SOUP_MEMORY_TAKE, content, size);
+ soup_message_set_status(msg, SOUP_STATUS_OK);
+ }
+
+ g_free(file_path);
+ g_free(mime_type);
+ } else {
+ soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
+ soup_message_set_status(msg, SOUP_STATUS_OK);
+ }
+
+ ms_debug_fleave();
+}
+//LCOV_EXCL_STOP
+
+int ms_http_server_create(media_streamer_http_server_h *server)
{
_ms_http_server_s *ms_server;
if (!ms_server->server) {
ms_error("Failed to create http server");
- __ms_http_server_destroy(ms_server);
+ ms_http_server_destroy(ms_server);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
ms_server->uri_table = g_hash_table_new(g_str_hash, g_str_equal);
if (!ms_server->uri_table) {
ms_error("Failed to URIs hash table");
- __ms_http_server_destroy(ms_server);
+ ms_http_server_destroy(ms_server);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_http_server_destroy(media_streamer_http_server_h server)
+int ms_http_server_destroy(media_streamer_http_server_h server)
{
_ms_http_server_s *hserver = (_ms_http_server_s *) server;
ms_retvm_if(hserver == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "server is NULL");
/* Stop server first */
- __ms_http_server_stop(server);
+ ms_http_server_stop(server);
/* Destroy URIs hash table */
if (hserver->uri_table)
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_http_server_start(media_streamer_http_server_h server, int port)
+int ms_http_server_start(media_streamer_http_server_h server, int port)
{
_ms_http_server_s *hserver = (_ms_http_server_s *) server;
GError *error = NULL;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_http_server_stop(media_streamer_http_server_h server)
+int ms_http_server_stop(media_streamer_http_server_h server)
{
_ms_http_server_s *hserver = (_ms_http_server_s *) server;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_http_server_register_uri(media_streamer_http_server_h server, char *uri, char *file_path)
+int ms_http_server_register_uri(media_streamer_http_server_h server, char *uri, char *file_path)
{
_ms_http_server_s *hserver = (_ms_http_server_s *) server;
}
//LCOV_EXCL_START
-int __ms_http_server_unregister_uri(media_streamer_http_server_h server, char *uri)
+int ms_http_server_unregister_uri(media_streamer_http_server_h server, char *uri)
{
_ms_http_server_s *hserver = (_ms_http_server_s *) server;
return MEDIA_STREAMER_ERROR_NONE;
}
-
-static const char *get_filename_ext(const char *file_path)
-{
- const char *dot = strrchr(file_path, '.');
-
- if (!dot || dot == file_path) return "";
- return dot + 1;
-}
-
-static int __ms_http_server_file_read_contents(const char *file_path, char **content, gsize *size)
-{
- int ret = MEDIA_STREAMER_ERROR_NONE;
- struct stat stat_results = {0, };
- int file_open = 0;
-
- ms_debug_fenter();
-
- ms_retvm_if(content == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "content is NULL");
- ms_retvm_if(size == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "size is NULL");
-
- if (!file_path || !strlen(file_path))
- return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
-
- ret = __ms_util_uri_path_check(file_path);
- if (MEDIA_STREAMER_ERROR_NONE != ret)
- return ret;
-
- file_open = open(file_path, O_RDONLY);
- if (file_open < 0) {
- char mes_error[256];
- strerror_r(errno, mes_error, sizeof(mes_error));
- ms_error("Couldn`t open file [%s] according to [%s]. Error N [%d]", file_path, mes_error, errno);
-
- return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
- }
-
- if (fstat(file_open, &stat_results) < 0) {
- ms_error("Couldn`t get status of the file [%s]", file_path);
- } else if (stat_results.st_size == 0) {
- ms_error("The size of file is 0");
- close(file_open);
- return MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
- } else {
- ms_debug("Size of file [%lld] bytes", (long long)stat_results.st_size);
- }
-
- *content = malloc((size_t)stat_results.st_size);
- if (read(file_open, *content, (size_t)stat_results.st_size) < (size_t)stat_results.st_size) {
- close(file_open);
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
- *size = (gsize)stat_results.st_size;
-
- close(file_open);
-
- ms_debug_fleave();
-
- return MEDIA_STREAMER_ERROR_NONE;
-}
-
-static void __ms_http_server_connection_handle_cb(SoupServer *server, SoupMessage *msg,
- const char *path, GHashTable *query, SoupClientContext *client, gpointer user_data)
-{
- _ms_http_server_s *hserver = (_ms_http_server_s *) user_data;
- SoupMessageHeadersIter iter;
- const char *name, *value;
- char *content = NULL;
- gsize size = 0;
- char *mime_type = NULL;
- char *fs_dir = NULL;
- char *file_path = NULL;
- const char *extension = NULL;
-
- /* Close connection if handle is NULL */
- ms_retm_if(hserver == NULL, "server is NULL");
- ms_retm_if(msg == NULL || msg->method == NULL || msg->request_headers == NULL, "msg is NULL");
- ms_retm_if(path == NULL, "path is NULL");
-
- ms_debug("%s %s HTTP/1.%d", msg->method, path,
- soup_message_get_http_version(msg));
- soup_message_headers_iter_init(&iter, msg->request_headers);
- while (soup_message_headers_iter_next(&iter, &name, &value))
- ms_debug("%s: %s", name, value);
- if (msg->request_body->length && msg->request_body->data)
- ms_debug("%s", msg->request_body->data);
-
- if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD) {
- ms_info("Received read event");
-
- /* Extract file path with URI. First symbol is '/' */
- fs_dir = (char *)g_hash_table_lookup(hserver->uri_table, "adaptive_path");
- file_path = g_strjoin(NULL, fs_dir, path+1, NULL);
- extension = get_filename_ext(path+1);
-
- mime_type_get_mime_type(extension, &mime_type);
-
- ms_info("Received URI %s", path + 1);
- ms_info("mime-type: %s", mime_type);
-
- if (MEDIA_STREAMER_ERROR_NONE !=
- __ms_http_server_file_read_contents(file_path, &content, &size)) {
-
- soup_message_set_status(msg, SOUP_STATUS_BAD_REQUEST);
- } else {
- ms_info("Sending response");
- soup_message_set_response(msg, mime_type, SOUP_MEMORY_TAKE, content, size);
- soup_message_set_status(msg, SOUP_STATUS_OK);
- }
-
- g_free(file_path);
- g_free(mime_type);
- } else {
- soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
- soup_message_set_status(msg, SOUP_STATUS_OK);
- }
-
- ms_debug_fleave();
-
-}
//LCOV_EXCL_STOP
#include <cynara-client.h>
#include <system_info.h>
#include <Evas.h>
-#include <Ecore_Evas.h>
-#include <Ecore_Wl2.h>
-#include <tizen-extension-client-protocol.h>
#include <gst/video/videooverlay.h>
#include "media_streamer_node.h"
#include "media_streamer_node_resources.h"
{NULL, NULL}
};
-void __ms_get_state(media_streamer_s *ms_streamer)
-{
- GstState state_old = GST_STATE_NULL, state_new = GST_STATE_NULL;
- GstStateChangeReturn ret_state = -1;
-
- ms_debug_fenter();
-
- ms_retm_if(ms_streamer == NULL, "ms_streamer is NULL");
- ms_retm_if(ms_streamer->pipeline == NULL, "ms_streamer->pipeline is NULL");
-
- ret_state = gst_element_get_state(ms_streamer->pipeline, &state_old, &state_new, GST_CLOCK_TIME_NONE);
- if (ret_state == GST_STATE_CHANGE_SUCCESS)
- ms_info("Got state for [%s]: old [%s], new [%s]", GST_ELEMENT_NAME(ms_streamer->pipeline), gst_element_state_get_name(state_old), gst_element_state_get_name(state_new));
- else
- ms_error("Couldn`t get state for [%s]", GST_ELEMENT_NAME(ms_streamer->pipeline));
-
- ms_debug_fleave();
-}
-
static gboolean __ms_rtp_node_has_property(media_streamer_node_s *node, const char *param_name)
{
GValue *val = NULL;
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)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
GstCaps *sink_caps = NULL;
ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
- sink_caps = in_fmt ? __ms_create_caps_from_fmt(in_fmt) : NULL;
- src_caps = out_fmt ? __ms_create_caps_from_fmt(out_fmt) : NULL;
+ sink_caps = in_fmt ? ms_create_caps_from_fmt(in_fmt) : NULL;
+ src_caps = out_fmt ? ms_create_caps_from_fmt(out_fmt) : NULL;
node_plug_s plug_info = {&(nodes_info[node->type]), src_caps, sink_caps, NULL};
ms_info("Creating node with info: klass_name[%s]; default[%s]",
plug_info.info->klass_name, plug_info.info->default_name);
- node->gst_element = __ms_node_element_create(&plug_info, node->type);
+ node->gst_element = ms_node_element_create(&plug_info, node->type);
if (node->gst_element)
node->name = gst_element_get_name(node->gst_element);
else
return ret;
}
-int __ms_src_node_create(media_streamer_node_s *node)
+int ms_src_node_create(media_streamer_node_s *node)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
char *plugin_name = NULL;
switch (node->subtype) {
case MEDIA_STREAMER_NODE_SRC_TYPE_FILE:
- plugin_name = __ms_ini_get_string("node type 1:file", DEFAULT_FILE_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:file", DEFAULT_FILE_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_RTSP:
- plugin_name = __ms_ini_get_string("node type 1:rtsp", DEFAULT_UDP_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:rtsp", DEFAULT_UDP_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_HTTP:
- plugin_name = __ms_ini_get_string("node type 1:http", DEFAULT_HTTP_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:http", DEFAULT_HTTP_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA:
- plugin_name = __ms_ini_get_string("node type 1:camera", DEFAULT_CAMERA_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:camera", DEFAULT_CAMERA_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_CAPTURE:
- plugin_name = __ms_ini_get_string("node type 1:audio capture", DEFAULT_AUDIO_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:audio capture", DEFAULT_AUDIO_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_CAPTURE:
- plugin_name = __ms_ini_get_string("node type 1:video capture", DEFAULT_VIDEO_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:video capture", DEFAULT_VIDEO_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST:
- plugin_name = __ms_ini_get_string("node type 1:video test", DEFAULT_VIDEO_TEST_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:video test", DEFAULT_VIDEO_TEST_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_TEST:
- plugin_name = __ms_ini_get_string("node type 1:audio test", DEFAULT_AUDIO_TEST_SOURCE);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 1:audio test", DEFAULT_AUDIO_TEST_SOURCE);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM:
- plugin_name = __ms_ini_get_string("node type 1:custom", DEFAULT_APP_SOURCE);
- node->gst_element = __ms_element_create(DEFAULT_APP_SOURCE, NULL);
+ plugin_name = ms_ini_get_string("node type 1:custom", DEFAULT_APP_SOURCE);
+ node->gst_element = ms_element_create(DEFAULT_APP_SOURCE, NULL);
g_object_set(G_OBJECT(node->gst_element), "emit-signals", TRUE, NULL);
- __ms_signal_create(&node->sig_list, node->gst_element, "need-data", G_CALLBACK(__ms_src_start_feed_cb), node);
- __ms_signal_create(&node->sig_list, node->gst_element, "enough-data", G_CALLBACK(__ms_src_stop_feed_cb), node);
+ ms_signal_create(&node->sig_list, node->gst_element, "need-data", G_CALLBACK(__ms_src_start_feed_cb), node);
+ ms_signal_create(&node->sig_list, node->gst_element, "enough-data", G_CALLBACK(__ms_src_stop_feed_cb), node);
break;
case MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE:
- node->gst_element = __ms_adaptive_element_create();
+ node->gst_element = ms_adaptive_element_create();
break;
default:
ms_error("Error: invalid Src node Type [%d]", node->subtype);
else
node->name = gst_element_get_name(node->gst_element);
- ret = __ms_node_policy_init(node);
+ ret = ms_node_policy_init(node);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to init policy for node [%s]", node->name);
return ret;
}
//LCOV_EXCL_STOP
-int __ms_sink_node_create(media_streamer_node_s *node)
+int ms_sink_node_create(media_streamer_node_s *node)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
char *plugin_name = NULL;
switch (node->subtype) {
case MEDIA_STREAMER_NODE_SINK_TYPE_FILE:
- plugin_name = __ms_ini_get_string("node type 2:file", DEFAULT_FILE_SINK);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 2:file", DEFAULT_FILE_SINK);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SINK_TYPE_RTSP:
- plugin_name = __ms_ini_get_string("node type 2:rtsp", DEFAULT_UDP_SINK);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 2:rtsp", DEFAULT_UDP_SINK);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SINK_TYPE_HTTP:
ms_error("Error: not implemented yet");
break;
case MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO:
- plugin_name = __ms_ini_get_string("node type 2:audio", DEFAULT_AUDIO_SINK);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 2:audio", DEFAULT_AUDIO_SINK);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SINK_TYPE_OVERLAY:
- plugin_name = __ms_ini_get_string("node type 2:overlay", DEFAULT_VIDEO_SINK);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 2:overlay", DEFAULT_VIDEO_SINK);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SINK_TYPE_FAKE:
- plugin_name = __ms_ini_get_string("node type 2:fake", DEFAULT_FAKE_SINK);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 2:fake", DEFAULT_FAKE_SINK);
+ node->gst_element = ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM:
- plugin_name = __ms_ini_get_string("node type 2:custom", DEFAULT_APP_SINK);
- node->gst_element = __ms_element_create(plugin_name, NULL);
+ plugin_name = ms_ini_get_string("node type 2:custom", DEFAULT_APP_SINK);
+ node->gst_element = ms_element_create(plugin_name, NULL);
if (node->gst_element) {
g_object_set(G_OBJECT(node->gst_element), "emit-signals", TRUE, NULL);
- __ms_signal_create(&node->sig_list, node->gst_element, "new-sample", G_CALLBACK(__ms_sink_new_buffer_cb), node);
- __ms_signal_create(&node->sig_list, node->gst_element, "eos", G_CALLBACK(sink_eos), node);
+ ms_signal_create(&node->sig_list, node->gst_element, "new-sample", G_CALLBACK(__ms_sink_new_buffer_cb), node);
+ ms_signal_create(&node->sig_list, node->gst_element, "eos", G_CALLBACK(sink_eos), node);
}
break;
case MEDIA_STREAMER_NODE_SINK_TYPE_ADAPTIVE:
- plugin_name = __ms_ini_get_string("node type 2:adaptive", DEFAULT_ADAPTIVE_SINK);
- node->gst_element = __ms_element_create(plugin_name, "adaptive_sink");
+ plugin_name = ms_ini_get_string("node type 2:adaptive", DEFAULT_ADAPTIVE_SINK);
+ node->gst_element = ms_element_create(plugin_name, "adaptive_sink");
if (g_strrstr(plugin_name, "hlssink")) {
g_object_set(G_OBJECT(node->gst_element),
return ret;
}
-void __ms_node_destroy(media_streamer_node_s *node)
+void ms_node_destroy(media_streamer_node_s *node)
{
gchar *node_name = NULL;
node_name = g_strdup(node->name);
/* Disconnects and clean all node signals */
- g_list_free_full(node->sig_list, __ms_signal_destroy);
+ g_list_free_full(node->sig_list, ms_signal_destroy);
/* Deinitialize policy manager */
- if (MEDIA_STREAMER_ERROR_NONE != __ms_node_policy_deinit(node))
+ if (MEDIA_STREAMER_ERROR_NONE != ms_node_policy_deinit(node))
ms_error("Failed to deinitialize policy manager");
MS_SAFE_UNREF(node->gst_element);
ms_debug_fleave();
}
-int __ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s *node)
+int ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s *node)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
GstElement *bin = NULL;
break;
}
- if (!__ms_bin_add_element(bin, node->gst_element, TRUE)) {
+ if (!ms_bin_add_element(bin, node->gst_element, TRUE)) {
ms_error("Failed to add Element [%s] into [%s] bin.", node->name, GST_ELEMENT_NAME(bin));
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
return ret;
}
-int __ms_node_insert_into_table(GHashTable *nodes_table, media_streamer_node_s *node)
+int ms_node_insert_into_table(GHashTable *nodes_table, media_streamer_node_s *node)
{
ms_debug_fenter();
return MEDIA_STREAMER_ERROR_NONE;
}
-void __ms_node_remove_from_table(void *data)
+void ms_node_remove_from_table(void *data)
{
media_streamer_node_s *node = (media_streamer_node_s *) data;
ms_retm_if(node == NULL, "data is NULL");
- if (__ms_element_unlink(node->gst_element)) {
+ if (ms_element_unlink(node->gst_element)) {
node->linked_by_user = FALSE;
node->parent_streamer = NULL;
- __ms_bin_remove_element(node->gst_element);
+ ms_bin_remove_element(node->gst_element);
ms_info("Node [%s] removed from Media Streamer", node->name);
} else {
ms_error("Error: Node [%s] remove failed", node->name);
return ret;
}
-node_info_s * __ms_node_get_klass_by_its_type(media_streamer_node_type_e element_type)
+node_info_s * ms_node_get_klass_by_its_type(media_streamer_node_type_e element_type)
{
int it_klass;
return &nodes_info[it_klass];
}
-gboolean _ms_sink_node_prepare_iter(const GValue *item, GValue *g_ret, gpointer user_data)
+gboolean ms_sink_node_prepare_iter(const GValue *item, GValue *g_ret, gpointer user_data)
{
gboolean ret = FALSE;
ms_debug_fenter();
- ret = __ms_element_lock_state(item, g_ret, user_data);
+ ret = ms_element_lock_state(item, g_ret, user_data);
ms_debug_fleave();
return ret;
}
-gboolean _ms_src_node_prepare_iter(const GValue *item, GValue *ret, gpointer user_data)
+gboolean ms_src_node_prepare_iter(const GValue *item, GValue *ret, gpointer user_data)
{
media_streamer_s *ms_streamer = (media_streamer_s *) user_data;
GstElement *src_element = NULL;
src_pad = gst_element_get_static_pad(src_element, "src");
if (__ms_src_need_typefind(src_pad)) {
- __ms_find_type(ms_streamer, src_element);
+ ms_find_type(ms_streamer, src_element);
MS_SAFE_UNREF(src_element);
} else {
/* Check the source element`s pad type */
- const gchar *new_pad_type = __ms_get_pad_type(src_pad);
+ const gchar *new_pad_type = ms_get_pad_type(src_pad);
/* If SRC Element linked by user, don`t consider the following nodes` managing */
if (gst_pad_is_linked(src_pad)) {
MS_SAFE_UNREF(src_pad);
}
/* It is media streamer Server part */
if (MS_ELEMENT_IS_VIDEO(new_pad_type) || MS_ELEMENT_IS_IMAGE(new_pad_type)) {
- found_element = __ms_combine_next_element(src_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_FILTER);
+ found_element = ms_combine_next_element(src_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_FILTER);
GstCaps *videoCaps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_CAMERA_FORMAT);
g_object_set(G_OBJECT(found_element), "caps", videoCaps, NULL);
gst_caps_unref(videoCaps);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
}
if (MS_ELEMENT_IS_AUDIO(new_pad_type)) {
- found_element = __ms_combine_next_element(src_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY);
- found_element = __ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
+ found_element = ms_combine_next_element(src_element, src_pad, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY);
+ found_element = ms_combine_next_element(found_element, NULL, ms_streamer->transform_bin, MEDIA_STREAMER_NODE_TYPE_RTP);
}
- __ms_generate_dots(ms_streamer->pipeline, "after_connecting_rtp");
+ ms_generate_dots(ms_streamer->pipeline, "after_connecting_rtp");
MS_SAFE_UNREF(found_element);
}
MS_SAFE_UNREF(src_pad);
protocol = gst_uri_is_valid(uri) ? gst_uri_get_protocol(uri) : NULL;
if (protocol && g_strrstr(protocol, "http")) {
- manifest_src_name = __ms_ini_get_string("node type 1:http", DEFAULT_HTTP_SOURCE);
+ manifest_src_name = ms_ini_get_string("node type 1:http", DEFAULT_HTTP_SOURCE);
location = g_strdup(uri);
} else if (protocol && g_strrstr(protocol, "file")) {
- manifest_src_name = __ms_ini_get_string("node type 1:file", DEFAULT_FILE_SOURCE);
+ manifest_src_name = ms_ini_get_string("node type 1:file", DEFAULT_FILE_SOURCE);
location = gst_uri_get_location(uri);
} else {
ms_error("Unsupported URI protocol... Check URI is file path");
- if (__ms_util_uri_path_check(uri) == MEDIA_STREAMER_ERROR_NONE) {
- manifest_src_name = __ms_ini_get_string("node type 1:file", DEFAULT_FILE_SOURCE);
+ if (ms_util_uri_path_check(uri) == MEDIA_STREAMER_ERROR_NONE) {
+ manifest_src_name = ms_ini_get_string("node type 1:file", DEFAULT_FILE_SOURCE);
location = g_strdup(uri);
} else {
g_free(protocol);
return manifest_src;
}
-int __ms_adaptive_src_node_prepare(media_streamer_node_s *node, bool auto_plug)
+int ms_adaptive_src_node_prepare(media_streamer_node_s *node, bool auto_plug)
{
char *plugin_name = NULL;
GstElement *manifest_src = NULL;
ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
if (!auto_plug) {
- plugin_name = __ms_ini_get_string("node type 1:adaptive", DEFAULT_ADAPTIVE_SOURCE);
+ plugin_name = ms_ini_get_string("node type 1:adaptive", DEFAULT_ADAPTIVE_SOURCE);
ms_retvm_if(plugin_name == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error empty plugin name for adaptive source");
ms_info("Creating [%s] element", plugin_name);
plugin_elem = gst_element_factory_make(plugin_name, NULL);
if (!auto_plug) {
g_signal_connect_object(plugin_elem, "pad-added",
- G_CALLBACK(__ms_hlsdemux_pad_added_cb), gp, 0);
+ G_CALLBACK(ms_hlsdemux_pad_added_cb), gp, 0);
} else {
GstPad *manifest_src_pad = gst_element_get_static_pad(manifest_src, "src");
gst_ghost_pad_set_target(GST_GHOST_PAD(gp), manifest_src_pad);
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_adaptive_sink_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node)
+int ms_adaptive_sink_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node)
{
int err_code = MEDIA_STREAMER_ERROR_NONE;
gchar *playlist_location = NULL;
ms_retvm_if(node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node->gst_element is NULL");
/* Create and start http server */
- err_code = __ms_http_server_create(&ms_streamer->http_server);
+ err_code = ms_http_server_create(&ms_streamer->http_server);
if (MEDIA_STREAMER_ERROR_NONE != err_code) {
ms_error("Failed to create http server during prepare");
goto _DONE;
ms_info("Starting http server");
/* FIXME: find out how to set default port */
- err_code = __ms_http_server_start(ms_streamer->http_server, DEFAULT_HTTP_PORT);
+ err_code = ms_http_server_start(ms_streamer->http_server, DEFAULT_HTTP_PORT);
if (MEDIA_STREAMER_ERROR_NONE != err_code) {
ms_error("Failed to start http server during prepare. Destroying http server");
- __ms_http_server_destroy(ms_streamer->http_server);
+ ms_http_server_destroy(ms_streamer->http_server);
goto _DONE;
}
if (!playlist_location) {
err_code = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
ms_error("Failed to get playlist location");
- __ms_http_server_destroy(ms_streamer->http_server);
+ ms_http_server_destroy(ms_streamer->http_server);
goto _DONE;
}
split = strrchr(playlist_location, '/');
playlist_dir = g_strndup(playlist_location, split - playlist_location + 1);
- __ms_http_server_register_uri(ms_streamer->http_server, "adaptive_path", playlist_dir);
+ ms_http_server_register_uri(ms_streamer->http_server, "adaptive_path", playlist_dir);
MS_SAFE_GFREE(playlist_location);
}
//LCOV_EXCL_START
-gboolean __ms_rtp_node_prepare(media_streamer_node_s *node)
+gboolean ms_rtp_node_prepare(media_streamer_node_s *node)
{
GstElement *rtpbin = NULL;
gboolean ret = TRUE;
ms_retvm_if(!node, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "node is NULL");
- rtpbin = __ms_element_create("rtpbin", "rtpbin");
+ rtpbin = ms_element_create("rtpbin", "rtpbin");
ms_retvm_if(!rtpbin, FALSE, "Error: creating elements for rtp container");
- if (!__ms_bin_add_element(node->gst_element, rtpbin, FALSE)) {
+ if (!ms_bin_add_element(node->gst_element, rtpbin, FALSE)) {
MS_SAFE_UNREF(rtpbin);
return FALSE;
}
- __ms_signal_create(&node->sig_list, rtpbin, "pad-added", G_CALLBACK(__ms_rtpbin_pad_added_cb), node);
+ ms_signal_create(&node->sig_list, rtpbin, "pad-added", G_CALLBACK(ms_rtpbin_pad_added_cb), node);
val = (GValue *)g_object_get_data(G_OBJECT(node->gst_element), MEDIA_STREAMER_PARAM_HOST);
host = g_value_get_string(val);
val = (GValue *)g_object_get_data(G_OBJECT(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(node->gst_element, rtp_el, FALSE);
+ rtp_el = ms_element_create("udpsrc", MS_RTP_PAD_VIDEO_IN"_rtp");
+ ms_bin_add_element(node->gst_element, rtp_el, FALSE);
- rtcp_el = __ms_element_create("udpsrc", MS_RTP_PAD_VIDEO_IN"_rctp");
- __ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
+ rtcp_el = ms_element_create("udpsrc", MS_RTP_PAD_VIDEO_IN"_rctp");
+ ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
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");
val = (GValue *)g_object_get_data(G_OBJECT(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(node->gst_element, rtp_el, FALSE);
+ rtp_el = ms_element_create("udpsrc", MS_RTP_PAD_AUDIO_IN"_rtp");
+ ms_bin_add_element(node->gst_element, rtp_el, FALSE);
- rtcp_el = __ms_element_create("udpsrc", MS_RTP_PAD_AUDIO_IN"_rctp");
- __ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
+ rtcp_el = ms_element_create("udpsrc", MS_RTP_PAD_AUDIO_IN"_rctp");
+ ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
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");
val = (GValue *)g_object_get_data(G_OBJECT(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(node->gst_element, rtp_el, FALSE);
+ rtp_el = ms_element_create("udpsink", MS_RTP_PAD_VIDEO_OUT"_rtp");
+ ms_bin_add_element(node->gst_element, rtp_el, FALSE);
- rtcp_el = __ms_element_create("udpsink", MS_RTP_PAD_VIDEO_OUT"_rctp");
- __ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
+ rtcp_el = ms_element_create("udpsink", MS_RTP_PAD_VIDEO_OUT"_rctp");
+ ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
- video_filter = __ms_element_create("capsfilter", NULL);
- __ms_bin_add_element(node->gst_element, video_filter, FALSE);
+ video_filter = ms_element_create("capsfilter", NULL);
+ ms_bin_add_element(node->gst_element, video_filter, FALSE);
video_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_VIDEO_RTP_FORMAT);
g_object_set(G_OBJECT(video_filter), "caps", video_caps, NULL);
val = (GValue *)g_object_get_data(G_OBJECT(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(node->gst_element, rtp_el, FALSE);
+ rtp_el = ms_element_create("udpsink", MS_RTP_PAD_AUDIO_OUT"_rtp");
+ ms_bin_add_element(node->gst_element, rtp_el, FALSE);
- rtcp_el = __ms_element_create("udpsink", MS_RTP_PAD_AUDIO_OUT"_rctp");
- __ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
+ rtcp_el = ms_element_create("udpsink", MS_RTP_PAD_AUDIO_OUT"_rctp");
+ ms_bin_add_element(node->gst_element, rtcp_el, FALSE);
- audio_filter = __ms_element_create("capsfilter", NULL);
- __ms_bin_add_element(node->gst_element, audio_filter, FALSE);
+ audio_filter = ms_element_create("capsfilter", NULL);
+ ms_bin_add_element(node->gst_element, audio_filter, FALSE);
audio_caps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_AUDIO_RTP_FORMAT);
g_object_set(G_OBJECT(audio_filter), "caps", audio_caps, NULL);
g_object_set(GST_OBJECT(rtcp_el), MEDIA_STREAMER_PARAM_HOST, host, NULL);
}
- __ms_generate_dots(node->gst_element, "rtp_prepared");
+ ms_generate_dots(node->gst_element, "rtp_prepared");
ms_debug_fleave();
}
//LCOV_EXCL_STOP
-int __ms_demux_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node)
+int ms_demux_node_prepare(media_streamer_s *ms_streamer, media_streamer_node_s *node)
{
ms_debug_fenter();
ms_retvm_if(!ms_streamer, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "ms_streamer is NULL");
ms_retvm_if(!node, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
- __ms_signal_create(&ms_streamer->autoplug_sig_list, node->gst_element, "pad-added", G_CALLBACK(__ms_demux_pad_added_cb), ms_streamer);
- __ms_signal_create(&ms_streamer->autoplug_sig_list, node->gst_element, "no-more-pads", G_CALLBACK(__ms_demux_nomore_pads_cb), ms_streamer);
+ ms_signal_create(&ms_streamer->autoplug_sig_list, node->gst_element, "pad-added", G_CALLBACK(ms_demux_pad_added_cb), ms_streamer);
+ ms_signal_create(&ms_streamer->autoplug_sig_list, node->gst_element, "no-more-pads", G_CALLBACK(ms_demux_nomore_pads_cb), ms_streamer);
+
+ ms_debug_fleave();
+
+ return MEDIA_STREAMER_ERROR_NONE;
+}
+
+static int __ms_node_get_param_list(media_streamer_node_s *node, GList **param_list)
+{
+ GParamSpec *param_spec;
+ int it_param;
+
+ ms_debug_fenter();
+
+ ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
+ ms_retvm_if(param_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param_list is NULL");
+
+ 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].origin_name) ||
+ __ms_adaptive_src_node_has_property(node, param_table[it_param].origin_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);
ms_debug_fleave();
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_node_set_params_from_bundle(media_streamer_node_s *node, bundle *param_list)
+static int __ms_node_set_display(media_streamer_node_s *node, const char *param_value)
+{
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ Evas_Object *obj = NULL;
+ media_streamer_wl_info_s wl_info;
+
+ obj = (Evas_Object *)param_value;
+
+ /* get wayland parent id */
+ if (ms_get_wl_info(obj, &wl_info) != MEDIA_STREAMER_ERROR_NONE) {
+ LOGE("failed to get wayland info");
+ return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ }
+
+ LOGD("wayland global surface id : %d", wl_info.parent_id);
+
+ gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(node->gst_element), wl_info.parent_id);
+
+ return ret;
+}
+//LCOV_EXCL_STOP
+
+int ms_node_set_param_value(media_streamer_node_s *node, param_s *param, const char *param_value)
+{
+
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+
+ ms_debug_fenter();
+
+ ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
+ ms_retvm_if(param == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param is NULL");
+ ms_retvm_if(param_value == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param_value is NULL");
+
+ if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP) {
+ ret = __ms_rtp_node_set_property(node, param, param_value);
+ ms_debug_fleave();
+ return ret;
+ }
+
+ if (node->type == MEDIA_STREAMER_NODE_TYPE_SRC &&
+ node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE) {
+ ret = __ms_adaptive_src_node_set_property(node, param, param_value);
+ ms_debug_fleave();
+ return ret;
+ }
+
+ 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);
+ g_object_set(node->gst_element, param->origin_name, camera_id, NULL);
+ } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_STREAM_TYPE) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PORT) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_ROTATE) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_FLIP) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD)) {
+ g_object_set(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_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USE_TBM) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VISIBLE)) {
+ g_object_set(node->gst_element, param->origin_name, !g_ascii_strcasecmp(param_value, "true"), NULL);
+ } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_URI)) {
+ if (node->type == MEDIA_STREAMER_NODE_TYPE_SRC && node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_FILE) {
+ ret = ms_util_uri_path_check(param_value);
+ if (ret != MEDIA_STREAMER_ERROR_NONE)
+ return ret;
+ }
+ g_object_set(node->gst_element, param->origin_name, param_value, NULL);
+ } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USER_AGENT) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IP_ADDRESS) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_DEVICE) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_HOST) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_SEGMENT_LOCATION) ||
+ !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PLAYLIST_LOCATION)) {
+ g_object_set(node->gst_element, param->origin_name, param_value, NULL);
+ } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY)) {
+ ret = __ms_node_set_display(node, param_value);
+ } else {
+ ms_info("Can not set parameter [%s] in the node [%s]", param->param_name, node->name);
+ ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
+ }
+
+ ms_debug_fleave();
+
+ return ret;
+}
+
+int ms_node_set_params_from_bundle(media_streamer_node_s *node, bundle *param_list)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
GList *p_list = 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) {
- ret = __ms_node_set_param_value(node, param, string_val);
+ ret = ms_node_set_param_value(node, param, string_val);
if (ret == MEDIA_STREAMER_ERROR_NONE) {
written_count++;
} else {
return ret;
}
-int __ms_node_write_params_into_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;
GList *p_list = 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) {
+ if (ms_node_get_param_value(node, param, &string_val) == MEDIA_STREAMER_ERROR_NONE) {
bundle_add_str(param_list, param->param_name, string_val);
MS_SAFE_FREE(string_val);
}
return ret;
}
-int __ms_node_get_param(media_streamer_node_s *node, const char *param_name, param_s **param)
+int ms_node_get_param(media_streamer_node_s *node, const char *param_name, param_s **param)
{
GParamSpec *param_spec;
gboolean found_param = FALSE;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_node_get_param_list(media_streamer_node_s *node, GList **param_list)
-{
- GParamSpec *param_spec;
- int it_param;
-
- ms_debug_fenter();
-
- ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
- ms_retvm_if(param_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param_list is NULL");
-
- 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].origin_name) ||
- __ms_adaptive_src_node_has_property(node, param_table[it_param].origin_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);
-
- ms_debug_fleave();
-
- return MEDIA_STREAMER_ERROR_NONE;
-}
-
-int __ms_node_get_param_value(media_streamer_node_s *node, param_s *param, char **string_value)
+int ms_node_get_param_value(media_streamer_node_s *node, param_s *param, char **string_value)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
char *string_val = NULL;
return ret;
}
-//LCOV_EXCL_START
-static void __global(void *data, struct wl_registry *registry,
- uint32_t name, const char *interface, uint32_t version)
-{
- struct tizen_surface **tz_surface = NULL;
-
- if (!data) {
- LOGE("NULL data");
- return;
- }
-
- tz_surface = (struct tizen_surface **)data;
-
- if (!interface) {
- LOGW("NULL interface");
- return;
- }
-
- if (strcmp(interface, "tizen_surface") == 0) {
- LOGD("binding tizen surface for wayland");
-
- *tz_surface = wl_registry_bind(registry, name, &tizen_surface_interface, 1);
- if (*tz_surface == NULL)
- LOGE("failed to bind");
-
- LOGD("done");
- }
-
- return;
-}
-
-static void __global_remove(void *data, struct wl_registry *wl_registry, uint32_t name)
-{
- LOGD("enter");
- return;
-}
-
-static const struct wl_registry_listener _media_streamer_wl_registry_listener = {
- __global,
- __global_remove
-};
-
-void __parent_id_getter(void *data, struct tizen_resource *tizen_resource, uint32_t id)
-{
- if (!data) {
- LOGE("NULL data");
- return;
- }
-
- *((unsigned int *)data) = id;
-
- LOGD("[CLIENT] got parent_id [%u] from server", id);
-
- return;
-}
-
-static const struct tizen_resource_listener _media_streamer_tz_resource_listener = {
- __parent_id_getter
-};
-
-int _media_streamer_get_wl_info(Evas_Object *obj, media_streamer_wl_info_s *wl_info)
-{
- int ret = MEDIA_STREAMER_ERROR_NONE;
- Ecore_Wl2_Window *window = NULL;
- Ecore_Evas *ee = NULL;
- Ecore_Wl2_Display *e_wl2_display = NULL;
- Evas *e = NULL;
- struct wl_display *display = NULL;
- struct wl_display *display_wrapper = NULL;
- struct wl_surface *surface = NULL;
- struct wl_registry *registry = NULL;
- struct wl_event_queue *queue = NULL;
- struct tizen_surface *tz_surface = NULL;
- struct tizen_resource *tz_resource = NULL;
-
- if (!obj || !wl_info) {
- LOGE("NULL parameter %p %p", obj, wl_info);
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
-
- e = evas_object_evas_get(obj);
- if (!e) {
- LOGE("failed to get evas object");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- ee = ecore_evas_ecore_evas_get(e);
- if (!ee) {
- LOGE("failed to get ecore evas object");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- window = ecore_evas_wayland2_window_get(ee);
- if (!window) {
- LOGE("failed to get wayland window");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- /* set video_has flag to a video application window */
- ecore_wl2_window_video_has(window, EINA_TRUE);
-
- surface = (struct wl_surface *)ecore_wl2_window_surface_get(window);
- if (!surface) {
- LOGE("failed to get wayland surface");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- e_wl2_display = ecore_wl2_connected_display_get(NULL);
- if (!e_wl2_display) {
- LOGE("failed to get ecore wl2 display");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- display = (struct wl_display *)ecore_wl2_display_get(e_wl2_display);
- if (!display) {
- LOGE("failed to get wayland display");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- display_wrapper = wl_proxy_create_wrapper(display);
- if (!display_wrapper) {
- LOGE("failed to create wl display wrapper");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- queue = wl_display_create_queue(display);
- if (!queue) {
- LOGE("failed to create wl display queue");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- wl_proxy_set_queue((struct wl_proxy *)display_wrapper, queue);
-
- registry = wl_display_get_registry(display_wrapper);
- if (!registry) {
- LOGE("failed to get wayland registry");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- wl_registry_add_listener(registry, &_media_streamer_wl_registry_listener, &tz_surface);
-
- wl_display_dispatch_queue(display, queue);
- wl_display_roundtrip_queue(display, queue);
-
- if (!tz_surface) {
- LOGE("failed to get tizen surface");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- tz_resource = tizen_surface_get_tizen_resource(tz_surface, surface);
- if (!tz_resource) {
- LOGE("failed to get tizen resource");
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- goto _DONE;
- }
-
- wl_info->parent_id = 0;
-
- tizen_resource_add_listener(tz_resource, &_media_streamer_tz_resource_listener, &wl_info->parent_id);
-
- wl_display_roundtrip_queue(display, queue);
-
- if (wl_info->parent_id > 0) {
- LOGD("parent id : %u", wl_info->parent_id);
- } else {
- ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- LOGE("failed to get parent id");
- }
-
-_DONE:
- if (tz_surface) {
- tizen_surface_destroy(tz_surface);
- tz_surface = NULL;
- }
-
- if (tz_resource) {
- tizen_resource_destroy(tz_resource);
- tz_resource = NULL;
- }
-
- if (registry) {
- wl_registry_destroy(registry);
- registry = NULL;
- }
-
- if (queue) {
- wl_event_queue_destroy(queue);
- queue = NULL;
- }
-
- if (display_wrapper) {
- wl_proxy_wrapper_destroy(display_wrapper);
- display_wrapper = NULL;
- }
-
- return ret;
-}
-
-int __ms_node_set_display(media_streamer_node_s *node, const char *param_value)
-{
- int ret = MEDIA_STREAMER_ERROR_NONE;
- Evas_Object *obj = NULL;
- media_streamer_wl_info_s wl_info;
-
- obj = (Evas_Object *)param_value;
-
- /* get wayland parent id */
- if (_media_streamer_get_wl_info(obj, &wl_info) != MEDIA_STREAMER_ERROR_NONE) {
- LOGE("failed to get wayland info");
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
-
- LOGD("wayland global surface id : %d", wl_info.parent_id);
-
- gst_video_overlay_set_wl_window_wl_surface_id(GST_VIDEO_OVERLAY(node->gst_element), wl_info.parent_id);
-
- return ret;
-}
-//LCOV_EXCL_STOP
-
-int __ms_node_set_param_value(media_streamer_node_s *node, param_s *param, const char *param_value)
-{
-
- int ret = MEDIA_STREAMER_ERROR_NONE;
-
- ms_debug_fenter();
-
- ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "node is NULL");
- ms_retvm_if(param == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param is NULL");
- ms_retvm_if(param_value == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "param_value is NULL");
-
- if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP) {
- ret = __ms_rtp_node_set_property(node, param, param_value);
- ms_debug_fleave();
- return ret;
- }
-
- if (node->type == MEDIA_STREAMER_NODE_TYPE_SRC &&
- node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_ADAPTIVE) {
- ret = __ms_adaptive_src_node_set_property(node, param, param_value);
- ms_debug_fleave();
- return ret;
- }
-
- 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);
- g_object_set(node->gst_element, param->origin_name, camera_id, NULL);
- } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_STREAM_TYPE) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PORT) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_ROTATE) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_FLIP) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY_GEOMETRY_METHOD)) {
- g_object_set(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_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_CLOCK_SYNCHRONIZED) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USE_TBM) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_VISIBLE)) {
- g_object_set(node->gst_element, param->origin_name, !g_ascii_strcasecmp(param_value, "true"), NULL);
- } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_URI)) {
- if (node->type == MEDIA_STREAMER_NODE_TYPE_SRC && node->subtype == MEDIA_STREAMER_NODE_SRC_TYPE_FILE) {
- ret = __ms_util_uri_path_check(param_value);
- if (ret != MEDIA_STREAMER_ERROR_NONE)
- return ret;
- }
- g_object_set(node->gst_element, param->origin_name, param_value, NULL);
- } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_USER_AGENT) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_IP_ADDRESS) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_AUDIO_DEVICE) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_HOST) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_SEGMENT_LOCATION) ||
- !g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_PLAYLIST_LOCATION)) {
- g_object_set(node->gst_element, param->origin_name, param_value, NULL);
- } else if (!g_strcmp0(param->param_name, MEDIA_STREAMER_PARAM_DISPLAY)) {
- ret = __ms_node_set_display(node, param_value);
- } else {
- ms_info("Can not set parameter [%s] in the node [%s]", param->param_name, node->name);
- ret = MEDIA_STREAMER_ERROR_INVALID_PARAMETER;
- }
-
- ms_debug_fleave();
-
- return ret;
-}
-
-int __ms_node_set_pad_format(media_streamer_node_s *node, const char *pad_name, media_format_h fmt)
+int ms_node_set_pad_format(media_streamer_node_s *node, const char *pad_name, media_format_h fmt)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
if (g_strrstr(pad_name, MS_RTP_PAD_VIDEO_IN)) {
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=(string)video,clock-rate=(int)90000,encoding-name=%s", __ms_convert_mime_to_rtp_format(mime));
+ rtp_caps_str = g_strdup_printf("application/x-rtp,media=(string)video,clock-rate=(int)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);
+ ret = ms_node_set_param_value(node, ¶m, rtp_caps_str);
}
} else if (g_strrstr(pad_name, MS_RTP_PAD_AUDIO_IN)) {
int audio_channels, audio_samplerate;
if (MEDIA_FORMAT_ERROR_NONE == ret) {
rtp_caps_str = g_strdup_printf("application/x-rtp,media=(string)audio,clock-rate=(int)8000,encoding-name=(string)AMR,encoding-params=(string)1,octet-align=(string)1");
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);
+ ret = ms_node_set_param_value(node, ¶m, rtp_caps_str);
}
}
MS_SAFE_GFREE(rtp_caps_str);
} else {
- ret = __ms_element_set_fmt(node->gst_element, pad_name, fmt);
+ ret = ms_element_set_fmt(node->gst_element, pad_name, fmt);
}
ms_debug_fleave();
return ret;
}
-gboolean _ms_node_resources_acquire_iter(const GValue *item, GValue *ret, gpointer user_data)
+gboolean ms_node_resources_acquire_iter(const GValue *item, GValue *ret, gpointer user_data)
{
media_streamer_s *ms_streamer = (media_streamer_s *) user_data;
media_streamer_node_s *node = NULL;
return TRUE;
}
- if (MEDIA_STREAMER_ERROR_NONE != _ms_node_resource_acquire(node)) {
+ if (MEDIA_STREAMER_ERROR_NONE != ms_node_resource_acquire(node)) {
ms_error("Failed to acquire resource for node [%s]", node->name);
g_object_unref(element);
return FALSE;
return TRUE;
}
-gboolean _ms_node_resources_release_iter(const GValue *item, GValue *ret, gpointer user_data)
+gboolean ms_node_resources_release_iter(const GValue *item, GValue *ret, gpointer user_data)
{
media_streamer_s *ms_streamer = (media_streamer_s *) user_data;
media_streamer_node_s *node = NULL;
return TRUE;
}
- if (MEDIA_STREAMER_ERROR_NONE != _ms_node_resource_release(node)) {
+ if (MEDIA_STREAMER_ERROR_NONE != ms_node_resource_release(node)) {
ms_error("Failed to release resource for node [%s]", node->name);
g_object_unref(element);
return FALSE;
return TRUE;
}
-gboolean _ms_node_policy_check_iter(const GValue *item, GValue *ret, gpointer user_data)
+gboolean ms_node_policy_check_iter(const GValue *item, GValue *ret, gpointer user_data)
{
media_streamer_s *ms_streamer = (media_streamer_s *) user_data;
media_streamer_node_s *node = NULL;
return TRUE;
}
- if (MEDIA_STREAMER_ERROR_NONE != _ms_node_policy_check(node)) {
+ if (MEDIA_STREAMER_ERROR_NONE != ms_node_policy_check(node)) {
ms_error("Failed to check policy for node [%s]", node->name);
g_object_unref(element);
return FALSE;
g_mutex_lock(&streamer->mutex_lock);
streamer->is_interrupted = TRUE;
if (MEDIA_STREAMER_ERROR_NONE !=
- __ms_pipeline_unprepare(streamer)) {
+ ms_pipeline_unprepare(streamer)) {
ms_error("Failed to unprepare streamer");
streamer->is_interrupted = FALSE;
g_mutex_unlock(&streamer->mutex_lock);
}
//LCOV_EXCL_STOP
-int __ms_node_policy_init(media_streamer_node_s *node)
+int ms_node_policy_init(media_streamer_node_s *node)
{
media_streamer_policy_type_e policy = POLICY_TYPE_NONE;
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-int __ms_node_policy_deinit(media_streamer_node_s *node)
+int ms_node_policy_deinit(media_streamer_node_s *node)
{
media_streamer_policy_type_e policy = POLICY_TYPE_NONE;
int ret = MEDIA_STREAMER_ERROR_NONE;
return ret;
}
-int _ms_node_policy_check(media_streamer_node_s *node)
+int ms_node_policy_check(media_streamer_node_s *node)
{
media_streamer_policy_type_e policy = POLICY_TYPE_NONE;
int ret = MEDIA_STREAMER_ERROR_NONE;
return FALSE;
}
-int _ms_node_resource_acquire(media_streamer_node_s *node)
+int ms_node_resource_acquire(media_streamer_node_s *node)
{
mm_resource_manager_res_type_e resource;
mm_resource_manager_h resource_manager;
return MEDIA_STREAMER_ERROR_NONE;
}
-int _ms_node_resource_release(media_streamer_node_s *node)
+int ms_node_resource_release(media_streamer_node_s *node)
{
mm_resource_manager_h resource_manager;
static int __ms_resource_release_cb(mm_resource_manager_h rm,
mm_resource_manager_res_h resource_h, void *user_data);
-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;
* Media streamer must be in IDLE state
* Unlink and destroy all bins and elements.
*/
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_NULL);
+ ret = ms_element_set_state(ms_streamer->pipeline, GST_STATE_NULL);
ms_streamer->pend_state = 0;
ms_streamer->state = state;
break;
/*
* Unlink all gst_elements, set pipeline into state NULL
*/
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_NULL);
- __ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin), __ms_element_unlock_state, ms_streamer);
+ ret = ms_element_set_state(ms_streamer->pipeline, GST_STATE_NULL);
+ ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin), ms_element_unlock_state, ms_streamer);
ms_streamer->pend_state = MEDIA_STREAMER_STATE_IDLE;
ms_streamer->state = state;
break;
case MEDIA_STREAMER_STATE_READY:
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
+ ret = ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
ms_streamer->pend_state = MEDIA_STREAMER_STATE_READY;
break;
case MEDIA_STREAMER_STATE_PLAYING:
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING);
- __ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin), __ms_element_unlock_state, ms_streamer);
+ ret = ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING);
+ ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin), ms_element_unlock_state, ms_streamer);
ms_streamer->pend_state = MEDIA_STREAMER_STATE_PLAYING;
break;
case MEDIA_STREAMER_STATE_PAUSED:
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
+ ret = ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
ms_streamer->pend_state = MEDIA_STREAMER_STATE_PAUSED;
break;
case MEDIA_STREAMER_STATE_SEEKING:
return ret;
}
-int __ms_create(media_streamer_s *ms_streamer)
+int ms_create(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "ms_streamer is NULL");
- __ms_load_ini_settings(&ms_streamer->ini);
+ ms_load_ini_settings(&ms_streamer->ini);
- ms_streamer->nodes_table = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __ms_node_remove_from_table);
+ ms_streamer->nodes_table = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, ms_node_remove_from_table);
ms_retvm_if(ms_streamer->nodes_table == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating hash table");
- ret = __ms_pipeline_create(ms_streamer);
+ ret = ms_pipeline_create(ms_streamer);
if (MM_RESOURCE_MANAGER_ERROR_NONE != mm_resource_manager_create(
MM_RESOURCE_MANAGER_APP_CLASS_MEDIA,
return ret;
}
-int __ms_get_position(media_streamer_s *ms_streamer, int *time)
+int ms_get_position(media_streamer_s *ms_streamer, int *time)
{
gint64 current = GST_CLOCK_TIME_NONE;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_get_duration(media_streamer_s *ms_streamer, int *time)
+int ms_get_duration(media_streamer_s *ms_streamer, int *time)
{
gint64 duration = GST_CLOCK_TIME_NONE;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_seek(media_streamer_s *ms_streamer, int g_time, bool flag)
+int ms_seek(media_streamer_s *ms_streamer, int g_time, bool flag)
{
GstSeekFlags seek_flag;
else
seek_flag = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT;
- if (!__ms_gst_seek(ms_streamer->pipeline, (gint64) g_time * GST_MSECOND, seek_flag)) {
+ if (!ms_gst_seek(ms_streamer->pipeline, (gint64) g_time * GST_MSECOND, seek_flag)) {
ms_error("Error while seeking media streamer to [%d]", g_time);
return MEDIA_STREAMER_ERROR_SEEK_FAILED;
} else {
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_destroy(media_streamer_s *ms_streamer)
+int ms_destroy(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
g_mutex_lock(&ms_streamer->mutex_lock);
- ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_NONE);
+ ret = ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_NONE);
MS_TABLE_SAFE_UNREF(ms_streamer->nodes_table);
MS_SAFE_UNREF(ms_streamer->bus);
return ret;
}
-int __ms_acquire_resources(media_streamer_s *ms_streamer)
+int ms_acquire_resources(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "ms_streamer is NULL");
/* Acquire resources for src bin */
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin),
- _ms_node_resources_acquire_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin),
+ ms_node_resources_acquire_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to acquire resources for src bin");
return ret;
add nodes explicitly they will be acquired later.
For example when decodebin is used resources are quired
when 'autoplug-select' signal is triggered for new GstElement. */
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->transform_bin),
- _ms_node_resources_acquire_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->transform_bin),
+ ms_node_resources_acquire_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to acquire resources for transform bin");
return ret;
}
/* Acquire resources for src bin */
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin),
- _ms_node_resources_acquire_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin),
+ ms_node_resources_acquire_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to acquire resources for sink bin");
return ret;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_release_resources(media_streamer_s *ms_streamer)
+int ms_release_resources(media_streamer_s *ms_streamer)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "ms_streamer is NULL");
/* Release resources for src bin */
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin),
- _ms_node_resources_release_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin),
+ ms_node_resources_release_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to release resources for src bin");
return ret;
/* Release resources for transform bin. Here we also consider
nodes that were not added by user explicitly (e.g. decodebin
was used). */
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->transform_bin),
- _ms_node_resources_release_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->transform_bin),
+ ms_node_resources_release_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to release resources for transform bin");
return ret;
}
/* Release resources for src bin */
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin),
- _ms_node_resources_release_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->sink_bin),
+ ms_node_resources_release_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to release resources for sink bin");
return ret;
case MEDIA_STREAMER_STATE_PAUSED:
case MEDIA_STREAMER_STATE_PLAYING:
/* After unprepare function call */
- ret = __ms_release_resources(ms_streamer);
+ ret = ms_release_resources(ms_streamer);
break;
case MEDIA_STREAMER_STATE_NONE:
case MEDIA_STREAMER_STATE_IDLE:
switch (ms_streamer->pend_state) {
case MEDIA_STREAMER_STATE_IDLE:
/* After prepare function */
- ret = __ms_acquire_resources(ms_streamer);
+ ret = ms_acquire_resources(ms_streamer);
break;
case MEDIA_STREAMER_STATE_PAUSED:
case MEDIA_STREAMER_STATE_PLAYING:
streamer->is_interrupted = TRUE;
if (MEDIA_STREAMER_ERROR_NONE !=
- __ms_pipeline_unprepare(streamer)) {
+ ms_pipeline_unprepare(streamer)) {
ms_error("Failed to unprepare streamer");
streamer->is_interrupted = FALSE;
g_mutex_unlock(&streamer->mutex_lock);
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "ms_streamer is NULL");
/* Acquire resources for src bin */
- ret = __ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin),
- _ms_node_policy_check_iter, ms_streamer);
+ ret = ms_bin_foreach_elements(GST_BIN(ms_streamer->src_bin),
+ ms_node_policy_check_iter, ms_streamer);
if (MEDIA_STREAMER_ERROR_NONE != ret) {
ms_error("Failed to check policies for src bin");
return ret;
#include <glib/gstdio.h>
#include <fcntl.h>
#include <sys/stat.h>
+#include <tizen-extension-client-protocol.h>
+#include <Ecore_Evas.h>
+#include <Ecore_Wl2.h>
#include "media_streamer.h"
#include "media_streamer_priv.h"
#include "media_streamer_util.h"
return instance;
}
-gchar *__ms_ini_get_string(const char *ini_path, const char *default_str)
+gchar *ms_ini_get_string(const char *ini_path, const char *default_str)
{
const char *result_str = default_str;
return g_strdup(result_str);
}
-void __ms_ini_read_list(const char *key, gchar ***list)
+void ms_ini_read_list(const char *key, gchar ***list)
{
const gchar *str;
}
-void __ms_load_ini_settings(media_streamer_ini_t *ini)
+void ms_load_ini_settings(media_streamer_ini_t *ini)
{
ms_debug_fenter();
ini->use_decodebin = iniparser_getboolean(__ms_get_ini_instance(), "general:use decodebin", DEFAULT_USE_DECODEBIN);
/* Read exclude elements list */
- __ms_ini_read_list("general:exclude elements", &ini->exclude_elem_names);
+ ms_ini_read_list("general:exclude elements", &ini->exclude_elem_names);
/* Read resource require elements list */
- __ms_ini_read_list("general:resource elements", &ini->resource_required_elem_names);
+ ms_ini_read_list("general:resource elements", &ini->resource_required_elem_names);
/* Read gstreamer arguments list */
- __ms_ini_read_list("general:gstreamer arguments", &ini->gst_args);
+ ms_ini_read_list("general:gstreamer arguments", &ini->gst_args);
} else {
/* if dict is not available just fill the structure with default values */
}
-const gchar *__ms_convert_mime_to_string_format(media_format_mimetype_e mime)
+const gchar *ms_convert_mime_to_string_format(media_format_mimetype_e mime)
{
gchar *format_name = NULL;
int it_format;
}
//LCOV_EXCL_START
-const gchar *__ms_convert_mime_to_rtp_format(media_format_mimetype_e mime)
+const gchar *ms_convert_mime_to_rtp_format(media_format_mimetype_e mime)
{
switch (mime) {
case MEDIA_FORMAT_I420:
}
//LCOV_EXCL_STOP
-media_format_mimetype_e __ms_convert_string_format_to_media_format(const char *format_type)
+media_format_mimetype_e ms_convert_string_format_to_media_format(const char *format_type)
{
media_format_mimetype_e mime = MEDIA_FORMAT_NATIVE_VIDEO;
int it_format;
return mime;
}
-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)
{
media_streamer_signal_s *sig_data;
ms_debug_fleave();
}
-void __ms_signal_destroy(void *data)
+void ms_signal_destroy(void *data)
{
media_streamer_signal_s *sig_data = (media_streamer_signal_s *) data;
ms_debug_fleave();
}
-void __ms_param_value_destroy(gpointer data)
+void ms_param_value_destroy(gpointer data)
{
GValue *val = (GValue *)data;
ms_debug_fleave();
}
-int __ms_util_uri_path_check(const char *file_uri)
+int ms_util_uri_path_check(const char *file_uri)
{
struct stat stat_results = {0, };
int file_open = 0;
return MEDIA_STREAMER_ERROR_NONE;
}
-int __ms_bin_foreach_elements(GstBin *bin, GstIteratorFoldFunction func, void *user_data)
+int ms_bin_foreach_elements(GstBin *bin, GstIteratorFoldFunction func, void *user_data)
{
media_streamer_s *streamer = (media_streamer_s *) user_data;
return MEDIA_STREAMER_ERROR_NONE;
}
+
+//LCOV_EXCL_START
+static void __global(void *data, struct wl_registry *registry,
+ uint32_t name, const char *interface, uint32_t version)
+{
+ struct tizen_surface **tz_surface = NULL;
+
+ if (!data) {
+ LOGE("NULL data");
+ return;
+ }
+
+ tz_surface = (struct tizen_surface **)data;
+
+ if (!interface) {
+ LOGW("NULL interface");
+ return;
+ }
+
+ if (strcmp(interface, "tizen_surface") == 0) {
+ LOGD("binding tizen surface for wayland");
+
+ *tz_surface = wl_registry_bind(registry, name, &tizen_surface_interface, 1);
+ if (*tz_surface == NULL)
+ LOGE("failed to bind");
+
+ LOGD("done");
+ }
+
+ return;
+}
+
+static void __global_remove(void *data, struct wl_registry *wl_registry, uint32_t name)
+{
+ LOGD("enter");
+ return;
+}
+
+static const struct wl_registry_listener _media_streamer_wl_registry_listener = {
+ __global,
+ __global_remove
+};
+
+static void __parent_id_getter(void *data, struct tizen_resource *tizen_resource, uint32_t id)
+{
+ if (!data) {
+ LOGE("NULL data");
+ return;
+ }
+
+ *((unsigned int *)data) = id;
+
+ LOGD("[CLIENT] got parent_id [%u] from server", id);
+
+ return;
+}
+
+static const struct tizen_resource_listener _media_streamer_tz_resource_listener = {
+ __parent_id_getter
+};
+
+int ms_get_wl_info(Evas_Object *obj, media_streamer_wl_info_s *wl_info)
+{
+ int ret = MEDIA_STREAMER_ERROR_NONE;
+ Ecore_Wl2_Window *window = NULL;
+ Ecore_Evas *ee = NULL;
+ Ecore_Wl2_Display *e_wl2_display = NULL;
+ Evas *e = NULL;
+ struct wl_display *display = NULL;
+ struct wl_display *display_wrapper = NULL;
+ struct wl_surface *surface = NULL;
+ struct wl_registry *registry = NULL;
+ struct wl_event_queue *queue = NULL;
+ struct tizen_surface *tz_surface = NULL;
+ struct tizen_resource *tz_resource = NULL;
+
+ if (!obj || !wl_info) {
+ LOGE("NULL parameter %p %p", obj, wl_info);
+ return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ }
+
+ e = evas_object_evas_get(obj);
+ if (!e) {
+ LOGE("failed to get evas object");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ ee = ecore_evas_ecore_evas_get(e);
+ if (!ee) {
+ LOGE("failed to get ecore evas object");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ window = ecore_evas_wayland2_window_get(ee);
+ if (!window) {
+ LOGE("failed to get wayland window");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ /* set video_has flag to a video application window */
+ ecore_wl2_window_video_has(window, EINA_TRUE);
+
+ surface = (struct wl_surface *)ecore_wl2_window_surface_get(window);
+ if (!surface) {
+ LOGE("failed to get wayland surface");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ e_wl2_display = ecore_wl2_connected_display_get(NULL);
+ if (!e_wl2_display) {
+ LOGE("failed to get ecore wl2 display");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ display = (struct wl_display *)ecore_wl2_display_get(e_wl2_display);
+ if (!display) {
+ LOGE("failed to get wayland display");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ display_wrapper = wl_proxy_create_wrapper(display);
+ if (!display_wrapper) {
+ LOGE("failed to create wl display wrapper");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ queue = wl_display_create_queue(display);
+ if (!queue) {
+ LOGE("failed to create wl display queue");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ wl_proxy_set_queue((struct wl_proxy *)display_wrapper, queue);
+
+ registry = wl_display_get_registry(display_wrapper);
+ if (!registry) {
+ LOGE("failed to get wayland registry");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ wl_registry_add_listener(registry, &_media_streamer_wl_registry_listener, &tz_surface);
+
+ wl_display_dispatch_queue(display, queue);
+ wl_display_roundtrip_queue(display, queue);
+
+ if (!tz_surface) {
+ LOGE("failed to get tizen surface");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ tz_resource = tizen_surface_get_tizen_resource(tz_surface, surface);
+ if (!tz_resource) {
+ LOGE("failed to get tizen resource");
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ goto _DONE;
+ }
+
+ wl_info->parent_id = 0;
+
+ tizen_resource_add_listener(tz_resource, &_media_streamer_tz_resource_listener, &wl_info->parent_id);
+
+ wl_display_roundtrip_queue(display, queue);
+
+ if (wl_info->parent_id > 0) {
+ LOGD("parent id : %u", wl_info->parent_id);
+ } else {
+ ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ LOGE("failed to get parent id");
+ }
+
+_DONE:
+ if (tz_surface) {
+ tizen_surface_destroy(tz_surface);
+ tz_surface = NULL;
+ }
+
+ if (tz_resource) {
+ tizen_resource_destroy(tz_resource);
+ tz_resource = NULL;
+ }
+
+ if (registry) {
+ wl_registry_destroy(registry);
+ registry = NULL;
+ }
+
+ if (queue) {
+ wl_event_queue_destroy(queue);
+ queue = NULL;
+ }
+
+ if (display_wrapper) {
+ wl_proxy_wrapper_destroy(display_wrapper);
+ display_wrapper = NULL;
+ }
+
+ return ret;
+}
+//LCOV_EXCL_STOP
\ No newline at end of file
projects / platform / core / api / mediastreamer.git / commitdiff