From: Eunhae Choi Date: Tue, 13 Oct 2015 05:02:57 +0000 (+0900) Subject: apply tizen coding rule X-Git-Tag: tizen_3.0.m2.a1_tv_release X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Ftags%2Ftizen_3.0.m2.a1_tv_release;p=platform%2Fcore%2Fapi%2Fmediastreamer.git apply tizen coding rule Change-Id: I6f5fac0d533bddeb06dd714bee125f423e480bf9 --- diff --git a/include/media_streamer.h b/include/media_streamer.h index d26c437..db5d8df 100644 --- a/include/media_streamer.h +++ b/include/media_streamer.h @@ -374,8 +374,7 @@ typedef enum { * @see media_streamer_unset_error_cb() */ typedef void (*media_streamer_error_cb)(media_streamer_h streamer, - media_streamer_error_e error, - void *user_data); + media_streamer_error_e error, void *user_data); /** * @brief Called when media streamer state is changed. @@ -391,9 +390,7 @@ typedef void (*media_streamer_error_cb)(media_streamer_h streamer, * @see media_streamer_unset_state_change_cb() */ typedef void (*media_streamer_state_changed_cb)(media_streamer_h streamer, - media_streamer_state_e previous_state, - media_streamer_state_e current_state, - void *user_data); + media_streamer_state_e previous_state, media_streamer_state_e current_state, void *user_data); /** * @brief Called when the custom source needs more data or has enough data. @@ -408,8 +405,7 @@ typedef void (*media_streamer_state_changed_cb)(media_streamer_h streamer, * @see media_streamer_node_set_param() */ typedef void (*media_streamer_custom_buffer_status_cb)(media_streamer_node_h node, - media_streamer_custom_buffer_status_e status, - void *user_data); + media_streamer_custom_buffer_status_e status, void *user_data); /** * @brief Called when new data is available from custom sink. @@ -424,8 +420,7 @@ typedef void (*media_streamer_custom_buffer_status_cb)(media_streamer_node_h nod * @see media_streamer_sink_set_data_ready_cb() * @see media_streamer_sink_unset_data_ready_cb() */ -typedef void (*media_streamer_sink_data_ready_cb)(media_streamer_node_h node, - void *user_data); +typedef void (*media_streamer_sink_data_ready_cb)(media_streamer_node_h node, void *user_data); /** * @brief Called when the end-of-stream has been reached. @@ -440,8 +435,7 @@ typedef void (*media_streamer_sink_data_ready_cb)(media_streamer_node_h node, * @see media_streamer_sink_set_eos_cb() * @see media_streamer_sink_unset_eos_cb() */ -typedef void (*media_streamer_sink_eos_cb)(media_streamer_node_h node, - void *user_data); +typedef void (*media_streamer_sink_eos_cb)(media_streamer_node_h node, void *user_data); /** * @brief Called when the seek operation is completed. @@ -475,9 +469,7 @@ typedef void (*media_streamer_position_changed_cb)(void *user_data); * @see media_streamer_unset_error_cb() * @see media_streamer_error_cb() */ -int media_streamer_set_error_cb(media_streamer_h streamer, - media_streamer_error_cb callback, - void *user_data); +int media_streamer_set_error_cb(media_streamer_h streamer, media_streamer_error_cb callback, void *user_data); /** * @brief Unregisters the error callback function. @@ -510,9 +502,7 @@ int media_streamer_unset_error_cb(media_streamer_h streamer); * @see media_streamer_unset_state_change_cb() * @see media_streamer_state_change_cb() */ -int media_streamer_set_state_change_cb(media_streamer_h streamer, - media_streamer_state_changed_cb callback, - void *user_data); +int media_streamer_set_state_change_cb(media_streamer_h streamer, media_streamer_state_changed_cb callback, void *user_data); /** * @brief Unregisters the state changed callback function. @@ -548,9 +538,7 @@ int media_streamer_unset_state_change_cb(media_streamer_h streamer); * @see media_streamer_src_unset_buffer_status_cb() * @see media_streamer_custom_buffer_status_cb() */ -int media_streamer_src_set_buffer_status_cb(media_streamer_node_h source, - media_streamer_custom_buffer_status_cb callback, - void *user_data); +int media_streamer_src_set_buffer_status_cb(media_streamer_node_h source, media_streamer_custom_buffer_status_cb callback, void *user_data); /** * @brief Unregisters the src buffer status callback function. @@ -585,9 +573,7 @@ int media_streamer_src_unset_buffer_status_cb(media_streamer_node_h source); * @see media_streamer_sink_unset_data_ready_cb() * @see media_streamer_sink_data_ready_cb() */ -int media_streamer_sink_set_data_ready_cb(media_streamer_node_h sink, - media_streamer_sink_data_ready_cb callback, - void *user_data); +int media_streamer_sink_set_data_ready_cb(media_streamer_node_h sink, media_streamer_sink_data_ready_cb callback, void *user_data); /** * @brief Unregisters the sink data ready callback function. @@ -621,9 +607,7 @@ int media_streamer_sink_unset_data_ready_cb(media_streamer_node_h sink); * @see media_streamer_sink_unset_eos_cb() * @see media_streamer_sink_eos_cb() */ -int media_streamer_sink_set_eos_cb(media_streamer_node_h sink, - media_streamer_sink_eos_cb callback, - void *user_data); +int media_streamer_sink_set_eos_cb(media_streamer_node_h sink, media_streamer_sink_eos_cb callback, void *user_data); /** * @brief Unregisters the sink end-of-stream callback function. @@ -788,11 +772,8 @@ int media_streamer_destroy(media_streamer_h streamer); * @post It invokes media_streamer_set_play_position() when seek operation completes, if you set a callback. * @see media_streamer_get_play_position() */ -int media_streamer_set_play_position(media_streamer_h streamer, - int time, - bool accurate, - media_streamer_position_changed_cb callback, - void *user_data); +int media_streamer_set_play_position(media_streamer_h streamer, int time, + bool accurate, media_streamer_position_changed_cb callback, void *user_data); /** * @brief Gets the current position in milliseconds. @@ -823,8 +804,7 @@ int media_streamer_get_play_position(media_streamer_h streamer, int *time); * @pre Create a media streamer handle by calling media_streamer_create() function * @see #media_streamer_state_e */ -int media_streamer_get_state(media_streamer_h streamer, - media_streamer_state_e *state); +int media_streamer_get_state(media_streamer_h streamer, media_streamer_state_e *state); /** * @brief Creates media streamer source node. @@ -847,8 +827,7 @@ int media_streamer_get_state(media_streamer_h streamer, * @see #media_streamer_node_src_type_e * @see media_streamer_node_destroy() */ -int media_streamer_node_create_src(media_streamer_node_src_type_e type, - media_streamer_node_h *src); +int media_streamer_node_create_src(media_streamer_node_src_type_e type, media_streamer_node_h *src); /** * @brief Pushes packet into custom source node. @@ -867,8 +846,7 @@ int media_streamer_node_create_src(media_streamer_node_src_type_e type, * @pre The media streamer state must be set to #MEDIA_STREAMER_STATE_IDLE at least. * @see #media_packet_h */ -int media_streamer_node_push_packet(media_streamer_node_h src, - media_packet_h packet); +int media_streamer_node_push_packet(media_streamer_node_h src, media_packet_h packet); /** * @brief Creates media streamer sink node. @@ -889,8 +867,7 @@ int media_streamer_node_push_packet(media_streamer_node_h src, * @see #media_streamer_node_sink_type_e * @see media_streamer_node_destroy() */ -int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, - media_streamer_node_h *sink); +int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, media_streamer_node_h *sink); /** * @brief Pulls packet from custom sink node. @@ -909,8 +886,7 @@ int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, * @see #media_packet_h * @see media_streamer_node_create_sink() */ -int media_streamer_node_pull_packet(media_streamer_node_h sink, - media_packet_h *packet); +int media_streamer_node_pull_packet(media_streamer_node_h sink, media_packet_h *packet); /** * @brief Creates media streamer node except MEDIA_STREAMER_NODE_TYPE_SRC and MEDIA_STREAMER_NODE_TYPE_SINK. @@ -933,10 +909,8 @@ int media_streamer_node_pull_packet(media_streamer_node_h sink, * @see #media_format_h * @see media_streamer_node_destroy() */ -int media_streamer_node_create(media_streamer_node_type_e type, - media_format_h in_fmt, - media_format_h out_fmt, - media_streamer_node_h *node); +int media_streamer_node_create(media_streamer_node_type_e type, media_format_h in_fmt, + media_format_h out_fmt, media_streamer_node_h *node); /** * @brief Adds node to media streamer. @@ -956,8 +930,7 @@ int media_streamer_node_create(media_streamer_node_type_e type, * @see media_streamer_node_create_src() * @see media_streamer_node_create_sink() */ -int media_streamer_node_add(media_streamer_h streamer, - media_streamer_node_h node); +int media_streamer_node_add(media_streamer_h streamer, media_streamer_node_h node); /** * @brief Destroys media streamer node. @@ -994,8 +967,7 @@ int media_streamer_node_destroy(media_streamer_node_h node); * @pre Add node to streamer by calling media_streamer_node_add() function * @see media_streamer_node_add() */ -int media_streamer_node_remove(media_streamer_h streamer, - media_streamer_node_h node); +int media_streamer_node_remove(media_streamer_h streamer, media_streamer_node_h node); /** * @brief Links two media streamer nodes. @@ -1024,10 +996,8 @@ int media_streamer_node_remove(media_streamer_h streamer, * @see media_streamer_node_create() * @see media_streamer_node_add() */ -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); +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); /** * @brief Sets media format for pad of media streamer node. @@ -1045,9 +1015,7 @@ int media_streamer_node_link(media_streamer_node_h src_node, * @pre Get pad name by calling media_streamer_node_get_pad_name() function * @see #media_format_h */ -int media_streamer_node_set_pad_format(media_streamer_node_h node, - const char *pad_name, - media_format_h fmt); +int media_streamer_node_set_pad_format(media_streamer_node_h node, const char *pad_name, media_format_h fmt); /** * @brief Gets media format for pad of media streamer node. @@ -1065,9 +1033,7 @@ int media_streamer_node_set_pad_format(media_streamer_node_h node, * @pre Get pad name by calling media_streamer_node_get_pad_name() function * @see #media_format_h */ -int media_streamer_node_get_pad_format(media_streamer_node_h node, - const char *pad_name, - media_format_h *fmt); +int media_streamer_node_get_pad_format(media_streamer_node_h node, const char *pad_name, media_format_h *fmt); /** * @brief Gets name of node pads. @@ -1091,11 +1057,8 @@ int media_streamer_node_get_pad_format(media_streamer_node_h node, * @see media_streamer_node_create_src() * @see media_streamer_node_create_sink() */ -int media_streamer_node_get_pad_name(media_streamer_node_h node, - char ***src_pad_name, - int *src_pad_num, - char ***sink_pad_name, - int *sink_pad_num); +int 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); /** @@ -1117,8 +1080,7 @@ int media_streamer_node_get_pad_name(media_streamer_node_h node, * @see media_streamer_node_create_sink() * @see media_streamer_node_get_params() */ -int media_streamer_node_set_params(media_streamer_node_h node, - bundle *param_list); +int media_streamer_node_set_params(media_streamer_node_h node, bundle *param_list); /** * @brief Gets node parameter list. * @since_tizen 3.0 @@ -1140,8 +1102,7 @@ int media_streamer_node_set_params(media_streamer_node_h node, * @see media_streamer_node_set_params() * @see media_streamer_node_set_param() */ -int media_streamer_node_get_params(media_streamer_node_h node, - bundle **param_list); +int media_streamer_node_get_params(media_streamer_node_h node, bundle **param_list); /** * @brief Sets single parameter of node. @@ -1165,7 +1126,7 @@ int media_streamer_node_get_params(media_streamer_node_h node, * @see media_streamer_node_get_param() */ int media_streamer_node_set_param(media_streamer_node_h node, - const char *param_name, const char *param_value); + const char *param_name, const char *param_value); /** @@ -1190,7 +1151,7 @@ int media_streamer_node_set_param(media_streamer_node_h node, * @see media_streamer_node_set_param() */ int media_streamer_node_get_param(media_streamer_node_h node, - const char *param_name, char **param_value); + const char *param_name, char **param_value); /** * @} diff --git a/include/media_streamer_gst.h b/include/media_streamer_gst.h index 6e9b9bd..a9cc18e 100755 --- a/include/media_streamer_gst.h +++ b/include/media_streamer_gst.h @@ -49,18 +49,15 @@ void __ms_generate_dots(GstElement *bin, gchar *name_tag); * * @since_tizen 3.0 */ -GstElement *__ms_bin_find_element_by_klass(GstElement *sink_bin, - GstElement *previous_elem, - const gchar *klass_name, - const gchar *bin_name); +GstElement *__ms_bin_find_element_by_klass(GstElement *sink_bin, GstElement *previous_elem, + const gchar *klass_name, const gchar *bin_name); /** * @brief Creates GstElement by klass name. * * @since_tizen 3.0 */ -GstElement *__ms_create_element_by_registry(GstPad *src_pad, - const gchar *klass_name); +GstElement *__ms_create_element_by_registry(GstPad *src_pad, const gchar *klass_name); /** * @brief Links two Gstelements and returns the last one. @@ -68,8 +65,7 @@ GstElement *__ms_create_element_by_registry(GstPad *src_pad, * @since_tizen 3.0 */ GstElement *__ms_link_with_new_element(GstElement *previous_element, - GstElement *new_element, - const gchar *next_elem_bin_name); + GstElement *new_element, const gchar *next_elem_bin_name); /** * @brief Creates GstElement by plugin name. @@ -118,12 +114,8 @@ GstElement *__ms_rtp_element_create(media_streamer_node_s *ms_node); * * @since_tizen 3.0 */ -gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node, - GstElement **rtp_elem, - GstElement **rtcp_elem, - const gchar *elem_name, - const gchar *direction, - gboolean auto_create); +gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node, GstElement **rtp_elem, + GstElement **rtcp_elem, const gchar *elem_name, const gchar *direction, gboolean auto_create); /** * @brief Converts key-value property into needed GType @@ -131,8 +123,7 @@ gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node, * * @since_tizen 3.0 */ -gboolean __ms_element_set_property(GstElement *src_element, - const char *key, const gchar *param_value); +gboolean __ms_element_set_property(GstElement *src_element, const char *key, const gchar *param_value); /** * @brief Unlink all pads into GstElement. @@ -160,11 +151,7 @@ gboolean __ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ * * @since_tizen 3.0 */ -gint __ms_decodebin_autoplug_select(GstElement *bin, - GstPad *pad, - GstCaps *caps, - GstElementFactory *factory, - gpointer data); +gint __ms_decodebin_autoplug_select(GstElement *bin, GstPad *pad, GstCaps *caps, GstElementFactory *factory, gpointer data); /** * @brief Callback function to link decodebin with the sink element at the streamer part. @@ -192,10 +179,7 @@ void __decodebin_newpad_client_cb(GstElement *decodebin, GstPad *pad, gpointer u * * @since_tizen 3.0 */ -GstElement *__ms_combine_next_element(GstElement *previous_element, - const gchar *next_elem_klass_name, - const gchar *next_elem_bin_name, - gchar *default_element); +GstElement *__ms_combine_next_element(GstElement *previous_element, const gchar *next_elem_klass_name, const gchar *next_elem_bin_name, gchar *default_element); /** * @brief Creates pipeline, bus and src/sink/topology bins. diff --git a/include/media_streamer_node.h b/include/media_streamer_node.h index 8e58895..51205e5 100644 --- a/include/media_streamer_node.h +++ b/include/media_streamer_node.h @@ -21,18 +21,14 @@ * * @since_tizen 3.0 */ -int __ms_node_set_property(media_streamer_node_s *ms_node, - const gchar *param_key, - const gchar *param_value); +int __ms_node_set_property(media_streamer_node_s *ms_node, const gchar *param_key, const gchar *param_value); /** * @brief Creates media streamer node using input and output format. * * @since_tizen 3.0 */ -int __ms_node_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. @@ -60,8 +56,7 @@ void __ms_node_destroy(media_streamer_node_s *node); * * @since_tizen 3.0 */ -int __ms_node_insert_into_table(GHashTable *nodes_table, - media_streamer_node_s *ms_node); +int __ms_node_insert_into_table(GHashTable *nodes_table, media_streamer_node_s *ms_node); /** * @brief Removes media streamer node from nodes table. @@ -90,21 +85,18 @@ int __ms_pipeline_unprepare(media_streamer_s *ms_streamer); * * @since_tizen 3.0 */ -int __ms_node_read_params_from_bundle(media_streamer_node_s *node, - bundle *param_list); +int __ms_node_read_params_from_bundle(media_streamer_node_s *node, bundle *param_list); /** * @brief Writes GstElement properties into user's bundle object. * * @since_tizen 3.0 */ -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 Writes GstElement property into user's value. * * @since_tizen 3.0 */ -int __ms_node_write_param_into_value(media_streamer_node_s *node, - const char *param_name, char **param_value); \ No newline at end of file +int __ms_node_write_param_into_value(media_streamer_node_s *node, const char *param_name, char **param_value); diff --git a/include/media_streamer_priv.h b/include/media_streamer_priv.h index 188cb51..d7df7d0 100755 --- a/include/media_streamer_priv.h +++ b/include/media_streamer_priv.h @@ -85,10 +85,7 @@ typedef struct { * * @since_tizen 3.0 */ -typedef int (*ms_node_set_param)( - struct media_streamer_node_s *node, - const char *param_key, - const char *param_value); +typedef int (*ms_node_set_param)(struct media_streamer_node_s *node, const char *param_key, const char *param_value); /** * @brief Media Streamer node type handle. @@ -145,7 +142,7 @@ int __ms_state_change(media_streamer_s *ms_streamer, media_streamer_state_e stat * @since_tizen 3.0 */ void __ms_node_check_param_name(GstElement *element, gboolean name_is_known, - const char *param_name, char **init_param_name); + const char *param_name, char **init_param_name); #ifdef __cplusplus } diff --git a/include/media_streamer_util.h b/include/media_streamer_util.h index adfb9f6..dc87448 100755 --- a/include/media_streamer_util.h +++ b/include/media_streamer_util.h @@ -44,42 +44,42 @@ extern "C" { #define ms_debug(fmt, arg...) do { \ LOGD(FONT_COLOR_RESET""fmt"", ##arg); \ - } while(0) + } while (0) #define ms_info(fmt, arg...) do { \ LOGI(FONT_COLOR_GREEN""fmt"", ##arg); \ - } while(0) + } while (0) #define ms_error(fmt, arg...) do { \ LOGE(FONT_COLOR_RED""fmt"", ##arg); \ - } while(0) + } while (0) #define ms_debug_fenter() do { \ LOGD(FONT_COLOR_YELLOW""); \ - } while(0) + } while (0) #define ms_debug_fleave() do { \ LOGD(FONT_COLOR_PURPLE""); \ - } while(0) + } while (0) #define ms_retm_if(expr, fmt, arg...) do { \ - if(expr) { \ + if (expr) { \ LOGE(FONT_COLOR_RED""fmt"", ##arg); \ return; \ } \ - } while(0) + } while (0) #define ms_retvm_if(expr, val, fmt, arg...) do { \ - if(expr) { \ + if (expr) { \ LOGE(FONT_COLOR_RED""fmt"", ##arg); \ return(val); \ } \ - } while(0) + } while (0) -#define MS_SAFE_FREE(src) {if(src) {free(src); src = NULL;}} -#define MS_SAFE_GFREE(src) {if(src) {g_free(src); src = NULL;}} -#define MS_SAFE_UNREF(src) {if(src) {gst_object_unref(GST_OBJECT(src)); src = NULL;}} -#define MS_TABLE_SAFE_UNREF(src) {if(src) {g_hash_table_unref(src); src = NULL;}} +#define MS_SAFE_FREE(src) {if (src) { free(src); src = NULL; } } +#define MS_SAFE_GFREE(src) {if (src) { g_free(src); src = NULL; } } +#define MS_SAFE_UNREF(src) {if (src) { gst_object_unref(GST_OBJECT(src)); src = NULL; } } +#define MS_TABLE_SAFE_UNREF(src) {if (src) { g_hash_table_unref(src); src = NULL; } } /* Ini Utils */ #define MEDIA_STREAMER_INI_DEFAULT_PATH "/usr/etc/media_streamer.ini" @@ -231,8 +231,7 @@ gboolean __ms_destroy_ini_dictionary(dictionary *dict); * * @since_tizen 3.0 */ -gchar *__ms_ini_get_string(dictionary *dict, const char *ini_path, - char *default_str); +gchar *__ms_ini_get_string(dictionary *dict, const char *ini_path, char *default_str); /** * @brief Converts Media Format mime type into Caps media format string. diff --git a/src/media_streamer.c b/src/media_streamer.c index 0a40f52..902a9e4 100755 --- a/src/media_streamer.c +++ b/src/media_streamer.c @@ -28,19 +28,18 @@ * Public Implementation */ -int media_streamer_node_create_src(media_streamer_node_src_type_e type, - media_streamer_node_h *src) +int media_streamer_node_create_src(media_streamer_node_src_type_e type, media_streamer_node_h * src) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_node_s *ms_src = (media_streamer_node_s *)src; + media_streamer_node_s *ms_src = (media_streamer_node_s *) src; ms_retvm_if(ms_src == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_src = (media_streamer_node_s *)calloc(1, sizeof(media_streamer_node_s)); + ms_src = (media_streamer_node_s *) calloc(1, sizeof(media_streamer_node_s)); ms_retvm_if(ms_src == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error allocation memory"); ms_src->type = MEDIA_STREAMER_NODE_TYPE_SRC; - ms_src->subtype = (media_streamer_node_src_type_e)type; + ms_src->subtype = (media_streamer_node_src_type_e) type; ret = __ms_src_node_create(ms_src); if (ret != MEDIA_STREAMER_ERROR_NONE) { @@ -50,24 +49,23 @@ int media_streamer_node_create_src(media_streamer_node_src_type_e type, } ms_info("Source node [%s] created", ms_src->name); - *src = (media_streamer_node_h)ms_src; + *src = (media_streamer_node_h) ms_src; return ret; } -int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, - media_streamer_node_h *sink) +int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, media_streamer_node_h * sink) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_node_s *ms_sink = (media_streamer_node_s *)sink; + media_streamer_node_s *ms_sink = (media_streamer_node_s *) sink; ms_retvm_if(ms_sink == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_sink = (media_streamer_node_s *)calloc(1, sizeof(media_streamer_node_s)); + ms_sink = (media_streamer_node_s *) calloc(1, sizeof(media_streamer_node_s)); ms_retvm_if(ms_sink == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error allocation memory"); ms_sink->type = MEDIA_STREAMER_NODE_TYPE_SINK; - ms_sink->subtype = (media_streamer_node_sink_type_e)type; + ms_sink->subtype = (media_streamer_node_sink_type_e) type; ret = __ms_sink_node_create(ms_sink); if (ret != MEDIA_STREAMER_ERROR_NONE) { @@ -77,22 +75,19 @@ int media_streamer_node_create_sink(media_streamer_node_sink_type_e type, } ms_info("Sink node [%s] created", ms_sink->name); - *sink = (media_streamer_node_h)ms_sink; + *sink = (media_streamer_node_h) ms_sink; return ret; } -int media_streamer_node_create(media_streamer_node_type_e type, - media_format_h in_fmt, - media_format_h out_fmt, - media_streamer_node_h *node) +int media_streamer_node_create(media_streamer_node_type_e type, media_format_h in_fmt, media_format_h out_fmt, media_streamer_node_h * node) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_node = (media_streamer_node_s *)calloc(1, sizeof(media_streamer_node_s)); + ms_node = (media_streamer_node_s *) calloc(1, sizeof(media_streamer_node_s)); ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error allocation memory"); ms_node->type = type; @@ -106,14 +101,14 @@ int media_streamer_node_create(media_streamer_node_type_e type, } ms_info("Node [%s] created", ms_node->name); - *node = (media_streamer_node_h)ms_node; + *node = (media_streamer_node_h) ms_node; return ret; } int media_streamer_node_destroy(media_streamer_node_h node) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); if (ms_node->parent_streamer == NULL) { @@ -127,25 +122,22 @@ int media_streamer_node_destroy(media_streamer_node_h node) return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_node_remove(media_streamer_h streamer, - media_streamer_node_h node) +int media_streamer_node_remove(media_streamer_h streamer, media_streamer_node_h node) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, - "Error: Media streamer must be in IDLE state"); + ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be in IDLE state"); - ms_retvm_if(ms_streamer != ms_node->parent_streamer, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, - "Node [%s] added into another Media Streamer object", ms_node->name); + ms_retvm_if(ms_streamer != ms_node->parent_streamer, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Node [%s] added into another Media Streamer object", ms_node->name); int ret = MEDIA_STREAMER_ERROR_NONE; g_mutex_lock(&ms_streamer->mutex_lock); - if (g_hash_table_remove(ms_streamer->nodes_table, (gpointer)ms_node->name)) { + if (g_hash_table_remove(ms_streamer->nodes_table, (gpointer) ms_node->name)) { ms_info("Node [%s] removed from Media Streamer", ms_node->name); } else { ms_error("Error: Node [%s] remove failed", ms_node->name); @@ -157,22 +149,19 @@ int media_streamer_node_remove(media_streamer_h streamer, return ret; } -int media_streamer_node_add(media_streamer_h streamer, - media_streamer_node_h node) +int media_streamer_node_add(media_streamer_h streamer, media_streamer_node_h node) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, - "Error: Media streamer must be in IDLE state"); + ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be in IDLE state"); - ms_retvm_if(ms_node->parent_streamer != NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, - "Node [%s] already added into Media Streamer object", ms_node->name); + ms_retvm_if(ms_node->parent_streamer != NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Node [%s] already added into Media Streamer object", ms_node->name); g_mutex_lock(&ms_streamer->mutex_lock); @@ -189,10 +178,9 @@ int media_streamer_node_add(media_streamer_h streamer, int media_streamer_prepare(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, - "Error: Media streamer already prepared"); + ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer already prepared"); int ret = MEDIA_STREAMER_ERROR_NONE; g_mutex_lock(&ms_streamer->mutex_lock); @@ -203,9 +191,8 @@ int media_streamer_prepare(media_streamer_h streamer) ret = __ms_pipeline_prepare(ms_streamer); - if (ret == MEDIA_STREAMER_ERROR_NONE) { + if (ret == MEDIA_STREAMER_ERROR_NONE) ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY); - } __ms_generate_dots(ms_streamer->pipeline, "after_prepare"); __ms_generate_dots(ms_streamer->sink_audio_bin, "after_prepare_audio"); @@ -218,10 +205,9 @@ int media_streamer_prepare(media_streamer_h streamer) int media_streamer_unprepare(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_streamer->state < MEDIA_STREAMER_STATE_READY, MEDIA_STREAMER_ERROR_INVALID_STATE, - "Error: Media streamer must be prepared first!"); + ms_retvm_if(ms_streamer->state < MEDIA_STREAMER_STATE_READY, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be prepared first!"); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -233,9 +219,8 @@ int media_streamer_unprepare(media_streamer_h streamer) ret = __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE); - if (ret == MEDIA_STREAMER_ERROR_NONE) { + if (ret == MEDIA_STREAMER_ERROR_NONE) ret = __ms_pipeline_unprepare(ms_streamer); - } __ms_generate_dots(ms_streamer->sink_audio_bin, "after_unprepare_audio"); __ms_generate_dots(ms_streamer->sink_video_bin, "after_unprepare_video"); @@ -248,10 +233,9 @@ int media_streamer_unprepare(media_streamer_h streamer) int media_streamer_play(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_streamer->state < MEDIA_STREAMER_STATE_READY, MEDIA_STREAMER_ERROR_INVALID_STATE, - "Error: Media streamer must be prepared first!"); + ms_retvm_if(ms_streamer->state < MEDIA_STREAMER_STATE_READY, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be prepared first!"); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -264,11 +248,11 @@ int media_streamer_play(media_streamer_h streamer) return ret; } -int media_streamer_create(media_streamer_h *streamer) +int media_streamer_create(media_streamer_h * streamer) { ms_retvm_if(streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - media_streamer_s *ms_streamer = (media_streamer_s *)calloc(1, sizeof(media_streamer_s)); + media_streamer_s *ms_streamer = (media_streamer_s *) calloc(1, sizeof(media_streamer_s)); ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error allocation memory"); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -293,19 +277,16 @@ int media_streamer_create(media_streamer_h *streamer) int media_streamer_destroy(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle 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!"); + ms_retvm_if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be unprepared before destroying!"); return __ms_streamer_destroy(ms_streamer); } -int media_streamer_set_error_cb(media_streamer_h streamer, - media_streamer_error_cb callback, - void *data) +int media_streamer_set_error_cb(media_streamer_h streamer, media_streamer_error_cb callback, void *data) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(callback == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Callback is NULL"); @@ -321,7 +302,7 @@ int media_streamer_set_error_cb(media_streamer_h streamer, int media_streamer_unset_error_cb(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); g_mutex_lock(&ms_streamer->mutex_lock); @@ -334,11 +315,9 @@ int media_streamer_unset_error_cb(media_streamer_h streamer) return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_set_state_change_cb(media_streamer_h streamer, - media_streamer_state_changed_cb callback, - void *data) +int media_streamer_set_state_change_cb(media_streamer_h streamer, media_streamer_state_changed_cb callback, void *data) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(callback == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Callback is NULL"); @@ -354,7 +333,7 @@ int media_streamer_set_state_change_cb(media_streamer_h streamer, int media_streamer_unset_state_change_cb(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); g_mutex_lock(&ms_streamer->mutex_lock); @@ -367,11 +346,9 @@ int media_streamer_unset_state_change_cb(media_streamer_h streamer) return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_src_set_buffer_status_cb(media_streamer_node_h source, - media_streamer_custom_buffer_status_cb callback, - void *user_data) +int media_streamer_src_set_buffer_status_cb(media_streamer_node_h source, media_streamer_custom_buffer_status_cb callback, void *user_data) { - media_streamer_node_s *ms_src = (media_streamer_node_s *)source; + media_streamer_node_s *ms_src = (media_streamer_node_s *) source; media_streamer_callback_s *src_callback = NULL; ms_retvm_if(ms_src == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); @@ -379,7 +356,7 @@ int media_streamer_src_set_buffer_status_cb(media_streamer_node_h source, src_callback = (media_streamer_callback_s *) calloc(1, sizeof(media_streamer_callback_s)); ms_retvm_if(src_callback == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error allocation memory"); } else { - src_callback = (media_streamer_callback_s *)ms_src->callbacks_structure; + src_callback = (media_streamer_callback_s *) ms_src->callbacks_structure; } src_callback->callback = callback; @@ -391,7 +368,7 @@ int media_streamer_src_set_buffer_status_cb(media_streamer_node_h source, int media_streamer_src_unset_buffer_status_cb(media_streamer_node_h source) { - media_streamer_node_s *ms_src = (media_streamer_node_s *)source; + media_streamer_node_s *ms_src = (media_streamer_node_s *) source; ms_retvm_if(ms_src == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); media_streamer_callback_s *src_callback = (media_streamer_callback_s *) ms_src->callbacks_structure; @@ -401,11 +378,9 @@ int media_streamer_src_unset_buffer_status_cb(media_streamer_node_h source) return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_sink_set_data_ready_cb(media_streamer_node_h sink, - media_streamer_sink_data_ready_cb callback, - void *data) +int media_streamer_sink_set_data_ready_cb(media_streamer_node_h sink, media_streamer_sink_data_ready_cb callback, void *data) { - media_streamer_node_s *ms_sink = (media_streamer_node_s *)sink; + media_streamer_node_s *ms_sink = (media_streamer_node_s *) sink; ms_retvm_if(ms_sink == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); media_streamer_sink_callbacks_s *sink_callbacks = ms_sink->callbacks_structure; @@ -423,7 +398,7 @@ int media_streamer_sink_set_data_ready_cb(media_streamer_node_h sink, int media_streamer_sink_unset_data_ready_cb(media_streamer_node_h sink) { - media_streamer_node_s *ms_sink = (media_streamer_node_s *)sink; + media_streamer_node_s *ms_sink = (media_streamer_node_s *) sink; ms_retvm_if(ms_sink == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); media_streamer_sink_callbacks_s *sink_callbacks = ms_sink->callbacks_structure; @@ -436,11 +411,9 @@ int media_streamer_sink_unset_data_ready_cb(media_streamer_node_h sink) return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_sink_set_eos_cb(media_streamer_node_h sink, - media_streamer_sink_eos_cb callback, - void *data) +int media_streamer_sink_set_eos_cb(media_streamer_node_h sink, media_streamer_sink_eos_cb callback, void *data) { - media_streamer_node_s *ms_sink = (media_streamer_node_s *)sink; + media_streamer_node_s *ms_sink = (media_streamer_node_s *) sink; ms_retvm_if(ms_sink == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); media_streamer_sink_callbacks_s *sink_callbacks = ms_sink->callbacks_structure; @@ -458,7 +431,7 @@ int media_streamer_sink_set_eos_cb(media_streamer_node_h sink, int media_streamer_sink_unset_eos_cb(media_streamer_node_h sink) { - media_streamer_node_s *ms_sink = (media_streamer_node_s *)sink; + media_streamer_node_s *ms_sink = (media_streamer_node_s *) sink; ms_retvm_if(ms_sink == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); media_streamer_sink_callbacks_s *sink_callbacks = ms_sink->callbacks_structure; @@ -473,10 +446,9 @@ int media_streamer_sink_unset_eos_cb(media_streamer_node_h sink) int media_streamer_pause(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_streamer->state != MEDIA_STREAMER_STATE_PLAYING, MEDIA_STREAMER_ERROR_INVALID_STATE, - "Error: Media streamer must be in PLAYING state."); + ms_retvm_if(ms_streamer->state != MEDIA_STREAMER_STATE_PLAYING, MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be in PLAYING state."); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -491,12 +463,9 @@ int media_streamer_pause(media_streamer_h streamer) int media_streamer_stop(media_streamer_h streamer) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(!(ms_streamer->state == MEDIA_STREAMER_STATE_PLAYING - || ms_streamer->state == MEDIA_STREAMER_STATE_PAUSED), - MEDIA_STREAMER_ERROR_INVALID_STATE, - "Error: Media streamer must be in PLAYING or PAUSED state."); + ms_retvm_if(!(ms_streamer->state == MEDIA_STREAMER_STATE_PLAYING || ms_streamer->state == MEDIA_STREAMER_STATE_PAUSED), MEDIA_STREAMER_ERROR_INVALID_STATE, "Error: Media streamer must be in PLAYING or PAUSED state."); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -510,10 +479,9 @@ int media_streamer_stop(media_streamer_h streamer) return ret; } -int media_streamer_get_state(media_streamer_h streamer, - media_streamer_state_e *state) +int media_streamer_get_state(media_streamer_h streamer, media_streamer_state_e * state) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); *state = ms_streamer->state; @@ -521,19 +489,12 @@ int media_streamer_get_state(media_streamer_h streamer, return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_set_play_position(media_streamer_h streamer, - int time, - bool accurate, - media_streamer_position_changed_cb callback, - void *user_data) +int media_streamer_set_play_position(media_streamer_h streamer, int time, bool accurate, media_streamer_position_changed_cb callback, void *user_data) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_streamer->state < MEDIA_STREAMER_STATE_READY || - ms_streamer->state > MEDIA_STREAMER_STATE_PAUSED, - MEDIA_STREAMER_ERROR_INVALID_STATE, - "The media streamer state is not in the appropriate state"); + ms_retvm_if(ms_streamer->state < MEDIA_STREAMER_STATE_READY || ms_streamer->state > MEDIA_STREAMER_STATE_PAUSED, MEDIA_STREAMER_ERROR_INVALID_STATE, "The media streamer state is not in the appropriate state"); /* Notify: the seeking must be reseted while streamer got ASYNC_DONE message */ ms_retvm_if(ms_streamer->is_seeking, MEDIA_STREAMER_ERROR_INVALID_STATE, "Media streamer is seeking"); @@ -553,52 +514,43 @@ int media_streamer_set_play_position(media_streamer_h streamer, int media_streamer_get_play_position(media_streamer_h streamer, int *time) { - media_streamer_s *ms_streamer = (media_streamer_s *)streamer; + media_streamer_s *ms_streamer = (media_streamer_s *) streamer; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_node_push_packet(media_streamer_node_h src, - media_packet_h packet) +int media_streamer_node_push_packet(media_streamer_node_h src, media_packet_h packet) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)src; + media_streamer_node_s *ms_node = (media_streamer_node_s *) src; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_node->type != MEDIA_STREAMER_NODE_TYPE_SRC, - MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Node type must be Src type for pushing packets."); - ms_retvm_if(ms_node->subtype != MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM, - MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Source Node must be a custom type for pushing packets."); + ms_retvm_if(ms_node->type != MEDIA_STREAMER_NODE_TYPE_SRC, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Node type must be Src type for pushing packets."); + ms_retvm_if(ms_node->subtype != MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Source Node must be a custom type for pushing packets."); return __ms_element_push_packet(ms_node->gst_element, packet); } -int media_streamer_node_pull_packet(media_streamer_node_h sink, - media_packet_h *packet) +int media_streamer_node_pull_packet(media_streamer_node_h sink, media_packet_h * packet) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)sink; + media_streamer_node_s *ms_node = (media_streamer_node_s *) sink; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(packet == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Media packet is NULL"); ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_node->type != MEDIA_STREAMER_NODE_TYPE_SINK, - MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Node type must be Sink type for pulling packets."); - ms_retvm_if(ms_node->subtype != MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM, - MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Sink Node must be a custom type for pulling packets."); + ms_retvm_if(ms_node->type != MEDIA_STREAMER_NODE_TYPE_SINK, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Node type must be Sink type for pulling packets."); + ms_retvm_if(ms_node->subtype != MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Sink Node must be a custom type for pulling packets."); 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) +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) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_node_s *ms_src_node = (media_streamer_node_s *)src_node; + media_streamer_node_s *ms_src_node = (media_streamer_node_s *) src_node; ms_retvm_if(ms_src_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - media_streamer_node_s *ms_dest_node = (media_streamer_node_s *)dest_node; + media_streamer_node_s *ms_dest_node = (media_streamer_node_s *) dest_node; ms_retvm_if(ms_dest_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(src_pad_name == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Pad is NULL"); @@ -608,12 +560,9 @@ int media_streamer_node_link(media_streamer_node_h src_node, gchar *sink_element_name = gst_element_get_name(ms_dest_node->gst_element); gboolean link_ret = gst_element_link_pads(ms_src_node->gst_element, src_pad_name, - ms_dest_node->gst_element, sink_pad_name); + ms_dest_node->gst_element, sink_pad_name); if (!link_ret) { - ms_error("Can not link [%s]->%s pad to [%s]->%s pad, ret code [%d] ", - ms_src_node->name, src_pad_name, - ms_dest_node->name, sink_pad_name, - link_ret); + ms_error("Can not link [%s]->%s pad to [%s]->%s pad, ret code [%d] ", ms_src_node->name, src_pad_name, ms_dest_node->name, sink_pad_name, link_ret); ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; } else { ms_src_node->linked_by_user = TRUE; @@ -625,23 +574,19 @@ int media_streamer_node_link(media_streamer_node_h src_node, return ret; } -int media_streamer_node_set_pad_format(media_streamer_node_h node, - const char *pad_name, - media_format_h fmt) +int media_streamer_node_set_pad_format(media_streamer_node_h node, const char *pad_name, media_format_h fmt) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(fmt == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Format is NULL"); - /* By default it sets format to object's property 'caps'*/ + /* By default it sets format to object's property 'caps' */ return __ms_element_set_fmt(node, pad_name, fmt); } -int media_streamer_node_get_pad_format(media_streamer_node_h node, - const char *pad_name, - media_format_h *fmt) +int media_streamer_node_get_pad_format(media_streamer_node_h node, const char *pad_name, media_format_h * fmt) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(pad_name == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Empty pad name"); ms_retvm_if(fmt == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Format is NULL"); @@ -653,14 +598,10 @@ int media_streamer_node_get_pad_format(media_streamer_node_h node, return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_node_get_pad_name(media_streamer_node_h node, - char ***src_pad_name, - int *src_pad_num, - char ***sink_pad_name, - int *sink_pad_num) +int media_streamer_node_get_pad_name(media_streamer_node_h node, char ***src_pad_name, int *src_pad_num, char ***sink_pad_name, int *sink_pad_num) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(src_pad_name == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Empty src pad name"); @@ -678,27 +619,24 @@ int media_streamer_node_get_pad_name(media_streamer_node_h node, return ret; } -int media_streamer_node_set_params(media_streamer_node_h node, - bundle *param_list) +int media_streamer_node_set_params(media_streamer_node_h node, bundle * param_list) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(ms_node->gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(param_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Parameters list is NULL"); ret = __ms_node_read_params_from_bundle(ms_node, param_list); - ms_retvm_if(ret != MEDIA_STREAMER_ERROR_NONE, MEDIA_STREAMER_ERROR_INVALID_OPERATION, - "Parameters list is NULL"); + ms_retvm_if(ret != MEDIA_STREAMER_ERROR_NONE, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Parameters list is NULL"); return ret; } -int media_streamer_node_get_params(media_streamer_node_h node, - bundle **param_list) +int media_streamer_node_get_params(media_streamer_node_h node, bundle ** param_list) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(param_list == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Param list pionter is NULL"); @@ -718,23 +656,19 @@ int media_streamer_node_get_params(media_streamer_node_h node, return MEDIA_STREAMER_ERROR_NONE; } -int media_streamer_node_set_param(media_streamer_node_h node, - const char *param_name, const char *param_value) +int media_streamer_node_set_param(media_streamer_node_h node, const char *param_name, const char *param_value) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(ms_node->gst_element == NULL && ms_node->set_param, - MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); - ms_retvm_if(param_name == NULL || param_value == NULL, - MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Parameters name or value is NULL"); + ms_retvm_if(ms_node->gst_element == NULL && ms_node->set_param, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); + ms_retvm_if(param_name == NULL || param_value == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Parameters name or value is NULL"); return ms_node->set_param((struct media_streamer_node_s *)ms_node, param_name, param_value); } -int media_streamer_node_get_param(media_streamer_node_h node, - const char *param_name, char **param_value) +int media_streamer_node_get_param(media_streamer_node_h node, const char *param_name, char **param_value) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)node; + media_streamer_node_s *ms_node = (media_streamer_node_s *) node; ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(param_name == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Param name is NULL"); ms_retvm_if(param_value == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Param value is NULL"); @@ -750,4 +684,3 @@ int media_streamer_node_get_param(media_streamer_node_h node, *param_value = ms_param; return MEDIA_STREAMER_ERROR_NONE; } - diff --git a/src/media_streamer_gst.c b/src/media_streamer_gst.c index ad6748b..d6ac506 100755 --- a/src/media_streamer_gst.c +++ b/src/media_streamer_gst.c @@ -22,25 +22,22 @@ gst_pad_unlink(peer, pad) #define H264_PARSER_CONFIG_INTERVAL 5 -void __ms_generate_dots(GstElement *bin, gchar *name_tag) +void __ms_generate_dots(GstElement * bin, gchar * name_tag) { gchar *dot_name; ms_retm_if(bin == NULL, "Handle is NULL"); - if (!name_tag) { + if (!name_tag) dot_name = g_strdup(DOT_FILE_NAME); - } else { + else dot_name = g_strconcat(DOT_FILE_NAME, ".", name_tag, NULL); - } GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(GST_BIN(bin), GST_DEBUG_GRAPH_SHOW_ALL, dot_name); MS_SAFE_GFREE(dot_name); } -static int __ms_add_no_target_ghostpad(GstElement *gst_bin, - const char *ghost_pad_name, - GstPadDirection pad_direction) +static int __ms_add_no_target_ghostpad(GstElement * gst_bin, const char *ghost_pad_name, GstPadDirection pad_direction) { int ret = MEDIA_STREAMER_ERROR_NONE; @@ -57,10 +54,8 @@ static int __ms_add_no_target_ghostpad(GstElement *gst_bin, MS_SAFE_GFREE(bin_name); return ret; } -static int __ms_add_ghostpad(GstElement *gst_element, - const char *pad_name, - GstElement *gst_bin, - const char *ghost_pad_name) + +static int __ms_add_ghostpad(GstElement * gst_element, const char *pad_name, GstElement * gst_bin, const char *ghost_pad_name) { ms_retvm_if(!gst_element || !pad_name || !ghost_pad_name || !gst_bin, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); @@ -86,8 +81,7 @@ static int __ms_add_ghostpad(GstElement *gst_element, ret = MEDIA_STREAMER_ERROR_NONE; } else { - ms_error("Error: element [%s] does not have valid [%s] pad for adding into [%s] bin", - element_name, pad_name, bin_name); + ms_error("Error: element [%s] does not have valid [%s] pad for adding into [%s] bin", element_name, pad_name, bin_name); ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; } @@ -95,7 +89,7 @@ static int __ms_add_ghostpad(GstElement *gst_element, return ret; } -static GObject *__ms_get_property_owner(GstElement *element, const gchar *key, GValue *value) +static GObject *__ms_get_property_owner(GstElement * element, const gchar * key, GValue * value) { GParamSpec *param; GObject *obj = NULL; @@ -128,7 +122,7 @@ static GObject *__ms_get_property_owner(GstElement *element, const gchar *key, G return obj; } -gboolean __ms_element_set_property(GstElement *element, const char *key, const gchar *param_value) +gboolean __ms_element_set_property(GstElement * element, const char *key, const gchar * param_value) { gchar *element_name = gst_element_get_name(element); GValue value = G_VALUE_INIT; @@ -253,11 +247,10 @@ gboolean __ms_element_set_property(GstElement *element, const char *key, const g } /* This unlinks from its peer and ghostpads on its way */ -static gboolean __ms_pad_peer_unlink(GstPad *pad) +static gboolean __ms_pad_peer_unlink(GstPad * pad) { - if (!gst_pad_is_linked(pad)) { + if (!gst_pad_is_linked(pad)) return TRUE; - } gboolean ret = TRUE; GstPad *peer_pad = gst_pad_get_peer(pad); @@ -289,7 +282,7 @@ static gboolean __ms_pad_peer_unlink(GstPad *pad) return ret; } -gboolean __ms_element_unlink(GstElement *element) +gboolean __ms_element_unlink(GstElement * element) { gboolean ret = TRUE; GstPad *pad = NULL; @@ -299,7 +292,7 @@ gboolean __ms_element_unlink(GstElement *element) GstIterator *pad_iterator = gst_element_iterate_pads(element); while (GST_ITERATOR_OK == gst_iterator_next(pad_iterator, &elem)) { - pad = (GstPad *)g_value_get_object(&elem); + pad = (GstPad *) g_value_get_object(&elem); pad_name = gst_pad_get_name(pad); ret = ret && __ms_pad_peer_unlink(pad); @@ -313,37 +306,32 @@ gboolean __ms_element_unlink(GstElement *element) return ret; } -gboolean __ms_bin_remove_element(GstElement *element) +gboolean __ms_bin_remove_element(GstElement * element) { - GstElement *parent = (GstElement *)gst_element_get_parent(element); + GstElement *parent = (GstElement *) gst_element_get_parent(element); gboolean ret = FALSE; /* Remove node's element from bin that decreases ref count */ if (parent != NULL) { ret = gst_bin_remove(GST_BIN(parent), element); - if (ret) { - ms_debug("Element [%s] removed from [%s] bin", - GST_ELEMENT_NAME(element), - GST_ELEMENT_NAME(parent)); - } + if (ret) + ms_debug("Element [%s] removed from [%s] bin", GST_ELEMENT_NAME(element), GST_ELEMENT_NAME(parent)); } MS_SAFE_UNREF(parent); return ret; } -gboolean __ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ref) +gboolean __ms_bin_add_element(GstElement * bin, GstElement * element, gboolean do_ref) { - GstElement *parent = (GstElement *)gst_element_get_parent(element); + GstElement *parent = (GstElement *) gst_element_get_parent(element); gboolean ret = FALSE; /* Add node's element into bin and increases ref count if needed */ if (parent == NULL) { ret = gst_bin_add(GST_BIN(bin), element); if (ret && do_ref) { - ms_debug("Element [%s] added into [%s] bin", - GST_ELEMENT_NAME(element), - GST_ELEMENT_NAME(bin)); + ms_debug("Element [%s] added into [%s] bin", GST_ELEMENT_NAME(element), GST_ELEMENT_NAME(bin)); gst_object_ref(element); } } @@ -352,17 +340,14 @@ gboolean __ms_bin_add_element(GstElement *bin, GstElement *element, gboolean do_ return ret; } -GstElement *__ms_bin_find_element_by_klass(GstElement *sink_bin, - GstElement *previous_elem, - const gchar *klass_name, - const gchar *bin_name) +GstElement *__ms_bin_find_element_by_klass(GstElement * sink_bin, GstElement * previous_elem, const gchar * klass_name, const gchar * bin_name) { GValue element_value = G_VALUE_INIT; GstElement *found_element; gboolean found = FALSE; gboolean unlinked_sink_pad_found = FALSE; - GstElement * linked_sink_element = NULL; + GstElement *linked_sink_element = NULL; GValue sink_pad_value = G_VALUE_INIT; GstIterator *sink_pad_iterator = NULL; @@ -382,7 +367,7 @@ GstElement *__ms_bin_find_element_by_klass(GstElement *sink_bin, /* Check if found element has any unlinked sink pad */ sink_pad_iterator = gst_element_iterate_sink_pads(found_element); while (GST_ITERATOR_OK == gst_iterator_next(sink_pad_iterator, &sink_pad_value)) { - GstPad *sink_pad = (GstPad *)g_value_get_object(&sink_pad_value); + GstPad *sink_pad = (GstPad *) g_value_get_object(&sink_pad_value); /* Check if sink pad of found element is unlinked */ if (!gst_pad_is_linked(sink_pad)) { @@ -391,12 +376,12 @@ GstElement *__ms_bin_find_element_by_klass(GstElement *sink_bin, } else { /* Check if src pad of previous element is linked to sink pad of found element */ - src_pad_iterator = gst_element_iterate_src_pads( previous_elem); + src_pad_iterator = gst_element_iterate_src_pads(previous_elem); while (GST_ITERATOR_OK == gst_iterator_next(src_pad_iterator, &src_pad_value)) { - GstPad *src_pad = (GstPad *)g_value_get_object(&src_pad_value); - if(src_pad == gst_pad_get_peer(sink_pad)) { + GstPad *src_pad = (GstPad *) g_value_get_object(&src_pad_value); + if (src_pad == gst_pad_get_peer(sink_pad)) linked_sink_element = found_element; - } + g_value_reset(&src_pad_value); } g_value_unset(&src_pad_value); @@ -421,9 +406,8 @@ GstElement *__ms_bin_find_element_by_klass(GstElement *sink_bin, } /* If found element is of the needed class but has been linked previously by user, - we return this found element for further connection*/ - if (linked_sink_element && - (bin_name == NULL || g_strrstr(GST_ELEMENT_NAME(linked_sink_element), bin_name))) { + we return this found element for further connection */ + if (linked_sink_element && (bin_name == NULL || g_strrstr(GST_ELEMENT_NAME(linked_sink_element), bin_name))) { found_element = linked_sink_element; found = TRUE; } @@ -450,7 +434,7 @@ int __ms_get_rank_increase(const char *factory_name) return ret; } -int __ms_factory_rank_compare(GstPluginFeature *first_feature, GstPluginFeature *second_feature) +int __ms_factory_rank_compare(GstPluginFeature * first_feature, GstPluginFeature * second_feature) { const gchar *name; int first_feature_rank_inc = 0, second_feature_rank_inc = 0; @@ -461,19 +445,18 @@ int __ms_factory_rank_compare(GstPluginFeature *first_feature, GstPluginFeature name = gst_plugin_feature_get_plugin_name(second_feature); second_feature_rank_inc = __ms_get_rank_increase(name); - return (gst_plugin_feature_get_rank(second_feature) + second_feature_rank_inc) - - (gst_plugin_feature_get_rank(first_feature) + first_feature_rank_inc); + return (gst_plugin_feature_get_rank(second_feature) + second_feature_rank_inc) - (gst_plugin_feature_get_rank(first_feature) + first_feature_rank_inc); } -gboolean __ms_feature_filter(GstPluginFeature *feature, gpointer data) +gboolean __ms_feature_filter(GstPluginFeature * feature, gpointer data) { - if (!GST_IS_ELEMENT_FACTORY(feature)) { + if (!GST_IS_ELEMENT_FACTORY(feature)) return FALSE; - } + return TRUE; } -GstElement *__ms_create_element_by_registry(GstPad *src_pad, const gchar *klass_name) +GstElement *__ms_create_element_by_registry(GstPad * src_pad, const gchar * klass_name) { GList *factories; const GList *pads; @@ -481,11 +464,10 @@ GstElement *__ms_create_element_by_registry(GstPad *src_pad, const gchar *klass_ GstCaps *new_pad_caps = gst_pad_query_caps(src_pad, NULL); - factories = gst_registry_feature_filter(gst_registry_get(), - (GstPluginFeatureFilter)__ms_feature_filter, FALSE, NULL); - factories = g_list_sort(factories, (GCompareFunc)__ms_factory_rank_compare); + factories = gst_registry_feature_filter(gst_registry_get(), (GstPluginFeatureFilter) __ms_feature_filter, FALSE, NULL); + factories = g_list_sort(factories, (GCompareFunc) __ms_factory_rank_compare); - for (; factories != NULL ; factories = factories->next) { + for (; factories != NULL; factories = factories->next) { GstElementFactory *factory = GST_ELEMENT_FACTORY(factories->data); if (g_strrstr(gst_element_factory_get_klass(GST_ELEMENT_FACTORY(factory)), klass_name)) { @@ -495,23 +477,19 @@ GstElement *__ms_create_element_by_registry(GstPad *src_pad, const gchar *klass_ GstCaps *static_caps = NULL; GstStaticPadTemplate *pad_temp = pads->data; - if (pad_temp->presence != GST_PAD_ALWAYS || pad_temp->direction != GST_PAD_SINK) { + if (pad_temp->presence != GST_PAD_ALWAYS || pad_temp->direction != GST_PAD_SINK) continue; - } - if (GST_IS_CAPS(&pad_temp->static_caps.caps)) { + if (GST_IS_CAPS(&pad_temp->static_caps.caps)) static_caps = gst_caps_ref(pad_temp->static_caps.caps); - } else { + else static_caps = gst_caps_from_string(pad_temp->static_caps.string); - } intersect_caps = gst_caps_intersect_full(new_pad_caps, static_caps, GST_CAPS_INTERSECT_FIRST); if (!gst_caps_is_empty(intersect_caps)) { - - if (!next_element) { + if (!next_element) next_element = __ms_element_create(GST_OBJECT_NAME(factory), NULL); - } } gst_caps_unref(intersect_caps); gst_caps_unref(static_caps); @@ -523,9 +501,7 @@ GstElement *__ms_create_element_by_registry(GstPad *src_pad, const gchar *klass_ return next_element; } -GstElement *__ms_link_with_new_element(GstElement *previous_element, - GstElement *new_element, - const gchar *next_elem_bin_name) +GstElement *__ms_link_with_new_element(GstElement * previous_element, GstElement * new_element, const gchar * next_elem_bin_name) { GstCaps *new_pad_caps = NULL; GstStructure *new_pad_struct = NULL; @@ -540,7 +516,7 @@ GstElement *__ms_link_with_new_element(GstElement *previous_element, pad_iterator = gst_element_iterate_sink_pads(new_element); while (GST_ITERATOR_OK == gst_iterator_next(pad_iterator, &element)) { - sink_pad = (GstPad *)g_value_get_object(&element); + sink_pad = (GstPad *) g_value_get_object(&element); prev_elem_sink_pad = gst_element_get_static_pad(previous_element, "sink"); new_pad_caps = gst_pad_query_caps(prev_elem_sink_pad, 0); @@ -549,16 +525,10 @@ GstElement *__ms_link_with_new_element(GstElement *previous_element, if (!gst_pad_is_linked(sink_pad)) { if (!strncmp(new_pad_type, GST_PAD_NAME(sink_pad), 5)) { - if (gst_element_link_pads_filtered(previous_element, "src", new_element, - GST_PAD_NAME(sink_pad), NULL)) { - ms_info("Succeeded to link [%s] -> [%s]\n", - GST_ELEMENT_NAME(previous_element), - GST_ELEMENT_NAME(new_element)); - } else { - ms_error("Failed to link [%s] -> [%s]\n", - GST_ELEMENT_NAME(previous_element), - GST_ELEMENT_NAME(new_element)); - } + if (gst_element_link_pads_filtered(previous_element, "src", new_element, GST_PAD_NAME(sink_pad), NULL)) + ms_info("Succeeded to link [%s] -> [%s]\n", GST_ELEMENT_NAME(previous_element), GST_ELEMENT_NAME(new_element)); + else + ms_error("Failed to link [%s] -> [%s]\n", GST_ELEMENT_NAME(previous_element), GST_ELEMENT_NAME(new_element)); } } MS_SAFE_UNREF(prev_elem_sink_pad); @@ -572,62 +542,47 @@ GstElement *__ms_link_with_new_element(GstElement *previous_element, } else { gboolean ret = gst_element_link_pads_filtered(previous_element, NULL, new_element, NULL, NULL); - if (ret) { - ms_info("Succeeded to link [%s] -> [%s]\n", - GST_ELEMENT_NAME(previous_element), - GST_ELEMENT_NAME(new_element)); - } else { - ms_error("Failed to link [%s] and [%s] \n", - GST_ELEMENT_NAME(previous_element), - GST_ELEMENT_NAME(new_element)); - - } + if (ret) + ms_info("Succeeded to link [%s] -> [%s]\n", GST_ELEMENT_NAME(previous_element), GST_ELEMENT_NAME(new_element)); + else + ms_error("Failed to link [%s] and [%s] \n", GST_ELEMENT_NAME(previous_element), GST_ELEMENT_NAME(new_element)); } return new_element; } -GstElement *__ms_combine_next_element(GstElement *previous_element, - const gchar *next_elem_klass_name, - const gchar *next_elem_bin_name, - gchar *default_element) +GstElement *__ms_combine_next_element(GstElement * previous_element, const gchar * next_elem_klass_name, const gchar * next_elem_bin_name, gchar * default_element) { GstElement *found_element = NULL; GstElement *parent_element = NULL; - if (!previous_element) { + if (!previous_element) return NULL; - } - parent_element = (GstElement *)gst_element_get_parent(previous_element); + parent_element = (GstElement *) gst_element_get_parent(previous_element); - /*Look for node created by user*/ - if (next_elem_klass_name) { - found_element = __ms_bin_find_element_by_klass(parent_element, previous_element, - next_elem_klass_name, next_elem_bin_name); - } + /*Look for node created by user */ + if (next_elem_klass_name) + found_element = __ms_bin_find_element_by_klass(parent_element, previous_element, next_elem_klass_name, next_elem_bin_name); - /* Link with found node created by user*/ + /* Link with found node created by user */ if (found_element) { previous_element = __ms_link_with_new_element(previous_element, found_element, next_elem_bin_name); } else { - /* Create element by element name*/ + /* Create element by element name */ if (!found_element && !next_elem_bin_name && default_element) { found_element = __ms_element_create(default_element, NULL); - /* Create element by predefined format element type*/ - } else if (!found_element - && next_elem_bin_name - && MS_ELEMENT_IS_ENCODER(next_elem_bin_name)) { + /* Create element by predefined format element type */ + } else if (!found_element && next_elem_bin_name && MS_ELEMENT_IS_ENCODER(next_elem_bin_name)) { dictionary *dict = NULL; __ms_load_ini_dictionary(&dict); - if (MS_ELEMENT_IS_VIDEO(next_elem_bin_name)) { + if (MS_ELEMENT_IS_VIDEO(next_elem_bin_name)) found_element = __ms_video_encoder_element_create(dict, MEDIA_FORMAT_H264_SP); - } else { + else found_element = __ms_audio_encoder_element_create(); - } __ms_destroy_ini_dictionary(dict); @@ -638,7 +593,7 @@ GstElement *__ms_combine_next_element(GstElement *previous_element, MS_SAFE_UNREF(src_pad); } - /*Add created element*/ + /*Add created element */ if (found_element) { if (__ms_bin_add_element(parent_element, found_element, FALSE)) { gst_element_sync_state_with_parent(found_element); @@ -646,9 +601,7 @@ GstElement *__ms_combine_next_element(GstElement *previous_element, previous_element = __ms_link_with_new_element(previous_element, found_element, NULL); __ms_generate_dots(parent_element, GST_ELEMENT_NAME(found_element)); } else { - ms_error("Element [%s] was not added into [%s] bin", - GST_ELEMENT_NAME(found_element), - GST_ELEMENT_NAME(parent_element)); + ms_error("Element [%s] was not added into [%s] bin", GST_ELEMENT_NAME(found_element), GST_ELEMENT_NAME(parent_element)); MS_SAFE_UNREF(found_element); found_element = NULL; } @@ -662,17 +615,13 @@ GstElement *__ms_combine_next_element(GstElement *previous_element, return found_element; } -gint __ms_decodebin_autoplug_select(GstElement *bin, - GstPad *pad, - GstCaps *caps, - GstElementFactory *factory, - gpointer data) +gint __ms_decodebin_autoplug_select(GstElement * bin, GstPad * pad, GstCaps * caps, GstElementFactory * factory, gpointer data) { /* NOTE : GstAutoplugSelectResult is defined in gstplay-enum.h but not exposed */ typedef enum { - GST_AUTOPLUG_SELECT_TRY, - GST_AUTOPLUG_SELECT_EXPOSE, - GST_AUTOPLUG_SELECT_SKIP + GST_AUTOPLUG_SELECT_TRY, + GST_AUTOPLUG_SELECT_EXPOSE, + GST_AUTOPLUG_SELECT_SKIP } GstAutoplugSelectResult; gchar *factory_name = NULL; @@ -701,9 +650,9 @@ gint __ms_decodebin_autoplug_select(GstElement *bin, return GST_AUTOPLUG_SELECT_TRY; } -void __decodebin_newpad_streamer_cb(GstElement *decodebin, GstPad *new_pad, gpointer user_data) +void __decodebin_newpad_streamer_cb(GstElement * decodebin, GstPad * new_pad, gpointer user_data) { - media_streamer_s *ms_streamer = (media_streamer_s *)user_data; + media_streamer_s *ms_streamer = (media_streamer_s *) user_data; ms_retm_if(ms_streamer == NULL, "Handle is NULL"); GstElement *found_element = NULL; @@ -736,9 +685,9 @@ void __decodebin_newpad_streamer_cb(GstElement *decodebin, GstPad *new_pad, gpoi gst_caps_unref(new_pad_caps); } -void __decodebin_newpad_cb(GstElement *decodebin, GstPad *new_pad, gpointer user_data) +void __decodebin_newpad_cb(GstElement * decodebin, GstPad * new_pad, gpointer user_data) { - media_streamer_s *ms_streamer = (media_streamer_s *)user_data; + media_streamer_s *ms_streamer = (media_streamer_s *) user_data; ms_retm_if(ms_streamer == NULL, "Handle is NULL"); GstElement *found_element = NULL; @@ -762,8 +711,7 @@ void __decodebin_newpad_cb(GstElement *decodebin, GstPad *new_pad, gpointer user found_element = __ms_combine_next_element(decodebin, NULL, NULL, DEFAULT_AUDIO_CONVERT); } else if (MS_ELEMENT_IS_VIDEO(new_pad_type)) { sink_bin = ms_streamer->sink_video_bin; - found_element = __ms_bin_find_element_by_klass(GST_ELEMENT_PARENT(decodebin), - decodebin, MEDIA_STREAMER_OVERLAY_KLASS, NULL); + found_element = __ms_bin_find_element_by_klass(GST_ELEMENT_PARENT(decodebin), decodebin, MEDIA_STREAMER_OVERLAY_KLASS, NULL); if (!found_element) { found_element = __ms_combine_next_element(decodebin, NULL, NULL, DEFAULT_VIDEO_CONVERT); } else { @@ -781,36 +729,33 @@ void __decodebin_newpad_cb(GstElement *decodebin, GstPad *new_pad, gpointer user /* Add sink_bin if it hasn't been added to pipeline before */ if (__ms_bin_add_element(ms_streamer->pipeline, sink_bin, TRUE)) { - gst_element_sync_state_with_parent(sink_bin); + gst_element_sync_state_with_parent(sink_bin); queue_element = __ms_element_create(DEFAULT_QUEUE, NULL); - /*Add created queue element*/ + /*Add created queue element */ if (__ms_bin_add_element(sink_bin, queue_element, FALSE)) { gst_element_sync_state_with_parent(queue_element); found_element = __ms_link_with_new_element(found_element, queue_element, NULL); __ms_generate_dots(ms_streamer->pipeline, GST_ELEMENT_NAME(found_element)); } else { - ms_error("Element [%s] was not added into [%s] bin", - GST_ELEMENT_NAME(queue_element), - GST_ELEMENT_NAME(sink_bin)); + ms_error("Element [%s] was not added into [%s] bin", GST_ELEMENT_NAME(queue_element), GST_ELEMENT_NAME(sink_bin)); } - /* Getting Sink */ - found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_SINK_KLASS, NULL, NULL); + /* Getting Sink */ + found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_SINK_KLASS, NULL, NULL); - if (!found_element) { + if (!found_element) ms_error("Could not link to sink element \n"); - } } gst_caps_unref(new_pad_caps); __ms_generate_dots(ms_streamer->pipeline, "pipeline_linked"); } -void __decodebin_newpad_client_cb(GstElement *decodebin, GstPad *new_pad, gpointer user_data) +void __decodebin_newpad_client_cb(GstElement * decodebin, GstPad * new_pad, gpointer user_data) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)user_data; + media_streamer_node_s *ms_node = (media_streamer_node_s *) user_data; ms_retm_if(ms_node == NULL, "Handle is NULL"); GstElement *found_element = NULL; @@ -830,8 +775,7 @@ void __decodebin_newpad_client_cb(GstElement *decodebin, GstPad *new_pad, gpoint found_element = __ms_combine_next_element(decodebin, MEDIA_STREAMER_CONVERTER_KLASS, NULL, DEFAULT_AUDIO_CONVERT); } else if (MS_ELEMENT_IS_VIDEO(new_pad_type)) { - found_element = __ms_bin_find_element_by_klass(GST_ELEMENT_PARENT(decodebin), - decodebin, MEDIA_STREAMER_OVERLAY_KLASS, NULL); + found_element = __ms_bin_find_element_by_klass(GST_ELEMENT_PARENT(decodebin), decodebin, MEDIA_STREAMER_OVERLAY_KLASS, NULL); if (!found_element) { found_element = __ms_combine_next_element(decodebin, MEDIA_STREAMER_CONVERTER_KLASS, NULL, DEFAULT_VIDEO_CONVERT); } else { @@ -850,14 +794,13 @@ void __decodebin_newpad_client_cb(GstElement *decodebin, GstPad *new_pad, gpoint /* Getting Sink */ found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_SINK_KLASS, NULL, NULL); - if (!found_element) { + if (!found_element) ms_error("Could not link to sink element \n"); - } + gst_caps_unref(new_pad_caps); } -static gboolean __ms_sink_bin_prepare(media_streamer_node_s *ms_node, - GstElement *sink_bin, GstPad *source_pad) +static gboolean __ms_sink_bin_prepare(media_streamer_node_s * ms_node, GstElement * sink_bin, GstPad * source_pad) { GstPad *src_pad = NULL; gboolean decodebin_usage = FALSE; @@ -869,16 +812,12 @@ static gboolean __ms_sink_bin_prepare(media_streamer_node_s *ms_node, const gchar *new_pad_type = NULL; /* Getting Depayloader */ - found_element = __ms_bin_find_element_by_klass(sink_bin,NULL, MEDIA_STREAMER_DEPAYLOADER_KLASS, - MEDIA_STREAMER_NODE_TYPE_NONE); + found_element = __ms_bin_find_element_by_klass(sink_bin, NULL, MEDIA_STREAMER_DEPAYLOADER_KLASS, MEDIA_STREAMER_NODE_TYPE_NONE); if (!found_element) { found_element = __ms_create_element_by_registry(source_pad, MEDIA_STREAMER_DEPAYLOADER_KLASS); - if (!__ms_bin_add_element(sink_bin, found_element, FALSE)) { - ms_error("Failed to add element [%s] into bin [%s]", - GST_ELEMENT_NAME(found_element), - GST_ELEMENT_NAME(sink_bin)); - } + if (!__ms_bin_add_element(sink_bin, found_element, FALSE)) + ms_error("Failed to add element [%s] into bin [%s]", GST_ELEMENT_NAME(found_element), GST_ELEMENT_NAME(sink_bin)); } previous_element = found_element; @@ -887,16 +826,15 @@ static gboolean __ms_sink_bin_prepare(media_streamer_node_s *ms_node, /* Getting Decodebin */ decodebin_usage = ms_node->parent_streamer->ini.use_decodebin; - found_element = __ms_bin_find_element_by_klass(sink_bin, previous_element, - MEDIA_STREAMER_BIN_KLASS, MEDIA_STREAMER_NODE_TYPE_NONE); + found_element = __ms_bin_find_element_by_klass(sink_bin, previous_element, MEDIA_STREAMER_BIN_KLASS, MEDIA_STREAMER_NODE_TYPE_NONE); if (!found_element) { if (decodebin_usage) { found_element = __ms_element_create("decodebin", NULL); - gst_bin_add_many((GstBin *)sink_bin, found_element, NULL); + gst_bin_add_many((GstBin *) sink_bin, found_element, NULL); gst_element_sync_state_with_parent(found_element); - g_signal_connect(found_element, "pad-added", G_CALLBACK(__decodebin_newpad_client_cb), (gpointer)ms_node); + g_signal_connect(found_element, "pad-added", G_CALLBACK(__decodebin_newpad_client_cb), (gpointer) ms_node); g_signal_connect(found_element, "autoplug-select", G_CALLBACK(__ms_decodebin_autoplug_select), NULL); previous_element = __ms_link_with_new_element(previous_element, found_element, NULL); __ms_element_set_state(found_element, GST_STATE_PLAYING); @@ -914,9 +852,8 @@ static gboolean __ms_sink_bin_prepare(media_streamer_node_s *ms_node, previous_element = __ms_combine_next_element(previous_element, NULL, NULL, DEFAULT_QUEUE); previous_element = __ms_combine_next_element(previous_element, NULL, NULL, DEFAULT_VIDEO_CONVERT); } - if (MS_ELEMENT_IS_AUDIO(new_pad_type)) { + if (MS_ELEMENT_IS_AUDIO(new_pad_type)) previous_element = __ms_combine_next_element(previous_element, NULL, NULL, DEFAULT_AUDIO_CONVERT); - } /* Getting Sink */ previous_element = __ms_combine_next_element(previous_element, MEDIA_STREAMER_SINK_KLASS, NULL, NULL); @@ -938,9 +875,8 @@ static gboolean __ms_sink_bin_prepare(media_streamer_node_s *ms_node, /* Find sink element and link with it, if it was not linked yet */ previous_element = __ms_combine_next_element(previous_element, MEDIA_STREAMER_SINK_KLASS, NULL, NULL); - if (!gst_pad_is_linked(src_pad)) { + if (!gst_pad_is_linked(src_pad)) previous_element = __ms_link_with_new_element(previous_element, found_element, NULL); - } } } __ms_generate_dots(ms_node->parent_streamer->pipeline, "pipeline_linked"); @@ -949,12 +885,12 @@ static gboolean __ms_sink_bin_prepare(media_streamer_node_s *ms_node, return TRUE; } -static void __ms_rtpbin_pad_added_cb(GstElement *src, GstPad *new_pad, gpointer user_data) +static void __ms_rtpbin_pad_added_cb(GstElement * src, GstPad * new_pad, gpointer user_data) { gchar *new_pad_name = NULL; gchar *src_element_name = NULL; - media_streamer_node_s *ms_node = (media_streamer_node_s *)user_data; + media_streamer_node_s *ms_node = (media_streamer_node_s *) user_data; ms_retm_if(ms_node == NULL, "Handle is NULL"); new_pad_name = gst_pad_get_name(new_pad); @@ -991,7 +927,7 @@ static void __ms_rtpbin_pad_added_cb(GstElement *src, GstPad *new_pad, gpointer if (__ms_sink_bin_prepare(ms_node, sink_bin, source_pad)) { if (__ms_bin_add_element(ms_node->parent_streamer->pipeline, sink_bin, TRUE)) { - gst_element_sync_state_with_parent(sink_bin); + gst_element_sync_state_with_parent(sink_bin); if (gst_element_link_pads(ms_node->gst_element, source_pad_name, sink_bin, "sink")) { __ms_element_set_state(ms_node->gst_element, GST_STATE_PLAYING); @@ -1019,7 +955,7 @@ static void __ms_rtpbin_pad_added_cb(GstElement *src, GstPad *new_pad, gpointer MS_SAFE_GFREE(src_element_name); } -int __ms_element_set_state(GstElement *gst_element, GstState gst_state) +int __ms_element_set_state(GstElement * gst_element, GstState gst_state) { ms_retvm_if(gst_element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); @@ -1028,8 +964,7 @@ int __ms_element_set_state(GstElement *gst_element, GstState gst_state) ret_state = gst_element_set_state(gst_element, gst_state); if (ret_state == GST_STATE_CHANGE_FAILURE) { - ms_error("Failed to set element [%s] into %s state", - element_name, gst_element_state_get_name(gst_state)); + ms_error("Failed to set element [%s] into %s state", element_name, gst_element_state_get_name(gst_state)); MS_SAFE_GFREE(element_name); return MEDIA_STREAMER_ERROR_INVALID_OPERATION; } @@ -1041,16 +976,16 @@ int __ms_element_set_state(GstElement *gst_element, GstState gst_state) GstElement *__ms_element_create(const char *plugin_name, const char *name) { GstElement *plugin_elem = NULL; - ms_retvm_if(plugin_name == NULL, (GstElement *)NULL, "Error empty plugin name"); + ms_retvm_if(plugin_name == NULL, (GstElement *) NULL, "Error empty plugin name"); ms_info("Creating [%s] element", plugin_name); plugin_elem = gst_element_factory_make(plugin_name, name); - ms_retvm_if(plugin_elem == NULL, (GstElement *)NULL, "Error creating element [%s]", plugin_name); + ms_retvm_if(plugin_elem == NULL, (GstElement *) NULL, "Error creating element [%s]", plugin_name); return plugin_elem; } GstElement *__ms_camera_element_create(const char *camera_plugin_name) { - ms_retvm_if(camera_plugin_name == NULL, (GstElement *)NULL, "Error empty camera plugin name"); + ms_retvm_if(camera_plugin_name == NULL, (GstElement *) NULL, "Error empty camera plugin name"); gboolean gst_ret = FALSE; GstElement *camera_bin = gst_bin_new("camera_src"); @@ -1058,8 +993,7 @@ GstElement *__ms_camera_element_create(const char *camera_plugin_name) GstElement *filter = __ms_element_create("capsfilter", NULL); GstElement *scale = __ms_element_create("videoscale", NULL); GstElement *videoconvert = __ms_element_create("videoconvert", NULL); - ms_retvm_if(!filter || !camera_elem || !camera_bin || !scale || !videoconvert , (GstElement *)NULL, - "Error: creating elements for camera bin"); + ms_retvm_if(!filter || !camera_elem || !camera_bin || !scale || !videoconvert, (GstElement *) NULL, "Error: creating elements for camera bin"); GstCaps *videoCaps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_CAMERA_FORMAT); g_object_set(G_OBJECT(filter), "caps", videoCaps, NULL); @@ -1077,7 +1011,7 @@ GstElement *__ms_camera_element_create(const char *camera_plugin_name) return camera_bin; } -GstElement *__ms_video_encoder_element_create(dictionary *dict, media_format_mimetype_e mime) +GstElement *__ms_video_encoder_element_create(dictionary * dict, media_format_mimetype_e mime) { char *plugin_name = NULL; char *format_prefix = NULL; @@ -1097,11 +1031,9 @@ GstElement *__ms_video_encoder_element_create(dictionary *dict, media_format_mim gboolean gst_ret = FALSE; GstElement *encoder_bin = gst_bin_new("video_encoder"); GstElement *filter = __ms_element_create("capsfilter", NULL); - ms_retvm_if(!filter || !encoder_elem || !encoder_bin || !encoder_parser, (GstElement *)NULL, - "Error: creating elements for video encoder bin"); + ms_retvm_if(!filter || !encoder_elem || !encoder_bin || !encoder_parser, (GstElement *) NULL, "Error: creating elements for video encoder bin"); - format_prefix = g_strdup_printf("video/x-%s,stream-format=byte-stream,profile=main", - __ms_convert_mime_to_string(mime)); + format_prefix = g_strdup_printf("video/x-%s,stream-format=byte-stream,profile=main", __ms_convert_mime_to_string(mime)); GstCaps *videoCaps = gst_caps_from_string(format_prefix); g_object_set(G_OBJECT(filter), "caps", videoCaps, NULL); MS_SAFE_FREE(format_prefix); @@ -1121,7 +1053,7 @@ GstElement *__ms_video_encoder_element_create(dictionary *dict, media_format_mim return encoder_bin; } -GstElement *__ms_video_decoder_element_create(dictionary *dict, media_format_mimetype_e mime) +GstElement *__ms_video_decoder_element_create(dictionary * dict, media_format_mimetype_e mime) { char *plugin_name = NULL; char *format_prefix = NULL; @@ -1138,13 +1070,11 @@ GstElement *__ms_video_decoder_element_create(dictionary *dict, media_format_mim plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_PARSER); GstElement *decoder_parser = __ms_element_create(plugin_name, NULL); - if (mime == MEDIA_FORMAT_H264_SP) { + if (mime == MEDIA_FORMAT_H264_SP) g_object_set(G_OBJECT(decoder_parser), "config-interval", H264_PARSER_CONFIG_INTERVAL, NULL); - } - if (g_strrstr(format_prefix, "omx")) { + if (g_strrstr(format_prefix, "omx")) is_omx = TRUE; - } MS_SAFE_FREE(format_prefix); MS_SAFE_FREE(plugin_name); @@ -1152,8 +1082,7 @@ GstElement *__ms_video_decoder_element_create(dictionary *dict, media_format_mim gboolean gst_ret = FALSE; GstElement *decoder_bin = gst_bin_new("video_decoder"); GstElement *decoder_queue = __ms_element_create("queue", NULL); - ms_retvm_if(!decoder_elem || !decoder_queue || !decoder_bin || !decoder_parser, (GstElement *)NULL, - "Error: creating elements for video decoder bin"); + ms_retvm_if(!decoder_elem || !decoder_queue || !decoder_bin || !decoder_parser, (GstElement *) NULL, "Error: creating elements for video decoder bin"); gst_bin_add_many(GST_BIN(decoder_bin), decoder_queue, decoder_elem, decoder_parser, NULL); gst_ret = gst_element_link_many(decoder_queue, decoder_parser, decoder_elem, NULL); @@ -1167,8 +1096,7 @@ GstElement *__ms_video_decoder_element_create(dictionary *dict, media_format_mim if (!is_omx) { GstElement *video_conv = __ms_element_create("videoconvert", NULL); GstElement *video_scale = __ms_element_create("videoscale", NULL); - ms_retvm_if(!video_conv || !video_scale, (GstElement *)NULL, - "Error: creating elements for video decoder bin"); + ms_retvm_if(!video_conv || !video_scale, (GstElement *) NULL, "Error: creating elements for video decoder bin"); gst_bin_add_many(GST_BIN(decoder_bin), video_conv, video_scale, NULL); gst_ret = gst_element_link_many(decoder_elem, video_conv, video_scale, NULL); if (gst_ret != TRUE) { @@ -1191,8 +1119,7 @@ GstElement *__ms_audio_encoder_element_create(void) GstElement *audio_convert = __ms_element_create("audioconvert", NULL); GstElement *audio_filter = __ms_element_create("capsfilter", NULL); GstElement *audio_enc_bin = gst_bin_new("audio_encoder"); - ms_retvm_if(!audio_convert || !audio_filter || !audio_enc_bin, (GstElement *)NULL, - "Error: creating elements for encoder bin"); + ms_retvm_if(!audio_convert || !audio_filter || !audio_enc_bin, (GstElement *) NULL, "Error: creating elements for encoder bin"); GstCaps *audioCaps = gst_caps_from_string(MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT); g_object_set(G_OBJECT(audio_filter), "caps", audioCaps, NULL); @@ -1211,14 +1138,13 @@ GstElement *__ms_audio_encoder_element_create(void) return audio_enc_bin; } -GstElement *__ms_rtp_element_create(media_streamer_node_s *ms_node) +GstElement *__ms_rtp_element_create(media_streamer_node_s * ms_node) { - ms_retvm_if(ms_node == NULL, (GstElement *)NULL, "Error empty rtp node Handle"); + ms_retvm_if(ms_node == NULL, (GstElement *) NULL, "Error empty rtp node Handle"); GstElement *rtp_container = gst_bin_new("rtp_container"); GstElement *rtp_elem = __ms_element_create("rtpbin", "rtpbin"); - ms_retvm_if(!rtp_container || !rtp_elem, (GstElement *)NULL, - "Error: creating elements for rtp container"); + ms_retvm_if(!rtp_container || !rtp_elem, (GstElement *) NULL, "Error: creating elements for rtp container"); if (!gst_bin_add(GST_BIN(rtp_container), rtp_elem)) { MS_SAFE_UNREF(rtp_container); @@ -1231,12 +1157,7 @@ GstElement *__ms_rtp_element_create(media_streamer_node_s *ms_node) return rtp_container; } -gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node, - GstElement **rtp_elem, - GstElement **rtcp_elem, - const gchar *elem_name, - const gchar *direction, - gboolean auto_create) +gboolean __ms_get_rtp_elements(media_streamer_node_s * ms_node, GstElement ** rtp_elem, GstElement ** rtcp_elem, const gchar * elem_name, const gchar * direction, gboolean auto_create) { gboolean ret = TRUE; gchar *rtp_elem_name = NULL; @@ -1267,8 +1188,7 @@ gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node, if ((NULL == *rtp_elem) && (NULL == *rtcp_elem) && auto_create) { *rtp_elem = __ms_element_create(plugin_name, rtp_elem_name); *rtcp_elem = __ms_element_create(plugin_name, rtcp_elem_name); - gst_bin_add_many(GST_BIN(ms_node->gst_element), - *rtp_elem, *rtcp_elem, NULL); + gst_bin_add_many(GST_BIN(ms_node->gst_element), *rtp_elem, *rtcp_elem, NULL); } else { /*rtp/rtcp elements already into rtp bin. */ @@ -1284,22 +1204,18 @@ gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node, if (MS_ELEMENT_IS_VIDEO(elem_name)) { __ms_add_ghostpad(rtpbin, "send_rtp_sink_0", ms_node->gst_element, "video_in"); - ret = gst_element_link_pads(rtpbin, "send_rtp_src_0", *rtp_elem, "sink") && - gst_element_link_pads(rtpbin, "send_rtcp_src_0", *rtcp_elem, "sink"); + ret = gst_element_link_pads(rtpbin, "send_rtp_src_0", *rtp_elem, "sink") && gst_element_link_pads(rtpbin, "send_rtcp_src_0", *rtcp_elem, "sink"); } else { __ms_add_ghostpad(rtpbin, "send_rtp_sink_1", ms_node->gst_element, "audio_in"); - ret = gst_element_link_pads(rtpbin, "send_rtp_src_1", *rtp_elem, "sink") && - gst_element_link_pads(rtpbin, "send_rtcp_src_1", *rtcp_elem, "sink"); + ret = gst_element_link_pads(rtpbin, "send_rtp_src_1", *rtp_elem, "sink") && gst_element_link_pads(rtpbin, "send_rtcp_src_1", *rtcp_elem, "sink"); } } else { if (MS_ELEMENT_IS_VIDEO(elem_name)) { - ret = gst_element_link_pads(*rtp_elem, "src", rtpbin, "recv_rtp_sink_0") && - gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_0"); + ret = gst_element_link_pads(*rtp_elem, "src", rtpbin, "recv_rtp_sink_0") && gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_0"); __ms_add_no_target_ghostpad(ms_node->gst_element, "video_out", GST_PAD_SRC); __ms_add_no_target_ghostpad(ms_node->gst_element, "video_in_rtp", GST_PAD_SINK); } else { - ret = gst_element_link_pads(*rtp_elem, "src", rtpbin, "recv_rtp_sink_1") && - gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_1"); + ret = gst_element_link_pads(*rtp_elem, "src", rtpbin, "recv_rtp_sink_1") && gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_1"); __ms_add_no_target_ghostpad(ms_node->gst_element, "audio_out", GST_PAD_SRC); __ms_add_no_target_ghostpad(ms_node->gst_element, "audio_in_rtp", GST_PAD_SINK); } @@ -1318,48 +1234,47 @@ gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node, return ret; } -int __ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s *ms_node) +int __ms_add_node_into_bin(media_streamer_s * ms_streamer, media_streamer_node_s * ms_node) { int ret = MEDIA_STREAMER_ERROR_NONE; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL"); ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL"); - ms_info("Try to add [%s] node into streamer, node type/subtype [%d/%d]", - ms_node->name, ms_node->type, ms_node->subtype); + ms_info("Try to add [%s] node into streamer, node type/subtype [%d/%d]", ms_node->name, ms_node->type, ms_node->subtype); GstElement *bin = NULL; switch (ms_node->type) { - case MEDIA_STREAMER_NODE_TYPE_SRC: - bin = ms_streamer->src_bin; - break; - case MEDIA_STREAMER_NODE_TYPE_SINK: - switch (ms_node->subtype) { - case MEDIA_STREAMER_NODE_SINK_TYPE_SCREEN: - bin = ms_streamer->sink_video_bin; - break; - case MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO: - bin = ms_streamer->sink_audio_bin; - break; - default: - bin = ms_streamer->topology_bin; - break; - } - break; - case MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER: - case MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY: - case MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER: + case MEDIA_STREAMER_NODE_TYPE_SRC: + bin = ms_streamer->src_bin; + break; + case MEDIA_STREAMER_NODE_TYPE_SINK: + switch (ms_node->subtype) { + case MEDIA_STREAMER_NODE_SINK_TYPE_SCREEN: bin = ms_streamer->sink_video_bin; break; - case MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY: - case MEDIA_STREAMER_NODE_TYPE_AUDIO_RESAMPLE: - case MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER: + case MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO: bin = ms_streamer->sink_audio_bin; break; default: - /* Another elements will be add into topology bin */ bin = ms_streamer->topology_bin; break; + } + break; + case MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER: + case MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY: + case MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER: + bin = ms_streamer->sink_video_bin; + break; + case MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY: + case MEDIA_STREAMER_NODE_TYPE_AUDIO_RESAMPLE: + case MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER: + bin = ms_streamer->sink_audio_bin; + break; + default: + /* Another elements will be add into topology bin */ + bin = ms_streamer->topology_bin; + break; } if (!__ms_bin_add_element(bin, ms_node->gst_element, TRUE)) { @@ -1370,85 +1285,77 @@ int __ms_add_node_into_bin(media_streamer_s *ms_streamer, media_streamer_node_s return ret; } -static gboolean -__ms_parse_gst_error(media_streamer_s *ms_streamer, GstMessage *message, GError *error) +static gboolean __ms_parse_gst_error(media_streamer_s * ms_streamer, GstMessage * message, GError * error) { ms_retvm_if(!ms_streamer, FALSE, "Error: invalid Media Streamer handle."); ms_retvm_if(!error, FALSE, "Error: invalid error handle."); ms_retvm_if(!message, FALSE, "Error: invalid bus message handle."); media_streamer_error_e ret_error = MEDIA_STREAMER_ERROR_NONE; - if (error->domain == GST_CORE_ERROR) { + if (error->domain == GST_CORE_ERROR) ret_error = MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } else if (error->domain == GST_LIBRARY_ERROR) { + else if (error->domain == GST_LIBRARY_ERROR) ret_error = MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } else if (error->domain == GST_RESOURCE_ERROR) { + else if (error->domain == GST_RESOURCE_ERROR) ret_error = MEDIA_STREAMER_ERROR_RESOURCE_CONFLICT; - } else if (error->domain == GST_STREAM_ERROR) { + else if (error->domain == GST_STREAM_ERROR) ret_error = MEDIA_STREAMER_ERROR_CONNECTION_FAILED; - } else { + else ret_error = MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } /* post error to application */ if (ms_streamer->error_cb.callback) { - media_streamer_error_cb error_cb = (media_streamer_error_cb)ms_streamer->error_cb.callback; - error_cb((media_streamer_h)ms_streamer, ret_error, ms_streamer->error_cb.user_data); + media_streamer_error_cb error_cb = (media_streamer_error_cb) ms_streamer->error_cb.callback; + error_cb((media_streamer_h) ms_streamer, ret_error, ms_streamer->error_cb.user_data); } return TRUE; } -static gboolean __ms_bus_cb(GstBus *bus, GstMessage *message, gpointer userdata) +static gboolean __ms_bus_cb(GstBus * bus, GstMessage * message, gpointer userdata) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_s *ms_streamer = (media_streamer_s *)userdata; + media_streamer_s *ms_streamer = (media_streamer_s *) userdata; ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); ms_retvm_if(ms_streamer->pipeline == NULL, MEDIA_STREAMER_ERROR_INVALID_STATE, "Pipeline doesn`t exist"); /* Parse message */ if (message != NULL) { switch (GST_MESSAGE_TYPE(message)) { - case GST_MESSAGE_ERROR: { - GError *err = NULL; - gchar *debug = NULL; - gst_message_parse_error(message, &err, &debug); + case GST_MESSAGE_ERROR:{ + GError *err = NULL; + gchar *debug = NULL; + gst_message_parse_error(message, &err, &debug); - /* Transform gst error code to media streamer error code. - * then post it to application if needed */ - __ms_parse_gst_error(ms_streamer, message, err); + /* Transform gst error code to media streamer error code. + * then post it to application if needed */ + __ms_parse_gst_error(ms_streamer, message, err); - ms_error("[Source: %s] Error: %s", - GST_OBJECT_NAME(GST_OBJECT_CAST(GST_ELEMENT(GST_MESSAGE_SRC(message)))), - err->message); + ms_error("[Source: %s] Error: %s", GST_OBJECT_NAME(GST_OBJECT_CAST(GST_ELEMENT(GST_MESSAGE_SRC(message)))), err->message); - g_error_free(err); - MS_SAFE_FREE(debug); - break; - } + g_error_free(err); + MS_SAFE_FREE(debug); + break; + } - case GST_MESSAGE_STATE_CHANGED: { - if (GST_MESSAGE_SRC(message) == GST_OBJECT(ms_streamer->pipeline)) { - GstState state_old, state_new, state_pending; - gchar *state_transition_name; - - gst_message_parse_state_changed(message, &state_old, &state_new, &state_pending); - state_transition_name = g_strdup_printf("%s_%s", - gst_element_state_get_name(state_old), - gst_element_state_get_name(state_new)); - ms_info("GST_MESSAGE_STATE_CHANGED: [%s] %s", - gst_object_get_name(GST_MESSAGE_SRC(message)), - state_transition_name); - __ms_generate_dots(ms_streamer->pipeline, state_transition_name); - - MS_SAFE_GFREE(state_transition_name); - } - break; + case GST_MESSAGE_STATE_CHANGED:{ + if (GST_MESSAGE_SRC(message) == GST_OBJECT(ms_streamer->pipeline)) { + GstState state_old, state_new, state_pending; + gchar *state_transition_name; + + gst_message_parse_state_changed(message, &state_old, &state_new, &state_pending); + state_transition_name = g_strdup_printf("%s_%s", gst_element_state_get_name(state_old), gst_element_state_get_name(state_new)); + ms_info("GST_MESSAGE_STATE_CHANGED: [%s] %s", gst_object_get_name(GST_MESSAGE_SRC(message)), state_transition_name); + __ms_generate_dots(ms_streamer->pipeline, state_transition_name); + + MS_SAFE_GFREE(state_transition_name); } + break; + } - case GST_MESSAGE_ASYNC_DONE: { + case GST_MESSAGE_ASYNC_DONE:{ if (GST_MESSAGE_SRC(message) == GST_OBJECT(ms_streamer->pipeline) - && ms_streamer->is_seeking) { + && ms_streamer->is_seeking) { if (ms_streamer->seek_done_cb.callback) { media_streamer_position_changed_cb cb = (media_streamer_position_changed_cb) ms_streamer->seek_done_cb.callback; @@ -1461,56 +1368,49 @@ static gboolean __ms_bus_cb(GstBus *bus, GstMessage *message, gpointer userdata) } break; } - case GST_MESSAGE_EOS: { - ms_info("GST_MESSAGE_EOS end-of-stream"); - ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED); - if (ret != MEDIA_STREAMER_ERROR_NONE) { - ms_error("ERROR - Pause Pipeline"); - return FALSE; - } - break; + case GST_MESSAGE_EOS:{ + ms_info("GST_MESSAGE_EOS end-of-stream"); + ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED); + if (ret != MEDIA_STREAMER_ERROR_NONE) { + ms_error("ERROR - Pause Pipeline"); + return FALSE; } - default: break; + } + default: + break; } } return TRUE; } -int __ms_pipeline_create(media_streamer_s *ms_streamer) +int __ms_pipeline_create(media_streamer_s * ms_streamer) { ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); gst_init(NULL, NULL); ms_streamer->pipeline = gst_pipeline_new(MEDIA_STREAMER_PIPELINE_NAME); - ms_retvm_if(ms_streamer->pipeline == NULL, - MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating pipeline"); + ms_retvm_if(ms_streamer->pipeline == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating pipeline"); ms_streamer->bus = gst_pipeline_get_bus(GST_PIPELINE(ms_streamer->pipeline)); - ms_retvm_if(ms_streamer->bus == NULL, - MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error getting the bus of the pipeline"); + ms_retvm_if(ms_streamer->bus == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error getting the bus of the pipeline"); - ms_streamer->bus_watcher = gst_bus_add_watch(ms_streamer->bus, (GstBusFunc)__ms_bus_cb, ms_streamer); + ms_streamer->bus_watcher = gst_bus_add_watch(ms_streamer->bus, (GstBusFunc) __ms_bus_cb, ms_streamer); ms_streamer->src_bin = gst_bin_new(MEDIA_STREAMER_SRC_BIN_NAME); - ms_retvm_if(ms_streamer->src_bin == NULL, - MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Src bin"); + ms_retvm_if(ms_streamer->src_bin == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Src bin"); ms_streamer->sink_video_bin = gst_bin_new(MEDIA_STREAMER_VIDEO_SINK_BIN_NAME); - ms_retvm_if(ms_streamer->sink_video_bin == NULL, - MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Sink Video bin"); + ms_retvm_if(ms_streamer->sink_video_bin == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Sink Video bin"); ms_streamer->sink_audio_bin = gst_bin_new(MEDIA_STREAMER_AUDIO_SINK_BIN_NAME); - ms_retvm_if(ms_streamer->sink_audio_bin == NULL, - MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Sink Audio bin"); + ms_retvm_if(ms_streamer->sink_audio_bin == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Sink Audio bin"); ms_streamer->topology_bin = gst_bin_new(MEDIA_STREAMER_TOPOLOGY_BIN_NAME); - ms_retvm_if(ms_streamer->topology_bin == NULL, - MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Topology bin"); + ms_retvm_if(ms_streamer->topology_bin == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Topology bin"); - gst_bin_add_many(GST_BIN(ms_streamer->pipeline), ms_streamer->src_bin, - ms_streamer->topology_bin, NULL); + gst_bin_add_many(GST_BIN(ms_streamer->pipeline), ms_streamer->src_bin, ms_streamer->topology_bin, NULL); ms_info("Media streamer pipeline created successfully."); return MEDIA_STREAMER_ERROR_NONE; @@ -1531,35 +1431,23 @@ static GstCaps *__ms_create_caps_from_fmt(media_format_h fmt) if (media_format_get_video_info(fmt, &mime, &width, &height, &avg_bps, &max_bps) == MEDIA_PACKET_ERROR_NONE) { - ms_info("Creating video Caps from media format [width=%d, height=%d, bps=%d, mime=%d]", - width, height, avg_bps, mime); + ms_info("Creating video Caps from media format [width=%d, height=%d, bps=%d, mime=%d]", width, height, avg_bps, mime); if (mime & MEDIA_FORMAT_RAW) { format_name = g_strdup(__ms_convert_mime_to_string(mime)); - caps = gst_caps_new_simple("video/x-raw", - "framerate", GST_TYPE_FRACTION, max_bps, avg_bps, - "format", G_TYPE_STRING, format_name, - "width", G_TYPE_INT, width, - "height", G_TYPE_INT, height, NULL); + caps = gst_caps_new_simple("video/x-raw", "framerate", GST_TYPE_FRACTION, max_bps, avg_bps, "format", G_TYPE_STRING, format_name, "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL); } else { /*mime & MEDIA_FORMAT_ENCODED */ format_name = g_strdup_printf("video/x-%s", __ms_convert_mime_to_string(mime)); - caps = gst_caps_new_simple(format_name, - "framerate", GST_TYPE_FRACTION, max_bps, avg_bps, - "width", G_TYPE_INT, width, - "height", G_TYPE_INT, height, NULL); + caps = gst_caps_new_simple(format_name, "framerate", GST_TYPE_FRACTION, max_bps, avg_bps, "width", G_TYPE_INT, width, "height", G_TYPE_INT, height, NULL); } } else if (media_format_get_audio_info(fmt, &mime, &channel, &samplerate, &bit, &avg_bps) == MEDIA_PACKET_ERROR_NONE) { - ms_info("Creating audio Caps from media format [channel=%d, samplerate=%d, bit=%d, avg_bps=%d, mime=%d]", - channel, samplerate, bit, avg_bps, mime); + ms_info("Creating audio Caps from media format [channel=%d, samplerate=%d, bit=%d, avg_bps=%d, mime=%d]", channel, samplerate, bit, avg_bps, mime); if (mime & MEDIA_FORMAT_RAW) { format_name = g_strdup(__ms_convert_mime_to_string(mime)); - caps = gst_caps_new_simple("audio/x-raw", - "channels", G_TYPE_INT, channel, - "format", G_TYPE_STRING, format_name, - "rate", G_TYPE_INT, samplerate, NULL); + caps = gst_caps_new_simple("audio/x-raw", "channels", G_TYPE_INT, channel, "format", G_TYPE_STRING, format_name, "rate", G_TYPE_INT, samplerate, NULL); } else { ms_error("Encoded audio formats does not supported yet."); } @@ -1571,7 +1459,7 @@ static GstCaps *__ms_create_caps_from_fmt(media_format_h fmt) return caps; } -static media_format_h __ms_create_fmt_from_caps(GstCaps *caps) +static media_format_h __ms_create_fmt_from_caps(GstCaps * caps) { media_format_h fmt; GstStructure *pad_struct; @@ -1585,17 +1473,15 @@ static media_format_h __ms_create_fmt_from_caps(GstCaps *caps) int fmt_ret = MEDIA_FORMAT_ERROR_NONE; fmt_ret = media_format_create(&fmt); - ms_retvm_if(fmt_ret != MEDIA_FORMAT_ERROR_NONE, NULL, - "Error: while creating media format object, err[%d]!", fmt_ret); + ms_retvm_if(fmt_ret != MEDIA_FORMAT_ERROR_NONE, NULL, "Error: while creating media format object, err[%d]!", fmt_ret); pad_struct = gst_caps_get_structure(caps, 0); const gchar *pad_type = gst_structure_get_name(pad_struct); const gchar *pad_format = pad_type; /* Got raw format type if needed */ - if (g_strrstr(pad_type, "/x-raw")) { + if (g_strrstr(pad_type, "/x-raw")) pad_format = gst_structure_get_string(pad_struct, "format"); - } ms_debug("Pad type is [%s], format: [%s]", pad_type, pad_format); if (MS_ELEMENT_IS_VIDEO(pad_type)) { @@ -1622,7 +1508,7 @@ static media_format_h __ms_create_fmt_from_caps(GstCaps *caps) 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; @@ -1642,9 +1528,9 @@ int __ms_element_pad_names(GstElement *gst_element, GstPadDirection pad_type, ch } while (GST_ITERATOR_OK == gst_iterator_next(pad_iterator, &elem)) { - pad = (GstPad *)g_value_get_object(&elem); + pad = (GstPad *) g_value_get_object(&elem); - pad_names = (char **)realloc(pad_names, sizeof(char *)*(pad_number + 1)); + pad_names = (char **)realloc(pad_names, sizeof(char *) * (pad_number + 1)); if (!pad_names) { ms_error("Error allocation memory"); ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; @@ -1668,7 +1554,7 @@ int __ms_element_pad_names(GstElement *gst_element, GstPadDirection pad_type, ch return ret; } -media_format_h __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad_name) +media_format_h __ms_element_get_pad_fmt(GstElement * gst_element, const char *pad_name) { media_format_h fmt; GstCaps *caps = NULL; @@ -1697,20 +1583,20 @@ media_format_h __ms_element_get_pad_fmt(GstElement *gst_element, const char *pad return fmt; } -int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, media_format_h fmt) +int __ms_element_set_fmt(media_streamer_node_s * node, const char *pad_name, media_format_h fmt) { GstCaps *caps = NULL; GObject *obj = NULL; GValue value = G_VALUE_INIT; if (node->type == MEDIA_STREAMER_NODE_TYPE_RTP) { - /* It is needed to set 'application/x-rtp' for audio and video udpsrc*/ + /* It is needed to set 'application/x-rtp' for audio and video udpsrc */ media_format_mimetype_e mime; int audio_channels, audio_samplerate; GstElement *rtp_elem, *rtcp_elem; gchar *rtp_caps_str = NULL; - /*Check if it is a valid pad*/ + /*Check if it is a valid pad */ GstPad *pad = gst_element_get_static_pad(node->gst_element, pad_name); if (!pad) { ms_error("Error: Failed set format to pad [%s].[%s].", node->name, pad_name); @@ -1720,8 +1606,7 @@ int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, medi if (MEDIA_FORMAT_ERROR_NONE == media_format_get_video_info(fmt, &mime, NULL, NULL, NULL, NULL)) { __ms_get_rtp_elements(node, &rtp_elem, &rtcp_elem, "video", "in", FALSE); - rtp_caps_str = g_strdup_printf("application/x-rtp,media=video,clock-rate=90000,encoding-name=%s", - __ms_convert_mime_to_rtp_format(mime)); + rtp_caps_str = g_strdup_printf("application/x-rtp,media=video,clock-rate=90000,encoding-name=%s", __ms_convert_mime_to_rtp_format(mime)); caps = gst_caps_from_string(rtp_caps_str); ms_retvm_if(caps == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail creating caps from fmt."); @@ -1729,8 +1614,7 @@ int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, medi } else if (MEDIA_FORMAT_ERROR_NONE == media_format_get_audio_info(fmt, &mime, &audio_channels, &audio_samplerate, NULL, NULL)) { __ms_get_rtp_elements(node, &rtp_elem, &rtcp_elem, "audio", "in", FALSE); - rtp_caps_str = g_strdup_printf("application/x-rtp,media=audio,clock-rate=%d,encoding-name=%s,channels=%d,payload=96", - audio_samplerate, __ms_convert_mime_to_rtp_format(mime), audio_channels); + rtp_caps_str = g_strdup_printf("application/x-rtp,media=audio,clock-rate=%d,encoding-name=%s,channels=%d,payload=96", audio_samplerate, __ms_convert_mime_to_rtp_format(mime), audio_channels); caps = gst_caps_from_string(rtp_caps_str); ms_retvm_if(caps == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Fail creating caps from fmt."); @@ -1756,24 +1640,23 @@ int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, medi 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; ms_retvm_if(element == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Element is NULL"); GstEvent *event = gst_event_new_seek(1.0, GST_FORMAT_TIME, seek_flag, - GST_SEEK_TYPE_SET, g_time, - GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE); + GST_SEEK_TYPE_SET, g_time, + GST_SEEK_TYPE_NONE, GST_CLOCK_TIME_NONE); - if (event) { + if (event) result = gst_element_send_event(element, event); - } 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; @@ -1792,7 +1675,7 @@ int __ms_element_push_packet(GstElement *src_element, media_packet_h packet) GstMapInfo buff_info = GST_MAP_INFO_INIT; guint64 pts = 0; guint64 duration = 0; - guint64 size = 0; + guint64 size = 0; media_packet_get_buffer_size(packet, &size); @@ -1821,14 +1704,13 @@ int __ms_element_push_packet(GstElement *src_element, media_packet_h packet) g_signal_emit_by_name(G_OBJECT(src_element), "end-of-stream", &gst_ret, NULL); } - if (gst_ret != GST_FLOW_OK) { + if (gst_ret != GST_FLOW_OK) return MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } 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) { GstBuffer *buffer = NULL; GstSample *sample = NULL; @@ -1854,7 +1736,7 @@ int __ms_element_pull_packet(GstElement *sink_element, media_packet_h *packet) return MEDIA_STREAMER_ERROR_INVALID_OPERATION; } - buffer_res = (guint8 *)calloc(map.size, sizeof(guint8)); + buffer_res = (guint8 *) calloc(map.size, sizeof(guint8)); memcpy(buffer_res, map.data, map.size); media_packet_create_from_external_memory(fmt, (void *)buffer_res, map.size, NULL, NULL, packet); diff --git a/src/media_streamer_node.c b/src/media_streamer_node.c index 862bd4f..27c6145 100755 --- a/src/media_streamer_node.c +++ b/src/media_streamer_node.c @@ -45,9 +45,7 @@ char *param_table[PROPERTY_COUNT][2] = { {MEDIA_STREAMER_PARAM_HOST, "host"} }; -int __ms_node_set_property(media_streamer_node_s *ms_node, - const gchar *param_key, - const gchar *param_value) +int __ms_node_set_property(media_streamer_node_s * ms_node, const gchar * param_key, const gchar * param_value) { ms_retvm_if(!ms_node && !ms_node->gst_element, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error: empty node"); ms_retvm_if(!param_key && !param_value, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error: invalid property parameter"); @@ -57,9 +55,7 @@ int __ms_node_set_property(media_streamer_node_s *ms_node, return MEDIA_STREAMER_ERROR_NONE; } -static int __ms_rtp_node_set_property(media_streamer_node_s *ms_node, - const char *param_key, - const char *param_value) +static int __ms_rtp_node_set_property(media_streamer_node_s * ms_node, const char *param_key, const char *param_value) { ms_retvm_if(!ms_node && !ms_node->gst_element, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error: empty node"); @@ -130,9 +126,7 @@ static int __ms_rtp_node_set_property(media_streamer_node_s *ms_node, return MEDIA_STREAMER_ERROR_INVALID_PARAMETER; } -int __ms_node_create(media_streamer_node_s *node, - media_format_h in_fmt, - media_format_h out_fmt) +int __ms_node_create(media_streamer_node_s * node, media_format_h in_fmt, media_format_h out_fmt) { ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); @@ -142,127 +136,124 @@ int __ms_node_create(media_streamer_node_s *node, media_format_mimetype_e mime; gboolean dec_use; - if (MEDIA_FORMAT_ERROR_NONE != media_format_get_video_info(out_fmt, &mime, NULL, NULL, NULL, NULL)) { + if (MEDIA_FORMAT_ERROR_NONE != media_format_get_video_info(out_fmt, &mime, NULL, NULL, NULL, NULL)) media_format_get_audio_info(out_fmt, &mime, NULL, NULL, NULL, NULL); - } + char *format_prefix = NULL; __ms_load_ini_dictionary(&dict); - node->set_param = (ms_node_set_param)__ms_node_set_property; + node->set_param = (ms_node_set_param) __ms_node_set_property; switch (node->type) { - case MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER: - format_prefix = g_strdup_printf("%s:encoder", __ms_convert_mime_to_string(mime)); - plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_ENCODER); - node->gst_element = __ms_video_encoder_element_create(dict, mime); - break; - case MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER: - dec_use = iniparser_getboolean(dict, "general:use decodebin", DEFAULT_USE_DECODEBIN); - if (dec_use) { - node->gst_element = __ms_element_create("decodebin", NULL); - g_signal_connect(node->gst_element, "pad-added", G_CALLBACK(__decodebin_newpad_client_cb), (gpointer)node); - g_signal_connect(node->gst_element, "autoplug-select", G_CALLBACK(__ms_decodebin_autoplug_select), NULL); - } else { - format_prefix = g_strdup_printf("%s:decoder", __ms_convert_mime_to_string(mime)); - plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_DECODER); - node->gst_element = __ms_video_decoder_element_create(dict, mime); - } - break; - case MEDIA_STREAMER_NODE_TYPE_PARSER: - format_prefix = g_strdup_printf("%s:parser", __ms_convert_mime_to_string(mime)); - plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_PARSER); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_FILTER: - node->gst_element = __ms_element_create("capsfilter", NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY: - format_prefix = g_strdup_printf("%s:rtppay", __ms_convert_mime_to_string(mime)); - plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_RTPPAY); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY: - plugin_name = __ms_ini_get_string(dict, "audio-raw:rtppay", DEFAULT_AUDIO_RTPPAY); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY: - format_prefix = g_strdup_printf("%s:rtpdepay", __ms_convert_mime_to_string(mime)); - plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_RTPDEPAY); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY: - plugin_name = __ms_ini_get_string(dict, "audio-raw:rtpdepay", DEFAULT_AUDIO_RTPDEPAY); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_RTP: - node->gst_element = __ms_rtp_element_create(node); - node->set_param = (ms_node_set_param)__ms_rtp_node_set_property; - break; - case MEDIA_STREAMER_NODE_TYPE_QUEUE: - node->gst_element = __ms_element_create(DEFAULT_QUEUE, NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER: - node->gst_element = __ms_audio_encoder_element_create(); - break; - case MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER: - node->gst_element = __ms_element_create("videoconvert", NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER: - node->gst_element = __ms_element_create("audioconvert", NULL); - break; - case MEDIA_STREAMER_NODE_TYPE_AUDIO_RESAMPLE: - node->gst_element = __ms_element_create("audioresample", NULL); - break; - default: - ms_error("Error: invalid node Type [%d]", node->type); - break; + case MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER: + format_prefix = g_strdup_printf("%s:encoder", __ms_convert_mime_to_string(mime)); + plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_ENCODER); + node->gst_element = __ms_video_encoder_element_create(dict, mime); + break; + case MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER: + dec_use = iniparser_getboolean(dict, "general:use decodebin", DEFAULT_USE_DECODEBIN); + if (dec_use) { + node->gst_element = __ms_element_create("decodebin", NULL); + g_signal_connect(node->gst_element, "pad-added", G_CALLBACK(__decodebin_newpad_client_cb), (gpointer) node); + g_signal_connect(node->gst_element, "autoplug-select", G_CALLBACK(__ms_decodebin_autoplug_select), NULL); + } else { + format_prefix = g_strdup_printf("%s:decoder", __ms_convert_mime_to_string(mime)); + plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_DECODER); + node->gst_element = __ms_video_decoder_element_create(dict, mime); + } + break; + case MEDIA_STREAMER_NODE_TYPE_PARSER: + format_prefix = g_strdup_printf("%s:parser", __ms_convert_mime_to_string(mime)); + plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_PARSER); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_FILTER: + node->gst_element = __ms_element_create("capsfilter", NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY: + format_prefix = g_strdup_printf("%s:rtppay", __ms_convert_mime_to_string(mime)); + plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_RTPPAY); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY: + plugin_name = __ms_ini_get_string(dict, "audio-raw:rtppay", DEFAULT_AUDIO_RTPPAY); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY: + format_prefix = g_strdup_printf("%s:rtpdepay", __ms_convert_mime_to_string(mime)); + plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_RTPDEPAY); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY: + plugin_name = __ms_ini_get_string(dict, "audio-raw:rtpdepay", DEFAULT_AUDIO_RTPDEPAY); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_RTP: + node->gst_element = __ms_rtp_element_create(node); + node->set_param = (ms_node_set_param) __ms_rtp_node_set_property; + break; + case MEDIA_STREAMER_NODE_TYPE_QUEUE: + node->gst_element = __ms_element_create(DEFAULT_QUEUE, NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER: + node->gst_element = __ms_audio_encoder_element_create(); + break; + case MEDIA_STREAMER_NODE_TYPE_VIDEO_CONVERTER: + node->gst_element = __ms_element_create("videoconvert", NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER: + node->gst_element = __ms_element_create("audioconvert", NULL); + break; + case MEDIA_STREAMER_NODE_TYPE_AUDIO_RESAMPLE: + node->gst_element = __ms_element_create("audioresample", NULL); + break; + default: + ms_error("Error: invalid node Type [%d]", node->type); + break; } MS_SAFE_FREE(plugin_name); MS_SAFE_FREE(format_prefix); __ms_destroy_ini_dictionary(dict); - if (node->gst_element == NULL) { + if (node->gst_element == NULL) ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } else { + else node->name = gst_element_get_name(node->gst_element); - } return ret; } /* This signal callback is called when appsrc needs data, we add an idle handler * to the mainloop to start pushing data into the appsrc */ -static void __ms_src_start_feed_cb(GstElement *pipeline, guint size, gpointer data) +static void __ms_src_start_feed_cb(GstElement * pipeline, guint size, gpointer data) { - media_streamer_node_s *ms_src = (media_streamer_node_s *)data; + media_streamer_node_s *ms_src = (media_streamer_node_s *) data; ms_retm_if(ms_src == NULL, "Handle is NULL"); if (ms_src->callbacks_structure != NULL) { - media_streamer_callback_s *src_callback = (media_streamer_callback_s *)ms_src->callbacks_structure; - media_streamer_custom_buffer_status_cb buffer_status_cb = - (media_streamer_custom_buffer_status_cb) src_callback->callback; - buffer_status_cb((media_streamer_node_h)ms_src, MEDIA_STREAMER_CUSTOM_BUFFER_UNDERRUN, src_callback->user_data); + media_streamer_callback_s *src_callback = (media_streamer_callback_s *) ms_src->callbacks_structure; + media_streamer_custom_buffer_status_cb buffer_status_cb = (media_streamer_custom_buffer_status_cb) src_callback->callback; + buffer_status_cb((media_streamer_node_h) ms_src, MEDIA_STREAMER_CUSTOM_BUFFER_UNDERRUN, src_callback->user_data); } } /* This callback is called when appsrc has enough data and we can stop sending. * We remove the idle handler from the mainloop */ -static void __ms_src_stop_feed_cb(GstElement *pipeline, gpointer data) +static void __ms_src_stop_feed_cb(GstElement * pipeline, gpointer data) { - media_streamer_node_s *ms_src = (media_streamer_node_s *)data; + media_streamer_node_s *ms_src = (media_streamer_node_s *) data; ms_retm_if(ms_src == NULL, "Handle is NULL"); if (ms_src->callbacks_structure != NULL) { - media_streamer_callback_s *src_callback = (media_streamer_callback_s *)ms_src->callbacks_structure; - media_streamer_custom_buffer_status_cb buffer_status_cb = - (media_streamer_custom_buffer_status_cb) src_callback->callback; - buffer_status_cb((media_streamer_node_h)ms_src, MEDIA_STREAMER_CUSTOM_BUFFER_OVERFLOW, src_callback->user_data); + media_streamer_callback_s *src_callback = (media_streamer_callback_s *) ms_src->callbacks_structure; + media_streamer_custom_buffer_status_cb buffer_status_cb = (media_streamer_custom_buffer_status_cb) src_callback->callback; + buffer_status_cb((media_streamer_node_h) ms_src, MEDIA_STREAMER_CUSTOM_BUFFER_OVERFLOW, src_callback->user_data); } } -int __ms_src_node_create(media_streamer_node_s *node) +int __ms_src_node_create(media_streamer_node_s * node) { ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); @@ -272,96 +263,89 @@ int __ms_src_node_create(media_streamer_node_s *node) __ms_load_ini_dictionary(&dict); - node->set_param = (ms_node_set_param)__ms_node_set_property; + node->set_param = (ms_node_set_param) __ms_node_set_property; switch (node->subtype) { - case MEDIA_STREAMER_NODE_SRC_TYPE_FILE: - node->gst_element = __ms_element_create(DEFAULT_FILE_SOURCE, NULL); - break; - case MEDIA_STREAMER_NODE_SRC_TYPE_RTSP: - node->gst_element = __ms_element_create(DEFAULT_UDP_SOURCE, NULL); - break; - case MEDIA_STREAMER_NODE_SRC_TYPE_HTTP: - node->gst_element = __ms_element_create(DEFAULT_HTTP_SOURCE, NULL); - break; - case MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA: - plugin_name = __ms_ini_get_string(dict, "sources:camera_source", DEFAULT_CAMERA_SOURCE); - node->gst_element = __ms_camera_element_create(plugin_name); - - break; - case MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_CAPTURE: - plugin_name = __ms_ini_get_string(dict, "sources:audio_source", 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(dict, "sources:video_source", DEFAULT_VIDEO_SOURCE); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST: - node->gst_element = __ms_element_create(DEFAULT_VIDEO_TEST_SOURCE, NULL); - break; - case MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_TEST: - node->gst_element = __ms_element_create(DEFAULT_AUDIO_TEST_SOURCE, NULL); - break; - case MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM: - node->gst_element = __ms_element_create(DEFAULT_APP_SOURCE, NULL); - g_signal_connect(node->gst_element, "need-data", G_CALLBACK(__ms_src_start_feed_cb), (gpointer)node); - g_signal_connect(node->gst_element, "enough-data", G_CALLBACK(__ms_src_stop_feed_cb), (gpointer)node); - break; - default: - ms_error("Error: invalid Src node Type [%d]", node->subtype); - break; + case MEDIA_STREAMER_NODE_SRC_TYPE_FILE: + node->gst_element = __ms_element_create(DEFAULT_FILE_SOURCE, NULL); + break; + case MEDIA_STREAMER_NODE_SRC_TYPE_RTSP: + node->gst_element = __ms_element_create(DEFAULT_UDP_SOURCE, NULL); + break; + case MEDIA_STREAMER_NODE_SRC_TYPE_HTTP: + node->gst_element = __ms_element_create(DEFAULT_HTTP_SOURCE, NULL); + break; + case MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA: + plugin_name = __ms_ini_get_string(dict, "sources:camera_source", DEFAULT_CAMERA_SOURCE); + node->gst_element = __ms_camera_element_create(plugin_name); + + break; + case MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_CAPTURE: + plugin_name = __ms_ini_get_string(dict, "sources:audio_source", 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(dict, "sources:video_source", DEFAULT_VIDEO_SOURCE); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST: + node->gst_element = __ms_element_create(DEFAULT_VIDEO_TEST_SOURCE, NULL); + break; + case MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_TEST: + node->gst_element = __ms_element_create(DEFAULT_AUDIO_TEST_SOURCE, NULL); + break; + case MEDIA_STREAMER_NODE_SRC_TYPE_CUSTOM: + node->gst_element = __ms_element_create(DEFAULT_APP_SOURCE, NULL); + g_signal_connect(node->gst_element, "need-data", G_CALLBACK(__ms_src_start_feed_cb), (gpointer) node); + g_signal_connect(node->gst_element, "enough-data", G_CALLBACK(__ms_src_stop_feed_cb), (gpointer) node); + break; + default: + ms_error("Error: invalid Src node Type [%d]", node->subtype); + break; } MS_SAFE_FREE(plugin_name); __ms_destroy_ini_dictionary(dict); - if (node->gst_element == NULL) { + if (node->gst_element == NULL) ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } else { + else node->name = gst_element_get_name(node->gst_element); - } return ret; } /* The appsink has received a buffer */ -static void __ms_sink_new_buffer_cb(GstElement *sink, gpointer *data) +static void __ms_sink_new_buffer_cb(GstElement * sink, gpointer * data) { - media_streamer_node_s *ms_sink = (media_streamer_node_s *)data; + media_streamer_node_s *ms_sink = (media_streamer_node_s *) data; ms_retm_if(ms_sink == NULL, "Handle is NULL"); if (ms_sink->callbacks_structure != NULL) { - media_streamer_sink_callbacks_s *sink_callbacks = - (media_streamer_sink_callbacks_s *)ms_sink->callbacks_structure; - media_streamer_sink_data_ready_cb data_ready_cb = - (media_streamer_sink_data_ready_cb) sink_callbacks->data_ready_cb.callback; + media_streamer_sink_callbacks_s *sink_callbacks = (media_streamer_sink_callbacks_s *) ms_sink->callbacks_structure; + media_streamer_sink_data_ready_cb data_ready_cb = (media_streamer_sink_data_ready_cb) sink_callbacks->data_ready_cb.callback; - if (data_ready_cb) { - data_ready_cb((media_streamer_node_h)ms_sink, sink_callbacks->data_ready_cb.user_data); - } + if (data_ready_cb) + data_ready_cb((media_streamer_node_h) ms_sink, sink_callbacks->data_ready_cb.user_data); } } /* The appsink has got eos */ -static void sink_eos(GstElement *sink, gpointer *data) +static void sink_eos(GstElement * sink, gpointer * data) { - media_streamer_node_s *ms_sink = (media_streamer_node_s *)data; + media_streamer_node_s *ms_sink = (media_streamer_node_s *) data; ms_retm_if(ms_sink == NULL, "Handle is NULL"); if (ms_sink->callbacks_structure != NULL) { - media_streamer_sink_callbacks_s *sink_callbacks = - (media_streamer_sink_callbacks_s *)ms_sink->callbacks_structure; - media_streamer_sink_eos_cb eos_cb = - (media_streamer_sink_eos_cb) sink_callbacks->eos_cb.callback; + media_streamer_sink_callbacks_s *sink_callbacks = (media_streamer_sink_callbacks_s *) ms_sink->callbacks_structure; + media_streamer_sink_eos_cb eos_cb = (media_streamer_sink_eos_cb) sink_callbacks->eos_cb.callback; - if (eos_cb) { - eos_cb((media_streamer_node_h)ms_sink, sink_callbacks->eos_cb.user_data); - } + if (eos_cb) + eos_cb((media_streamer_node_h) ms_sink, sink_callbacks->eos_cb.user_data); } } -int __ms_sink_node_create(media_streamer_node_s *node) +int __ms_sink_node_create(media_streamer_node_s * node) { ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); @@ -371,53 +355,52 @@ int __ms_sink_node_create(media_streamer_node_s *node) __ms_load_ini_dictionary(&dict); - node->set_param = (ms_node_set_param)__ms_node_set_property; + node->set_param = (ms_node_set_param) __ms_node_set_property; switch (node->subtype) { - case MEDIA_STREAMER_NODE_SINK_TYPE_FILE: - ms_error("Error: not implemented yet"); - break; - case MEDIA_STREAMER_NODE_SINK_TYPE_RTSP: - node->gst_element = __ms_element_create(DEFAULT_UDP_SINK, 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(dict, "sinks:audio_sink", DEFAULT_AUDIO_SINK); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_SINK_TYPE_SCREEN: - plugin_name = __ms_ini_get_string(dict, "sinks:video_sink", DEFAULT_VIDEO_SINK); - node->gst_element = __ms_element_create(plugin_name, NULL); - break; - case MEDIA_STREAMER_NODE_SINK_TYPE_FAKE: - node->gst_element = __ms_element_create(DEFAULT_FAKE_SINK, NULL); - break; - case MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM: - node->gst_element = __ms_element_create(DEFAULT_APP_SINK, NULL); - g_object_set(G_OBJECT(node->gst_element), "emit-signals", TRUE, NULL); - g_signal_connect(node->gst_element, "new-sample", G_CALLBACK(__ms_sink_new_buffer_cb), (gpointer)node); - g_signal_connect(node->gst_element, "eos", G_CALLBACK(sink_eos), (gpointer)node); - break; - default: - ms_error("Error: invalid Sink node Type [%d]", node->subtype); - break; + case MEDIA_STREAMER_NODE_SINK_TYPE_FILE: + ms_error("Error: not implemented yet"); + break; + case MEDIA_STREAMER_NODE_SINK_TYPE_RTSP: + node->gst_element = __ms_element_create(DEFAULT_UDP_SINK, 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(dict, "sinks:audio_sink", DEFAULT_AUDIO_SINK); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_SINK_TYPE_SCREEN: + plugin_name = __ms_ini_get_string(dict, "sinks:video_sink", DEFAULT_VIDEO_SINK); + node->gst_element = __ms_element_create(plugin_name, NULL); + break; + case MEDIA_STREAMER_NODE_SINK_TYPE_FAKE: + node->gst_element = __ms_element_create(DEFAULT_FAKE_SINK, NULL); + break; + case MEDIA_STREAMER_NODE_SINK_TYPE_CUSTOM: + node->gst_element = __ms_element_create(DEFAULT_APP_SINK, NULL); + g_object_set(G_OBJECT(node->gst_element), "emit-signals", TRUE, NULL); + g_signal_connect(node->gst_element, "new-sample", G_CALLBACK(__ms_sink_new_buffer_cb), (gpointer) node); + g_signal_connect(node->gst_element, "eos", G_CALLBACK(sink_eos), (gpointer) node); + break; + default: + ms_error("Error: invalid Sink node Type [%d]", node->subtype); + break; } MS_SAFE_FREE(plugin_name); __ms_destroy_ini_dictionary(dict); - if (node->gst_element == NULL) { + if (node->gst_element == NULL) ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } else { + else node->name = gst_element_get_name(node->gst_element); - } return ret; } -void __ms_node_destroy(media_streamer_node_s *node) +void __ms_node_destroy(media_streamer_node_s * node) { char *node_name = NULL; @@ -431,26 +414,24 @@ void __ms_node_destroy(media_streamer_node_s *node) MS_SAFE_FREE(node_name); } -int __ms_node_insert_into_table(GHashTable *nodes_table, - media_streamer_node_s *ms_node) +int __ms_node_insert_into_table(GHashTable * nodes_table, media_streamer_node_s * ms_node) { if (g_hash_table_contains(nodes_table, ms_node->name)) { ms_debug("Current Node [%s] already added into Media Streamer", ms_node->name); return MEDIA_STREAMER_ERROR_INVALID_OPERATION; } - if (!g_hash_table_insert(nodes_table, (gpointer)ms_node->name, (gpointer)ms_node)) { + if (!g_hash_table_insert(nodes_table, (gpointer) ms_node->name, (gpointer) ms_node)) { ms_debug("Error: Failed to add node [%s] into Media Streamer", ms_node->name); return MEDIA_STREAMER_ERROR_INVALID_OPERATION; } - ms_info("Node [%s] added into streamer, node type/subtype [%d/%d]", - ms_node->name, ms_node->type, ms_node->subtype); + ms_info("Node [%s] added into streamer, node type/subtype [%d/%d]", ms_node->name, ms_node->type, ms_node->subtype); return MEDIA_STREAMER_ERROR_NONE; } void __ms_node_remove_from_table(void *data) { - media_streamer_node_s *ms_node = (media_streamer_node_s *)data; + media_streamer_node_s *ms_node = (media_streamer_node_s *) data; ms_retm_if(ms_node == NULL, "Handle is NULL"); if (__ms_element_unlink(ms_node->gst_element)) { @@ -463,7 +444,7 @@ void __ms_node_remove_from_table(void *data) } } -static gboolean __ms_src_need_typefind(GstElement *src) +static gboolean __ms_src_need_typefind(GstElement * src) { gboolean ret = FALSE; g_assert(src); @@ -475,16 +456,15 @@ static gboolean __ms_src_need_typefind(GstElement *src) } GstCaps *src_caps = gst_pad_query_caps(src_pad, NULL); - if (gst_caps_is_any(src_caps)) { + if (gst_caps_is_any(src_caps)) ret = TRUE; - } gst_caps_unref(src_caps); MS_SAFE_UNREF(src_pad); return ret; } -int __ms_pipeline_prepare(media_streamer_s *ms_streamer) +int __ms_pipeline_prepare(media_streamer_s * ms_streamer) { GstElement *unlinked_element = NULL; GstPad *unlinked_pad = NULL; @@ -505,22 +485,21 @@ int __ms_pipeline_prepare(media_streamer_s *ms_streamer) unlinked_element = gst_pad_get_parent_element(unlinked_pad); ms_debug("Autoplug: found unlinked element [%s]", GST_ELEMENT_NAME(unlinked_element)); - parent = (GstElement *)gst_element_get_parent(GST_OBJECT_CAST(unlinked_element)); + parent = (GstElement *) gst_element_get_parent(GST_OBJECT_CAST(unlinked_element)); ms_info("Received new pad '%s' from [%s]", GST_PAD_NAME(unlinked_pad), GST_ELEMENT_NAME(unlinked_element)); /* If element in src bin is filesrc */ if (__ms_src_need_typefind(unlinked_element)) { found_element = __ms_element_create("decodebin", NULL); - gst_bin_add_many((GstBin *)ms_streamer->topology_bin, found_element, NULL); + gst_bin_add_many((GstBin *) ms_streamer->topology_bin, found_element, NULL); gst_element_sync_state_with_parent(found_element); - if (__ms_bin_find_element_by_klass(ms_streamer->topology_bin, found_element, - MEDIA_STREAMER_BIN_KLASS, "rtp_container")) { + if (__ms_bin_find_element_by_klass(ms_streamer->topology_bin, found_element, MEDIA_STREAMER_BIN_KLASS, "rtp_container")) g_signal_connect(found_element, "pad-added", G_CALLBACK(__decodebin_newpad_streamer_cb), ms_streamer); - } else { + else g_signal_connect(found_element, "pad-added", G_CALLBACK(__decodebin_newpad_cb), ms_streamer); - } + g_signal_connect(found_element, "autoplug-select", G_CALLBACK(__ms_decodebin_autoplug_select), NULL); found_element = __ms_link_with_new_element(unlinked_element, found_element, NULL); @@ -531,7 +510,7 @@ int __ms_pipeline_prepare(media_streamer_s *ms_streamer) } else { found_element = __ms_element_create(DEFAULT_QUEUE, NULL); - gst_bin_add_many((GstBin *)ms_streamer->topology_bin, found_element, NULL); + gst_bin_add_many((GstBin *) ms_streamer->topology_bin, found_element, NULL); gst_element_sync_state_with_parent(found_element); @@ -562,26 +541,25 @@ int __ms_pipeline_prepare(media_streamer_s *ms_streamer) return MEDIA_STREAMER_ERROR_NONE; } -static gboolean __ms_bin_remove_elements(media_streamer_s *ms_streamer, GstElement *bin) +static gboolean __ms_bin_remove_elements(media_streamer_s * ms_streamer, GstElement * bin) { GValue element = G_VALUE_INIT; GstIterator *bin_iterator = gst_bin_iterate_elements(GST_BIN(bin)); - gboolean ret = TRUE; /* If Bin doesn't have any elements function returns TRUE */ + gboolean ret = TRUE; /* If Bin doesn't have any elements function returns TRUE */ GstElement *found_element = NULL; GstIteratorResult it_res = gst_iterator_next(bin_iterator, &element); while (GST_ITERATOR_OK == it_res) { found_element = (GstElement *) g_value_get_object(&element); - /* Get node of this element if it appears as node*/ - media_streamer_node_s *found_node = (media_streamer_node_s *)g_hash_table_lookup( - ms_streamer->nodes_table, GST_ELEMENT_NAME(found_element)); + /* Get node of this element if it appears as node */ + media_streamer_node_s *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) { + if (!found_node->linked_by_user) ret = ret && __ms_element_unlink(found_element); - } else { + else ms_info("Unprepare skipped user-linked node [%s]", found_node->name); - } + __ms_generate_dots(ms_streamer->pipeline, GST_ELEMENT_NAME(found_element)); } else { ret = ret && __ms_bin_remove_element(found_element); @@ -601,7 +579,7 @@ static gboolean __ms_bin_remove_elements(media_streamer_s *ms_streamer, GstEleme return ret; } -int __ms_pipeline_unprepare(media_streamer_s *ms_streamer) +int __ms_pipeline_unprepare(media_streamer_s * ms_streamer) { ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -625,13 +603,10 @@ int __ms_pipeline_unprepare(media_streamer_s *ms_streamer) return ret; } -static void __params_foreach_cb(const char *key, - const int type, - const bundle_keyval_t *kv, - void *user_data) +static void __params_foreach_cb(const char *key, const int type, const bundle_keyval_t * kv, void *user_data) { int ret = MEDIA_STREAMER_ERROR_NONE; - media_streamer_node_s *ms_node = (media_streamer_node_s *)user_data; + media_streamer_node_s *ms_node = (media_streamer_node_s *) user_data; ms_retm_if(ms_node == NULL, "Handle is NULL"); void *basic_val = NULL; @@ -639,34 +614,30 @@ static void __params_foreach_cb(const char *key, ms_info("Try to add parameter [%s] with type [%d] to the node [%s].", key, type, ms_node->name); - if (!bundle_keyval_type_is_array((bundle_keyval_t *)kv)) { - bundle_keyval_get_basic_val((bundle_keyval_t *)kv, &basic_val, &basic_size); - ms_info("Read param value[%s] with size [%lu].", (gchar *)basic_val, (unsigned long)basic_size); + if (!bundle_keyval_type_is_array((bundle_keyval_t *) kv)) { + bundle_keyval_get_basic_val((bundle_keyval_t *) kv, &basic_val, &basic_size); + ms_info("Read param value[%s] with size [%lu].", (gchar *) basic_val, (unsigned long)basic_size); - if (ms_node->set_param != NULL) { + if (ms_node->set_param != NULL) ret = ms_node->set_param((struct media_streamer_node_s *)ms_node, (char *)key, (char *)basic_val); - } else { + else ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } } else { ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION; } - ms_retm_if(ret != MEDIA_STREAMER_ERROR_NONE, - "Error while adding param [%s,%d] to the node [%s]", - key, type, ms_node->name); + ms_retm_if(ret != MEDIA_STREAMER_ERROR_NONE, "Error while adding param [%s,%d] to the node [%s]", key, type, ms_node->name); } -int __ms_node_read_params_from_bundle(media_streamer_node_s *node, - bundle *param_list) +int __ms_node_read_params_from_bundle(media_streamer_node_s * node, bundle * param_list) { int ret = MEDIA_STREAMER_ERROR_NONE; bundle_foreach(param_list, __params_foreach_cb, (void *)node); return ret; } -static void __ms_node_get_param_value(GParamSpec *param, GValue value, char **string_value) +static void __ms_node_get_param_value(GParamSpec * param, GValue value, char **string_value) { char *string_val = NULL; GParamSpecInt *pint = NULL; @@ -674,18 +645,15 @@ static void __ms_node_get_param_value(GParamSpec *param, GValue value, char **st if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_CAMERA_ID)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_CAPTURE_WIDTH)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_CAPTURE_HEIGHT)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_IS_LIVE_STREAM)) { string_val = g_strdup_printf("%s", g_value_get_boolean(&value) ? "true" : "false"); ms_info("Got boolean value: [%s]", string_val); @@ -701,28 +669,23 @@ static void __ms_node_get_param_value(GParamSpec *param, GValue value, char **st } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_PORT)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT)) { pint = G_PARAM_SPEC_INT(param); string_val = g_strdup_printf("%d", g_value_get_int(&value)); - ms_info("Got int value: [%s], range: %d - %d", string_val, - pint->minimum, pint->maximum); + ms_info("Got int value: [%s], range: %d - %d", string_val, pint->minimum, pint->maximum); } else if (!g_strcmp0(param->name, MEDIA_STREAMER_PARAM_IP_ADDRESS)) { string_val = g_strdup_printf("%s", g_value_get_string(&value)); ms_info("Got string value: [%s]", g_value_get_string(&value)); @@ -752,8 +715,7 @@ static void __ms_node_get_param_value(GParamSpec *param, GValue value, char **st *string_value = string_val; } -void __ms_node_check_param_name(GstElement *element, gboolean name_is_known, - const char *param_name, char **init_param_name) +void __ms_node_check_param_name(GstElement * element, gboolean name_is_known, const char *param_name, char **init_param_name) { char *set_param_name = NULL; char *orig_param_name = NULL; @@ -784,20 +746,17 @@ void __ms_node_check_param_name(GstElement *element, gboolean name_is_known, } } -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) { GParamSpec **property_specs; guint num_properties, i; char *string_val = NULL; char *param_init_name = NULL; - property_specs = g_object_class_list_properties(G_OBJECT_GET_CLASS(node->gst_element), - &num_properties); + property_specs = g_object_class_list_properties(G_OBJECT_GET_CLASS(node->gst_element), &num_properties); - if (num_properties <= 0) { + if (num_properties <= 0) return MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } ms_info("Getting parameter of the Node [%s]", node->name); @@ -829,8 +788,7 @@ int __ms_node_write_params_into_bundle(media_streamer_node_s *node, return MEDIA_STREAMER_ERROR_NONE; } -int __ms_node_write_param_into_value(media_streamer_node_s *node, const char *param_name, - char **param_value) +int __ms_node_write_param_into_value(media_streamer_node_s * node, const char *param_name, char **param_value) { char *string_val = NULL; char *param_init_name = NULL; @@ -847,19 +805,17 @@ int __ms_node_write_param_into_value(media_streamer_node_s *node, const char *pa g_value_init(&value, param->value_type); - if (param->flags & G_PARAM_READWRITE) { + if (param->flags & G_PARAM_READWRITE) g_object_get_property(G_OBJECT(node->gst_element), param_init_name, &value); - } ms_info("%-20s: %s\n", param_name, g_param_spec_get_blurb(param)); __ms_node_get_param_value(param, value, &string_val); } - if (!string_val) { + if (!string_val) return MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } *param_value = string_val; return MEDIA_STREAMER_ERROR_NONE; -} \ No newline at end of file +} diff --git a/src/media_streamer_priv.c b/src/media_streamer_priv.c index 9f31d53..ab3588e 100644 --- a/src/media_streamer_priv.c +++ b/src/media_streamer_priv.c @@ -19,7 +19,7 @@ #include "media_streamer_node.h" #include "media_streamer_gst.h" -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; @@ -29,37 +29,35 @@ int __ms_state_change(media_streamer_s *ms_streamer, media_streamer_state_e stat ms_retvm_if(previous_state == state, MEDIA_STREAMER_ERROR_NONE, "Media streamer already in this state"); switch (state) { - case MEDIA_STREAMER_STATE_NONE: - /* - * Media streamer must be in IDLE state - * Unlink and destroy all bins and elements. - */ - if (previous_state != MEDIA_STREAMER_STATE_IDLE) { - __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE); - } - break; - case MEDIA_STREAMER_STATE_IDLE: - /* - * Unlink all gst_elements, set pipeline into state NULL - */ - if (previous_state != MEDIA_STREAMER_STATE_NONE) { - ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_NULL); - } - break; - case MEDIA_STREAMER_STATE_READY: - ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_READY); - break; - case MEDIA_STREAMER_STATE_PLAYING: - ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING); - break; - case MEDIA_STREAMER_STATE_PAUSED: - ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED); - break; - case MEDIA_STREAMER_STATE_SEEKING: - default: { - ms_info("Error: invalid state [%d]", state); - return MEDIA_STREAMER_ERROR_INVALID_OPERATION; - } + case MEDIA_STREAMER_STATE_NONE: + /* + * Media streamer must be in IDLE state + * Unlink and destroy all bins and elements. + */ + if (previous_state != MEDIA_STREAMER_STATE_IDLE) + __ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE); + break; + case MEDIA_STREAMER_STATE_IDLE: + /* + * Unlink all gst_elements, set pipeline into state NULL + */ + if (previous_state != MEDIA_STREAMER_STATE_NONE) + ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_NULL); + break; + case MEDIA_STREAMER_STATE_READY: + ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_READY); + break; + case MEDIA_STREAMER_STATE_PLAYING: + ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING); + break; + case MEDIA_STREAMER_STATE_PAUSED: + ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED); + break; + case MEDIA_STREAMER_STATE_SEEKING: + default:{ + ms_info("Error: invalid state [%d]", state); + return MEDIA_STREAMER_ERROR_INVALID_OPERATION; + } } if (ret != MEDIA_STREAMER_ERROR_NONE) { @@ -72,30 +70,28 @@ int __ms_state_change(media_streamer_s *ms_streamer, media_streamer_state_e stat return ret; } -int __ms_create(media_streamer_s *ms_streamer) +int __ms_create(media_streamer_s * ms_streamer) { __ms_load_ini_settings(&ms_streamer->ini); 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"); + ms_retvm_if(ms_streamer->nodes_table == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating hash table"); return __ms_pipeline_create(ms_streamer); } -int __ms_streamer_seek(media_streamer_s *ms_streamer, int g_time, bool flag) +int __ms_streamer_seek(media_streamer_s * ms_streamer, int g_time, bool flag) { ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL"); GstSeekFlags seek_flag; - if (flag) { + if (flag) seek_flag = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE; - } else { + 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]\n", g_time); return MEDIA_STREAMER_ERROR_SEEK_FAILED; } else { @@ -107,7 +103,7 @@ int __ms_streamer_seek(media_streamer_s *ms_streamer, int g_time, bool flag) return MEDIA_STREAMER_ERROR_NONE; } -int __ms_streamer_destroy(media_streamer_s *ms_streamer) +int __ms_streamer_destroy(media_streamer_s * ms_streamer) { int ret = MEDIA_STREAMER_ERROR_NONE; @@ -126,6 +122,6 @@ int __ms_streamer_destroy(media_streamer_s *ms_streamer) g_mutex_clear(&ms_streamer->mutex_lock); MS_SAFE_FREE(ms_streamer); - /* gst_deinit(); */ + /* gst_deinit(); */ return ret; } diff --git a/src/media_streamer_util.c b/src/media_streamer_util.c index 6658a1e..f71b195 100644 --- a/src/media_streamer_util.c +++ b/src/media_streamer_util.c @@ -28,8 +28,7 @@ static gboolean __ms_generate_default_ini(void); static void __ms_check_ini_status(void); -gchar *__ms_ini_get_string(dictionary *dict, - const char *ini_path, char *default_str) +gchar *__ms_ini_get_string(dictionary * dict, const char *ini_path, char *default_str) { gchar *result_str = NULL; @@ -40,18 +39,15 @@ gchar *__ms_ini_get_string(dictionary *dict, } else { gchar *str = NULL; str = iniparser_getstring(dict, ini_path, default_str); - if (str && - (strlen(str) > 0) && - (strlen(str) < MEDIA_STREAMER_INI_MAX_STRLEN)) { + if (str && (strlen(str) > 0) && (strlen(str) < MEDIA_STREAMER_INI_MAX_STRLEN)) result_str = g_strdup(str); - } else { + else result_str = g_strdup(default_str); - } } return result_str; } -gboolean __ms_load_ini_dictionary(dictionary **dict) +gboolean __ms_load_ini_dictionary(dictionary ** dict) { ms_retvm_if(dict == NULL, FALSE, "Handle is NULL"); @@ -82,7 +78,7 @@ gboolean __ms_load_ini_dictionary(dictionary **dict) return TRUE; } -gboolean __ms_destroy_ini_dictionary(dictionary *dict) +gboolean __ms_destroy_ini_dictionary(dictionary * dict) { ms_retvm_if(dict == NULL, FALSE, "Handle is null"); @@ -92,7 +88,7 @@ gboolean __ms_destroy_ini_dictionary(dictionary *dict) return TRUE; } -void __ms_load_ini_settings(media_streamer_ini_t *ini) +void __ms_load_ini_settings(media_streamer_ini_t * ini) { dictionary *dict = NULL; @@ -103,7 +99,7 @@ void __ms_load_ini_settings(media_streamer_ini_t *ini) /* general */ ini->generate_dot = iniparser_getboolean(dict, "general:generate dot", DEFAULT_GENERATE_DOT); if (ini->generate_dot == TRUE) { - gchar *dot_path = iniparser_getstring(dict, "general:dot dir" , MEDIA_STREAMER_DEFAULT_DOT_DIR); + gchar *dot_path = iniparser_getstring(dict, "general:dot dir", MEDIA_STREAMER_DEFAULT_DOT_DIR); ms_debug("generate_dot is TRUE, dot file will be stored into %s", dot_path); g_setenv("GST_DEBUG_DUMP_DOT_DIR", dot_path, FALSE); } @@ -113,7 +109,7 @@ void __ms_load_ini_settings(media_streamer_ini_t *ini) /* if dict is not available just fill the structure with default values */ ms_debug("failed to load ini. using hardcoded default"); - /* general settings*/ + /* general settings */ ini->generate_dot = DEFAULT_GENERATE_DOT; ini->use_decodebin = DEFAULT_USE_DECODEBIN; } @@ -140,9 +136,8 @@ static void __ms_check_ini_status(void) if (file_size < 5) { ms_debug("media_streamer.ini file size=%d, Corrupted! Removed", file_size); status = g_remove(MEDIA_STREAMER_INI_DEFAULT_PATH); - if (status == -1) { + if (status == -1) ms_error("failed to delete corrupted ini"); - } } } } @@ -153,13 +148,11 @@ static gboolean __ms_generate_default_ini(void) FILE *fp = NULL; gchar *default_ini = MEDIA_STREAMER_DEFAULT_INI; - /* create new file */ fp = fopen(MEDIA_STREAMER_INI_DEFAULT_PATH, "wt"); - if (!fp) { + if (!fp) return FALSE; - } /* writing default ini file */ if (strlen(default_ini) != fwrite(default_ini, 1, strlen(default_ini), fp)) { @@ -175,21 +168,21 @@ static gboolean __ms_generate_default_ini(void) const gchar *__ms_convert_mime_to_string(media_format_mimetype_e mime) { switch (mime) { - case MEDIA_FORMAT_I420: - return "I420"; - case MEDIA_FORMAT_YV12: - return "YV12"; - case MEDIA_FORMAT_H263: - return "h263"; - case MEDIA_FORMAT_H264_HP: - case MEDIA_FORMAT_H264_MP: - case MEDIA_FORMAT_H264_SP: - return "h264"; - case MEDIA_FORMAT_PCM: - return DEFAULT_AUDIO; - default: - ms_error("Invalid or Unsupported media format [%d].", mime); - return NULL; + case MEDIA_FORMAT_I420: + return "I420"; + case MEDIA_FORMAT_YV12: + return "YV12"; + case MEDIA_FORMAT_H263: + return "h263"; + case MEDIA_FORMAT_H264_HP: + case MEDIA_FORMAT_H264_MP: + case MEDIA_FORMAT_H264_SP: + return "h264"; + case MEDIA_FORMAT_PCM: + return DEFAULT_AUDIO; + default: + ms_error("Invalid or Unsupported media format [%d].", mime); + return NULL; } } @@ -197,20 +190,20 @@ const gchar *__ms_convert_mime_to_string(media_format_mimetype_e mime) const gchar *__ms_convert_mime_to_rtp_format(media_format_mimetype_e mime) { switch (mime) { - case MEDIA_FORMAT_I420: - case MEDIA_FORMAT_YV12: - return "RAW"; - case MEDIA_FORMAT_H263: - return "H263"; - case MEDIA_FORMAT_H264_HP: - case MEDIA_FORMAT_H264_MP: - case MEDIA_FORMAT_H264_SP: - return "H264"; - case MEDIA_FORMAT_PCM: - return "L16"; - default: - ms_error("Invalid or Unsupported media format [%d].", mime); - return NULL; + case MEDIA_FORMAT_I420: + case MEDIA_FORMAT_YV12: + return "RAW"; + case MEDIA_FORMAT_H263: + return "H263"; + case MEDIA_FORMAT_H264_HP: + case MEDIA_FORMAT_H264_MP: + case MEDIA_FORMAT_H264_SP: + return "H264"; + case MEDIA_FORMAT_PCM: + return "L16"; + default: + ms_error("Invalid or Unsupported media format [%d].", mime); + return NULL; } } diff --git a/test/media_streamer_test.c b/test/media_streamer_test.c index c3da0e5..fa16d13 100755 --- a/test/media_streamer_test.c +++ b/test/media_streamer_test.c @@ -24,12 +24,12 @@ #include typedef enum { - MENU_STATE_UNKNOWN = 0, - MENU_STATE_MAIN_MENU, - MENU_STATE_BROADCAST_MENU, - MENU_STATE_VOIP_MENU, - MENU_STATE_PLAYING_MENU, - MENU_STATE_PRESET_MENU + MENU_STATE_UNKNOWN = 0, + MENU_STATE_MAIN_MENU, + MENU_STATE_BROADCAST_MENU, + MENU_STATE_VOIP_MENU, + MENU_STATE_PLAYING_MENU, + MENU_STATE_PRESET_MENU } menu_state_e; typedef enum { @@ -115,8 +115,8 @@ media_format_h vfmt_encoded = NULL; media_format_h afmt_raw = NULL; static void streamer_error_cb(media_streamer_h streamer, - media_streamer_error_e error, - void *user_data) + media_streamer_error_e error, + void *user_data) { g_print("Media Streamer posted error [%d] \n", error); } @@ -131,9 +131,8 @@ static void _create(media_streamer_h *streamer) g_print("== create \n"); int ret = MEDIA_STREAMER_ERROR_NONE; - if (*streamer != NULL) { + if (*streamer != NULL) return; - } ret = media_streamer_create(streamer); @@ -171,7 +170,7 @@ static void _unprepare(void) g_print("== success unprepare \n"); } -static void _play() +static void _play(void) { g_print("== play \n"); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -184,7 +183,7 @@ static void _play() g_print("== success play \n"); } -static void _pause() +static void _pause(void) { g_print("== pause \n"); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -197,13 +196,13 @@ static void _pause() g_print("== success pause \n"); } -static void _seek() +static void _seek(void) { g_print("== seek \n"); int ret = MEDIA_STREAMER_ERROR_NONE; ret = media_streamer_set_play_position(current_media_streamer, g_time, TRUE, - streamer_seek_cb, current_media_streamer); + streamer_seek_cb, current_media_streamer); if (ret != MEDIA_STREAMER_ERROR_NONE) { g_print("Fail to seek media streamer"); @@ -212,7 +211,7 @@ static void _seek() g_print("== success seek \n"); } -static void _stop() +static void _stop(void) { g_print("== stop \n"); int ret = MEDIA_STREAMER_ERROR_NONE; @@ -241,11 +240,11 @@ static void _destroy(media_streamer_h streamer) return; } - if (current_media_streamer == g_media_streamer) { + if (current_media_streamer == g_media_streamer) g_media_streamer = NULL; - } else { + else g_media_streamer_2 = NULL; - } + current_media_streamer = NULL; g_print("== success destroy \n"); @@ -253,15 +252,14 @@ static void _destroy(media_streamer_h streamer) static void create_formats(void) { - if (!vfmt_raw || !vfmt_encoded || !afmt_raw) { + if (!vfmt_raw || !vfmt_encoded || !afmt_raw) g_print("Formats already created!"); - } /* Define video raw format */ media_format_create(&vfmt_raw); - if (media_format_set_video_mime(vfmt_raw, MEDIA_FORMAT_YV12) != MEDIA_FORMAT_ERROR_NONE) { + if (media_format_set_video_mime(vfmt_raw, MEDIA_FORMAT_YV12) != MEDIA_FORMAT_ERROR_NONE) g_print("media_format_set_video_mime failed!"); - } + media_format_set_video_width(vfmt_raw, 800); media_format_set_video_height(vfmt_raw, 600); media_format_set_video_avg_bps(vfmt_raw, 10000); @@ -269,9 +267,9 @@ static void create_formats(void) /* Define encoded video format */ media_format_create(&vfmt_encoded); - if (media_format_set_video_mime(vfmt_encoded, MEDIA_FORMAT_H263) != MEDIA_FORMAT_ERROR_NONE) { + if (media_format_set_video_mime(vfmt_encoded, MEDIA_FORMAT_H263) != MEDIA_FORMAT_ERROR_NONE) g_print("media_format_set_video_mime failed!"); - } + media_format_set_video_width(vfmt_encoded, 800); media_format_set_video_height(vfmt_encoded, 600); media_format_set_video_avg_bps(vfmt_encoded, 10000); @@ -279,19 +277,16 @@ static void create_formats(void) /* Define audio raw format */ media_format_create(&afmt_raw); - if (media_format_set_audio_mime(afmt_raw, MEDIA_FORMAT_PCM) != MEDIA_FORMAT_ERROR_NONE) { + if (media_format_set_audio_mime(afmt_raw, MEDIA_FORMAT_PCM) != MEDIA_FORMAT_ERROR_NONE) g_print("media_format_set_audio_mime failed!"); - } + media_format_set_audio_channel(afmt_raw, 1); media_format_set_audio_samplerate(afmt_raw, 44100); media_format_set_audio_bit(afmt_raw, 16); } -static void set_rtp_params(media_streamer_node_h rtp_node, - const char *ip, - int video_port, - int audio_port, - gboolean port_reverse) +static void set_rtp_params(media_streamer_node_h rtp_node, const char *ip, + int video_port, int audio_port, gboolean port_reverse) { bundle *params = bundle_create(); @@ -299,12 +294,10 @@ static void set_rtp_params(media_streamer_node_h rtp_node, gchar *audio_src_port = g_strdup_printf("%d", port_reverse ? (audio_port + 5) : audio_port); gchar *audio_sink_port = g_strdup_printf("%d", port_reverse ? audio_port : (audio_port + 5)); - if (g_menu_preset & PRESET_RTP_STREAMER) { + if (g_menu_preset & PRESET_RTP_STREAMER) bundle_add_str(params, MEDIA_STREAMER_PARAM_AUDIO_OUT_PORT, audio_sink_port); - } - if (g_menu_preset & PRESET_RTP_CLIENT) { + if (g_menu_preset & PRESET_RTP_CLIENT) bundle_add_str(params, MEDIA_STREAMER_PARAM_AUDIO_IN_PORT, audio_src_port); - } g_free(audio_src_port); g_free(audio_sink_port); @@ -314,12 +307,10 @@ static void set_rtp_params(media_streamer_node_h rtp_node, char *video_src_port = g_strdup_printf("%d", port_reverse ? (video_port + 5) : video_port); char *video_sink_port = g_strdup_printf("%d", port_reverse ? video_port : (video_port + 5)); - if (g_menu_preset & PRESET_RTP_STREAMER) { + if (g_menu_preset & PRESET_RTP_STREAMER) bundle_add_str(params, MEDIA_STREAMER_PARAM_VIDEO_OUT_PORT, video_sink_port); - } - if (g_menu_preset & PRESET_RTP_CLIENT) { + if (g_menu_preset & PRESET_RTP_CLIENT) bundle_add_str(params, MEDIA_STREAMER_PARAM_VIDEO_IN_PORT, video_src_port); - } g_free(video_src_port); g_free(video_sink_port); @@ -379,8 +370,8 @@ static void _create_file_streaming() { g_print("\n _create_file_playing \n"); media_streamer_node_h file_src = NULL; - media_streamer_node_create_src( MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &file_src); - media_streamer_node_set_param(file_src,MEDIA_STREAMER_PARAM_URI, g_uri); + media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &file_src); + media_streamer_node_set_param(file_src, MEDIA_STREAMER_PARAM_URI, g_uri); media_streamer_node_add(current_media_streamer, file_src); } @@ -414,7 +405,7 @@ static void _create_rtp_streamer(media_streamer_node_h rtp_bin) g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA, &video_src); } else if (g_scenario_mode == SCENARIO_MODE_VIDEOTEST_SCREEN || - g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { + g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST, &video_src); } @@ -447,7 +438,7 @@ static void _create_rtp_streamer(media_streamer_node_h rtp_bin) g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_CAPTURE, &audio_src); } else if (g_scenario_mode == SCENARIO_MODE_AUDIOTEST_PHONE || - g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { + g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_TEST, &audio_src); } @@ -485,7 +476,7 @@ static void _create_rtp_streamer_autoplug(media_streamer_node_h rtp_bin) g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_CAMERA, &video_src); } else if (g_scenario_mode == SCENARIO_MODE_VIDEOTEST_SCREEN || - g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { + g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_VIDEO_TEST, &video_src); } @@ -502,7 +493,7 @@ static void _create_rtp_streamer_autoplug(media_streamer_node_h rtp_bin) g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_CAPTURE, &audio_src); } else if (g_scenario_mode == SCENARIO_MODE_AUDIOTEST_PHONE || - g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { + g_scenario_mode == SCENARIO_MODE_TEST_VIDEO_AUDIO) { media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_AUDIO_TEST, &audio_src); } @@ -604,8 +595,7 @@ static void _create_rtp_client_autoplug(media_streamer_node_h rtp_bin) } static media_streamer_node_h _create_rtp(int video_port, - int audio_port, - gboolean second_client) + int audio_port, gboolean second_client) { g_print("== create rtp node for current preset \n"); @@ -619,8 +609,7 @@ static media_streamer_node_h _create_rtp(int video_port, /* Application source callback */ static void buffer_status_cb(media_streamer_node_h node, - media_streamer_custom_buffer_status_e status, - void *user_data) + media_streamer_custom_buffer_status_e status, void *user_data) { static int count = 0; @@ -774,7 +763,7 @@ static void display_autoplug_select_menu(void) g_print("\n"); g_print("Please select Media Streamer pluging mode\n"); g_print("By default will be used [%s] mode\n", - g_autoplug_mode == TRUE ? "autoplug" : "manual"); + g_autoplug_mode == TRUE ? "autoplug" : "manual"); g_print("1. Manual mode \n"); g_print("2. Autoplug mode \n"); } @@ -880,51 +869,51 @@ static void display_menu(void) { if (g_sub_menu_state == SUBMENU_STATE_UNKNOWN) { switch (g_menu_state) { - case MENU_STATE_MAIN_MENU: - display_main_menu(); - break; - case MENU_STATE_BROADCAST_MENU: - display_broadcast_menu(); - break; - case MENU_STATE_VOIP_MENU: - display_voip_menu(); - break; - case MENU_STATE_PLAYING_MENU: - display_preset_menu(); - break; - case MENU_STATE_PRESET_MENU: - display_preset_menu(); - break; - default: - g_print("*** Unknown status.\n"); - break; + case MENU_STATE_MAIN_MENU: + display_main_menu(); + break; + case MENU_STATE_BROADCAST_MENU: + display_broadcast_menu(); + break; + case MENU_STATE_VOIP_MENU: + display_voip_menu(); + break; + case MENU_STATE_PLAYING_MENU: + display_preset_menu(); + break; + case MENU_STATE_PRESET_MENU: + display_preset_menu(); + break; + default: + g_print("*** Unknown status.\n"); + break; } } else { switch (g_sub_menu_state) { - case SUBMENU_STATE_GETTING_IP: - display_getting_ip_menu(); - break; - case SUBMENU_STATE_GETTING_SEEK_POS: - display_getting_seek_position_menu(); - break; - case SUBMENU_STATE_GETTING_VIDEOFILE_URI: - display_getting_uri_menu(); - break; - case SUBMENU_STATE_GETTING_SUBFILE_URI: - display_getting_sub_uri_menu(); - break; - case SUBMENU_STATE_AUTOPLUG: - display_autoplug_select_menu(); - break; - case SUBMENU_STATE_SCENARIO: - display_scenario_select_menu(); - break; - case SUBMENU_STATE_PLAYING_SCENARIO: - display_playing_scenario_select_menu(); - break; - default: - g_print("*** Unknown Submenu state.\n"); - break; + case SUBMENU_STATE_GETTING_IP: + display_getting_ip_menu(); + break; + case SUBMENU_STATE_GETTING_SEEK_POS: + display_getting_seek_position_menu(); + break; + case SUBMENU_STATE_GETTING_VIDEOFILE_URI: + display_getting_uri_menu(); + break; + case SUBMENU_STATE_GETTING_SUBFILE_URI: + display_getting_sub_uri_menu(); + break; + case SUBMENU_STATE_AUTOPLUG: + display_autoplug_select_menu(); + break; + case SUBMENU_STATE_SCENARIO: + display_scenario_select_menu(); + break; + case SUBMENU_STATE_PLAYING_SCENARIO: + display_playing_scenario_select_menu(); + break; + default: + g_print("*** Unknown Submenu state.\n"); + break; } } } @@ -935,51 +924,51 @@ static void run_preset(void) create_formats(); switch (g_menu_preset) { - case PRESET_RTP_STREAMER: - rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, FALSE); - if (g_autoplug_mode) { - _create_rtp_streamer_autoplug(rtp_bin); - } else { - _create_rtp_streamer(rtp_bin); - } - break; - case PRESET_RTP_CLIENT: - rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, TRUE); - if (g_autoplug_mode) { - _create_rtp_client_autoplug(rtp_bin); - } else { - _create_rtp_client(rtp_bin); - } - break; - case PRESET_VOIP: - rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, FALSE); - _create_rtp_streamer(rtp_bin); - _create_rtp_client(rtp_bin); - break; - case PRESET_VOIP_2: - rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, TRUE); + case PRESET_RTP_STREAMER: + rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, FALSE); + if (g_autoplug_mode) + _create_rtp_streamer_autoplug(rtp_bin); + else _create_rtp_streamer(rtp_bin); + + break; + case PRESET_RTP_CLIENT: + rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, TRUE); + if (g_autoplug_mode) + _create_rtp_client_autoplug(rtp_bin); + else _create_rtp_client(rtp_bin); - break; - case PRESET_DOUBLE_VOIP_SERVER: - rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, FALSE); - _create_rtp_streamer(rtp_bin); - break; - case PRESET_DOUBLE_VOIP_SERVER_2: - rtp_bin = _create_rtp(VIDEO_PORT + 10, AUDIO_PORT + 10, TRUE); - _create_rtp_streamer(rtp_bin); - break; - case PRESET_DOUBLE_VOIP_CLIENT: - rtp_bin = _create_rtp(VIDEO_PORT + 10, AUDIO_PORT + 10, FALSE); - _create_rtp_client(rtp_bin); - break; - case PRESET_DOUBLE_VOIP_CLIENT_2: - rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, TRUE); - _create_rtp_client(rtp_bin); - break; - default: - g_print("Invalid menu preset was selected!"); - break; + + break; + case PRESET_VOIP: + rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, FALSE); + _create_rtp_streamer(rtp_bin); + _create_rtp_client(rtp_bin); + break; + case PRESET_VOIP_2: + rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, TRUE); + _create_rtp_streamer(rtp_bin); + _create_rtp_client(rtp_bin); + break; + case PRESET_DOUBLE_VOIP_SERVER: + rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, FALSE); + _create_rtp_streamer(rtp_bin); + break; + case PRESET_DOUBLE_VOIP_SERVER_2: + rtp_bin = _create_rtp(VIDEO_PORT + 10, AUDIO_PORT + 10, TRUE); + _create_rtp_streamer(rtp_bin); + break; + case PRESET_DOUBLE_VOIP_CLIENT: + rtp_bin = _create_rtp(VIDEO_PORT + 10, AUDIO_PORT + 10, FALSE); + _create_rtp_client(rtp_bin); + break; + case PRESET_DOUBLE_VOIP_CLIENT_2: + rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, TRUE); + _create_rtp_client(rtp_bin); + break; + default: + g_print("Invalid menu preset was selected!"); + break; } } @@ -987,17 +976,17 @@ void run_playing_preset(void) { create_formats(); - if (g_scenario_mode == SCENARIO_MODE_FILE_PLAY_VIDEO_AUDIO) { + if (g_scenario_mode == SCENARIO_MODE_FILE_PLAY_VIDEO_AUDIO) _create_file_playing(); - } else if (g_scenario_mode == SCENARIO_MODE_FILE_SUBTITLE_VIDEO_AUDIO) { + else if (g_scenario_mode == SCENARIO_MODE_FILE_SUBTITLE_VIDEO_AUDIO) _create_file_sub_playing(); - } else if (g_scenario_mode == SCENARIO_MODE_HTTP_VIDEO_AUDIO) { + else if (g_scenario_mode == SCENARIO_MODE_HTTP_VIDEO_AUDIO) _create_http_playing(); - } else if ((g_scenario_mode == SCENARIO_MODE_APPSRC_APPSINK)) { + else if ((g_scenario_mode == SCENARIO_MODE_APPSRC_APPSINK)) _create_app_test(); - } else { + else g_print("Invalid playing menu preset was selected!"); - } + } void _interpret_main_menu(char *cmd) @@ -1005,15 +994,15 @@ void _interpret_main_menu(char *cmd) int len = strlen(cmd); if (len == 1) { - if (!strncmp(cmd, "1", len)) { + if (!strncmp(cmd, "1", len)) g_menu_state = MENU_STATE_BROADCAST_MENU; - } else if (!strncmp(cmd, "2", len)) { + else if (!strncmp(cmd, "2", len)) g_menu_state = MENU_STATE_VOIP_MENU; - } else if (!strncmp(cmd, "3", len)) { + else if (!strncmp(cmd, "3", len)) g_menu_state = MENU_STATE_PLAYING_MENU; - } else if (!strncmp(cmd, "q", len)) { + else if (!strncmp(cmd, "q", len)) quit(); - } + } else { g_print("wrong command\n"); } @@ -1161,9 +1150,9 @@ void _interpret_getting_ip_menu(char *cmd) { int min_len = strlen("0.0.0.0"); int cmd_len = strlen(cmd); - if (g_broadcast_address != NULL) { + if (g_broadcast_address != NULL) g_free(g_broadcast_address); - } + if (cmd_len > min_len) { g_broadcast_address = g_strdup(cmd); @@ -1194,9 +1183,9 @@ void _interpret_getting_seek_position_menu(char *cmd) void _interpret_getting_sub_uri_menu(char *cmd) { if (cmd) { - if (g_sub_uri != NULL) { + if (g_sub_uri != NULL) g_free(g_sub_uri); - } + g_sub_uri = g_strdup(cmd); g_print("== URI set to [%s]\n", g_sub_uri); } else { @@ -1216,9 +1205,9 @@ void _interpret_getting_sub_uri_menu(char *cmd) void _interpret_getting_uri_menu(char *cmd) { if (cmd) { - if (g_uri != NULL) { + if (g_uri != NULL) g_free(g_uri); - } + g_uri = g_strdup(cmd); g_print("== URI set to [%s]\n", g_uri); } else { @@ -1249,23 +1238,22 @@ void _interpret_getting_uri_menu(char *cmd) void _interpret_autoplug_menu(char *cmd) { if (strlen(cmd) == 1) { - if (cmd[0] == '2') { + if (cmd[0] == '2') g_autoplug_mode = true; - } else { + else g_autoplug_mode = false; - } + } else { g_print("Invalid input. Default autoplug mode will be used\n"); } g_print("Selected pluging mode is [%s]\n", - g_autoplug_mode == TRUE ? "autoplug" : "manual"); + g_autoplug_mode == TRUE ? "autoplug" : "manual"); - if (g_menu_preset & PRESET_RTP_STREAMER) { + if (g_menu_preset & PRESET_RTP_STREAMER) g_sub_menu_state = SUBMENU_STATE_GETTING_IP; - } else { + else g_sub_menu_state = SUBMENU_STATE_SCENARIO; - } } void _interpret_preset_menu(char *cmd) @@ -1287,11 +1275,11 @@ void _interpret_preset_menu(char *cmd) } else if (!strncmp(cmd, "2", len)) { /* call the run_preset function after autoplug mode was selected; */ - if (g_menu_state == MENU_STATE_PLAYING_MENU) { + if (g_menu_state == MENU_STATE_PLAYING_MENU) g_sub_menu_state = SUBMENU_STATE_PLAYING_SCENARIO; - } else { + else g_sub_menu_state = SUBMENU_STATE_AUTOPLUG; - } + } else if (!strncmp(cmd, "3", len)) { _prepare(); } else if (!strncmp(cmd, "4", len)) { @@ -1327,52 +1315,52 @@ static void interpret_cmd(char *cmd) { if (g_sub_menu_state == SUBMENU_STATE_UNKNOWN) { switch (g_menu_state) { - case MENU_STATE_MAIN_MENU: - _interpret_main_menu(cmd); - break; - case MENU_STATE_BROADCAST_MENU: - _interpret_broadcast_menu(cmd); - break; - case MENU_STATE_VOIP_MENU: - _interpret_voip_menu(cmd); - break; - case MENU_STATE_PLAYING_MENU: - _interpret_preset_menu(cmd); - break; - case MENU_STATE_PRESET_MENU: - _interpret_preset_menu(cmd); - break; - default: - g_print("Invalid command\n"); - return; - break; + case MENU_STATE_MAIN_MENU: + _interpret_main_menu(cmd); + break; + case MENU_STATE_BROADCAST_MENU: + _interpret_broadcast_menu(cmd); + break; + case MENU_STATE_VOIP_MENU: + _interpret_voip_menu(cmd); + break; + case MENU_STATE_PLAYING_MENU: + _interpret_preset_menu(cmd); + break; + case MENU_STATE_PRESET_MENU: + _interpret_preset_menu(cmd); + break; + default: + g_print("Invalid command\n"); + return; + break; } } else { switch (g_sub_menu_state) { - case SUBMENU_STATE_GETTING_IP: - _interpret_getting_ip_menu(cmd); - break; - case SUBMENU_STATE_GETTING_SEEK_POS: - _interpret_getting_seek_position_menu(cmd); - break; - case SUBMENU_STATE_GETTING_VIDEOFILE_URI: - _interpret_getting_uri_menu(cmd); - break; - case SUBMENU_STATE_GETTING_SUBFILE_URI: - _interpret_getting_sub_uri_menu(cmd); - break; - case SUBMENU_STATE_AUTOPLUG: - _interpret_autoplug_menu(cmd); - break; - case SUBMENU_STATE_SCENARIO: - _interpret_scenario_menu(cmd); - break; - case SUBMENU_STATE_PLAYING_SCENARIO: - _interpret_playing_scenario_menu(cmd); - break; - default: - g_print("*** Unknown Submenu state.\n"); - break; + case SUBMENU_STATE_GETTING_IP: + _interpret_getting_ip_menu(cmd); + break; + case SUBMENU_STATE_GETTING_SEEK_POS: + _interpret_getting_seek_position_menu(cmd); + break; + case SUBMENU_STATE_GETTING_VIDEOFILE_URI: + _interpret_getting_uri_menu(cmd); + break; + case SUBMENU_STATE_GETTING_SUBFILE_URI: + _interpret_getting_sub_uri_menu(cmd); + break; + case SUBMENU_STATE_AUTOPLUG: + _interpret_autoplug_menu(cmd); + break; + case SUBMENU_STATE_SCENARIO: + _interpret_scenario_menu(cmd); + break; + case SUBMENU_STATE_PLAYING_SCENARIO: + _interpret_playing_scenario_menu(cmd); + break; + default: + g_print("*** Unknown Submenu state.\n"); + break; } }