* @see media_streamer_node_destroy()
*/
int media_streamer_node_create_src(media_streamer_node_src_type_e type,
- media_streamer_node_h *src);
+ media_streamer_node_h *src);
/**
* @brief Pushes packet into custom source node.
* @see #media_packet_h
*/
int media_streamer_node_push_packet(media_streamer_node_h src,
- media_packet_h packet);
+ media_packet_h packet);
/**
* @brief Creates media streamer sink node.
* @see media_streamer_node_destroy()
*/
int media_streamer_node_create_sink(media_streamer_node_sink_type_e type,
- media_streamer_node_h *sink);
+ media_streamer_node_h *sink);
/**
* @brief Pulls packet from custom sink node.
* @see media_streamer_node_create_sink()
*/
int media_streamer_node_pull_packet(media_streamer_node_h sink,
- media_packet_h *packet);
+ 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
*/
int media_streamer_node_set_pad_format(media_streamer_node_h node,
- const char *pad_name,
- media_format_h fmt);
+ const char *pad_name,
+ media_format_h fmt);
/**
* @brief Gets media format for pad of media streamer node.
* @see #media_format_h
*/
int media_streamer_node_get_pad_format(media_streamer_node_h node,
- const char *pad_name,
- media_format_h *fmt);
+ const char *pad_name,
+ media_format_h *fmt);
/**
* @brief Gets name of node pads.
* @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);
+ char ***src_pad_name,
+ int *src_pad_num,
+ char ***sink_pad_name,
+ int *sink_pad_num);
/**
* @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);
/**
*
* @since_tizen 3.0
*/
-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);
/**
* @brief Creates GstElement by plugin name.
gpointer data);
/**
- * @brief Callback function to link decodebin for file playing.
+ * @brief Callback function to link decodebin with the sink element at the streamer part.
*
* @since_tizen 3.0
*/
*
* @since_tizen 3.0
*/
-GstElement * __ms_combine_next_element(GstElement *previous_element,
- const gchar *next_elem_klass_name,
- const gchar *next_elem_bin_name,
- const gchar *element_type,
- gchar *default_element);
+GstElement *__ms_combine_next_element(GstElement *previous_element,
+ const gchar *next_elem_klass_name,
+ const gchar *next_elem_bin_name,
+ const gchar *element_type,
+ gchar *default_element);
/**
* @brief Creates pipeline, bus and src/sink/topology bins.
*/
int __ms_element_set_fmt(media_streamer_node_s *node, const char *pad_name, media_format_h fmt);
+/**
+ * @brief Seeks GstElement to according time value.
+ *
+ * @since_tizen 3.0
+ */
+gboolean __ms_gst_seek(GstElement *element, gint64 g_time, GstSeekFlags seek_flag);
+
/**
* @brief Push the media packet buffer to the source element.
*
* @since_tizen 3.0
*/
int __ms_node_set_property(media_streamer_node_s *ms_node,
- const gchar *param_key,
- const gchar *param_value);
+ const gchar *param_key,
+ const gchar *param_value);
/**
* @brief Creates media streamer node using input and output format.
/* setting default values if each value is not specified in .ini file */
/* general */
#define DEFAULT_GENERATE_DOT FALSE
-#define DEFAULT_USE_DECODEBIN FALSE
+#define DEFAULT_USE_DECODEBIN FALSE
#define DEFAULT_AUDIO_SOURCE "alsasrc"
#define DEFAULT_CAMERA_SOURCE "v4l2src"
#define DEFAULT_VIDEO_SOURCE "ximagesrc"
#define DEFAULT_AUDIO_RTPDEPAY "rtpL16depay"
#define MEDIA_STREAMER_DEFAULT_CAMERA_FORMAT "video/x-raw,width=1280,height=720"
-#define MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT "audio/x-raw,channels=1,rate=44100,format=S16BE"
+#define MEDIA_STREAMER_DEFAULT_AUDIO_FORMAT "audio/x-raw,channels=1,rate=44100,format=S16LE"
#define MEDIA_STREAMER_DEFAULT_ENCODER_FORMAT "video/x-h263,stream-format=byte-stream,profile=high"
#define MS_ELEMENT_IS_OUTPUT(el) g_strrstr(el, "out")
#define MS_ELEMENT_IS_DECODER(el) g_strrstr(el, "decoder")
#define MEDIA_STREAMER_DEFAULT_DOT_DIR "/tmp"
-#define MEDIA_STREAMER_DEFAULT_INI \
-"\
+#define MEDIA_STREAMER_DEFAULT_INI "\
[general] \n\
; generating dot file representing pipeline state \n\
generate dot = no \n\
*/
int media_streamer_node_create_src(media_streamer_node_src_type_e type,
- media_streamer_node_h *src)
+ media_streamer_node_h *src)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
}
int media_streamer_node_create_sink(media_streamer_node_sink_type_e type,
- media_streamer_node_h *sink)
+ media_streamer_node_h *sink)
{
int ret = MEDIA_STREAMER_ERROR_NONE;
}
int media_streamer_node_push_packet(media_streamer_node_h src,
- media_packet_h packet)
+ media_packet_h packet)
{
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.");
+ 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.");
+ 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)
+ media_packet_h *packet)
{
media_streamer_node_s *ms_node = (media_streamer_node_s *)sink;
ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
ms_retvm_if(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.");
+ 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.");
+ 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_set_param(media_streamer_node_h node,
- const char *param_name, const char *param_value)
+ const char *param_name, const char *param_value)
{
media_streamer_node_s *ms_node = (media_streamer_node_s *)node;
ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
char *ms_param = NULL;
- if (__ms_node_write_param_into_value(ms_node, param_name,&ms_param) != MEDIA_STREAMER_ERROR_NONE) {
+ if (__ms_node_write_param_into_value(ms_node, param_name, &ms_param) != MEDIA_STREAMER_ERROR_NONE) {
ms_info("Node [%s] does not have param [%s]", ms_node->name, param_name);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
gchar *bin_name = gst_element_get_name(gst_bin);
GstPad *ghost_pad = gst_ghost_pad_new_no_target(ghost_pad_name, pad_direction);
if (gst_element_add_pad(GST_ELEMENT(gst_bin), ghost_pad)) {
- gst_pad_set_active(ghost_pad, TRUE);
- ms_info("Added [%s] empty ghostpad into [%s]", ghost_pad_name, bin_name);
+ gst_pad_set_active(ghost_pad, TRUE);
+ ms_info("Added [%s] empty ghostpad into [%s]", ghost_pad_name, bin_name);
} else {
ms_info("Error: Failed to add empty [%s] ghostpad into [%s]", ghost_pad_name, bin_name);
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
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);
+ element_name, pad_name, bin_name);
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
__ms_node_check_param_name(element, TRUE, key, &init_name);
- if (init_name)
- {
+ if (init_name) {
GObject *obj = __ms_get_property_owner(element, init_name, &value);
if (obj == NULL) {
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;
+ int first_feature_rank_inc = 0, second_feature_rank_inc = 0;
name = gst_plugin_feature_get_plugin_name(first_feature);
first_feature_rank_inc = __ms_get_rank_increase(name);
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 );
+ (gst_plugin_feature_get_rank(first_feature) + first_feature_rank_inc);
}
gboolean __ms_feature_filter(GstPluginFeature *feature, gpointer data)
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);
+ (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))
- {
- for(pads = gst_element_factory_get_static_pad_templates(factory); pads != NULL; pads = pads->next) {
+ if (g_strrstr(gst_element_factory_get_klass(GST_ELEMENT_FACTORY(factory)), klass_name)) {
+ for (pads = gst_element_factory_get_static_pad_templates(factory); pads != NULL; pads = pads->next) {
GstCaps *intersect_caps = NULL;
GstCaps *static_caps = NULL;
intersect_caps = gst_caps_intersect_full(new_pad_caps, static_caps, GST_CAPS_INTERSECT_FIRST);
if ((!gst_caps_is_any(static_caps)) && (!gst_caps_is_empty(intersect_caps))) {
+
if (!next_element) {
next_element = __ms_element_create(GST_OBJECT_NAME(factory), NULL);
}
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;
new_pad_type = gst_structure_get_name(new_pad_struct);
if (!gst_pad_is_linked(sink_pad)) {
- if(!strncmp(new_pad_type,GST_PAD_NAME(sink_pad), COMPARED_NUMBER)) {
+ if (!strncmp(new_pad_type, GST_PAD_NAME(sink_pad), COMPARED_NUMBER)) {
if (gst_element_link_pads_filtered(previous_element, "src", new_element,
- GST_PAD_NAME(sink_pad), NULL)) {
+ GST_PAD_NAME(sink_pad), NULL)) {
ms_info("Succeeded to link [%s] -> [%s]\n",
- GST_ELEMENT_NAME(previous_element),
- GST_ELEMENT_NAME(new_element));
+ 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));
+ 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));
+ 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));
+ GST_ELEMENT_NAME(previous_element),
+ GST_ELEMENT_NAME(new_element));
/*Remove created element*/
if (gst_bin_remove(GST_BIN(GST_ELEMENT_PARENT(new_element)), new_element)) {
GstElement *found_element = NULL;
GstElement *parent_element = NULL;
- if(!previous_element) {
+ if (!previous_element) {
return NULL;
}
ms_error("Bin [%s] was not found", next_elem_bin_name);
return NULL;
- /* Create element by element name*/
- } else if(!found_element && !next_elem_klass_name && default_element) {
+ /* Create element by element name*/
+ } else if (!found_element && !next_elem_klass_name && default_element) {
found_element = __ms_element_create(default_element, NULL);
- /* Create element by predefined format element type*/
- } else if(!found_element && 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_destroy_ini_dictionary(dict);
- /* Create element by caps of the previous element */
+ /* Create element by caps of the previous element */
} else if (!found_element) {
GstPad *src_pad = gst_element_get_static_pad(previous_element, "src");
found_element = __ms_create_element_by_registry(src_pad, next_elem_klass_name);
if (found_element) {
if (gst_bin_add(GST_BIN(parent_element), found_element)) {
ms_debug("Element [%s] added into [%s] bin",
- GST_ELEMENT_NAME(found_element),
- GST_ELEMENT_NAME(parent_element));
+ GST_ELEMENT_NAME(found_element),
+ GST_ELEMENT_NAME(parent_element));
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));
+ GST_ELEMENT_NAME(found_element),
+ GST_ELEMENT_NAME(parent_element));
MS_SAFE_UNREF(found_element);
found_element = NULL;
}
} else {
- ms_error("Could not find compatible element to link [%s]",GST_ELEMENT_NAME(previous_element));
+ ms_error("Could not find compatible element to link [%s]", GST_ELEMENT_NAME(previous_element));
}
}
return found_element;
}
- gint __ms_decodebin_autoplug_select(GstElement *bin,
+gint __ms_decodebin_autoplug_select(GstElement *bin,
GstPad *pad,
GstCaps *caps,
GstElementFactory *factory,
{
/* 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;
new_pad_struct = gst_caps_get_structure(new_pad_caps, 0);
new_pad_type = gst_structure_get_name(new_pad_struct);
- if (g_str_has_prefix(new_pad_type, "video"))
- {
+ if (g_str_has_prefix(new_pad_type, "video")) {
found_element = __ms_combine_next_element(decodebin, NULL, NULL, NULL, DEFAULT_QUEUE);
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_BIN_KLASS, "video_encoder", "encoder", DEFAULT_VIDEO_ENCODER);
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_PAYLOADER_KLASS, NULL, NULL, NULL);
/*Add created sink bin*/
if (gst_bin_add(GST_BIN(ms_streamer->pipeline), sink_bin)) {
ms_debug("Bin [%s] added into [%s] bin",
- GST_ELEMENT_NAME(sink_bin),
- GST_ELEMENT_NAME(ms_streamer->pipeline));
+ GST_ELEMENT_NAME(sink_bin),
+ GST_ELEMENT_NAME(ms_streamer->pipeline));
gst_element_sync_state_with_parent(sink_bin);
} else {
ms_error("Bin [%s] was not added into [%s] bin",
- GST_ELEMENT_NAME(sink_bin),
- GST_ELEMENT_NAME(ms_streamer->pipeline));
+ GST_ELEMENT_NAME(sink_bin),
+ GST_ELEMENT_NAME(ms_streamer->pipeline));
}
queue_element = __ms_element_create(DEFAULT_QUEUE, NULL);
/*Add created queue element*/
if (gst_bin_add(GST_BIN(sink_bin), queue_element)) {
ms_debug("Element [%s] added into [%s] bin",
- GST_ELEMENT_NAME(queue_element),
- GST_ELEMENT_NAME(sink_bin));
+ GST_ELEMENT_NAME(queue_element),
+ GST_ELEMENT_NAME(sink_bin));
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));
+ 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, NULL);
- if(!found_element) {
+ if (!found_element) {
ms_error("Could not link to sink element \n");
}
found_element = __ms_combine_next_element(decodebin, NULL, NULL, NULL, DEFAULT_TEXT_OVERLAY);
found_element = __ms_combine_next_element(found_element, NULL, NULL, NULL, DEFAULT_VIDEO_CONVERT);
- }
- else {
+ } else {
ms_error("Pad type of the element is invalid");
return;
}
/* Getting Sink */
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_SINK_KLASS, NULL, NULL, NULL);
- if(!found_element) {
+ if (!found_element) {
ms_error("Could not link to sink element \n");
}
gst_caps_unref(new_pad_caps);
/* Getting Depayloader */
found_element = __ms_bin_find_element_by_klass(sink_bin, MEDIA_STREAMER_DEPAYLOADER_KLASS,
- MEDIA_STREAMER_NODE_TYPE_NONE);
+ MEDIA_STREAMER_NODE_TYPE_NONE);
if (!found_element) {
found_element = __ms_create_element_by_registry(source_pad, MEDIA_STREAMER_DEPAYLOADER_KLASS);
if (gst_bin_add(GST_BIN(sink_bin), found_element)) {
ms_debug("Succeeded to add element [%s] into bin [%s]",
- GST_ELEMENT_NAME(found_element),
- GST_ELEMENT_NAME(sink_bin));
+ GST_ELEMENT_NAME(found_element),
+ GST_ELEMENT_NAME(sink_bin));
} else {
ms_error("Failed to add element [%s] into bin [%s]",
- GST_ELEMENT_NAME(found_element),
- GST_ELEMENT_NAME(sink_bin));
+ GST_ELEMENT_NAME(found_element),
+ GST_ELEMENT_NAME(sink_bin));
}
}
found_element = __ms_element_create("decodebin", 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);
new_pad_type = gst_structure_get_name(new_pad_struct);
/* Getting elements if Decodebin is not used */
- if(MS_ELEMENT_IS_VIDEO(new_pad_type)) {
+ if (MS_ELEMENT_IS_VIDEO(new_pad_type)) {
previous_element = __ms_combine_next_element(previous_element, MEDIA_STREAMER_PARSER_KLASS, NULL, NULL, NULL);
previous_element = __ms_combine_next_element(previous_element, MEDIA_STREAMER_DECODER_KLASS, NULL, NULL, NULL);
previous_element = __ms_combine_next_element(previous_element, NULL, NULL, NULL, DEFAULT_QUEUE);
previous_element = __ms_combine_next_element(previous_element, NULL, 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, NULL, DEFAULT_AUDIO_CONVERT);
}
if (!decodebin_usage) {
/* 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, NULL);
+ previous_element = __ms_combine_next_element(previous_element, MEDIA_STREAMER_SINK_KLASS, NULL, NULL, NULL);
if (!gst_pad_is_linked(src_pad)) {
previous_element = __ms_link_with_new_element(previous_element, found_element, NULL);
}
add_ret = gst_bin_add(GST_BIN(ms_node->parent_streamer->pipeline), sink_bin);
}
- if(add_ret) {
+ if (add_ret) {
gst_element_sync_state_with_parent(sink_bin);
if (gst_element_link_pads(ms_node->gst_element, source_pad_name, sink_bin, "sink")) {
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));
+ element_name, gst_element_state_get_name(gst_state));
MS_SAFE_GFREE(element_name);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
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)) {
+ if (!gst_bin_add(GST_BIN(rtp_container), rtp_elem)) {
MS_SAFE_UNREF(rtp_container);
MS_SAFE_UNREF(rtp_elem);
return NULL;
}
/* post error to application */
- if(ms_streamer->error_cb.callback) {
+ 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);
}
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);
+ state_transition_name);
__ms_generate_dots(ms_streamer->pipeline, state_transition_name);
MS_SAFE_GFREE(state_transition_name);
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);
+ "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);
char **pad_names = NULL;
GstIterator *pad_iterator = NULL;
- if(pad_type == GST_PAD_SRC) {
+ if (pad_type == GST_PAD_SRC) {
pad_iterator = gst_element_iterate_src_pads(gst_element);
- } else if(pad_type == GST_PAD_SINK) {
+ } else if (pad_type == GST_PAD_SINK) {
pad_iterator = gst_element_iterate_sink_pads(gst_element);
} else {
pad_iterator = gst_element_iterate_pads(gst_element);
while (GST_ITERATOR_OK == gst_iterator_next(pad_iterator, &elem)) {
pad = (GstPad *)g_value_get_object(&elem);
- pad_names = (char **)realloc(pad_names, sizeof(char *) * (pad_number + 1));
- if(!pad_names){
+ pad_names = (char **)realloc(pad_names, sizeof(char *)*(pad_number + 1));
+ if (!pad_names) {
ms_error("Error allocation memory");
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
pad_number = 0;
__ms_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));
+ __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.");
__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);
+ 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.");
media_packet_get_buffer_data_ptr(packet, (void **)&buffer_data);
- if(buffer_data != NULL) {
+ if (buffer_data != NULL) {
GstMapInfo buff_info = GST_MAP_INFO_INIT;
guint64 pts = 0;
guint64 duration = 0;
media_packet_get_buffer_size(packet, &size);
- buffer = gst_buffer_new_and_alloc (size);
+ buffer = gst_buffer_new_and_alloc(size);
if (!buffer) {
ms_error("Failed to allocate memory for push buffer");
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- if (gst_buffer_map (buffer, &buff_info, GST_MAP_READWRITE)) {
- memcpy (buff_info.data, buffer_data, size);
+ if (gst_buffer_map(buffer, &buff_info, GST_MAP_READWRITE)) {
+ memcpy(buff_info.data, buffer_data, size);
buff_info.size = size;
- gst_buffer_unmap (buffer, &buff_info);
+ gst_buffer_unmap(buffer, &buff_info);
}
media_packet_get_pts(packet, &pts);
gst_buffer_unref(buffer);
} else {
- g_signal_emit_by_name(G_OBJECT(src_element), "end-of-stream", &gst_ret, NULL);
+ g_signal_emit_by_name(G_OBJECT(src_element), "end-of-stream", &gst_ret, NULL);
}
if (gst_ret != GST_FLOW_OK) {
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);
+ 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, "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);
+ 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);
+ 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:
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);
+ 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);
+ 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);
+ 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);
+ 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:
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;
+ (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);
}
}
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;
+ (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);
}
}
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);
+ 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);
+ 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);
+ 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:
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_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_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 (ms_sink->callbacks_structure != NULL) {
media_streamer_sink_callbacks_s *sink_callbacks =
- (media_streamer_sink_callbacks_s *)ms_sink->callbacks_structure;
+ (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_eos_cb) sink_callbacks->eos_cb.callback;
if (eos_cb) {
eos_cb((media_streamer_node_h)ms_sink, sink_callbacks->eos_cb.user_data);
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);
+ 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);
+ 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:
/* Find unlinked element in src_bin */
unlinked_pad = gst_bin_find_unlinked_pad(GST_BIN(ms_streamer->src_bin), GST_PAD_SRC);
- while (unlinked_pad)
- {
+ while (unlinked_pad) {
unlinked_element = gst_pad_get_parent_element(unlinked_pad);
ms_debug("Autoplug: found unlinked element [%s]\n", GST_ELEMENT_NAME(unlinked_element));
ms_info("Received new pad '%s' from [%s]\n", GST_PAD_NAME(unlinked_pad), GST_ELEMENT_NAME(unlinked_element));
/* If element in src bin is filesrc */
- if (__ms_src_need_typefind(unlinked_element))
- {
+ 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_element_sync_state_with_parent(found_element);
- if(__ms_bin_find_element_by_klass(ms_streamer->topology_bin,MEDIA_STREAMER_BIN_KLASS, "rtp_container")) {
- g_signal_connect(found_element, "pad-added", G_CALLBACK (__decodebin_newpad_streamer_cb), ms_streamer);
+ if (__ms_bin_find_element_by_klass(ms_streamer->topology_bin, MEDIA_STREAMER_BIN_KLASS, "rtp_container")) {
+ g_signal_connect(found_element, "pad-added", G_CALLBACK(__decodebin_newpad_streamer_cb), ms_streamer);
} else {
- g_signal_connect(found_element, "pad-added", G_CALLBACK (__decodebin_newpad_cb), ms_streamer);
+ 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);
new_pad_struct = gst_caps_get_structure(new_pad_caps, 0);
new_pad_type = gst_structure_get_name(new_pad_struct);
- if(MS_ELEMENT_IS_VIDEO(new_pad_type)) {
+ if (MS_ELEMENT_IS_VIDEO(new_pad_type)) {
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_BIN_KLASS, "video_encoder", "encoder", DEFAULT_VIDEO_ENCODER);
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_PAYLOADER_KLASS, NULL, NULL, NULL);
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_BIN_KLASS, "rtp_container", NULL, NULL);
}
- if(MS_ELEMENT_IS_AUDIO(new_pad_type)) {
+ if (MS_ELEMENT_IS_AUDIO(new_pad_type)) {
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_BIN_KLASS, "audio_encoder", "encoder", DEFAULT_AUDIO_PARSER);
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_PAYLOADER_KLASS, NULL, NULL, NULL);
found_element = __ms_combine_next_element(found_element, MEDIA_STREAMER_BIN_KLASS, "rtp_container", NULL, NULL);
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);
+ 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);
+ 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);
+ 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);
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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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));
{
char *set_param_name = NULL;
char *orig_param_name = NULL;
- int it_param=0;
+ int it_param = 0;
GParamSpec *param;
- for(it_param = 0; it_param < PROPERTY_COUNT; it_param++)
- {
+ for (it_param = 0; it_param < PROPERTY_COUNT; it_param++) {
set_param_name = param_table[it_param][0];
orig_param_name = param_table[it_param][1];
param = g_object_class_find_property(G_OBJECT_GET_CLASS(element), orig_param_name);
if (name_is_known) {
- if(!g_strcmp0(param_name, set_param_name)) {
+ if (!g_strcmp0(param_name, set_param_name)) {
if (param) {
*init_param_name = orig_param_name;
break;
}
}
} else {
- if(!g_strcmp0(param_name, orig_param_name)) {
+ if (!g_strcmp0(param_name, orig_param_name)) {
if (param) {
*init_param_name = set_param_name;
break;
char *param_init_name = NULL;
property_specs = g_object_class_list_properties(G_OBJECT_GET_CLASS(node->gst_element),
- &num_properties);
+ &num_properties);
if (num_properties <= 0) {
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
__ms_node_check_param_name(node->gst_element, TRUE, param_name, ¶m_init_name);
- if (param_init_name)
- {
+ if (param_init_name) {
param = g_object_class_find_property(G_OBJECT_GET_CLASS(node->gst_element), param_init_name);
ms_info("Getting parameter of the Node [%s]", node->name);
MS_TABLE_SAFE_UNREF(ms_streamer->nodes_table);
if (ms_streamer->sink_video_bin &&
- GST_OBJECT_PARENT(ms_streamer->sink_video_bin) != GST_OBJECT(ms_streamer->pipeline)) {
+ GST_OBJECT_PARENT(ms_streamer->sink_video_bin) != GST_OBJECT(ms_streamer->pipeline)) {
MS_SAFE_UNREF(ms_streamer->sink_video_bin);
ms_info("sink_video_bin removed from pipeline");
}
if (ms_streamer->sink_audio_bin &&
- GST_OBJECT_PARENT(ms_streamer->sink_audio_bin) != GST_OBJECT(ms_streamer->pipeline)) {
+ GST_OBJECT_PARENT(ms_streamer->sink_audio_bin) != GST_OBJECT(ms_streamer->pipeline)) {
MS_SAFE_UNREF(ms_streamer->sink_audio_bin);
ms_info("sink_audio_bin removed from pipeline");
}
ini->use_decodebin = iniparser_getboolean(dict, "general:use decodebin", DEFAULT_USE_DECODEBIN);
}
- else { /* if dict is not available just fill the structure with default value */
+ else { /* if dict is not available just fill the structure with default value */
ms_debug("failed to load ini. using hardcoded default");
/* general settings*/
PRESET_DOUBLE_VOIP_CLIENT_2 = PRESET_RTP_CLIENT | DOUBLE_STREAMER_MASK | SECOND_VOIP_MASK
} preset_type_e;
-typedef enum
-{
+typedef enum {
SCENARIO_MODE_UNKNOWN,
SCENARIO_MODE_CAMERA_SCREEN,
SCENARIO_MODE_MICROPHONE_PHONE,
g_print("Media Streamer posted error [%d] \n", error);
}
-static void streamer_seek_cb(void *user_data) {
+static void streamer_seek_cb(void *user_data)
+{
g_print("Media Streamer seeked to required position \n");
}
g_print("== success stop \n");
}
-static gboolean _destroy(media_streamer_h streamer)
+static void _destroy(media_streamer_h streamer)
{
g_print("== destroy \n");
int ret = MEDIA_STREAMER_ERROR_NONE;
if (streamer == NULL) {
g_print("media streamer already destroyed");
- return TRUE;
+ return;
}
ret = media_streamer_destroy(streamer);
if (ret != MEDIA_STREAMER_ERROR_NONE) {
g_print("Fail to destroy media streamer");
- return FALSE;
+ return;
}
if (current_media_streamer == g_media_streamer) {
current_media_streamer = NULL;
g_print("== success destroy \n");
- return TRUE;
}
static void create_formats(void)
/* Define encoded video format */
media_format_create(&vfmt_encoded);
- if (media_format_set_video_mime(vfmt_encoded, MEDIA_FORMAT_H264_SP) != 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);
{
bundle *params = bundle_create();
- if (g_audio_is_on)
- {
+ if (g_audio_is_on) {
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));
g_free(audio_sink_port);
}
- if (g_video_is_on)
- {
+ if (g_video_is_on) {
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));
static void _create_file_playing()
{
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);
+
+ /*********************** videosink *********************************** */
+ media_streamer_node_h video_sink = NULL;
+ media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_SCREEN, &video_sink);
+ media_streamer_node_add(current_media_streamer, video_sink);
+
+ /*********************** audiosink *********************************** */
+ media_streamer_node_h audio_sink = NULL;
+ media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO, &audio_sink);
+ media_streamer_node_add(current_media_streamer, audio_sink);
}
static void _create_file_sub_playing()
{
media_streamer_node_h file_sub_src = NULL;
- media_streamer_node_create_src( MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &file_sub_src);
- media_streamer_node_set_param(file_sub_src,MEDIA_STREAMER_PARAM_URI, g_uri);
+ media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &file_sub_src);
+ media_streamer_node_set_param(file_sub_src, MEDIA_STREAMER_PARAM_URI, g_uri);
media_streamer_node_add(current_media_streamer, file_sub_src);
media_streamer_node_h txt_src = NULL;
- media_streamer_node_create_src( MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &txt_src);
- media_streamer_node_set_param(txt_src,MEDIA_STREAMER_PARAM_URI, g_sub_uri);
+ media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_FILE, &txt_src);
+ media_streamer_node_set_param(txt_src, MEDIA_STREAMER_PARAM_URI, g_sub_uri);
media_streamer_node_add(current_media_streamer, txt_src);
+
+ /*********************** videosink *********************************** */
+ media_streamer_node_h video_sink = NULL;
+ media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_SCREEN, &video_sink);
+ media_streamer_node_add(current_media_streamer, video_sink);
+
+ /*********************** audiosink *********************************** */
+ media_streamer_node_h audio_sink = NULL;
+ media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO, &audio_sink);
+ media_streamer_node_add(current_media_streamer, audio_sink);
}
static void _create_http_playing()
{
media_streamer_node_h http_src = NULL;
- media_streamer_node_create_src( MEDIA_STREAMER_NODE_SRC_TYPE_HTTP, &http_src);
- media_streamer_node_set_param(http_src,MEDIA_STREAMER_PARAM_URI, g_uri);
+ media_streamer_node_create_src(MEDIA_STREAMER_NODE_SRC_TYPE_HTTP, &http_src);
+ media_streamer_node_set_param(http_src, MEDIA_STREAMER_PARAM_URI, g_uri);
media_streamer_node_add(current_media_streamer, http_src);
+
+ /*********************** videosink *********************************** */
+ media_streamer_node_h video_sink = NULL;
+ media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_SCREEN, &video_sink);
+ media_streamer_node_add(current_media_streamer, video_sink);
+
+ /*********************** audiosink *********************************** */
+ media_streamer_node_h audio_sink = NULL;
+ media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO, &audio_sink);
+ media_streamer_node_add(current_media_streamer, audio_sink);
}
static void _create_rtp_streamer(media_streamer_node_h rtp_bin)
{
g_print("== _create_rtp_streamer \n");
- if (g_video_is_on)
- {
+ if (g_video_is_on) {
/*********************** video source *********************************** */
media_streamer_node_h video_src = NULL;
if (g_scenario_mode == SCENARIO_MODE_CAMERA_SCREEN ||
- g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) {
+ 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);
}
/*********************** encoder **************************************** */
media_streamer_node_h video_enc = NULL;
- media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER, NULL,
- vfmt_encoded, &video_enc);
+ media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_ENCODER, NULL, vfmt_encoded, &video_enc);
media_streamer_node_add(current_media_streamer, video_enc);
/*********************** videopay *************************************** */
media_streamer_node_h video_pay = NULL;
- media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY, NULL,
- vfmt_encoded, &video_pay);
+ media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_PAY, NULL, vfmt_encoded, &video_pay);
media_streamer_node_add(current_media_streamer, video_pay);
/*====================Linking Video Streamer=========================== */
- /* media_streamer_node_link(video_src, "src", video_enc, "sink"); */
- /* media_streamer_node_link(video_enc, "src", video_pay, "sink"); */
- /* media_streamer_node_link(video_pay, "src", rtp_bin, "video_in"); */
+ media_streamer_node_link(video_src, "src", video_enc, "sink");
+ media_streamer_node_link(video_enc, "src", video_pay, "sink");
+ media_streamer_node_link(video_pay, "src", rtp_bin, "video_in");
/*====================================================================== */
g_print("== success streamer video part \n");
}
- if (g_audio_is_on)
- {
+ if (g_audio_is_on) {
/*********************** audiosrc *********************************** */
media_streamer_node_h audio_src = NULL;
if (g_scenario_mode == SCENARIO_MODE_MICROPHONE_PHONE ||
- g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) {
+ 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);
}
media_streamer_node_add(current_media_streamer, audio_pay);
/*====================Linking Audio Streamer========================== */
- /* media_streamer_node_link(audio_src, "src", audio_enc, "sink"); */
- /* media_streamer_node_link(audio_enc, "src", audio_pay, "sink"); */
- /* media_streamer_node_link(audio_pay, "src", rtp_bin, "audio_in"); */
+ media_streamer_node_link(audio_src, "src", audio_enc, "sink");
+ media_streamer_node_link(audio_enc, "src", audio_pay, "sink");
+ media_streamer_node_link(audio_pay, "src", rtp_bin, "audio_in");
/*====================================================================== */
g_print("== success streamer audio part \n");
{
g_print("== _create_rtp_streamer_autoplug \n");
- if (g_video_is_on)
- {
+ if (g_video_is_on) {
/*********************** video source *********************************** */
media_streamer_node_h video_src = NULL;
if (g_scenario_mode == SCENARIO_MODE_CAMERA_SCREEN ||
- g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) {
+ 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_print("== success streamer_autoplug video part \n");
}
- if (g_audio_is_on)
- {
+ if (g_audio_is_on) {
/*********************** audiosrc *********************************** */
media_streamer_node_h audio_src = NULL;
if (g_scenario_mode == SCENARIO_MODE_MICROPHONE_PHONE ||
- g_scenario_mode == SCENARIO_MODE_FULL_VIDEO_AUDIO) {
+ 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_print("== _create_rtp_client \n");
- if(g_video_is_on) {
+ if (g_video_is_on) {
/*********************** video_depay*********************************** */
media_streamer_node_h video_depay = NULL;
media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY, NULL, NULL, &audio_depay);
media_streamer_node_add(current_media_streamer, audio_depay);
- /*********************** audioconvert *********************************** */
- /*media_streamer_node_h audio_converter = NULL;*/
- /*media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER, NULL, NULL, &audio_converter);*/
- /*media_streamer_node_add(current_media_streamer, audio_converter);*/
-
- /*********************** audioresample *********************************** */
- /*media_streamer_node_h audio_res = NULL;*/
- /*media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_RESAMPLE, NULL, NULL, &audio_res);*/
- /*media_streamer_node_add(current_media_streamer, audio_res);*/
-
/*********************** audiosink *********************************** */
media_streamer_node_h audio_sink = NULL;
media_streamer_node_create_sink(MEDIA_STREAMER_NODE_SINK_TYPE_AUDIO, &audio_sink);
{
g_print("== _create_rtp_client_autoplug \n");
- if(g_video_is_on) {
+ if (g_video_is_on) {
/*********************** videosink *********************************** */
media_streamer_node_h video_sink = NULL;
media_streamer_node_add(current_media_streamer, video_sink);
g_print("== success client_autoplug video part \n");
- }
+ }
if (g_audio_is_on) {
return rtp_bin;
}
-//#if 0
/* Application source callback */
static void buffer_status_cb(media_streamer_node_h node,
- media_streamer_custom_buffer_status_e status,
- void *user_data) {
+ media_streamer_custom_buffer_status_e status,
+ void *user_data)
+{
static int count = 0;
g_print("== success appsrc part \n");
}
-//#endif
/***************************************************************/
/** Testsuite */
case SUBMENU_STATE_PLAYING_SCENARIO:
display_playing_scenario_select_menu();
break;
- case SUBMENU_STATE_FORMAT:
- /* display_format_menu(); */
- break;
default:
g_print("*** Unknown Submenu state.\n");
break;
void _interpret_autoplug_menu(char *cmd)
{
- int cmd_number = atoi(cmd) - 1;
-
- if (cmd_number == 1 || cmd_number == 0) {
- g_autoplug_mode = cmd_number;
+ if (strlen(cmd) == 1) {
+ if (cmd[0] == '2') {
+ g_autoplug_mode = true;
+ } 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");
case SUBMENU_STATE_AUTOPLUG:
_interpret_autoplug_menu(cmd);
break;
- case SUBMENU_STATE_FORMAT:
- /*display_format_menu(); */
- break;
case SUBMENU_STATE_SCENARIO:
_interpret_scenario_menu(cmd);
break;
projects / platform / core / api / mediastreamer.git / commitdiff