*
* @since_tizen 3.0
*/
-typedef enum
-{
+typedef enum {
MEDIA_STREAMER_NODE_TYPE_NONE, /**< Not defined type */
MEDIA_STREAMER_NODE_TYPE_SRC, /**< Src node type */
MEDIA_STREAMER_NODE_TYPE_SINK, /**< Sink node type */
*
* @since_tizen 3.0
*/
-typedef enum
-{
+typedef enum {
MEDIA_STREAMER_SRC_TYPE_NONE, /**< Not defined src type */
MEDIA_STREAMER_SRC_TYPE_FILE, /**< Local file src type */
MEDIA_STREAMER_SRC_TYPE_HTTP, /**< Http src type */
*
* @since_tizen 3.0
*/
-typedef enum
-{
+typedef enum {
MEDIA_STREAMER_SINK_TYPE_NONE, /**< Not defined sink type */
MEDIA_STREAMER_SINK_TYPE_FILE, /**< Local file sink type */
MEDIA_STREAMER_SINK_TYPE_RTSP, /**< Rtsp sink type */
*
* @since_tizen 3.0
*/
-typedef enum
-{
+typedef enum {
MEDIA_STREAMER_STATE_NONE, /**< Streamer is not created */
MEDIA_STREAMER_STATE_IDLE, /**< Streamer is created but not prepared */
MEDIA_STREAMER_STATE_READY, /**< Streamer is ready to play */
*
* @since_tizen 3.0
*/
-typedef enum
-{
+typedef enum {
MEDIA_STREAMER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
MEDIA_STREAMER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
MEDIA_STREAMER_ERROR_INVALID_OPERATION = TIZEN_ERROR_INVALID_OPERATION, /**< Invalid operation */
MEDIA_STREAMER_ERROR_FILE_NO_SPACE_ON_DEVICE = TIZEN_ERROR_FILE_NO_SPACE_ON_DEVICE, /**< No space left on the device */
MEDIA_STREAMER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
MEDIA_STREAMER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
- MEDIA_STREAMER_ERROR_INVALID_STATE = TIZEN_ERROR_MEDIA_STREAMER|0x01, /**< Invalid state */
- MEDIA_STREAMER_ERROR_CONNECTION_FAILED = TIZEN_ERROR_MEDIA_STREAMER|0x02, /**< Connection failed */
- MEDIA_STREAMER_ERROR_RESOURCE_CONFLICT = TIZEN_ERROR_MEDIA_STREAMER|0x03, /**< Resource conflict */
+ MEDIA_STREAMER_ERROR_INVALID_STATE = TIZEN_ERROR_MEDIA_STREAMER | 0x01, /**< Invalid state */
+ MEDIA_STREAMER_ERROR_CONNECTION_FAILED = TIZEN_ERROR_MEDIA_STREAMER | 0x02, /**< Connection failed */
+ MEDIA_STREAMER_ERROR_RESOURCE_CONFLICT = TIZEN_ERROR_MEDIA_STREAMER | 0x03, /**< Resource conflict */
} media_streamer_error_e;
/**
*
* @since_tizen 3.0
*/
-typedef enum
-{
- MEDIA_STREAMER_CUSTOM_BUFFER_UNDERRUN, /**< buffer underrun of custom src */
- MEDIA_STREAMER_CUSTOM_BUFFER_OVERFLOW, /**< buffer overflow of custom src */
+typedef enum {
+ MEDIA_STREAMER_CUSTOM_BUFFER_UNDERRUN, /**< buffer underrun of custom src */
+ MEDIA_STREAMER_CUSTOM_BUFFER_OVERFLOW, /**< buffer overflow of custom src */
} media_streamer_custom_buffer_status_e;
/**
* @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 was 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_get_param_list()
* @see media_streamer_node_set_params()
*/
-typedef void (*media_streamer_custom_buffer_status_cb) (media_streamer_node_h node,
- media_streamer_custom_buffer_status_e status,
- void *user_data);
+typedef void (*media_streamer_custom_buffer_status_cb)(media_streamer_node_h node,
+ media_streamer_custom_buffer_status_e status,
+ void *user_data);
/**
* @brief Called when new data is available from custom sink.
* @see media_streamer_sink_unset_data_ready_cb()
*/
typedef void (*media_streamer_sink_data_ready_cb)(media_streamer_node_h node,
- void *user_data);
+ void *user_data);
/**
* @brief Called when the end-of-stream has been reached.
* @see media_streamer_sink_unset_eos_cb()
*/
typedef void (*media_streamer_sink_eos_cb)(media_streamer_node_h node,
- void *user_data);
+ void *user_data);
/**
* @brief Register a error callback function to be invoked when an error occurs.
* @see media_streamer_error_cb()
*/
int media_streamer_set_error_cb(media_streamer_h streamer,
- media_streamer_error_cb callback,
- void *user_data);
+ media_streamer_error_cb callback,
+ void *user_data);
/**
* @brief Unregisters the error callback function.
* @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);
+ media_streamer_state_changed_cb callback,
+ void *user_data);
/**
* @brief Unregisters the state changed callback function.
* @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);
+ media_streamer_custom_buffer_status_cb callback,
+ void *user_data);
/**
* @brief Unregisters the src buffer status callback function.
* @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);
+ media_streamer_sink_data_ready_cb callback,
+ void *user_data);
/**
* @brief Unregisters the sink data ready callback function.
* @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);
+ media_streamer_sink_eos_cb callback,
+ void *user_data);
/**
* @brief Unregisters the sink end-of-stream callback function.
* @see #media_streamer_state_e
*/
int media_streamer_get_state(media_streamer_h streamer,
- media_streamer_state_e *state);
+ media_streamer_state_e *state);
/**
* @brief Creates media streamer source node.
* @see media_streamer_node_destroy()
*/
int media_streamer_src_create(media_streamer_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_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_sink_create(media_streamer_sink_type_e type,
- media_streamer_node_h *sink);
+ media_streamer_node_h *sink);
/**
* @brief Pulls packet from custom sink node.
* @see media_streamer_sink_create()
*/
int media_streamer_pull_packet(media_streamer_node_h sink,
- media_packet_h *packet);
+ media_packet_h *packet);
/**
* @brief Creates media streamer node except src and sink.
* @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);
+ media_format_h in_fmt,
+ media_format_h out_fmt,
+ media_streamer_node_h *node);
/**
* @brief Adds node to media streamer.
* @see media_streamer_sink_create()
*/
int media_streamer_node_add(media_streamer_h streamer,
- media_streamer_node_h node);
+ media_streamer_node_h node);
/**
* @brief Destroys media streamer node.
* @see media_streamer_node_add()
*/
int media_streamer_node_remove(media_streamer_h streamer,
- media_streamer_node_h node);
+ media_streamer_node_h node);
/**
* @brief Sets media format for media streamer node.
* @see #media_format_h
*/
int media_streamer_node_set_format(media_streamer_node_h node,
- media_format_h fmt);
+ media_format_h fmt);
/**
* @brief Gets media format for media streamer node.
* @see #media_format_h
*/
int media_streamer_node_get_format(media_streamer_node_h node,
- media_format_h *fmt);
+ media_format_h *fmt);
/**
* @brief Links two media streamer nodes.
* @see media_streamer_node_add()
*/
int media_streamer_node_link(media_streamer_node_h src_node,
- const char *src_pad,
- media_streamer_node_h dest_node,
- const char *sink_pad);
+ const char *src_pad,
+ media_streamer_node_h dest_node,
+ const char *sink_pad);
/**
* @brief Gets formats of node pads.
* @see media_streamer_sink_create()
*/
int media_streamer_node_get_pad_format(media_streamer_node_h node,
- char **src_fmt,
- char **sink_fmt);
+ char **src_fmt,
+ char **sink_fmt);
/**
* @brief Sets parameters of node.
* @see media_streamer_node_set_single_param()
*/
int media_streamer_node_set_params(media_streamer_node_h node,
- bundle *param_list);
+ bundle *param_list);
/**
* @brief Sets single parameter of node.
* @see media_streamer_node_set_params()
*/
int media_streamer_node_set_single_param(media_streamer_node_h node,
- const char *param_name, const char *param_value);
+ const char *param_name, const char *param_value);
/**
* @brief Gets node parameter list.
* @see media_streamer_node_set_params()
*/
int media_streamer_node_get_param_list(media_streamer_node_h node,
- bundle **param_list);
+ bundle **param_list);
/**
* @}
*
* @since_tizen 3.0
*/
-typedef struct
-{
+typedef struct {
void *callback;
void *user_data;
} media_streamer_callback_s;
*
* @since_tizen 3.0
*/
-typedef struct
-{
+typedef struct {
media_streamer_callback_s enough_data_cb;
media_streamer_callback_s need_data_cb;
} media_streamer_src_callbacks_s;
*
* @since_tizen 3.0
*/
-typedef struct
-{
+typedef struct {
media_streamer_callback_s data_ready_cb;
media_streamer_callback_s eos_cb;
} media_streamer_sink_callbacks_s;
*
* @since_tizen 3.0
*/
-typedef struct
-{
+typedef struct {
media_streamer_ini_t ini;
GstElement *pipeline;
* @since_tizen 3.0
*/
typedef int (*media_streamer_node_set_param)(
- struct media_streamer_node_s *node,
- const gchar *param_key,
- const gchar *param_value);
+ struct media_streamer_node_s *node,
+ const gchar *param_key,
+ const gchar *param_value);
/**
* @brief Media Streamer node type handle.
*
* @since_tizen 3.0
*/
-typedef struct
-{
+typedef struct {
GstElement *gst_element;
char *name;
media_streamer_s *parent_streamer;
#define FONT_COLOR_GRAY "\033[37m"
#define ms_debug(fmt, arg...) do { \
- LOGD(FONT_COLOR_RESET""fmt"", ##arg); \
-} while(0)
+ LOGD(FONT_COLOR_RESET""fmt"", ##arg); \
+ } while(0)
#define ms_info(fmt, arg...) do { \
- LOGI(FONT_COLOR_GREEN""fmt"", ##arg); \
-} while(0)
+ LOGI(FONT_COLOR_GREEN""fmt"", ##arg); \
+ } while(0)
#define ms_error(fmt, arg...) do { \
- LOGE(FONT_COLOR_RED""fmt"", ##arg); \
-} while(0)
+ LOGE(FONT_COLOR_RED""fmt"", ##arg); \
+ } while(0)
#define ms_debug_fenter() do { \
- LOGD(FONT_COLOR_YELLOW"<Enter>"); \
-} while(0)
+ LOGD(FONT_COLOR_YELLOW"<Enter>"); \
+ } while(0)
#define ms_debug_fleave() do { \
- LOGD(FONT_COLOR_PURPLE"<Leave>"); \
-} while(0)
+ LOGD(FONT_COLOR_PURPLE"<Leave>"); \
+ } while(0)
#define ms_retm_if(expr, fmt, arg...) do { \
- if(expr) { \
- LOGE(FONT_COLOR_RED""fmt"", ##arg); \
- return; \
-} \
-} while(0)
+ if(expr) { \
+ LOGE(FONT_COLOR_RED""fmt"", ##arg); \
+ return; \
+ } \
+ } while(0)
#define ms_retvm_if(expr, val, fmt, arg...) do { \
- if(expr) { \
- LOGE(FONT_COLOR_RED""fmt"", ##arg); \
- return(val); \
-} \
-} while(0)
+ if(expr) { \
+ LOGE(FONT_COLOR_RED""fmt"", ##arg); \
+ return(val); \
+ } \
+ } while(0)
#define MS_SAFE_FREE(src) {if(src) {free(src); src = NULL;}}
*
* @since_tizen 3.0
*/
-typedef struct __media_streamer_ini
-{
+typedef struct __media_streamer_ini {
/* general */
gboolean generate_dot;
* @since_tizen 3.0
*/
gchar *__ms_ini_get_string(dictionary *dict, const char *ini_path,
- char *default_str);
+ char *default_str);
/**
* @brief Converts Media Format mime type into string.
export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
%endif
MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
-cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
-
+%cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
make %{?jobs:-j%jobs}
%install
rm -rf %{buildroot}
-mkdir -p %{buildroot}/usr/share/license
+mkdir -p %{buildroot}%{_datadir}/license
mkdir -p %{buildroot}/usr/bin
-cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name}
+cp LICENSE.APLv2 %{buildroot}%{_datadir}/license/%{name}
cp test/media_streamer_test %{buildroot}/usr/bin
%make_install
%files
-%manifest capi-media-streamer.manifest
+%manifest %{name}.manifest
+%license LICENSE.APLv2
%{_libdir}/libcapi-media-streamer.so.*
%{_datadir}/license/%{name}
-/usr/bin/*
+%{_bindir}/*
%files devel
+%manifest %{name}.manifest
%{_includedir}/media/*.h
%{_libdir}/pkgconfig/*.pc
%{_libdir}/libcapi-media-streamer.so
*/
int media_streamer_src_create(media_streamer_src_type_e type,
- media_streamer_node_h *src)
+ 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->type = MEDIA_STREAMER_NODE_TYPE_SRC;
ms_src->subtype = (media_streamer_src_type_e)type;
ret = __ms_src_node_create(ms_src);
- if(ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
MS_SAFE_FREE(ms_src);
- ms_error( "Error creating Src node [%d]",ret);
+ ms_error("Error creating Src node [%d]", ret);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
}
int media_streamer_sink_create(media_streamer_sink_type_e type,
- media_streamer_node_h *sink)
+ 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->type = MEDIA_STREAMER_NODE_TYPE_SINK;
ms_sink->subtype = (media_streamer_sink_type_e)type;
ret = __ms_sink_node_create(ms_sink);
- if(ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
MS_SAFE_FREE(ms_sink);
- ms_error( "Error creating Sink node [%d]",ret);
+ ms_error("Error creating Sink node [%d]", ret);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
}
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)
+ 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->subtype = 0;
ret = __ms_node_create(ms_node, in_fmt, out_fmt);
- if(ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
MS_SAFE_FREE(ms_node);
- ms_error( "Error creating Node [%d]",ret);
+ ms_error("Error creating Node [%d]", ret);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
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)
- {
- // This node was not added into any media streamer
+ if (ms_node->parent_streamer == NULL) {
+ /* This node was not added into any media streamer */
__ms_node_destroy(ms_node);
- }
- else
- {
+ } else {
int ret = __ms_node_remove_from_table(ms_node->parent_streamer->nodes_table, ms_node);
ms_retvm_if(ret != MEDIA_STREAMER_ERROR_NONE, MEDIA_STREAMER_ERROR_INVALID_OPERATION,
- "Current key was not removed from nodes_table");
+ "Current key was not removed from nodes_table");
}
ms_info("Node destroyed successfully");
}
int media_streamer_node_add(media_streamer_h streamer,
- media_streamer_node_h node)
+ 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");
g_mutex_lock(&ms_streamer->mutex_lock);
- __ms_node_insert_into_table(ms_streamer->nodes_table,ms_node);
+ __ms_node_insert_into_table(ms_streamer->nodes_table, ms_node);
ms_node->parent_streamer = ms_streamer;
__ms_add_node_into_bin(ms_streamer, ms_node);
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->pipeline == NULL, MEDIA_STREAMER_ERROR_INVALID_STATE, "Pipeline doesn`t exist");
g_mutex_lock(&ms_streamer->mutex_lock);
- if(ms_streamer->state > MEDIA_STREAMER_STATE_IDLE)
- {
+ if (ms_streamer->state > MEDIA_STREAMER_STATE_IDLE) {
ms_error("Error: Media streamer already prepared [%d]!",
- MEDIA_STREAMER_ERROR_INVALID_OPERATION);
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- if(__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
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->pipeline == NULL, MEDIA_STREAMER_ERROR_INVALID_STATE, "Pipeline doesn`t exist");
g_mutex_lock(&ms_streamer->mutex_lock);
- if(__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
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");
g_mutex_lock(&ms_streamer->mutex_lock);
- if(ms_streamer->state < MEDIA_STREAMER_STATE_READY)
- {
+ if (ms_streamer->state < MEDIA_STREAMER_STATE_READY) {
ms_error("Error: Media streamer must be prepared first [%d]!",
- MEDIA_STREAMER_ERROR_INVALID_OPERATION);
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- if(__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PLAYING) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PLAYING) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
ms_streamer->state = MEDIA_STREAMER_STATE_NONE;
ret = __ms_create(ms_streamer);
- if(ret!=MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error creating Media Streamer");
__ms_streamer_destroy(ms_streamer);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- if(__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
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");
g_mutex_lock(&ms_streamer->mutex_lock);
}
int media_streamer_set_error_cb(media_streamer_h streamer,
- media_streamer_error_cb callback,
- void *data)
+ media_streamer_error_cb callback,
+ void *data)
{
return MEDIA_STREAMER_ERROR_NONE;
}
}
int media_streamer_set_state_change_cb(media_streamer_h streamer,
- media_streamer_state_changed_cb callback,
- void *data)
+ media_streamer_state_changed_cb callback,
+ void *data)
{
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)
+ media_streamer_custom_buffer_status_cb callback,
+ void *user_data)
{
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)
+ media_streamer_sink_data_ready_cb callback,
+ void *data)
{
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)
+ media_streamer_sink_eos_cb callback,
+ void *data)
{
return MEDIA_STREAMER_ERROR_NONE;
}
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");
g_mutex_lock(&ms_streamer->mutex_lock);
- if(__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PAUSED) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_PAUSED) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
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");
g_mutex_lock(&ms_streamer->mutex_lock);
- if(ms_streamer->state < MEDIA_STREAMER_STATE_READY)
- {
+ if (ms_streamer->state < MEDIA_STREAMER_STATE_READY) {
ms_error("Error: Media streamer must be prepared first [%d]!",
- MEDIA_STREAMER_ERROR_INVALID_OPERATION);
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- if(__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_READY) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
}
int media_streamer_get_state(media_streamer_h streamer,
- media_streamer_state_e *state)
+ 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;
}
int media_streamer_seek(media_streamer_h streamer,
- media_streamer_time_value time)
+ media_streamer_time_value time)
{
return MEDIA_STREAMER_ERROR_NONE;
}
int media_streamer_push_packet(media_streamer_node_h src,
- media_packet_h packet)
+ media_packet_h packet)
{
return MEDIA_STREAMER_ERROR_NONE;
}
int media_streamer_pull_packet(media_streamer_node_h sink,
- media_packet_h *packet)
+ media_packet_h *packet)
{
return MEDIA_STREAMER_ERROR_NONE;
}
int media_streamer_node_set_format(media_streamer_node_h node,
- media_format_h fmt)
+ media_format_h fmt)
{
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(fmt == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Format is NULL");
}
int media_streamer_node_get_format(media_streamer_node_h node,
- media_format_h *fmt)
+ media_format_h *fmt)
{
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(fmt == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Format is NULL");
}
int media_streamer_node_link(media_streamer_node_h src_node,
- const char *src_pad,
- media_streamer_node_h dest_node,
- const char *sink_pad)
+ const char *src_pad,
+ media_streamer_node_h dest_node,
+ const char *sink_pad)
{
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");
gchar *src_element_name = gst_element_get_name(ms_src_node->gst_element);
gchar *sink_element_name = gst_element_get_name(ms_dest_node->gst_element);
gboolean link_ret;
- link_ret = gst_element_link_pads (ms_src_node->gst_element, src_pad, ms_dest_node->gst_element, sink_pad);
- if(!link_ret)
- {
+ link_ret = gst_element_link_pads(ms_src_node->gst_element, src_pad, ms_dest_node->gst_element, sink_pad);
+ if (!link_ret) {
ms_error("Can not link [%s]->%s pad to [%s]->%s pad, ret code [%d] ", src_pad, sink_pad, src_element_name, sink_element_name, link_ret);
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
}
int media_streamer_node_get_pad_format(media_streamer_node_h node,
- char **in_fmt,
- char **out_fmt)
+ char **in_fmt,
+ char **out_fmt)
{
return MEDIA_STREAMER_ERROR_NONE;
}
int media_streamer_node_set_params(media_streamer_node_h node,
- bundle *param_list)
+ 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);
+ 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");
+ "Parameters list is NULL");
return ret;
}
int media_streamer_node_get_param_list(media_streamer_node_h node,
- bundle **param_list)
+ 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");
ms_params = bundle_create();
ms_retvm_if(ms_params == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Error creating new params object");
- if (__ms_node_write_params_into_bundle(ms_node, ms_params) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_node_write_params_into_bundle(ms_node, ms_params) != MEDIA_STREAMER_ERROR_NONE) {
ms_info("Node [%s] do not have any params.", ms_node->name);
bundle_free(ms_params);
*param_list = NULL;
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
- {
- dot_name = g_strconcat (DOT_FILE_NAME, ".", name_tag, NULL);
+ } 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);
+ MS_SAFE_GFREE(dot_name);
}
const char *_ms_state_to_string(GstState state)
static const char ready[] = "READY\0";
static const char paused[] = "PAUSED\0";
static const char playing[] = "PLAYING\0";
- switch(state)
- {
+ switch (state) {
case GST_STATE_VOID_PENDING:
return pending;
break;
}
static int __ms_add_ghostpad(GstElement *gst_element,
- const char *pad_name,
- GstElement *gst_bin,
- const char *ghost_pad_name)
+ const char *pad_name,
+ GstElement *gst_bin,
+ const char *ghost_pad_name)
{
ms_retvm_if(!ghost_pad_name || !gst_bin, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
GstPad *ghost_pad = NULL;
gchar *bin_name = gst_element_get_name(gst_bin);
- if(!gst_element || !pad_name)
- {
+ if (!gst_element || !pad_name) {
ghost_pad = gst_ghost_pad_new_no_target(ghost_pad_name, GST_PAD_SRC);
gst_element_add_pad(GST_ELEMENT(gst_bin), ghost_pad);
- ms_info("Added %s empty ghostpad into [%s]", bin_name);
- ret = MEDIA_STREAMER_ERROR_NONE;
- }
- else
- {
+ ms_info("Added %s empty ghostpad into [%s]", bin_name);
+ ret = MEDIA_STREAMER_ERROR_NONE;
+ } else {
gchar *element_name = gst_element_get_name(gst_element);
GstPad *element_pad = gst_element_get_static_pad(gst_element, pad_name);
- if(!element_pad)
- {
- //maybe it is request pad
+ if (!element_pad) {
+ /*maybe it is request pad */
element_pad = gst_element_get_request_pad(gst_element, pad_name);
}
- if(element_pad != NULL)
- {
+ if (element_pad != NULL) {
ghost_pad = gst_ghost_pad_new(ghost_pad_name, element_pad);
gst_pad_set_active(ghost_pad, TRUE);
MS_SAFE_GFREE(element_name);
ret = MEDIA_STREAMER_ERROR_NONE;
- }
- else
- {
+ } 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;
}
}
GParamSpec *param;
GObject *obj = NULL;
- if (GST_IS_CHILD_PROXY(element))
- {
+ if (GST_IS_CHILD_PROXY(element)) {
int i;
int childs_count = gst_child_proxy_get_children_count(GST_CHILD_PROXY(element));
param = NULL;
- for(i = 0; (i < childs_count) && (param == NULL); ++i)
- {
- obj = gst_child_proxy_get_child_by_index(GST_CHILD_PROXY(element),i);
+ for (i = 0; (i < childs_count) && (param == NULL); ++i) {
+ obj = gst_child_proxy_get_child_by_index(GST_CHILD_PROXY(element), i);
param = g_object_class_find_property(G_OBJECT_GET_CLASS(obj), key);
}
ms_retvm_if(param == NULL || obj == NULL, NULL, "Error: Bin object does not have property [%s].", key);
- }
- else
- {
+ } else {
obj = G_OBJECT(element);
param = g_object_class_find_property
- (G_OBJECT_GET_CLASS(obj), key);
+ (G_OBJECT_GET_CLASS(obj), key);
}
g_value_init(value, param->value_type);
- if (param->flags & G_PARAM_WRITABLE)
- {
+ if (param->flags & G_PARAM_WRITABLE) {
g_object_get_property(G_OBJECT(obj), key, value);
- }
- else
- {
- // Skip properties which user can not change.
+ } else {
+ /* Skip properties which user can not change. */
ms_error("Error: node param [%s] is not writable!", key);
return NULL;
}
GValue value = G_VALUE_INIT;
GObject *obj = __ms_get_property_owner(element, key, &value);
- if(obj == NULL)
- {
+ if (obj == NULL) {
ms_debug("Element [%s] does not have property [%s].", element_name, key);
MS_SAFE_GFREE(element_name);
return;
}
- switch(G_VALUE_TYPE(&value))
- {
+ switch (G_VALUE_TYPE(&value)) {
case G_TYPE_STRING:
g_value_set_string(&value, param_value);
ms_info("Set string value: [%s]", g_value_get_string(&value));
break;
- case G_TYPE_BOOLEAN:
- {
- gboolean bool_val = !g_strcmp0(param_value, "true") ? TRUE : FALSE;
- g_value_set_boolean(&value, bool_val);
- ms_info("Set boolean value: [%d]", g_value_get_boolean(&value));
- break;
- }
+ case G_TYPE_BOOLEAN: {
+ gboolean bool_val = !g_strcmp0(param_value, "true") ? TRUE : FALSE;
+ g_value_set_boolean(&value, bool_val);
+ ms_info("Set boolean value: [%d]", g_value_get_boolean(&value));
+ break;
+ }
- case G_TYPE_ULONG:
- {
- unsigned long pulong = atol(param_value);
- g_value_set_ulong(&value, pulong);
- ms_info("Set ulong value: [%lu]", g_value_get_ulong(&value));
- break;
- }
+ case G_TYPE_ULONG: {
+ unsigned long pulong = atol(param_value);
+ g_value_set_ulong(&value, pulong);
+ ms_info("Set ulong value: [%lu]", g_value_get_ulong(&value));
+ break;
+ }
- case G_TYPE_LONG:
- {
- long plong = atol(param_value);
- g_value_set_long(&value, plong);
- ms_info("Set long value: [%ld]", g_value_get_long(&value));
- break;
- }
+ case G_TYPE_LONG: {
+ long plong = atol(param_value);
+ g_value_set_long(&value, plong);
+ ms_info("Set long value: [%ld]", g_value_get_long(&value));
+ break;
+ }
- case G_TYPE_UINT:
- {
- unsigned int puint = atoi(param_value);
- g_value_set_uint(&value, puint);
- ms_info("Set uint value: [%u]", g_value_get_uint(&value));
- break;
- }
+ case G_TYPE_UINT: {
+ unsigned int puint = atoi(param_value);
+ g_value_set_uint(&value, puint);
+ ms_info("Set uint value: [%u]", g_value_get_uint(&value));
+ break;
+ }
- case G_TYPE_INT:
- {
- int pint = atoi(param_value);
- g_value_set_int(&value, pint);
- ms_info("Set int value: [%d]", g_value_get_int(&value));
- break;
- }
+ case G_TYPE_INT: {
+ int pint = atoi(param_value);
+ g_value_set_int(&value, pint);
+ ms_info("Set int value: [%d]", g_value_get_int(&value));
+ break;
+ }
- case G_TYPE_UINT64:
- {
- unsigned long long puint64 = strtoull(param_value, NULL, 10);
- g_value_set_uint64(&value, puint64);
- ms_info("Set long value: [%llu]", g_value_get_uint64(&value));
- break;
- }
+ case G_TYPE_UINT64: {
+ unsigned long long puint64 = strtoull(param_value, NULL, 10);
+ g_value_set_uint64(&value, puint64);
+ ms_info("Set long value: [%llu]", g_value_get_uint64(&value));
+ break;
+ }
- case G_TYPE_INT64:
- {
- long long pint64 = strtoll(param_value, NULL, 10);
- g_value_set_int64(&value, pint64);
- ms_info("Set long value: [%ll]", g_value_get_int64(&value));
- break;
- }
- case G_TYPE_FLOAT:
- {
- float pfloat = strtof(param_value, NULL);
- g_value_set_float(&value, pfloat);
- ms_info("Set long value: [%15.7g]", g_value_get_float(&value));
- break;
- }
- case G_TYPE_DOUBLE:
- {
- double pdouble = strtod(param_value, NULL);
- g_value_set_double(&value, pdouble);
- ms_info("Set long value: [%15.7g]", g_value_get_float(&value));
- break;
- }
- default:
- if(G_VALUE_TYPE(&value) == GST_TYPE_CAPS)
- {
- GstCaps *caps = gst_caps_from_string(param_value);
-
- if (!caps)
- {
- ms_error("Can not create caps from param value.");
+ case G_TYPE_INT64: {
+ long long pint64 = strtoll(param_value, NULL, 10);
+ g_value_set_int64(&value, pint64);
+ ms_info("Set long value: [%ll]", g_value_get_int64(&value));
+ break;
}
- else
- {
- ms_info("Create Caps from params and set to the object.");
- g_object_set(obj, key, caps, NULL);
- gst_caps_unref(caps);
+ case G_TYPE_FLOAT: {
+ float pfloat = strtof(param_value, NULL);
+ g_value_set_float(&value, pfloat);
+ ms_info("Set long value: [%15.7g]", g_value_get_float(&value));
+ break;
}
- return;
- }
- else
- {
- ms_info("Got unknown type with param->value_type [%d]", G_VALUE_TYPE(&value));
- return;
- }
- break;
+ case G_TYPE_DOUBLE: {
+ double pdouble = strtod(param_value, NULL);
+ g_value_set_double(&value, pdouble);
+ ms_info("Set long value: [%15.7g]", g_value_get_float(&value));
+ break;
+ }
+ default:
+ if (G_VALUE_TYPE(&value) == GST_TYPE_CAPS) {
+ GstCaps *caps = gst_caps_from_string(param_value);
+
+ if (!caps) {
+ ms_error("Can not create caps from param value.");
+ } else {
+ ms_info("Create Caps from params and set to the object.");
+ g_object_set(obj, key, caps, NULL);
+ gst_caps_unref(caps);
+ }
+ return;
+ } else {
+ ms_info("Got unknown type with param->value_type [%d]", G_VALUE_TYPE(&value));
+ return;
+ }
+ break;
}
g_object_set_property(obj, key, &value);
MS_SAFE_GFREE(element_name);
sink_element_name = gst_element_get_name(sink_element);
new_pad_name = gst_pad_get_name(new_pad);
- if(!gst_pad_is_linked(sink_pad))
- {
+ if (!gst_pad_is_linked(sink_pad)) {
ms_info("Pads [rtpbin].[%s] and [%s].[sink] are not linked\n", new_pad_name, sink_element_name);
ret = gst_pad_link(new_pad, sink_pad);
- if(GST_PAD_LINK_FAILED (ret))
- {
+ if (GST_PAD_LINK_FAILED(ret)) {
ms_error("Failed to link [rtpbin].[%s] and [%s].[sink]\n", new_pad_name, sink_element_name);
- }
- else
- {
+ } else {
ms_info("Succeeded to link [rtpbin].[%s]->[%s].[sink]\n", new_pad_name, sink_element_name);
}
- }
- else
- {
+ } else {
peer_pad = gst_pad_get_peer(sink_pad);
peer_pad_name = gst_pad_get_name(peer_pad);
ms_debug("Pads [rtpbin].[%s]->[%s].[sink] are previously linked\n", peer_pad_name, sink_element_name);
ret = gst_pad_unlink(peer_pad, sink_pad);
- if(!ret)
- {
+ if (!ret) {
ms_error("Filed to unlink pads [rtpbin].[%s] <-and-> [%s].[sink] \n", peer_pad_name, sink_element_name);
- }
- else
- {
+ } else {
ms_info("Pads [rtpbin].[%s] <-and-> [%s].[sink] are unlinked successfully\n", peer_pad_name, sink_element_name);
}
ret = gst_pad_link(new_pad, sink_pad);
- if(GST_PAD_LINK_FAILED(ret))
- {
+ if (GST_PAD_LINK_FAILED(ret)) {
ms_error("Failed to link [rtpbin].[%s] and [%s].[sink]\n", new_pad_name, sink_element_name);
- }
- else
- {
+ } else {
ms_info("Succeeded to link [rtpbin].[%s]->[%s].[sink]\n", new_pad_name, sink_element_name);
}
}
gchar *sink_element_name = NULL;
GstElement *sink_element;
- GValue elem=G_VALUE_INIT;
+ GValue elem = G_VALUE_INIT;
const gchar *depay_klass_name = "Codec/Depayloader/Network/RTP";
GstIterator *bin_iterator;
gchar *source_pad_name = g_strdup_printf("%s_source", compared_type);
bin_iterator = gst_bin_iterate_elements(GST_BIN(ms_node->parent_streamer->topology_bin));
- while(GST_ITERATOR_OK == gst_iterator_next(bin_iterator, &elem))
- {
+ while (GST_ITERATOR_OK == gst_iterator_next(bin_iterator, &elem)) {
sink_element = (GstElement *)g_value_get_object(&elem);
sink_element_name = gst_element_get_name(sink_element);
const gchar *klass_name = gst_element_factory_get_klass(gst_element_get_factory(sink_element));
- if( g_strrstr(klass_name, depay_klass_name))
- {
- src_pad = gst_element_get_static_pad (sink_element, "src");
+ if (g_strrstr(klass_name, depay_klass_name)) {
+ src_pad = gst_element_get_static_pad(sink_element, "src");
ms_retm_if(src_pad == NULL, "Src pad is NULL");
- src_pad_caps = gst_pad_query_caps(src_pad,NULL);
+ src_pad_caps = gst_pad_query_caps(src_pad, NULL);
src_pad_struct = gst_caps_get_structure(src_pad_caps, 0);
const gchar *src_pad_type = gst_structure_get_name(src_pad_struct);
- if (g_strrstr(src_pad_type, compared_type))
- {
+ if (g_strrstr(src_pad_type, compared_type)) {
ms_debug("Element to connect [%s] has type [%s] \n", sink_element_name, src_pad_type);
GstPad *video_source_pad = gst_element_get_static_pad(ms_node->gst_element, source_pad_name);
ms_debug("Pad [%s] added on [%s]\n", new_pad_name, src_element_name);
target_pad = gst_ghost_pad_get_target(GST_GHOST_PAD(new_pad));
- src_pad_caps = gst_pad_query_caps(target_pad,NULL);
+ src_pad_caps = gst_pad_query_caps(target_pad, NULL);
src_pad_struct = gst_caps_get_structure(src_pad_caps, 0);
const gchar *src_pad_type = gst_structure_get_string(src_pad_struct, "media");
ms_debug("type is [%s]", src_pad_type);
- if(ms_node->parent_streamer == NULL)
- {
+ if (ms_node->parent_streamer == NULL) {
ms_error("Node doesn`t have parent streamer:\n");
- }
- else
- {
+ } else {
gchar *source_pad_name = NULL;
GstElement *sink_bin = NULL;
- if(g_strrstr(src_pad_type, "video"))
- {
+ if (g_strrstr(src_pad_type, "video")) {
source_pad_name = g_strdup_printf("%s_source", "video");
sink_bin = ms_node->parent_streamer->sink_video_bin;
- }
- else if(g_strrstr(src_pad_type, "audio"))
- {
+ } else if (g_strrstr(src_pad_type, "audio")) {
source_pad_name = g_strdup_printf("%s_source", "audio");
sink_bin = ms_node->parent_streamer->sink_audio_bin;
}
- if(source_pad_name != NULL)
- {
- if(gst_object_get_parent(GST_OBJECT(sink_bin)) == NULL)
- {
+ if (source_pad_name != NULL) {
+ if (gst_object_get_parent(GST_OBJECT(sink_bin)) == NULL) {
gst_bin_add(GST_BIN(ms_node->parent_streamer->pipeline), sink_bin);
}
gst_element_sync_state_with_parent(sink_bin);
gst_pad_set_active(source_pad, TRUE);
GstPad *sink_pad = gst_bin_find_unlinked_pad(GST_BIN(sink_bin), GST_PAD_SINK);
- if(sink_pad != NULL)
- {
+ if (sink_pad != NULL) {
__ms_add_ghostpad(gst_pad_get_parent(sink_pad), "sink", sink_bin, "sink");
- if (gst_element_link_pads(ms_node->gst_element, source_pad_name, sink_bin, "sink"))
- {
+ 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_generate_dots(ms_node->parent_streamer->pipeline, "playing");
- }
- else
- {
+ } else {
ms_error("Failed to link [rtp_containeer].[%s] and [sink_bin].[sink]\n", source_pad_name);
}
MS_SAFE_UNREF(sink_pad);
gchar *element_name = gst_element_get_name(gst_element);
ret_state = gst_element_set_state(gst_element, gst_state);
- if(ret_state == GST_STATE_CHANGE_FAILURE)
- {
+ if (ret_state == GST_STATE_CHANGE_FAILURE) {
ms_error("Failed to set element [%s] into %s state", element_name, _ms_state_to_string(gst_state));
MS_SAFE_GFREE(element_name);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
GstElement *__ms_element_create(const char *plugin_name, const char *name)
{
- 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);
return gst_element_factory_make(plugin_name, name);
}
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);
+ g_object_set(G_OBJECT(filter), "caps", videoCaps, NULL);
gst_caps_unref(videoCaps);
gst_bin_add_many(GST_BIN(camera_bin), camera_elem, filter, scale, videoconvert, NULL);
gst_ret = gst_element_link_many(camera_elem, filter, scale, videoconvert, NULL);
- if (gst_ret != TRUE)
- {
+ if (gst_ret != TRUE) {
ms_error("Failed to link elements into camerabin");
MS_SAFE_UNREF(camera_bin);
}
format_prefix = g_strdup_printf("%s:encoder", __ms_convert_mime_to_string(mime));
plugin_name = __ms_ini_get_string(dict, format_prefix, DEFAULT_VIDEO_DECODER);
- GstElement *encoder_elem = __ms_element_create(plugin_name,NULL);
+ GstElement *encoder_elem = __ms_element_create(plugin_name, NULL);
MS_SAFE_FREE(format_prefix);
MS_SAFE_FREE(plugin_name);
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);
- GstElement *encoder_parser = __ms_element_create(plugin_name,NULL);
+ GstElement *encoder_parser = __ms_element_create(plugin_name, NULL);
MS_SAFE_FREE(format_prefix);
MS_SAFE_FREE(plugin_name);
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=high",
- __ms_convert_mime_to_string(mime));
+ __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);
gst_bin_add_many(GST_BIN(encoder_bin), encoder_elem, filter, encoder_parser, NULL);
gst_ret = gst_element_link_many(encoder_elem, filter, encoder_parser, NULL);
- if (gst_ret != TRUE)
- {
+ if (gst_ret != TRUE) {
ms_error("Failed to link elements into encoder_bin");
MS_SAFE_UNREF(encoder_bin);
}
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);
- GstElement *decoder_elem = __ms_element_create(plugin_name,NULL);
+ GstElement *decoder_elem = __ms_element_create(plugin_name, NULL);
MS_SAFE_FREE(format_prefix);
MS_SAFE_FREE(plugin_name);
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);
- GstElement *decoder_parser = __ms_element_create(plugin_name,NULL);
+ 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", 5, NULL);
}
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");
+ 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");
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 (gst_ret != TRUE)
- {
+ if (gst_ret != TRUE) {
ms_error("Failed to link elements into decoder_bin");
MS_SAFE_UNREF(decoder_bin);
return NULL;
}
last_elem = decoder_elem;
- 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");
+ 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");
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)
- {
+ if (gst_ret != TRUE) {
ms_error("Failed to link elements into decoder_bin");
MS_SAFE_UNREF(decoder_bin);
return NULL;
GstElement *__ms_audio_encoder_element_create(void)
{
gboolean gst_ret = FALSE;
- GstElement *audio_convert = __ms_element_create("audioconvert",NULL);
- GstElement *audio_filter = __ms_element_create("capsfilter",NULL);
+ 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);
gst_bin_add_many(GST_BIN(audio_enc_bin), audio_convert, audio_filter, NULL);
gst_ret = gst_element_link_many(audio_filter, audio_convert, NULL);
- if (gst_ret != TRUE)
- {
+ if (gst_ret != TRUE) {
ms_error("Failed to link elements into decoder_bin");
MS_SAFE_UNREF(audio_enc_bin);
}
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");
gst_bin_add(GST_BIN(rtp_container), rtp_elem);
- g_signal_connect (rtp_elem, "pad-added", G_CALLBACK (__ms_rtpbin_pad_added_cb), ms_node);
+ g_signal_connect(rtp_elem, "pad-added", G_CALLBACK(__ms_rtpbin_pad_added_cb), ms_node);
return rtp_container;
}
static gboolean __ms_get_rtp_elements(media_streamer_node_s *ms_node,
- GstElement **rtp_elem, GstElement **rtcp_elem, const gchar *elem_name)
+ GstElement **rtp_elem, GstElement **rtcp_elem, const gchar *elem_name)
{
gboolean ret = FALSE;
gchar *rtp_elem_name = NULL;
ms_retvm_if(!elem_name, FALSE, "Empty rtp element name.");
- if(MS_ELEMENT_IS_SOURCE(elem_name))
- {
+ if (MS_ELEMENT_IS_SOURCE(elem_name)) {
plugin_name = g_strdup("udpsrc");
- }
- else if(MS_ELEMENT_IS_SINK(elem_name))
- {
+ } else if (MS_ELEMENT_IS_SINK(elem_name)) {
plugin_name = g_strdup("udpsink");
- }
- else
- {
+ } else {
ms_error("Error: invalid parameter name [%s]", elem_name);
return FALSE;
}
rtp_elem_name = g_strdup_printf("%s_rtp", elem_name);
rtcp_elem_name = g_strdup_printf("%s_rtcp", elem_name);
- // Find video udp rtp/rtcp element if it present.
+ /* Find video udp rtp/rtcp element if it present. */
*rtp_elem = gst_bin_get_by_name(GST_BIN(ms_node->gst_element), rtp_elem_name);
*rtcp_elem = gst_bin_get_by_name(GST_BIN(ms_node->gst_element), rtcp_elem_name);
- // Create new udp element if it did not found.
- if((NULL == *rtp_elem) && (NULL == *rtcp_elem))
- {
+ /* Create new udp element if it did not found. */
+ if ((NULL == *rtp_elem) && (NULL == *rtcp_elem)) {
*rtp_elem = __ms_element_create(plugin_name, rtp_elem_name);
*rtcp_elem = __ms_element_create(plugin_name, rtcp_elem_name);
- }
- else
- {
- //rtp/rtcp elements already into rtp bin.
+ } else {
+ /*rtp/rtcp elements already into rtp bin. */
MS_SAFE_GFREE(rtp_elem_name);
MS_SAFE_GFREE(rtcp_elem_name);
MS_SAFE_GFREE(plugin_name);
}
gst_bin_add_many(GST_BIN(ms_node->gst_element),
- *rtp_elem, *rtcp_elem, NULL);
+ *rtp_elem, *rtcp_elem, NULL);
- if(MS_ELEMENT_IS_SINK(elem_name))
- {
+ if (MS_ELEMENT_IS_SINK(elem_name)) {
g_object_set(GST_OBJECT(*rtcp_elem), "sync", FALSE, NULL);
g_object_set(GST_OBJECT(*rtcp_elem), "async", FALSE, NULL);
- if(MS_ELEMENT_IS_VIDEO(elem_name))
- {
+ if (MS_ELEMENT_IS_VIDEO(elem_name)) {
__ms_add_ghostpad(rtpbin, "send_rtp_sink_0", ms_node->gst_element, "video_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
- {
+ 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_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");
+ gst_element_link_pads(rtpbin, "send_rtcp_src_1", *rtcp_elem, "sink");
}
- }
- else
- {
- if(MS_ELEMENT_IS_VIDEO(elem_name))
- {
+ } 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");
+ gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_0");
__ms_add_ghostpad(NULL, NULL, ms_node->gst_element, "video_source");
- }
- else
- {
+ } 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");
+ gst_element_link_pads(*rtcp_elem, "src", rtpbin, "recv_rtcp_sink_1");
__ms_add_ghostpad(NULL, NULL, ms_node->gst_element, "audio_source");
}
}
- if(!ret)
- {
+ if (!ret) {
ms_error("Can not link [rtpbin] pad to [%s] pad, ret code [%d] ", rtp_elem, ret);
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
}
int __ms_rtp_set_param(
- media_streamer_node_s *ms_node,
- const gchar *param_key,
- const gchar *param_value)
+ 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_NONE, "Error: empty node");
GstElement *rtp_elem = NULL;
GstElement *rtcp_elem = NULL;
- tokens = g_strsplit(param_key,",",3);
+ tokens = g_strsplit(param_key, ",", 3);
ms_retvm_if(tokens == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Invalid rtp parameter line.");
elem_name = tokens[0];
- if(FALSE == __ms_get_rtp_elements(ms_node, &rtp_elem, &rtcp_elem, elem_name))
- {
+ if (FALSE == __ms_get_rtp_elements(ms_node, &rtp_elem, &rtcp_elem, elem_name)) {
ms_error("Error: invalid parameter [%s]", param_key);
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- for(i = 1; (tokens && tokens[i]); i++)
- {
+ for (i = 1; (tokens && tokens[i]); i++) {
ms_retvm_if(!rtp_elem || !rtcp_elem,
- MEDIA_STREAMER_ERROR_INVALID_OPERATION,
- "Error: [%s] did not found or created into streamer", tokens[i]);
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION,
+ "Error: [%s] did not found or created into streamer", tokens[i]);
- if(!g_strcmp0(tokens[i], "port"))
- {
+ if (!g_strcmp0(tokens[i], "port")) {
__ms_element_set_property(rtp_elem, tokens[i], param_value);
gchar *next_port = g_strdup(param_value);
- next_port[strlen(next_port)-1] += 1;
+ next_port[strlen(next_port) - 1] += 1;
__ms_element_set_property(rtcp_elem, tokens[i], next_port);
MS_SAFE_GFREE(next_port);
- }
- else if(!g_strcmp0(tokens[i], "host") && MS_ELEMENT_IS_SINK(elem_name))
- {
+ } else if (!g_strcmp0(tokens[i], "host") && MS_ELEMENT_IS_SINK(elem_name)) {
__ms_element_set_property(rtp_elem, tokens[i], param_value);
__ms_element_set_property(rtcp_elem, tokens[i], param_value);
- }
- else if(!g_strcmp0(tokens[i], "format") && MS_ELEMENT_IS_SOURCE(elem_name))
- {
+ } else if (!g_strcmp0(tokens[i], "format") && MS_ELEMENT_IS_SOURCE(elem_name)) {
__ms_element_set_property(rtp_elem, "caps", param_value);
}
return MEDIA_STREAMER_ERROR_NONE;
}
-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_node->name, ms_node->type, ms_node->subtype);
gchar *bin_name = NULL;
gboolean gst_ret = FALSE;
- switch(ms_node->type)
- {
+ switch (ms_node->type) {
case MEDIA_STREAMER_NODE_TYPE_SRC:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->src_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->src_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_SRC_BIN_NAME);
break;
case MEDIA_STREAMER_NODE_TYPE_SINK:
- switch(ms_node->subtype)
- {
+ switch (ms_node->subtype) {
case MEDIA_STREAMER_SINK_TYPE_SCREEN:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_VIDEO_SINK_BIN_NAME);
break;
case MEDIA_STREAMER_SINK_TYPE_AUDIO:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_AUDIO_SINK_BIN_NAME);
break;
default:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_VIDEO_SINK_BIN_NAME);
break;
}
break;
case MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->topology_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->topology_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_TOPOLOGY_BIN_NAME);
break;
case MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_VIDEO_SINK_BIN_NAME);
break;
case MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_video_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_VIDEO_SINK_BIN_NAME);
break;
case MEDIA_STREAMER_NODE_TYPE_AUDIO_DEPAY:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_AUDIO_SINK_BIN_NAME);
break;
case MEDIA_STREAMER_NODE_TYPE_AUDIO_RESAMPLE:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_AUDIO_SINK_BIN_NAME);
break;
case MEDIA_STREAMER_NODE_TYPE_AUDIO_CONVERTER:
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin),ms_node->gst_element);
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->sink_audio_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_AUDIO_SINK_BIN_NAME);
break;
default:
- // Another elements will be add into topology bin
- gst_ret = gst_bin_add(GST_BIN(ms_streamer->topology_bin),ms_node->gst_element);
+ /* Another elements will be add into topology bin */
+ gst_ret = gst_bin_add(GST_BIN(ms_streamer->topology_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_TOPOLOGY_BIN_NAME);
break;
}
- if(!gst_ret)
- {
+ if (!gst_ret) {
ms_error("Failed to add Element [%s] into [%s] bin.", ms_node->name, bin_name);
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
- else
- {
+ } else {
ms_info("Success added Element [%s] into [%s] bin.", ms_node->name, bin_name);
ret = MEDIA_STREAMER_ERROR_NONE;
}
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;
- gchar *debug;
- gst_message_parse_error (message, &err, &debug);
-
- ms_error("[Source: %s] Error: %s", GST_OBJECT_NAME(GST_OBJECT_CAST(GST_ELEMENT(GST_MESSAGE_SRC (message)))), err->message);
-
- MS_SAFE_FREE(err);
- MS_SAFE_FREE(debug);
- break;
- }
+ if (message != NULL) {
+ switch (GST_MESSAGE_TYPE(message)) {
+ case GST_MESSAGE_ERROR: {
+ GError *err;
+ gchar *debug;
+ gst_message_parse_error(message, &err, &debug);
+
+ ms_error("[Source: %s] Error: %s", GST_OBJECT_NAME(GST_OBJECT_CAST(GST_ELEMENT(GST_MESSAGE_SRC(message)))), err->message);
- 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);
- ms_info ("GST_MESSAGE_STATE_CHANGED: [%s] %s -> %s\n",
- gst_object_get_name(GST_MESSAGE_SRC(message)),
- _ms_state_to_string(state_old),
- _ms_state_to_string(state_new));
-
- state_transition_name = g_strdup_printf ("%s_%s",
- gst_element_state_get_name (state_old),
- gst_element_state_get_name (state_new));
-
- __ms_generate_dots(ms_streamer->pipeline, state_transition_name);
-
- MS_SAFE_GFREE (state_transition_name);
-
- if (state_old == GST_STATE_NULL && state_new == GST_STATE_READY)
- {
- ms_info("[Success] GST_STATE_NULL => GST_STATE_READY");
-
- /* Pause Media_Streamer */
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
- if(ret != MEDIA_STREAMER_ERROR_NONE)
- {
- ms_error("ERROR - Pause pipeline");
- return FALSE;
+ MS_SAFE_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);
+ ms_info("GST_MESSAGE_STATE_CHANGED: [%s] %s -> %s\n",
+ gst_object_get_name(GST_MESSAGE_SRC(message)),
+ _ms_state_to_string(state_old),
+ _ms_state_to_string(state_new));
+
+ state_transition_name = g_strdup_printf("%s_%s",
+ gst_element_state_get_name(state_old),
+ gst_element_state_get_name(state_new));
+
+ __ms_generate_dots(ms_streamer->pipeline, state_transition_name);
+
+ MS_SAFE_GFREE(state_transition_name);
+
+ if (state_old == GST_STATE_NULL && state_new == GST_STATE_READY) {
+ ms_info("[Success] GST_STATE_NULL => GST_STATE_READY");
+
+ /* Pause Media_Streamer */
+ ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
+ ms_error("ERROR - Pause pipeline");
+ return FALSE;
+ }
}
- }
- if (state_old == GST_STATE_READY && state_new == GST_STATE_PAUSED)
- {
- ms_info("[Success] GST_STATE_READY => GST_STATE_PAUSED");
+ if (state_old == GST_STATE_READY && state_new == GST_STATE_PAUSED) {
+ ms_info("[Success] GST_STATE_READY => GST_STATE_PAUSED");
- ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING);
- if(ret != MEDIA_STREAMER_ERROR_NONE)
- {
- ms_error("ERROR - Play Pipeline");
- return FALSE;
+ ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PLAYING);
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
+ ms_error("ERROR - Play Pipeline");
+ return FALSE;
+ }
}
}
+ break;
}
- 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;
+ 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;
}
- break;
- }
default:
break;
}
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");
+ 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");
+ 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");
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Src bin");
-// g_signal_connect(ms_streamer->src_bin, "element-added", G_CALLBACK(__src_bin_element_added_cb), ms_streamer);
+ /* g_signal_connect(ms_streamer->src_bin, "element-added", G_CALLBACK(__src_bin_element_added_cb), ms_streamer); */
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 bin");
-// g_signal_connect(ms_streamer->sink_bin, "element-added", G_CALLBACK(__sink_bin_element_added_cb), ms_streamer);
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Sink bin");
+ /* g_signal_connect(ms_streamer->sink_bin, "element-added", G_CALLBACK(__sink_bin_element_added_cb), ms_streamer); */
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 Audio Sink bin");
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Audio Sink 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");
-// g_signal_connect(ms_streamer->topology_bin, "element-added", G_CALLBACK(__bin_element_added_cb), ms_streamer);
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating Topology bin");
+ /* g_signal_connect(ms_streamer->topology_bin, "element-added", G_CALLBACK(__bin_element_added_cb), ms_streamer); */
gst_bin_add_many(GST_BIN(ms_streamer->pipeline), ms_streamer->src_bin,
- ms_streamer->topology_bin, NULL);
+ ms_streamer->topology_bin, NULL);
return MEDIA_STREAMER_ERROR_NONE;
}
int samplerate;
int bit;
- if (media_format_get_video_info(fmt, &mime, &width, &height, &avg_bps, &max_bps) == MEDIA_PACKET_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);
+ width, height, avg_bps, mime);
- if (mime & MEDIA_FORMAT_RAW)
- {
+ 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);
- }
- else
- {
- //mime & MEDIA_FORMAT_ENCODED
+ /*"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);
+ "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)
- {
+ } 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);
+ channel, samplerate, bit, avg_bps, mime);
- if (mime & MEDIA_FORMAT_RAW)
- {
+ 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);
- }
- else
- {
+ "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.");
}
- }
- else
- {
+ } else {
ms_error("Failed getting media info from fmt.");
}
MS_SAFE_GFREE(format_name);
#include <media_streamer_gst.h>
int __ms_node_create(media_streamer_node_s *node,
- media_format_h in_fmt,
- media_format_h out_fmt)
+ media_format_h in_fmt,
+ media_format_h out_fmt)
{
ms_retvm_if(node == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
char *plugin_name = NULL;
media_format_mimetype_e mime;
- 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;
+ char *format_prefix = NULL;
__ms_load_ini_dictionary(&dict);
- switch(node->type)
- {
+ 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);
+ format_prefix, DEFAULT_VIDEO_ENCODER);
node->gst_element = __ms_video_encoder_element_create(dict, mime);
break;
case MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER:
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);
+ 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);
+ format_prefix, DEFAULT_VIDEO_PARSER);
node->gst_element = __ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_TYPE_FILTER:
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);
+ 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);
+ "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);
+ 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_RTPPAY);
+ "audio-raw:rtpdepay", DEFAULT_AUDIO_RTPPAY);
node->gst_element = __ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_NODE_TYPE_RTP:
node->gst_element = __ms_element_create("audioresample", NULL);
break;
default:
- ms_error( "Error: invalid node Type [%d]",node->type);
+ ms_error("Error: invalid node Type [%d]", node->type);
break;
}
__ms_load_ini_dictionary(&dict);
- switch(node->subtype)
- {
+ switch (node->subtype) {
case MEDIA_STREAMER_SRC_TYPE_FILE:
ms_error("Error: not implemented yet");
break;
break;
case MEDIA_STREAMER_SRC_TYPE_CAMERA:
plugin_name = __ms_ini_get_string(dict,
- "sources:camera_source",DEFAULT_CAMERA_SOURCE);
+ "sources:camera_source", DEFAULT_CAMERA_SOURCE);
node->gst_element = __ms_camera_element_create(plugin_name);
break;
case MEDIA_STREAMER_SRC_TYPE_AUDIO_CAPTURE:
plugin_name = __ms_ini_get_string(dict,
- "sources:audio_source",DEFAULT_AUDIO_SOURCE);
+ "sources:audio_source", DEFAULT_AUDIO_SOURCE);
node->gst_element = __ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_SRC_TYPE_VIDEO_CAPTURE:
plugin_name = __ms_ini_get_string(dict,
- "sources:video_source",DEFAULT_VIDEO_SOURCE);
+ "sources:video_source", DEFAULT_VIDEO_SOURCE);
node->gst_element = __ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_SRC_TYPE_VIDEO_TEST:
node->gst_element = __ms_element_create(DEFAULT_VIDEO_TEST_SOURCE, NULL);
- g_object_set (G_OBJECT (node->gst_element), "is-live", true, NULL);
+ g_object_set(G_OBJECT(node->gst_element), "is-live", true, NULL);
break;
case MEDIA_STREAMER_SRC_TYPE_AUDIO_TEST:
node->gst_element = __ms_element_create(DEFAULT_AUDIO_TEST_SOURCE, NULL);
ms_error("Error: not implemented yet");
break;
default:
- ms_error( "Error: invalid Src node Type [%d]",node->subtype);
+ ms_error("Error: invalid Src node Type [%d]", node->subtype);
break;
}
__ms_load_ini_dictionary(&dict);
- switch(node->subtype)
- {
+ switch (node->subtype) {
case MEDIA_STREAMER_SINK_TYPE_FILE:
ms_error("Error: not implemented yet");
break;
break;
case MEDIA_STREAMER_SINK_TYPE_AUDIO:
plugin_name = __ms_ini_get_string(dict,
- "sinks:audio_sink",DEFAULT_AUDIO_SINK);
+ "sinks:audio_sink", DEFAULT_AUDIO_SINK);
node->gst_element = __ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_SINK_TYPE_SCREEN:
plugin_name = __ms_ini_get_string(dict,
- "sinks:video_sink",DEFAULT_VIDEO_SINK);
+ "sinks:video_sink", DEFAULT_VIDEO_SINK);
node->gst_element = __ms_element_create(plugin_name, NULL);
break;
case MEDIA_STREAMER_SINK_TYPE_FAKE:
break;
default:
- ms_error( "Error: invalid Sink node Type [%d]",node->subtype);
+ ms_error("Error: invalid Sink node Type [%d]", node->subtype);
break;
}
void __ms_node_destroy(void *data)
{
char *node_name = NULL;
- media_streamer_node_s *node = (media_streamer_node_s*)data;
+ media_streamer_node_s *node = (media_streamer_node_s *)data;
ms_retm_if(node == NULL, "Empty value while deleting element from table");
node_name = g_strdup(node->name);
}
void __ms_node_insert_into_table(GHashTable *nodes_table,
- media_streamer_node_s *ms_node)
+ media_streamer_node_s *ms_node)
{
- if(g_hash_table_contains(nodes_table,ms_node->name))
- {
- ms_debug( "Current Node [%s] already added", ms_node->name);
+ if (g_hash_table_contains(nodes_table, ms_node->name)) {
+ ms_debug("Current Node [%s] already added", ms_node->name);
return;
}
- g_hash_table_insert(nodes_table,(gpointer)ms_node->name,(gpointer)ms_node);
+ g_hash_table_insert(nodes_table, (gpointer)ms_node->name, (gpointer)ms_node);
ms_info("Node [%s] added into streamer, node type/subtype [%d/%d]",
- ms_node->name, ms_node->type, ms_node->subtype);
+ ms_node->name, ms_node->type, ms_node->subtype);
}
int __ms_node_remove_from_table(GHashTable *nodes_table,
- media_streamer_node_s *ms_node)
+ media_streamer_node_s *ms_node)
{
ms_retvm_if(nodes_table == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL");
ms_retvm_if(ms_node == NULL, MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Handle is NULL");
gboolean g_ret = g_hash_table_remove(nodes_table, ms_node->name);
ms_retvm_if(g_ret != TRUE, MEDIA_STREAMER_ERROR_INVALID_OPERATION,
- "Error while removing element from table");
+ "Error while removing element from table");
return MEDIA_STREAMER_ERROR_NONE;
}
static void __params_foreach_cb(const char *key,
- const int type,
- const bundle_keyval_t *kv,
- void *user_data)
+ 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))
- {
+ 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 [%d].", (gchar*)basic_val, basic_size);
+ ms_info("Read param value[%s] with size [%d].", (gchar *)basic_val, basic_size);
- if(ms_node->set_param != NULL)
- {
- ret = ms_node->set_param(ms_node, (gchar*)key, (gchar*)basic_val);
- }
- else
- {
+ if (ms_node->set_param != NULL) {
+ ret = ms_node->set_param(ms_node, (gchar *)key, (gchar *)basic_val);
+ } else {
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
- }
- else
- {
+ } else {
ret = MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
ms_retm_if(ret != MEDIA_STREAMER_ERROR_NONE,
- "Error while adding param [%s,%s] to the node [%s]",
- key, type, ms_node->name);
+ "Error while adding param [%s,%s] 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);
+ bundle_foreach(param_list, __params_foreach_cb, (void *)node);
return ret;
}
-int __ms_node_write_params_into_bundle (media_streamer_node_s *node,
- bundle *param_list)
+int __ms_node_write_params_into_bundle(media_streamer_node_s *node,
+ bundle *param_list)
{
GParamSpec **property_specs;
guint num_properties, i;
char *string_val = NULL;
property_specs = g_object_class_list_properties
- (G_OBJECT_GET_CLASS(node->gst_element), &num_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 );
+ ms_info("Getting parameter of the Node [%s]", node->name);
- for (i = 0; i < num_properties; i++)
- {
+ for (i = 0; i < num_properties; i++) {
GValue value = { 0, };
GParamSpec *param = property_specs[i];
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->name, &value);
- }
- else
- {
- // Skip properties which user can not change.
+ } else {
+ /* Skip properties which user can not change. */
continue;
}
ms_info("%-20s: %s\n", g_param_spec_get_name(param), g_param_spec_get_blurb(param));
- switch(G_VALUE_TYPE(&value))
- {
+ switch (G_VALUE_TYPE(&value)) {
case G_TYPE_STRING:
bundle_add_str(param_list, g_param_spec_get_name(param), g_value_get_string(&value));
ms_info("Got string value: [%s]", g_value_get_string(&value));
ms_info("Got boolean value: [%s]", string_val);
break;
- case G_TYPE_ULONG:
- {
- GParamSpecULong *pulong = G_PARAM_SPEC_ULONG(param);
- string_val = g_strdup_printf("%lu", g_value_get_ulong(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got ulong value: [%s], range: %lu - %lu (default %s)",
- string_val, pulong->minimum, pulong->maximum);
- break;
- }
-
- case G_TYPE_LONG:
- {
- GParamSpecLong *plong = G_PARAM_SPEC_LONG(param);
- string_val = g_strdup_printf("%ld", g_value_get_long(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got long value: [%s], range: %ld - %ld (default %s)",
- string_val, plong->minimum, plong->maximum);
- break;
- }
-
- case G_TYPE_UINT:
- {
- GParamSpecUInt *puint = G_PARAM_SPEC_UINT(param);
- string_val = g_strdup_printf("%u", g_value_get_uint(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got uint value: [%s], range: %u - %u",
- string_val, puint->minimum, puint->maximum);
- break;
- }
-
- case G_TYPE_INT:
- {
- GParamSpecInt *pint = G_PARAM_SPEC_INT(param);
- string_val = g_strdup_printf("%d", g_value_get_int(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got int value: [%s], range: %d - %d",
- string_val, pint->minimum, pint->maximum);
- break;
- }
-
- case G_TYPE_UINT64:
- {
- GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64(param);
- string_val = g_strdup_printf("%" G_GUINT64_FORMAT, g_value_get_uint64(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got uint64 value: [%s], range: %" G_GUINT64_FORMAT "- %" G_GUINT64_FORMAT,
- string_val, puint64->minimum, puint64->maximum);
- break;
- }
-
- case G_TYPE_INT64:
- {
- GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64(param);
- string_val = g_strdup_printf("%" G_GINT64_FORMAT, g_value_get_int64(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got uint64 value: [%s], range: %" G_GINT64_FORMAT "- %" G_GINT64_FORMAT,
- string_val, pint64->minimum, pint64->maximum);
- break;
- }
-
- case G_TYPE_FLOAT:
- {
- GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT(param);
- string_val = g_strdup_printf("%15.7g", g_value_get_float(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got float value: [%s], range:%15.7g -%15.7g",
- string_val, pfloat->minimum, pfloat->maximum);
- break;
- }
-
- case G_TYPE_DOUBLE:
- {
- GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE(param);
- string_val = g_strdup_printf("%15.7g", g_value_get_double(&value));
- bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
- ms_info("Got double value: [%s], range:%15.7g -%15.7g",
- string_val, pdouble->minimum, pdouble->maximum);
- break;
- }
+ case G_TYPE_ULONG: {
+ GParamSpecULong *pulong = G_PARAM_SPEC_ULONG(param);
+ string_val = g_strdup_printf("%lu", g_value_get_ulong(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got ulong value: [%s], range: %lu - %lu (default %s)",
+ string_val, pulong->minimum, pulong->maximum);
+ break;
+ }
+
+ case G_TYPE_LONG: {
+ GParamSpecLong *plong = G_PARAM_SPEC_LONG(param);
+ string_val = g_strdup_printf("%ld", g_value_get_long(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got long value: [%s], range: %ld - %ld (default %s)",
+ string_val, plong->minimum, plong->maximum);
+ break;
+ }
+
+ case G_TYPE_UINT: {
+ GParamSpecUInt *puint = G_PARAM_SPEC_UINT(param);
+ string_val = g_strdup_printf("%u", g_value_get_uint(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got uint value: [%s], range: %u - %u",
+ string_val, puint->minimum, puint->maximum);
+ break;
+ }
+
+ case G_TYPE_INT: {
+ GParamSpecInt *pint = G_PARAM_SPEC_INT(param);
+ string_val = g_strdup_printf("%d", g_value_get_int(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got int value: [%s], range: %d - %d",
+ string_val, pint->minimum, pint->maximum);
+ break;
+ }
+
+ case G_TYPE_UINT64: {
+ GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64(param);
+ string_val = g_strdup_printf("%" G_GUINT64_FORMAT, g_value_get_uint64(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got uint64 value: [%s], range: %" G_GUINT64_FORMAT "- %" G_GUINT64_FORMAT,
+ string_val, puint64->minimum, puint64->maximum);
+ break;
+ }
+
+ case G_TYPE_INT64: {
+ GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64(param);
+ string_val = g_strdup_printf("%" G_GINT64_FORMAT, g_value_get_int64(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got uint64 value: [%s], range: %" G_GINT64_FORMAT "- %" G_GINT64_FORMAT,
+ string_val, pint64->minimum, pint64->maximum);
+ break;
+ }
+
+ case G_TYPE_FLOAT: {
+ GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT(param);
+ string_val = g_strdup_printf("%15.7g", g_value_get_float(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got float value: [%s], range:%15.7g -%15.7g",
+ string_val, pfloat->minimum, pfloat->maximum);
+ break;
+ }
+
+ case G_TYPE_DOUBLE: {
+ GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE(param);
+ string_val = g_strdup_printf("%15.7g", g_value_get_double(&value));
+ bundle_add_str(param_list, g_param_spec_get_name(param), string_val);
+ ms_info("Got double value: [%s], range:%15.7g -%15.7g",
+ string_val, pdouble->minimum, pdouble->maximum);
+ break;
+ }
default:
ms_info("Got unknown type with param->value_type [%d]", param->value_type);
ms_retvm_if(ms_streamer == NULL, MEDIA_STREAMER_ERROR_INVALID_PARAMETER, "Handle is NULL");
- media_streamer_state_e previous_state= ms_streamer->state;
+ media_streamer_state_e previous_state = ms_streamer->state;
ms_retvm_if(previous_state == state, MEDIA_STREAMER_ERROR_NONE, "Media streamer already in this state");
- switch(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)
- {
+ if (previous_state != MEDIA_STREAMER_STATE_IDLE) {
__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_IDLE);
}
break;
/*
* Unlink all gst_elements, set pipeline into state NULL
*/
- if (previous_state != MEDIA_STREAMER_STATE_NONE)
- {
+ if (previous_state != MEDIA_STREAMER_STATE_NONE) {
ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_NULL);
}
break;
ret = __ms_element_set_state(ms_streamer->pipeline, GST_STATE_PAUSED);
break;
case MEDIA_STREAMER_STATE_SEEKING:
- default:
- {
- ms_info("Error: invalid state [%s]", state);
- return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
- }
+ default: {
+ ms_info("Error: invalid state [%s]", state);
+ return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
+ }
}
- if(ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Failed change state");
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
int ret = MEDIA_STREAMER_ERROR_NONE;
ret = __ms_load_ini_settings(&ms_streamer->ini);
- ms_retvm_if(ret!=MEDIA_STREAMER_ERROR_NONE,
- MEDIA_STREAMER_ERROR_INVALID_OPERATION,"Error load ini file");
+ ms_retvm_if(ret != MEDIA_STREAMER_ERROR_NONE,
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error load ini file");
ms_streamer->nodes_table = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, __ms_node_destroy);
ms_retvm_if(ms_streamer->nodes_table == NULL,
- MEDIA_STREAMER_ERROR_INVALID_OPERATION,"Error creating hash table");
+ MEDIA_STREAMER_ERROR_INVALID_OPERATION, "Error creating hash table");
ret = __ms_pipeline_create(ms_streamer);
- if (ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error while creating media streamer pipeline.");
return MEDIA_STREAMER_ERROR_INVALID_OPERATION;
}
}
static void __node_remove_cb(gpointer key,
- gpointer value,
- gpointer user_data)
+ gpointer value,
+ 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");
- media_streamer_node_s *ms_node = (media_streamer_node_s*)value;
+ media_streamer_node_s *ms_node = (media_streamer_node_s *)value;
ms_retm_if(ms_node == NULL, "Handle is NULL");
ms_info("Try to delete [%s] node from streamer, node type/subtype [%d/%d]",
- ms_node->name, ms_node->type, ms_node->subtype);
+ ms_node->name, ms_node->type, ms_node->subtype);
gchar *bin_name = NULL;
gboolean gst_ret = FALSE;
__ms_element_set_state(ms_node->gst_element, GST_STATE_NULL);
gst_object_ref(ms_node->gst_element);
- switch(ms_node->type)
- {
+ switch (ms_node->type) {
case MEDIA_STREAMER_NODE_TYPE_SRC:
- gst_ret = gst_bin_remove(GST_BIN(ms_streamer->src_bin),ms_node->gst_element);
+ gst_ret = gst_bin_remove(GST_BIN(ms_streamer->src_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_SRC_BIN_NAME);
break;
case MEDIA_STREAMER_NODE_TYPE_SINK:
- gst_ret = gst_bin_remove(GST_BIN(ms_streamer->sink_video_bin),ms_node->gst_element);
+ gst_ret = gst_bin_remove(GST_BIN(ms_streamer->sink_video_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_VIDEO_SINK_BIN_NAME);
break;
default:
- gst_ret = gst_bin_remove(GST_BIN(ms_streamer->topology_bin),ms_node->gst_element);
+ gst_ret = gst_bin_remove(GST_BIN(ms_streamer->topology_bin), ms_node->gst_element);
bin_name = g_strdup(MEDIA_STREAMER_TOPOLOGY_BIN_NAME);
break;
}
- if(!gst_ret)
- {
+ if (!gst_ret) {
ms_error("Failed to remove Element [%s] from bin [%s]", ms_node->name, bin_name);
- }
- else
- {
+ } else {
ms_info("Success removed Element [%s] from bin [%s]", ms_node->name, bin_name);
}
void __ms_streamer_destroy(media_streamer_s *ms_streamer)
{
- if(__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_NONE) != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (__ms_state_change(ms_streamer, MEDIA_STREAMER_STATE_NONE) != MEDIA_STREAMER_ERROR_NONE) {
ms_error("Error: can not set state [%d]", MEDIA_STREAMER_ERROR_INVALID_OPERATION);
}
gst_element_unlink_many(ms_streamer->src_bin,
- ms_streamer->topology_bin,
- ms_streamer->sink_video_bin, NULL);
+ ms_streamer->topology_bin,
+ ms_streamer->sink_video_bin, NULL);
- g_hash_table_foreach(ms_streamer->nodes_table, __node_remove_cb,(gpointer)ms_streamer);
+ g_hash_table_foreach(ms_streamer->nodes_table, __node_remove_cb, (gpointer)ms_streamer);
- if(ms_streamer->src_bin && !gst_bin_remove(GST_BIN(ms_streamer->pipeline),ms_streamer->src_bin))
- {
+ if (ms_streamer->src_bin && !gst_bin_remove(GST_BIN(ms_streamer->pipeline), ms_streamer->src_bin)) {
ms_error("Failed to remove src_bin from pipeline");
- }
- else
- {
+ } else {
ms_info("src_bin removed from pipeline");
}
- if(ms_streamer->sink_video_bin && !gst_bin_remove(GST_BIN(ms_streamer->pipeline),ms_streamer->sink_video_bin))
- {
+ if (ms_streamer->sink_video_bin && !gst_bin_remove(GST_BIN(ms_streamer->pipeline), ms_streamer->sink_video_bin)) {
ms_error("Failed to remove sink_bin from pipeline");
- }
- else
- {
+ } else {
ms_info("sink_bin removed from pipeline");
}
- if(ms_streamer->topology_bin && !gst_bin_remove(GST_BIN(ms_streamer->pipeline),ms_streamer->topology_bin))
- {
+ if (ms_streamer->topology_bin && !gst_bin_remove(GST_BIN(ms_streamer->pipeline), ms_streamer->topology_bin)) {
ms_error("Failed to remove topology_bin from pipeline");
- }
- else
- {
+ } else {
ms_info("topology_bin removed from pipeline");
}
MS_SAFE_FREE(ms_streamer);
-// gst_deinit();
+ /* gst_deinit(); */
}
#include <media_streamer_util.h>
#ifdef MEDIA_STREAMER_DEFAULT_INI
- static gboolean __ms_generate_default_ini(void);
+static gboolean __ms_generate_default_ini(void);
#endif
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;
ms_retvm_if(ini_path == NULL, NULL, "Invalid ini path");
- if (dict == NULL)
- {
+ if (dict == NULL) {
result_str = g_strdup(default_str);
- }
- else
- {
+ } else {
gchar *str = NULL;
str = iniparser_getstring(dict, ini_path, default_str);
if (str &&
- (strlen(str) > 0) &&
- (strlen(str) < MEDIA_STREAMER_INI_MAX_STRLEN))
- {
+ (strlen(str) > 0) &&
+ (strlen(str) < MEDIA_STREAMER_INI_MAX_STRLEN)) {
result_str = g_strdup(str);
- }
- else
- {
+ } else {
result_str = g_strdup(default_str);
}
}
ms_dict = iniparser_load(MEDIA_STREAMER_INI_DEFAULT_PATH);
/* if no file exists. create one with set of default values */
- if (!ms_dict)
- {
+ if (!ms_dict) {
#ifdef MEDIA_STREAMER_DEFAULT_INI
ms_debug("No inifile found. Media streamer will create default inifile.");
- if (FALSE == __ms_generate_default_ini())
- {
+ if (FALSE == __ms_generate_default_ini()) {
ms_debug("Creating default .ini file failed. Media-streamer will use default values.");
- }
- else
- {
+ } else {
/* load default ini */
ms_dict = iniparser_load(MEDIA_STREAMER_INI_DEFAULT_PATH);
}
/* get ini values */
memset(ini, 0, sizeof(media_streamer_ini_t));
- if (__ms_load_ini_dictionary(&dict))
- {
+ if (__ms_load_ini_dictionary(&dict)) {
/* general */
ini->generate_dot = iniparser_getboolean(dict, "general:generate dot", DEFAULT_GENERATE_DOT);
- if (ini->generate_dot == TRUE)
- {
+ if (ini->generate_dot == TRUE) {
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);
+ 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);
}
- }
- 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*/
int file_size = 0;
int status = 0;
- if(fp == NULL)
- {
+ if (fp == NULL) {
ms_debug("Failed to get media streamer ini file.");
- }
- else
- {
+ } else {
fseek(fp, 0, SEEK_END);
file_size = ftell(fp);
fclose(fp);
- if (file_size < 5)
- {
+ 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");
}
}
/* 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))
- {
+ if (strlen(default_ini) != fwrite(default_ini, 1, strlen(default_ini), fp)) {
fclose(fp);
return FALSE;
}
const gchar *__ms_convert_mime_to_string(media_format_mimetype_e mime)
{
- switch(mime)
- {
+ switch (mime) {
case MEDIA_FORMAT_I420:
return "I420";
case MEDIA_FORMAT_YV12:
default:
ms_error("Invalid or Unsupported media format [%d].", mime);
return NULL;
- break;
+ break;
}
}
#include <media_streamer.h>
-typedef enum
-{
+typedef enum {
MENU_STATE_UNKNOWN = 0,
MENU_STATE_MAIN_MENU,
MENU_STATE_BROADCAST_MENU,
MENU_STATE_PRESET_MENU
} menu_state_e;
-typedef enum
-{
+typedef enum {
SUBMENU_STATE_UNKNOWN = 0,
SUBMENU_STATE_GETTING_IP,
SUBMENU_STATE_AUTOPLUG = 3,
#define SECOND_VOIP_MASK 0x8
#define DOUBLE_STREAMER_MASK 0x10
-typedef enum
-{
+typedef enum {
PRESET_UNKNOWN = 0,
PRESET_RTP_STREAMER = 0x01,
PRESET_RTP_CLIENT = 0x02,
static media_streamer_h g_media_streamer_2;
static media_streamer_h current_media_streamer = &g_media_streamer;
-//#define ONE_DEVICE_TEST
+/*#define ONE_DEVICE_TEST */
#define MAX_STRING_LEN 2048
#define DEFAULT_IP_ADDR "127.0.0.1"
#define VIDEO_PORT 5000
#define AUDIO_PORT 6000
-//#define DISABLE_AUDIO
-//#define DISABLE_VIDEO
+/*#define DISABLE_AUDIO */
+/*#define DISABLE_VIDEO */
/*---------------------------------------------------------------------------
| LOCAL VARIABLE DEFINITIONS: |
{
g_print("== create \n");
- if(*streamer != NULL)
- {
+ if (*streamer != NULL) {
return TRUE;
}
ret = media_streamer_create(streamer);
- if( ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
g_print("Fail to create media streamer");
return FALSE;
}
int ret = MEDIA_STREAMER_ERROR_NONE;
ret = media_streamer_prepare(current_media_streamer);
- if( ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
g_print("Fail to prepare media streamer");
return FALSE;
}
int ret = MEDIA_STREAMER_ERROR_NONE;
ret = media_streamer_unprepare(current_media_streamer);
- if( ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
g_print("Fail to unprepare media streamer");
return FALSE;
}
int ret = MEDIA_STREAMER_ERROR_NONE;
ret = media_streamer_play(current_media_streamer);
- if( ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
g_print("Fail to play media streamer");
return FALSE;
}
g_print("== destroy \n");
int ret = MEDIA_STREAMER_ERROR_NONE;
- if(streamer == NULL)
- {
+ if (streamer == NULL) {
g_print("media streamer already destroyed");
return TRUE;
}
ret = media_streamer_destroy(streamer);
- if( ret != MEDIA_STREAMER_ERROR_NONE)
- {
+ if (ret != MEDIA_STREAMER_ERROR_NONE) {
g_print("Fail to destroy media streamer");
return FALSE;
}
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);
/* 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_H264_SP) != MEDIA_FORMAT_ERROR_NONE) {
g_print("media_format_set_video_mime failed!");
}
media_format_set_video_width(vfmt_encoded, 800);
/* 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_bit(afmt_raw, 16);
}
-static void set_rtp_params (media_streamer_node_h rtp_node,
- const gchar *ip,
- int video_port,
- int audio_port,
- gboolean port_reverse)
+static void set_rtp_params(media_streamer_node_h rtp_node,
+ const gchar *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, "audio_sink,port", audio_sink_port);
bundle_add_str(params, "audio_sink,host", ip);
}
- if(g_menu_preset & PRESET_RTP_CLIENT)
- {
+ if (g_menu_preset & PRESET_RTP_CLIENT) {
bundle_add_str(params, "audio_source,port", audio_src_port);
bundle_add_str(params, "audio_source,format",
- "application/x-rtp,media=audio,clock-rate=44100,encoding-name=L16,"
- "encoding-params=1,channels=1,payload=96");
+ "application/x-rtp,media=audio,clock-rate=44100,encoding-name=L16,"
+ "encoding-params=1,channels=1,payload=96");
}
g_free(audio_src_port);
gchar *video_src_port = g_strdup_printf("%d", port_reverse ? (video_port + 5) : video_port);
gchar *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, "video_sink,port", video_sink_port);
bundle_add_str(params, "video_sink,host", ip);
}
- if(g_menu_preset & PRESET_RTP_CLIENT)
- {
+ if (g_menu_preset & PRESET_RTP_CLIENT) {
bundle_add_str(params, "video_source,port", video_src_port);
bundle_add_str(params, "video_source,format",
- "application/x-rtp,media=video,clock-rate=90000,encoding-name=H264");
+ "application/x-rtp,media=video,clock-rate=90000,encoding-name=H264");
}
g_free(video_src_port);
g_print("== _create_rtp_streamer \n");
#ifndef DISABLE_VIDEO
- //********************** video source ***********************************
+ /*********************** video source *********************************** */
media_streamer_node_h video_src = NULL;
#ifdef ONE_DEVICE_TEST
- if(g_menu_preset & SECOND_VOIP_MASK)
- {
+ if (g_menu_preset & SECOND_VOIP_MASK) {
media_streamer_src_create(MEDIA_STREAMER_SRC_TYPE_VIDEO_TEST, &video_src);
- }
- else
- {
+ } else {
media_streamer_src_create(MEDIA_STREAMER_SRC_TYPE_CAMERA, &video_src);
}
#else
media_streamer_src_create(MEDIA_STREAMER_SRC_TYPE_CAMERA, &video_src);
#endif
-// media_streamer_node_set_fmt(video_src, vfmt_raw);
+ /* media_streamer_node_set_fmt(video_src, vfmt_raw); */
media_streamer_node_add(current_media_streamer, video_src);
- //********************** encoder ****************************************
+ /*********************** 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_add(current_media_streamer, video_enc);
- //********************** videopay ***************************************
+ /*********************** 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_add(current_media_streamer, video_pay);
- //====================Linking Video Streamer===========================//
+ /*====================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_sink");
- //======================================================================//
+ /*====================================================================== */
g_print("== success streamer video part \n");
#endif
#ifndef DISABLE_AUDIO
- //********************** audiosrc ***********************************
+ /*********************** audiosrc *********************************** */
media_streamer_node_h audio_src = NULL;
media_streamer_src_create(MEDIA_STREAMER_SRC_TYPE_AUDIO_CAPTURE, &audio_src);
media_streamer_node_add(current_media_streamer, audio_src);
- //********************** audioencoder ***********************************
+ /*********************** audioencoder *********************************** */
media_streamer_node_h audio_enc = NULL;
media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_ENCODER, NULL, NULL, &audio_enc);
media_streamer_node_add(current_media_streamer, audio_enc);
- //********************** rtpL16pay ***********************************
+ /*********************** rtpL16pay *********************************** */
media_streamer_node_h audio_pay = NULL;
media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_AUDIO_PAY, NULL, NULL, &audio_pay);
media_streamer_node_add(current_media_streamer, audio_pay);
- //====================Linking Audio Streamer===========================//
+ /*====================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_sink");
- //======================================================================//
+ /*====================================================================== */
g_print("== success streamer audio part \n");
#endif
g_print("== _create_rtp_client \n");
#ifndef DISABLE_VIDEO
- //********************** video_depay***********************************
+ /*********************** video_depay*********************************** */
media_streamer_node_h video_depay = NULL;
media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_DEPAY, NULL, vfmt_encoded, &video_depay);
media_streamer_node_add(current_media_streamer, video_depay);
- //********************** videodec ***********************************
+ /*********************** videodec *********************************** */
media_streamer_node_h video_dec = NULL;
media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_VIDEO_DECODER, NULL, vfmt_encoded, &video_dec);
media_streamer_node_add(current_media_streamer, video_dec);
- //********************** videosink ***********************************
+ /*********************** videosink *********************************** */
media_streamer_node_h video_sink = NULL;
media_streamer_sink_create(MEDIA_STREAMER_SINK_TYPE_SCREEN, &video_sink);
media_streamer_node_add(current_media_streamer, video_sink);
- //====================Linking Video Client===========================//
+ /*====================Linking Video Client=========================== */
media_streamer_node_link(video_depay, "src", video_dec, "sink");
- media_streamer_node_link(video_dec, "src", video_sink,"sink");
-// media_streamer_node_link(rtp_bin, "video_source", video_depay,"sink");
+ media_streamer_node_link(video_dec, "src", video_sink, "sink");
+ /* media_streamer_node_link(rtp_bin, "video_source", video_depay,"sink"); */
g_print("== success client video part \n");
#endif
#ifndef DISABLE_AUDIO
- //********************** audiodepay ***********************************
+ /*********************** audiodepay *********************************** */
media_streamer_node_h audio_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 ***********************************
+ /*********************** 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 ***********************************
+ /*********************** 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 ***********************************
+ /*********************** audiosink *********************************** */
media_streamer_node_h audio_sink = NULL;
media_streamer_sink_create(MEDIA_STREAMER_SINK_TYPE_AUDIO, &audio_sink);
media_streamer_node_add(current_media_streamer, audio_sink);
- //====================Linking Audio Client===========================//
+ /*====================Linking Audio Client=========================== */
media_streamer_node_link(audio_depay, "src", audio_converter, "sink");
media_streamer_node_link(audio_converter, "src", audio_res, "sink");
- media_streamer_node_link(audio_res, "src", audio_sink,"sink");
-// media_streamer_node_link(rtp_bin, "audio_source", audio_depay,"sink");
- //======================================================================//
+ media_streamer_node_link(audio_res, "src", audio_sink, "sink");
+ /*media_streamer_node_link(rtp_bin, "audio_source", audio_depay,"sink"); */
+ /*====================================================================== */
g_print("== success client audio part \n");
#endif
}
static media_streamer_node_h _create_rtp(
- int video_port,
- int audio_port,
- gboolean second_client)
+ int video_port,
+ int audio_port,
+ gboolean second_client)
{
g_print("== create rtp node for current preset \n");
- //********************** rtpbin ***********************************
+ /*********************** rtpbin *********************************** */
media_streamer_node_h rtp_bin = NULL;
media_streamer_node_create(MEDIA_STREAMER_NODE_TYPE_RTP, vfmt_encoded, vfmt_encoded, &rtp_bin);
set_rtp_params(rtp_bin, g_broadcast_address, video_port, audio_port, second_client);
g_autoplug_mode = FALSE;
current_media_streamer = NULL;
- if (g_media_streamer)
- {
+ if (g_media_streamer) {
_destroy(g_media_streamer);
g_media_streamer = NULL;
}
- if (g_media_streamer_2)
- {
+ if (g_media_streamer_2) {
_destroy(g_media_streamer_2);
g_media_streamer_2 = NULL;
}
- if(g_broadcast_address != NULL)
- {
+ if (g_broadcast_address != NULL) {
g_free(g_broadcast_address);
g_broadcast_address = NULL;
}
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");
}
static void display_menu(void)
{
- if (g_sub_menu_state == SUBMENU_STATE_UNKNOWN)
- {
- switch (g_menu_state)
- {
+ if (g_sub_menu_state == SUBMENU_STATE_UNKNOWN) {
+ switch (g_menu_state) {
case MENU_STATE_MAIN_MENU:
display_main_menu();
break;
g_print("*** Unknown status.\n");
break;
}
- }
- else
- {
- switch (g_sub_menu_state)
- {
+ } else {
+ switch (g_sub_menu_state) {
case SUBMENU_STATE_GETTING_IP:
display_getting_ip_menu();
break;
display_autoplug_select_menu();
break;
case SUBMENU_STATE_FORMAT:
-// display_format_menu();
+ /* display_format_menu(); */
break;
default:
g_print("*** Unknown Submenu state.\n");
media_streamer_node_h rtp_bin = NULL;
create_formats();
- switch(g_menu_preset)
- {
+ switch (g_menu_preset) {
case PRESET_RTP_STREAMER:
rtp_bin = _create_rtp(VIDEO_PORT, AUDIO_PORT, FALSE);
_create_rtp_streamer(rtp_bin);
_create_rtp_streamer(rtp_bin);
break;
case PRESET_DOUBLE_VOIP_SERVER_2:
- rtp_bin = _create_rtp(VIDEO_PORT+10, AUDIO_PORT+10, TRUE);
+ 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);
+ rtp_bin = _create_rtp(VIDEO_PORT + 10, AUDIO_PORT + 10, FALSE);
_create_rtp_client(rtp_bin);
break;
case PRESET_DOUBLE_VOIP_CLIENT_2:
{
int len = strlen(cmd);
- if(len == 1)
- {
- if ( !strncmp(cmd, "1", len))
- {
+ if (len == 1) {
+ 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, "q", len))
- {
+ } else if (!strncmp(cmd, "q", len)) {
quit();
}
- }
- else
- {
+ } else {
g_print("wrong command\n");
}
}
-//=====================Broadcast Menu============================//
+/*=====================Broadcast Menu============================// */
void _interpret_broadcast_menu(char *cmd)
{
int len = strlen(cmd);
- if(len == 1)
- {
- if( !strncmp(cmd, "1", len))
- {
+ if (len == 1) {
+ if (!strncmp(cmd, "1", len)) {
g_menu_preset = PRESET_RTP_CLIENT;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "2", len))
- {
+ } else if (!strncmp(cmd, "2", len)) {
g_menu_preset = PRESET_RTP_STREAMER;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "b", len))
- {
+ } else if (!strncmp(cmd, "b", len)) {
reset_current_menu_state();
display_menu();
}
- }
- else
- {
+ } else {
g_print("wrong command\n");
}
}
{
int len = strlen(cmd);
- if(len == 1)
- {
- if( !strncmp(cmd, "1", len))
- {
+ if (len == 1) {
+ if (!strncmp(cmd, "1", len)) {
g_menu_preset = PRESET_VOIP;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "2", len))
- {
+ } else if (!strncmp(cmd, "2", len)) {
g_menu_preset = PRESET_VOIP_2;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "3", len))
- {
- //double Server 1
+ } else if (!strncmp(cmd, "3", len)) {
+ /*double Server 1 */
g_menu_preset = PRESET_DOUBLE_VOIP_SERVER;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "4", len))
- {
- //double Server 2
+ } else if (!strncmp(cmd, "4", len)) {
+ /*double Server 2 */
g_menu_preset = PRESET_DOUBLE_VOIP_SERVER_2;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "5", len))
- {
- //double Client 1
+ } else if (!strncmp(cmd, "5", len)) {
+ /*double Client 1 */
g_menu_preset = PRESET_DOUBLE_VOIP_CLIENT;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "6", len))
- {
- //double Client 2
+ } else if (!strncmp(cmd, "6", len)) {
+ /*double Client 2 */
g_menu_preset = PRESET_DOUBLE_VOIP_CLIENT_2;
g_menu_state = MENU_STATE_PRESET_MENU;
- }
- else if( !strncmp(cmd, "b", len))
- {
+ } else if (!strncmp(cmd, "b", len)) {
reset_current_menu_state();
- //display_menu();
+ /*display_menu(); */
}
- }
- else
- {
+ } 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)
- {
+ if (cmd_len > min_len) {
g_broadcast_address = g_strdup(cmd);
g_print("== IP address setted to [%s]\n", g_broadcast_address);
- }
- else
- {
+ } else {
g_broadcast_address = g_strdup(DEFAULT_IP_ADDR);
g_print("Invalid IP. Default address will be used [%s]\n", DEFAULT_IP_ADDR);
}
void _interpret_autoplug_menu(char *cmd)
{
- int cmd_number = atoi(cmd)-1;
+ int cmd_number = atoi(cmd) - 1;
- if(cmd_number == 1 || cmd_number == 0)
- {
+ if (cmd_number == 1 || cmd_number == 0) {
g_autoplug_mode = cmd_number;
- }
- else
- {
+ } 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 {
run_preset();
g_sub_menu_state = SUBMENU_STATE_UNKNOWN;
}
{
int len = strlen(cmd);
- if(len == 1 || len == 2)
- {
- if( !strncmp(cmd, "1", len))
- {
- if((g_menu_preset & DOUBLE_STREAMER_MASK) &&
- (g_menu_preset & PRESET_RTP_CLIENT))
- {
+ if (len == 1 || len == 2) {
+ if (!strncmp(cmd, "1", len)) {
+ if ((g_menu_preset & DOUBLE_STREAMER_MASK) &&
+ (g_menu_preset & PRESET_RTP_CLIENT)) {
_create(&g_media_streamer_2);
current_media_streamer = g_media_streamer_2;
g_print("== success create media streamer 2\n");
- }
- else
- {
+ } else {
_create(&g_media_streamer);
current_media_streamer = g_media_streamer;
g_print("== success create media streamer\n");
}
- }
- else if( !strncmp(cmd, "2", len))
- {
- // call the run_preset function after autoplug mode was selected;
+ } else if (!strncmp(cmd, "2", len)) {
+ /* call the run_preset function after autoplug mode was selected; */
g_sub_menu_state = SUBMENU_STATE_AUTOPLUG;
- }
- else if( !strncmp(cmd, "4", len))
- {
+ } else if (!strncmp(cmd, "4", len)) {
_prepare();
- }
- else if( !strncmp(cmd, "5", len))
- {
+ } else if (!strncmp(cmd, "5", len)) {
_unprepare();
- }
- else if( !strncmp(cmd, "6", len))
- {
+ } else if (!strncmp(cmd, "6", len)) {
_play(g_media_streamer);
- }
- else if( !strncmp(cmd, "7", len))
- {
+ } else if (!strncmp(cmd, "7", len)) {
_destroy(current_media_streamer);
current_media_streamer = NULL;
- }
- else if( !strncmp(cmd, "b", len))
- {
- if(g_menu_preset & DOUBLE_STREAMER_MASK)
- {
+ } else if (!strncmp(cmd, "b", len)) {
+ if (g_menu_preset & DOUBLE_STREAMER_MASK) {
g_menu_state = MENU_STATE_VOIP_MENU;
g_autoplug_mode = FALSE;
current_media_streamer = NULL;
- }
- else
- {
+ } else {
reset_current_menu_state();
}
display_menu();
}
- }
- else
- {
+ } else {
g_print("wrong command\n");
}
}
static void interpret_cmd(char *cmd)
{
- if(g_sub_menu_state == SUBMENU_STATE_UNKNOWN)
- {
- switch(g_menu_state)
- {
+ if (g_sub_menu_state == SUBMENU_STATE_UNKNOWN) {
+ switch (g_menu_state) {
case MENU_STATE_MAIN_MENU:
_interpret_main_menu(cmd);
break;
return;
break;
}
- }
- else
- {
- switch (g_sub_menu_state)
- {
+ } else {
+ switch (g_sub_menu_state) {
case SUBMENU_STATE_GETTING_IP:
_interpret_getting_ip_menu(cmd);
break;
_interpret_autoplug_menu(cmd);
break;
case SUBMENU_STATE_FORMAT:
- //display_format_menu();
+ /*display_format_menu(); */
break;
default:
g_print("*** Unknown Submenu state.\n");
GIOChannel *stdin_channel;
stdin_channel = g_io_channel_unix_new(0);
g_io_channel_set_flags(stdin_channel, G_IO_FLAG_NONBLOCK, NULL);
- g_io_add_watch(stdin_channel, G_IO_IN,(GIOFunc)input, NULL);
+ g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
display_menu();
projects / platform / core / api / mediastreamer.git / commitdiff