* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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.
* @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);
/**
* @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
* @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.
* @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);
/**
* @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);
/**
* @}
*
* @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.
* @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.
*
* @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
*
* @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.
*
* @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.
*
* @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.
*
* @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.
*
* @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.
*
* @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);
*
* @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.
* @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
}
#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"<Enter>"); \
- } while(0)
+ } while (0)
#define ms_debug_fleave() do { \
LOGD(FONT_COLOR_PURPLE"<Leave>"); \
- } 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"
*
* @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.
* 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) {
}
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) {
}
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;
}
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) {
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);
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);
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);
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");
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;
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");
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;
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;
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");
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);
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");
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);
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");
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;
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;
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;
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;
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;
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;
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;
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;
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;
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");
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");
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;
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");
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");
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");
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");
*param_value = ms_param;
return MEDIA_STREAMER_ERROR_NONE;
}
-
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;
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");
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;
}
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;
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;
}
/* 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);
return ret;
}
-gboolean __ms_element_unlink(GstElement *element)
+gboolean __ms_element_unlink(GstElement * element)
{
gboolean ret = TRUE;
GstPad *pad = NULL;
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);
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);
}
}
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;
/* 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)) {
} 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);
}
/* 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;
}
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;
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;
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)) {
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);
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;
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);
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);
} 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);
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);
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;
}
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;
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;
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;
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 {
/* 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;
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 {
/* 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;
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;
/* 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);
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);
/* 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");
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);
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);
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");
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;
}
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");
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);
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;
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);
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;
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);
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);
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) {
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);
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);
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;
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. */
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);
}
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)) {
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;
}
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;
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.");
}
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;
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)) {
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;
}
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;
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;
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);
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.");
} 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.");
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;
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);
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;
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);
{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");
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");
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");
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");
__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");
__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;
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)) {
}
}
-static gboolean __ms_src_need_typefind(GstElement *src)
+static gboolean __ms_src_need_typefind(GstElement * src)
{
gboolean ret = FALSE;
g_assert(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;
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);
} 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);
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);
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;
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;
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;
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);
} 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));
*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;
}
}
-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);
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;
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
+}
#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;
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) {
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 {
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;
g_mutex_clear(&ms_streamer->mutex_lock);
MS_SAFE_FREE(ms_streamer);
- /* gst_deinit(); */
+ /* gst_deinit(); */
return ret;
}
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;
} 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");
return TRUE;
}
-gboolean __ms_destroy_ini_dictionary(dictionary *dict)
+gboolean __ms_destroy_ini_dictionary(dictionary * dict)
{
ms_retvm_if(dict == NULL, FALSE, "Handle is null");
return TRUE;
}
-void __ms_load_ini_settings(media_streamer_ini_t *ini)
+void __ms_load_ini_settings(media_streamer_ini_t * ini)
{
dictionary *dict = NULL;
/* 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);
}
/* 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;
}
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");
- }
}
}
}
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)) {
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;
}
}
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;
}
}
#include <media_streamer.h>
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 {
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);
}
g_print("== create \n");
int ret = MEDIA_STREAMER_ERROR_NONE;
- if (*streamer != NULL) {
+ if (*streamer != NULL)
return;
- }
ret = media_streamer_create(streamer);
g_print("== success unprepare \n");
}
-static void _play()
+static void _play(void)
{
g_print("== play \n");
int ret = MEDIA_STREAMER_ERROR_NONE;
g_print("== success play \n");
}
-static void _pause()
+static void _pause(void)
{
g_print("== pause \n");
int ret = MEDIA_STREAMER_ERROR_NONE;
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");
g_print("== success seek \n");
}
-static void _stop()
+static void _stop(void)
{
g_print("== stop \n");
int ret = MEDIA_STREAMER_ERROR_NONE;
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");
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);
/* 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);
/* 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();
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);
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);
{
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);
}
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);
}
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);
}
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);
}
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);
}
}
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");
/* 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;
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");
}
{
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;
}
}
}
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;
}
}
{
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)
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");
}
{
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);
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 {
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 {
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)
} 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)) {
{
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;
}
}
projects / platform / core / api / mediastreamer.git / commitdiff