/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static int __mmplayer_gst_create_pipeline(mm_player_t* player);
-static int __mmplayer_gst_destroy_pipeline(mm_player_t* player);
-static int __mmplayer_gst_create_text_pipeline(mm_player_t* player);
-static int __mmplayer_gst_create_video_sink_bin(mm_player_t* player, GstCaps *caps, MMDisplaySurfaceType surface_type);
-static int __mmplayer_gst_create_audio_sink_bin(mm_player_t* player);
-static int __mmplayer_gst_create_text_sink_bin(mm_player_t* player);
-
-static GstPadProbeReturn __mmplayer_gst_selector_blocked(GstPad* pad, GstPadProbeInfo *info, gpointer data);
-static void __mmplayer_gst_decode_no_more_pads(GstElement* elem, gpointer data);
+static int __mmplayer_gst_create_pipeline(mm_player_t *player);
+static int __mmplayer_gst_destroy_pipeline(mm_player_t *player);
+static int __mmplayer_gst_create_text_pipeline(mm_player_t *player);
+static int __mmplayer_gst_create_video_sink_bin(mm_player_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type);
+static int __mmplayer_gst_create_audio_sink_bin(mm_player_t *player);
+static int __mmplayer_gst_create_text_sink_bin(mm_player_t *player);
+
+static GstPadProbeReturn __mmplayer_gst_selector_blocked(GstPad *pad, GstPadProbeInfo *info, gpointer data);
+static void __mmplayer_gst_decode_no_more_pads(GstElement *elem, gpointer data);
static void __mmplayer_gst_create_sinkbin(GstElement *decodebin, GstPad *pad, gpointer data);
-static void __mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad* pad, GstCaps *caps, gpointer data);
-static gboolean __mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad* pad, GstCaps * caps, gpointer data);
-static void __mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad* new_pad, gpointer data);
+static void __mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad *pad, GstCaps *caps, gpointer data);
+static gboolean __mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad *pad, GstCaps *caps, gpointer data);
+static void __mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad *new_pad, gpointer data);
static void __mmplayer_gst_decode_drained(GstElement *bin, gpointer data);
static void __mmplayer_pipeline_complete(GstElement *decodebin, gpointer data);
-static gboolean __mmplayer_is_midi_type(gchar* str_caps);
+static gboolean __mmplayer_is_midi_type(gchar *str_caps);
static gboolean __mmplayer_is_only_mp3_type(gchar *str_caps);
-static void __mmplayer_set_audio_attrs(mm_player_t* player, GstCaps* caps);
-
-static gboolean __mmplayer_update_subtitle(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data);
-static void __mmplayer_release_misc(mm_player_t* player);
-static void __mmplayer_release_misc_post(mm_player_t* player);
-static gboolean __mmplayer_init_gstreamer(mm_player_t* player);
-static void __mmplayer_video_stream_decoded_preroll_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data);
-static void __mmplayer_video_stream_decoded_render_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data);
+static void __mmplayer_set_audio_attrs(mm_player_t *player, GstCaps *caps);
+
+static gboolean __mmplayer_update_subtitle(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
+static void __mmplayer_release_misc(mm_player_t *player);
+static void __mmplayer_release_misc_post(mm_player_t *player);
+static gboolean __mmplayer_init_gstreamer(mm_player_t *player);
+static void __mmplayer_video_stream_decoded_preroll_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
+static void __mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data);
static GstPadProbeReturn __mmplayer_subtitle_adjust_position_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
-static int __mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int index);
-
-static gboolean __mmplayer_check_subtitle(mm_player_t* player);
-static int __mmplayer_handle_missed_plugin(mm_player_t* player);
-static int __mmplayer_check_not_supported_codec(mm_player_t* player, const gchar* factory_class, const gchar* mime);
-static void __mmplayer_add_sink(mm_player_t* player, GstElement* sink);
-static void __mmplayer_del_sink(mm_player_t* player, GstElement* sink);
-static void __mmplayer_release_signal_connection(mm_player_t* player, MMPlayerSignalType type);
+static int __mmplayer_change_selector_pad(mm_player_t *player, MMPlayerTrackType type, int index);
+
+static gboolean __mmplayer_check_subtitle(mm_player_t *player);
+static int __mmplayer_handle_missed_plugin(mm_player_t *player);
+static int __mmplayer_check_not_supported_codec(mm_player_t *player, const gchar *factory_class, const gchar *mime);
+static void __mmplayer_add_sink(mm_player_t *player, GstElement *sink);
+static void __mmplayer_del_sink(mm_player_t *player, GstElement *sink);
+static void __mmplayer_release_signal_connection(mm_player_t *player, MMPlayerSignalType type);
static gpointer __mmplayer_gapless_play_thread(gpointer data);
static gboolean __mmplayer_add_dump_buffer_probe(mm_player_t *player, GstElement *element);
static GstPadProbeReturn __mmplayer_dump_buffer_probe_cb(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static void __mmplayer_release_dump_list(GList *dump_list);
-static int __mmplayer_gst_realize(mm_player_t* player);
-static int __mmplayer_gst_unrealize(mm_player_t* player);
-static int __mmplayer_gst_adjust_subtitle_position(mm_player_t* player, int format, int position);
-static int __mmplayer_gst_set_message_callback(mm_player_t* player, MMMessageCallback callback, gpointer user_param);
+static int __mmplayer_gst_realize(mm_player_t *player);
+static int __mmplayer_gst_unrealize(mm_player_t *player);
+static int __mmplayer_gst_adjust_subtitle_position(mm_player_t *player, int format, int position);
+static int __mmplayer_gst_set_message_callback(mm_player_t *player, MMMessageCallback callback, gpointer user_param);
/* util */
static gboolean __mmplayer_verify_gapless_play_path(mm_player_t *player);
static void __mmplayer_activate_next_source(mm_player_t *player, GstState target);
-static void __mmplayer_check_pipeline(mm_player_t* player);
+static void __mmplayer_check_pipeline(mm_player_t *player);
static gboolean __mmplayer_deactivate_selector(mm_player_t *player, MMPlayerTrackType type);
static void __mmplayer_deactivate_old_path(mm_player_t *player);
-static int __mmplayer_gst_create_plain_text_elements(mm_player_t* player);
-static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar* format_name);
-static void __mmplayer_gst_caps_notify_cb(GstPad * pad, GParamSpec * unused, gpointer data);
-static void __mmplayer_audio_stream_send_data(mm_player_t* player, mm_player_audio_stream_buff_t *a_buffer);
-static void __mmplayer_initialize_storage_info(mm_player_t* player, MMPlayerPathType path_type);
+static int __mmplayer_gst_create_plain_text_elements(mm_player_t *player);
+static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar *format_name);
+static void __mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data);
+static void __mmplayer_audio_stream_send_data(mm_player_t *player, mm_player_audio_stream_buff_t *a_buffer);
+static void __mmplayer_initialize_storage_info(mm_player_t *player, MMPlayerPathType path_type);
static int __resource_release_cb(mm_resource_manager_h rm, mm_resource_manager_res_h res, void *user_data);
static gboolean __mmplayer_update_duration_attrs(mm_player_t *player, MMHandleType attrs);
static gboolean __mmplayer_update_audio_attrs(mm_player_t *player, MMHandleType attrs);
static gboolean __mmplayer_update_video_attrs(mm_player_t *player, MMHandleType attrs);
static gboolean __mmplayer_update_bitrate_attrs(mm_player_t *player, MMHandleType attrs);
-static void __mmplayer_copy_uri_and_set_type(MMPlayerParseProfile* data, const char *uri, int uri_type);
-static int __mmplayer_set_mem_uri(MMPlayerParseProfile* data, char *path, void *param);
-static int __mmplayer_set_file_uri(MMPlayerParseProfile* data, const char *uri);
+static void __mmplayer_copy_uri_and_set_type(MMPlayerParseProfile *data, const char *uri, int uri_type);
+static int __mmplayer_set_mem_uri(MMPlayerParseProfile *data, char *path, void *param);
+static int __mmplayer_set_file_uri(MMPlayerParseProfile *data, const char *uri);
-static MMPlayerVideoStreamDataType* __mmplayer_create_stream_from_pad(GstPad *pad);
+static MMPlayerVideoStreamDataType *__mmplayer_create_stream_from_pad(GstPad *pad);
static void __mmplayer_zerocopy_set_stride_elevation_bo(MMPlayerVideoStreamDataType *stream, GstMemory *mem);
static gboolean __mmplayer_swcodec_set_stride_elevation(MMPlayerVideoStreamDataType *stream);
static gboolean __mmplayer_swcodec_set_bo(mm_player_t *player, MMPlayerVideoStreamDataType *stream, GstMemory *mem);
#if 0 //debug
static void
-print_tag(const GstTagList * list, const gchar * tag, gpointer unused)
+print_tag(const GstTagList *list, const gchar *tag, gpointer unused)
{
gint i, count;
if (gst_tag_get_type(tag) == G_TYPE_STRING) {
if (!gst_tag_list_get_string_index(list, tag, i, &str))
g_assert_not_reached();
- } else
+ } else {
str = g_strdup_value_contents(gst_tag_list_get_value_index(list, tag, i));
+ }
if (i == 0)
- g_print(" %15s: %s\n", gst_tag_get_nick(tag), str);
+ g_print(" %15s: %s", gst_tag_get_nick(tag), str);
else
- g_print(" : %s\n", str);
+ g_print(" : %s", str);
g_free(str);
}
/* This function should be called after the pipeline goes PAUSED or higher
state. */
gboolean
-__mmplayer_update_content_attrs(mm_player_t* player, enum content_attr_flag flag)
+__mmplayer_update_content_attrs(mm_player_t *player, enum content_attr_flag flag)
{
static gboolean has_duration = FALSE;
static gboolean has_video_attrs = FALSE;
/* validate all */
if (mm_attrs_commit_all(attrs)) {
- LOGE("failed to update attributes\n");
+ LOGE("failed to update attributes");
return FALSE;
}
return TRUE;
}
-MMStreamingType __mmplayer_get_stream_service_type(mm_player_t* player)
+MMStreamingType
+__mmplayer_get_stream_service_type(mm_player_t *player)
{
MMStreamingType streaming_type = STREAMING_SERVICE_NONE;
return streaming_type;
}
-
/* this function sets the player state and also report
* it to applicaton by calling callback function
*/
MMPLAYER_RETURN_IF_FAIL(player);
if (MMPLAYER_CURRENT_STATE(player) == state) {
- LOGW("already same state(%s)\n", MMPLAYER_STATE_GET_NAME(state));
+ LOGW("already same state(%s)", MMPLAYER_STATE_GET_NAME(state));
MMPLAYER_PENDING_STATE(player) = MM_PLAYER_STATE_NONE;
return;
}
break;
case MM_PLAYER_STATE_NONE:
default:
- LOGW("invalid target state, there is nothing to do.\n");
+ LOGW("invalid target state, there is nothing to do.");
break;
}
LOGD("player reach the target state (%s)", MMPLAYER_STATE_GET_NAME(MMPLAYER_TARGET_STATE(player)));
/* state changed by resource callback */
- if (player->interrupted_by_resource) {
+ if (player->interrupted_by_resource)
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_INTERRUPTED, &msg);
- } else { /* state changed by usecase */
+ else /* state changed by usecase */
MMPLAYER_POST_MSG(player, MM_MESSAGE_STATE_CHANGED, &msg);
- }
+
} else {
- LOGD("intermediate state, do nothing.\n");
+ LOGD("intermediate state, do nothing.");
MMPLAYER_PRINT_STATE(player);
return;
}
}
int
-__mmplayer_check_state(mm_player_t* player, enum PlayerCommandState command)
+__mmplayer_check_state(mm_player_t *player, enum PlayerCommandState command)
{
MMPlayerStateType current_state = MM_PLAYER_STATE_NUM;
MMPlayerStateType pending_state = MM_PLAYER_STATE_NUM;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- //LOGD("incomming command : %d \n", command);
+ //LOGD("incomming command : %d ", command);
current_state = MMPLAYER_CURRENT_STATE(player);
pending_state = MMPLAYER_PENDING_STATE(player);
goto ALREADY_GOING;
} else if (pending_state == MM_PLAYER_STATE_PAUSED) {
LOGD("player is going to paused state, just change the pending state as playing");
- } else
+ } else {
goto INVALID_STATE;
+ }
}
break;
goto ALREADY_GOING;
} else if (pending_state == MM_PLAYER_STATE_PAUSED) {
LOGD("player is going to paused state, just change the pending state as playing");
- } else
+ } else {
goto INVALID_STATE;
+ }
}
break;
return MM_ERROR_PLAYER_NO_OP;
}
-static gpointer __mmplayer_gapless_play_thread(gpointer data)
+static gpointer
+__mmplayer_gapless_play_thread(gpointer data)
{
- mm_player_t* player = (mm_player_t*) data;
+ mm_player_t *player = (mm_player_t *)data;
MMPlayerGstElement *mainbin = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
while (!player->gapless_play_thread_exit) {
- LOGD("gapless play thread started. waiting for signal.\n");
+ LOGD("gapless play thread started. waiting for signal.");
MMPLAYER_GAPLESS_PLAY_THREAD_WAIT(player);
- LOGD("reconfigure pipeline for gapless play.\n");
+ LOGD("reconfigure pipeline for gapless play.");
if (player->gapless_play_thread_exit) {
if (player->gapless.reconfigure) {
player->gapless.reconfigure = false;
MMPLAYER_PLAYBACK_UNLOCK(player);
}
- LOGD("exiting gapless play thread\n");
+ LOGD("exiting gapless play thread");
break;
}
MMPLAYER_FENTER();
source = g_main_context_find_source_by_id(context, source_id);
-
if (source != NULL) {
LOGW("context: %p, source id: %d, source: %p", context, source_id, source);
g_source_destroy(source);
MMPLAYER_FLEAVE();
}
-void __mmplayer_bus_msg_thread_destroy(MMHandleType hplayer)
+void
+__mmplayer_bus_msg_thread_destroy(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
GstMessage *msg = NULL;
GQueue *queue = NULL;
}
gboolean
-__mmplayer_gst_remove_fakesink(mm_player_t* player, MMPlayerGstElement* fakesink)
+__mmplayer_gst_remove_fakesink(mm_player_t *player, MMPlayerGstElement *fakesink)
{
- GstElement* parent = NULL;
+ GstElement *parent = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, FALSE);
goto ERROR;
/* get parent of fakesink */
- parent = (GstElement*)gst_object_get_parent((GstObject*)fakesink->gst);
+ parent = (GstElement *)gst_object_get_parent((GstObject *)fakesink->gst);
if (!parent) {
- LOGD("fakesink already removed\n");
+ LOGD("fakesink already removed");
goto ERROR;
}
* so no need to wait for completion of state transiton
*/
if (GST_STATE_CHANGE_FAILURE == gst_element_set_state(fakesink->gst, GST_STATE_NULL))
- LOGE("fakesink state change failure!\n");
+ LOGE("fakesink state change failure!");
/* FIXIT : should I return here? or try to proceed to next? */
/* return FALSE; */
/* remove fakesink from it's parent */
if (!gst_bin_remove(GST_BIN(parent), fakesink->gst)) {
- LOGE("failed to remove fakesink\n");
+ LOGE("failed to remove fakesink");
gst_object_unref(parent);
gst_object_unref(parent);
- LOGD("state-holder removed\n");
+ LOGD("state-holder removed");
gst_element_set_locked_state(fakesink->gst, FALSE);
}
static GstPadProbeReturn
-__mmplayer_gst_selector_blocked(GstPad* pad, GstPadProbeInfo *info, gpointer data)
+__mmplayer_gst_selector_blocked(GstPad *pad, GstPadProbeInfo *info, gpointer data)
{
LOGD("pad(%s:%s) is blocked", GST_DEBUG_PAD_NAME(pad));
return GST_PAD_PROBE_OK;
}
static void
-__mmplayer_gst_selector_update_start_time(mm_player_t* player, MMPlayerTrackType stream_type)
+__mmplayer_gst_selector_update_start_time(mm_player_t *player, MMPlayerTrackType stream_type)
{
gint64 stop_running_time = 0;
gint64 position_running_time = 0;
{
GstPadProbeReturn ret = GST_PAD_PROBE_OK;
GstEvent *event = GST_PAD_PROBE_INFO_DATA(info);
- mm_player_t *player = (mm_player_t*)data;
+ mm_player_t *player = (mm_player_t *)data;
GstCaps *caps = NULL;
GstStructure *str = NULL;
const gchar *name = NULL;
return;
}
-static GstElement*
+static GstElement *
__mmplayer_gst_make_selector(mm_player_t *player, enum MainElementID elem_idx, MMPlayerTrackType stream_type)
{
GstElement *pipeline = NULL;
void
__mmplayer_gst_decode_pad_added(GstElement *elem, GstPad *pad, gpointer data)
{
- mm_player_t *player = NULL;
+ mm_player_t *player = (mm_player_t *)data;
GstElement *selector = NULL;
GstCaps *caps = NULL;
GstStructure *str = NULL;
enum MainElementID elem_idx = MMPLAYER_M_NUM;
MMPlayerTrackType stream_type = MM_PLAYER_TRACK_TYPE_AUDIO;
- /* check handles */
- player = (mm_player_t*)data;
-
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(elem && pad);
MMPLAYER_RETURN_IF_FAIL(player && player->pipeline && player->pipeline->mainbin);
caps_str = gst_caps_to_string(caps);
if (caps_str && (strstr(caps_str, "ST12") || strstr(caps_str, "SN12") ||
strstr(caps_str, "SN21") || strstr(caps_str, "S420") || strstr(caps_str, "SR32")))
- player->set_mode.video_zc = TRUE;
+ player->set_mode.video_zc = true;
MMPLAYER_FREEIF(caps_str);
return;
}
-static gboolean __mmplayer_create_sink_path(mm_player_t* player, GstElement* selector, MMPlayerTrackType type)
+static gboolean
+__mmplayer_create_sink_path(mm_player_t *player, GstElement *selector, MMPlayerTrackType type)
{
- GstPad* srcpad = NULL;
+ GstPad *srcpad = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, FALSE);
return TRUE;
}
-static void __mmplayer_set_decode_track_info(mm_player_t* player, MMPlayerTrackType type)
+static void
+__mmplayer_set_decode_track_info(mm_player_t *player, MMPlayerTrackType type)
{
MMHandleType attrs = 0;
gint active_index = 0;
return;
}
-static gboolean __mmplayer_create_audio_sink_path(mm_player_t* player, GstElement* audio_selector)
+static gboolean
+__mmplayer_create_audio_sink_path(mm_player_t *player, GstElement *audio_selector)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, FALSE);
return TRUE;
}
-static gboolean __mmplayer_create_text_sink_path(mm_player_t* player, GstElement* text_selector)
+static gboolean
+__mmplayer_create_text_sink_path(mm_player_t *player, GstElement *text_selector)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && text_selector, FALSE);
static gboolean
__mmplayer_gst_set_queue2_buffering(mm_player_t *player)
{
-#define ESTIMATED_BUFFER_UNIT (1*1024*1024)
+#define ESTIMATED_BUFFER_UNIT (1 * 1024 * 1024)
gint init_buffering_time = 0;
guint buffer_bytes = 0;
player->pipeline->mainbin && player->streamer, FALSE);
init_buffering_time = player->streamer->buffering_req.prebuffer_time;
- buffer_bytes = (guint)(init_buffering_time/1000) * ESTIMATED_BUFFER_UNIT;
+ buffer_bytes = (guint)(init_buffering_time / 1000) * ESTIMATED_BUFFER_UNIT;
buffer_bytes = MAX(buffer_bytes, player->streamer->buffer_handle[BUFFER_TYPE_MUXED].buffering_bytes);
LOGD("pre buffer time: %d ms, buffer size : %d", init_buffering_time, buffer_bytes);
- init_buffering_time = (init_buffering_time != 0) ? (init_buffering_time) : (player->ini.http_buffering_time);
+ init_buffering_time = (init_buffering_time != 0) ? init_buffering_time : player->ini.http_buffering_time;
if (!gst_element_query_duration(player->pipeline->mainbin[MMPLAYER_M_SRC].gst, GST_FORMAT_BYTES, &dur_bytes))
LOGE("fail to get duration.");
GstElement *text_selector = NULL;
MMPLAYER_FENTER();
- player = (mm_player_t*) data;
+ player = (mm_player_t *)data;
LOGD("no-more-pad signal handling");
MMPLAYER_FLEAVE();
return ret;
}
+
static void
__mmplayer_gst_create_sinkbin(GstElement *elem, GstPad *pad, gpointer data)
{
gchar *sink_pad_name = "sink";
/* check handles */
- player = (mm_player_t*) data;
+ player = (mm_player_t *)data;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(elem && pad);
}
static gboolean
-__mmplayer_get_property_value_for_rotation(mm_player_t* player, int display_angle, int orientation, int *value)
+__mmplayer_get_property_value_for_rotation(mm_player_t *player, int display_angle, int orientation, int *value)
{
int required_angle = 0; /* Angle required for straight view */
int rotation_angle = 0;
}
int
-__mmplayer_video_param_check_video_sink_bin(mm_player_t* player)
+__mmplayer_video_param_check_video_sink_bin(mm_player_t *player)
{
/* check video sinkbin is created */
MMPLAYER_RETURN_VAL_IF_FAIL(player &&
}
int
-__mmplayer_get_video_angle(mm_player_t* player, int *display_angle, int *orientation)
+__mmplayer_get_video_angle(mm_player_t *player, int *display_angle, int *orientation)
{
int display_rotation = 0;
gchar *org_orient = NULL;
}
void
-__mmplayer_video_param_set_display_rotation(mm_player_t* player)
+__mmplayer_video_param_set_display_rotation(mm_player_t *player)
{
int rotation_value = 0;
int orientations = 0; // current supported angle values are 0, 90, 180, 270
}
void
-__mmplayer_video_param_set_display_visible(mm_player_t* player)
+__mmplayer_video_param_set_display_visible(mm_player_t *player)
{
MMHandleType attrs = 0;
int visible = 0;
}
void
-__mmplayer_video_param_set_display_method(mm_player_t* player)
+__mmplayer_video_param_set_display_method(mm_player_t *player)
{
MMHandleType attrs = 0;
int display_method = 0;
g_object_set(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "display-geometry-method", display_method, NULL);
LOGD("set video param : method %d", display_method);
}
+
void
-__mmplayer_video_param_set_video_roi_area(mm_player_t* player)
+__mmplayer_video_param_set_video_roi_area(mm_player_t *player)
{
MMHandleType attrs = 0;
void *handle = NULL;
}
void
-__mmplayer_video_param_set_roi_area(mm_player_t* player)
+__mmplayer_video_param_set_roi_area(mm_player_t *player)
{
MMHandleType attrs = 0;
void *handle = NULL;
win_roi_x, win_roi_y, win_roi_width, win_roi_height);
}
}
+
void
-__mmplayer_video_param_set_display_overlay(mm_player_t* player)
+__mmplayer_video_param_set_display_overlay(mm_player_t *player)
{
MMHandleType attrs = 0;
void *handle = NULL;
if (handle) {
/* default is using wl_surface_id */
unsigned int wl_surface_id = 0;
- wl_surface_id = *(int*)handle;
+ wl_surface_id = *(int *)handle;
LOGD("set video param : wl_surface_id %d", wl_surface_id);
gst_video_overlay_set_wl_window_wl_surface_id(
GST_VIDEO_OVERLAY(player->pipeline->videobin[MMPLAYER_V_SINK].gst),
- *(int*)handle);
- } else
+ *(int *)handle);
+ } else {
/* FIXIT : is it error case? */
LOGW("still we don't have a window handle on player attribute. create it's own surface.");
+ }
}
-
int
-__mmplayer_update_wayland_videosink_video_param(mm_player_t* player, char *param_name)
+__mmplayer_update_wayland_videosink_video_param(mm_player_t *player, char *param_name)
{
- bool update_all_param = FALSE;
+ gboolean update_all_param = FALSE;
MMPLAYER_FENTER();
/* check video sinkbin is created */
}
int
-_mmplayer_update_video_param(mm_player_t* player, char *param_name)
+_mmplayer_update_video_param(mm_player_t *player, char *param_name)
{
MMHandleType attrs = 0;
int surface_type = 0;
_mmplayer_set_audio_only(MMHandleType hplayer, bool audio_only)
{
gboolean disable_overlay = FALSE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
ret = mm_resource_manager_mark_for_release(player->resource_manager,
player->video_overlay_resource);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("failed to mark overlay resource for release, ret(0x%x)\n", ret);
+ LOGE("failed to mark overlay resource for release, ret(0x%x)", ret);
goto ERROR;
}
player->video_overlay_resource = NULL;
ret = mm_resource_manager_commit(player->resource_manager);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("failed to commit acquiring of overlay resource, ret(0x%x)\n", ret);
+ LOGE("failed to commit acquiring of overlay resource, ret(0x%x)", ret);
goto ERROR;
}
} else {
MM_RESOURCE_MANAGER_RES_VOLUME_FULL,
&player->video_overlay_resource);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not prepare for video_overlay resource\n");
+ LOGE("could not prepare for video_overlay resource");
goto ERROR;
}
}
/* acquire resources for video overlay */
ret = mm_resource_manager_commit(player->resource_manager);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not acquire resources for video playing\n");
+ LOGE("could not acquire resources for video playing");
goto ERROR;
}
int
_mmplayer_get_audio_only(MMHandleType hplayer, bool *paudio_only)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
gboolean disable_overlay = FALSE;
MMPLAYER_FENTER();
g_object_get(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "disable-overlay", &disable_overlay, NULL);
- *paudio_only = (bool)(disable_overlay);
+ *paudio_only = (bool)disable_overlay;
LOGD("audio_only : %d", *paudio_only);
}
int
-__mmplayer_gst_element_link_bucket(GList* element_bucket)
+__mmplayer_gst_element_link_bucket(GList *element_bucket)
{
- GList* bucket = element_bucket;
- MMPlayerGstElement* element = NULL;
- MMPlayerGstElement* prv_element = NULL;
+ GList *bucket = element_bucket;
+ MMPlayerGstElement *element = NULL;
+ MMPlayerGstElement *prv_element = NULL;
gint successful_link_count = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(element_bucket, -1);
- prv_element = (MMPlayerGstElement*)bucket->data;
+ prv_element = (MMPlayerGstElement *)bucket->data;
bucket = bucket->next;
for (; bucket; bucket = bucket->next) {
- element = (MMPlayerGstElement*)bucket->data;
+ element = (MMPlayerGstElement *)bucket->data;
if (element && element->gst) {
if (prv_element && prv_element->gst) {
if (gst_element_link(GST_ELEMENT(prv_element->gst), GST_ELEMENT(element->gst))) {
- LOGD("linking [%s] to [%s] success\n",
+ LOGD("linking [%s] to [%s] success",
GST_ELEMENT_NAME(GST_ELEMENT(prv_element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
successful_link_count++;
} else {
- LOGD("linking [%s] to [%s] failed\n",
+ LOGD("linking [%s] to [%s] failed",
GST_ELEMENT_NAME(GST_ELEMENT(prv_element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)));
return -1;
}
int
-__mmplayer_gst_element_add_bucket_to_bin(GstBin* bin, GList* element_bucket)
+__mmplayer_gst_element_add_bucket_to_bin(GstBin *bin, GList *element_bucket)
{
- GList* bucket = element_bucket;
- MMPlayerGstElement* element = NULL;
+ GList *bucket = element_bucket;
+ MMPlayerGstElement *element = NULL;
int successful_add_count = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(bin, 0);
for (; bucket; bucket = bucket->next) {
- element = (MMPlayerGstElement*)bucket->data;
+ element = (MMPlayerGstElement *)bucket->data;
if (element && element->gst) {
if (!gst_bin_add(bin, GST_ELEMENT(element->gst))) {
- LOGD("__mmplayer_gst_element_link_bucket : Adding element [%s] to bin [%s] failed\n",
+ LOGD("__mmplayer_gst_element_link_bucket : Adding element [%s] to bin [%s] failed",
GST_ELEMENT_NAME(GST_ELEMENT(element->gst)),
GST_ELEMENT_NAME(GST_ELEMENT(bin)));
return 0;
return successful_add_count;
}
-static void __mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data)
+static void
+__mmplayer_gst_caps_notify_cb(GstPad *pad, GParamSpec *unused, gpointer data)
{
- mm_player_t *player = (mm_player_t*) data;
+ mm_player_t *player = (mm_player_t *)data;
GstCaps *caps = NULL;
GstStructure *str = NULL;
const char *name;
return;
}
-
-
/**
* This function is to create audio pipeline for playing.
*
*/
/* macro for code readability. just for sinkbin-creation functions */
#define MMPLAYER_CREATE_ELEMENT(x_bin, x_id, x_factory, x_name, x_add_bucket, x_player) \
-do {\
- x_bin[x_id].id = x_id;\
- x_bin[x_id].gst = gst_element_factory_make(x_factory, x_name);\
- if (!x_bin[x_id].gst) {\
- LOGE("failed to create %s \n", x_factory);\
- goto ERROR;\
- } else {\
- if (x_player->ini.set_dump_element_flag)\
- __mmplayer_add_dump_buffer_probe(x_player, x_bin[x_id].gst);\
- } \
- if (x_add_bucket)\
- element_bucket = g_list_append(element_bucket, &x_bin[x_id]);\
-} while (0);
+ do {\
+ x_bin[x_id].id = x_id;\
+ x_bin[x_id].gst = gst_element_factory_make(x_factory, x_name);\
+ if (!x_bin[x_id].gst) {\
+ LOGE("failed to create %s", x_factory);\
+ goto ERROR;\
+ } else {\
+ if (x_player->ini.set_dump_element_flag)\
+ __mmplayer_add_dump_buffer_probe(x_player, x_bin[x_id].gst);\
+ } \
+ if (x_add_bucket)\
+ element_bucket = g_list_append(element_bucket, &x_bin[x_id]);\
+ } while (0);
void
-__mmplayer_audio_stream_clear_buffer(mm_player_t* player, gboolean send_all)
+__mmplayer_audio_stream_clear_buffer(mm_player_t *player, gboolean send_all)
{
GList *l = NULL;
LOGD("[%"G_GUINT64_FORMAT"] send remained data.", tmp->channel_mask);
__mmplayer_audio_stream_send_data(player, tmp);
}
- if (tmp->pcm_data)
- g_free(tmp->pcm_data);
- g_free(tmp);
+ MMPLAYER_FREEIF(tmp->pcm_data);
+ MMPLAYER_FREEIF(tmp);
}
}
g_list_free(player->audio_stream_buff_list);
}
static void
-__mmplayer_audio_stream_send_data(mm_player_t* player, mm_player_audio_stream_buff_t *a_buffer)
+__mmplayer_audio_stream_send_data(mm_player_t *player, mm_player_audio_stream_buff_t *a_buffer)
{
MMPlayerAudioStreamDataType audio_stream = { 0, };
}
static void
-__mmplayer_audio_stream_decoded_render_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_audio_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*) data;
-
+ mm_player_t *player = (mm_player_t *)data;
gint channel = 0;
gint rate = 0;
gint depth = 0;
}
/* create new audio stream data */
- a_buffer = (mm_player_audio_stream_buff_t*)g_malloc0(sizeof(mm_player_audio_stream_buff_t));
+ a_buffer = (mm_player_audio_stream_buff_t *)g_try_malloc0(sizeof(mm_player_audio_stream_buff_t));
if (a_buffer == NULL) {
LOGE("failed to alloc data.");
goto DONE;
a_buffer->bitrate = rate;
a_buffer->channel = channel;
a_buffer->depth = depth;
- a_buffer->is_little_endian = (endianness == 1234 ? 1 : 0);
+ a_buffer->is_little_endian = (endianness == 1234 ? true : false);
a_buffer->channel_mask = channel_mask;
a_buffer->data_size = a_size;
if (!player->audio_stream_sink_sync) {
/* If sync is FALSE, use buffer list to reduce the IPC. */
a_buffer->buff_size = (a_size > player->ini.pcm_buffer_size) ? (a_size) : (player->ini.pcm_buffer_size);
- a_buffer->pcm_data = g_malloc(a_buffer->buff_size);
+ a_buffer->pcm_data = g_try_malloc(a_buffer->buff_size);
if (a_buffer->pcm_data == NULL) {
LOGE("failed to alloc data.");
- g_free(a_buffer);
+ MMPLAYER_FREEIF(a_buffer);
goto DONE;
}
memcpy(a_buffer->pcm_data, a_data, a_size);
/* If sync is TRUE, send data directly. */
a_buffer->pcm_data = a_data;
__mmplayer_audio_stream_send_data(player, a_buffer);
- g_free(a_buffer);
+ MMPLAYER_FREEIF(a_buffer);
}
DONE:
static void
__mmplayer_gst_audio_deinterleave_pad_added(GstElement *elem, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- MMPlayerGstElement* audiobin = player->pipeline->audiobin;
- GstPad* sinkpad = NULL;
+ mm_player_t *player = (mm_player_t *)data;
+ MMPlayerGstElement *audiobin = player->pipeline->audiobin;
+ GstPad *sinkpad = NULL;
GstElement *queue = NULL, *sink = NULL;
MMPLAYER_FENTER();
queue = gst_element_factory_make("queue", NULL);
if (queue == NULL) {
- LOGD("fail make queue\n");
+ LOGD("fail make queue");
goto ERROR;
}
sink = gst_element_factory_make("fakesink", NULL);
if (sink == NULL) {
- LOGD("fail make fakesink\n");
+ LOGD("fail make fakesink");
goto ERROR;
}
gst_bin_add_many(GST_BIN(audiobin[MMPLAYER_A_BIN].gst), queue, sink, NULL);
if (!gst_element_link_pads_full(queue, "src", sink, "sink", GST_PAD_LINK_CHECK_NOTHING)) {
- LOGW("failed to link queue & sink\n");
+ LOGW("failed to link queue & sink");
goto ERROR;
}
sinkpad = gst_element_get_static_pad(queue, "sink");
if (GST_PAD_LINK_OK != gst_pad_link(pad, sinkpad)) {
- LOGW("failed to link [%s:%s] to queue\n", GST_DEBUG_PAD_NAME(pad));
+ LOGW("failed to link [%s:%s] to queue", GST_DEBUG_PAD_NAME(pad));
goto ERROR;
}
- LOGE("player->audio_stream_sink_sync: %d\n", player->audio_stream_sink_sync);
+ LOGE("player->audio_stream_sink_sync: %d", player->audio_stream_sink_sync);
gst_object_unref(sinkpad);
g_object_set(sink, "sync", player->audio_stream_sink_sync, NULL);
return;
ERROR:
- LOGE("__mmplayer_gst_audio_deinterleave_pad_added ERROR\n");
+ LOGE("__mmplayer_gst_audio_deinterleave_pad_added ERROR");
if (queue) {
gst_object_unref(GST_OBJECT(queue));
queue = NULL;
return;
}
-void __mmplayer_gst_set_pulsesink_property(mm_player_t* player, MMHandleType attrs)
+void
+__mmplayer_gst_set_pulsesink_property(mm_player_t *player, MMHandleType attrs)
{
#define MAX_PROPS_LEN 128
gint latency_mode = 0;
LOGE("stream_type is null.");
} else {
if (player->sound.focus_id)
- snprintf(stream_props, sizeof(stream_props)-1, "props,media.role=%s, media.parent_id=%d, media.focus_id=%d",
+ snprintf(stream_props, sizeof(stream_props) - 1, "props,media.role=%s, media.parent_id=%d, media.focus_id=%d",
stream_type, stream_id, player->sound.focus_id);
else
- snprintf(stream_props, sizeof(stream_props)-1, "props,media.role=%s, media.parent_id=%d",
+ snprintf(stream_props, sizeof(stream_props) - 1, "props,media.role=%s, media.parent_id=%d",
stream_type, stream_id);
props = gst_structure_from_string(stream_props, NULL);
g_object_set(player->pipeline->audiobin[MMPLAYER_A_SINK].gst, "stream-properties", props, NULL);
LOGD("audiosink property - latency=%s", latency);
- g_free(latency);
+ MMPLAYER_FREEIF(latency);
MMPLAYER_FLEAVE();
}
-void __mmplayer_gst_set_openalsink_property(mm_player_t* player)
+void
+__mmplayer_gst_set_openalsink_property(mm_player_t *player)
{
MMPlayerGstElement *audiobin = NULL;
player->video360_pitch_radians <= M_PI_2 &&
player->video360_pitch_radians >= -M_PI_2) {
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst),
- "source-orientation-y", (int) (player->video360_yaw_radians * 180.0 / M_PI),
- "source-orientation-x", (int) (player->video360_pitch_radians * 180.0 / M_PI), NULL);
+ "source-orientation-y", (int)(player->video360_yaw_radians * 180.0 / M_PI),
+ "source-orientation-x", (int)(player->video360_pitch_radians * 180.0 / M_PI), NULL);
} else if (player->video360_metadata.init_view_heading || player->video360_metadata.init_view_pitch) {
g_object_set(G_OBJECT(audiobin[MMPLAYER_A_SINK].gst),
"source-orientation-y", player->video360_metadata.init_view_heading,
}
static int
-__mmplayer_gst_create_audio_sink_bin(mm_player_t* player)
+__mmplayer_gst_create_audio_sink_bin(mm_player_t *player)
{
MMPlayerGstElement *first_element = NULL;
MMPlayerGstElement *audiobin = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- audiobin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_A_NUM);
+ audiobin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_A_NUM);
if (!audiobin) {
LOGE("failed to allocate memory for audiobin");
return MM_ERROR_PLAYER_NO_FREE_SPACE;
for (i = 1; i < MMPLAYER_A_NUM; i++) {
/* NOTE : skip bin */
if (audiobin[i].gst) {
- GstObject* parent = NULL;
+ GstObject *parent = NULL;
parent = gst_element_get_parent(audiobin[i].gst);
if (!parent) {
return MM_ERROR_PLAYER_INTERNAL;
}
-static guint32 _mmplayer_convert_fourcc_string_to_value(const gchar* format_name)
+static guint32
+_mmplayer_convert_fourcc_string_to_value(const gchar *format_name)
{
return format_name[0] | (format_name[1] << 8) | (format_name[2] << 16) | (format_name[3] << 24);
}
-int _mmplayer_video_stream_release_bo(mm_player_t* player, void* bo)
+int
+_mmplayer_video_stream_release_bo(mm_player_t *player, void *bo)
{
int ret = MM_ERROR_NONE;
GList *l = NULL;
if (player->video_bo_list) {
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
+ mm_player_video_bo_info_t *tmp = (mm_player_video_bo_info_t *)l->data;
if (tmp && tmp->bo == bo) {
tmp->used = FALSE;
LOGD("release bo %p", bo);
}
static void
-__mmplayer_video_stream_destroy_bo_list(mm_player_t* player)
+__mmplayer_video_stream_destroy_bo_list(mm_player_t *player)
{
GList *l = NULL;
if (player->video_bo_list) {
LOGD("destroy video_bo_list : %d", g_list_length(player->video_bo_list));
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
+ mm_player_video_bo_info_t *tmp = (mm_player_video_bo_info_t *)l->data;
if (tmp) {
if (tmp->bo)
tbm_bo_unref(tmp->bo);
return;
}
-static void*
-__mmplayer_video_stream_get_bo(mm_player_t* player, int size)
+static void *
+__mmplayer_video_stream_get_bo(mm_player_t *player, int size)
{
GList *l = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
}
for (; idx < player->ini.num_of_video_bo; idx++) {
- mm_player_video_bo_info_t* bo_info = g_new(mm_player_video_bo_info_t, 1);
+ mm_player_video_bo_info_t *bo_info = g_new(mm_player_video_bo_info_t, 1);
if (!bo_info) {
LOGE("Fail to alloc bo_info.");
break;
bo_info->bo = tbm_bo_alloc(player->bufmgr, size, TBM_BO_DEFAULT);
if (!bo_info->bo) {
LOGE("Fail to tbm_bo_alloc.");
- g_free(bo_info);
+ MMPLAYER_FREEIF(bo_info);
break;
}
bo_info->used = FALSE;
while (TRUE) {
/* get bo from list*/
for (l = g_list_first(player->video_bo_list); l; l = g_list_next(l)) {
- mm_player_video_bo_info_t* tmp = (mm_player_video_bo_info_t *)l->data;
+ mm_player_video_bo_info_t *tmp = (mm_player_video_bo_info_t *)l->data;
if (tmp && (tmp->used == FALSE)) {
LOGD("found bo %p to use", tmp->bo);
tmp->used = TRUE;
if (player->ini.video_bo_timeout <= 0) {
MMPLAYER_VIDEO_BO_WAIT(player);
} else {
- gint64 timeout = g_get_monotonic_time() + player->ini.video_bo_timeout*G_TIME_SPAN_SECOND;
+ gint64 timeout = g_get_monotonic_time() + player->ini.video_bo_timeout * G_TIME_SPAN_SECOND;
ret = MMPLAYER_VIDEO_BO_WAIT_UNTIL(player, timeout);
}
continue;
}
static void
-__mmplayer_video_stream_decoded_preroll_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_video_stream_decoded_preroll_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mm_player_t *player = (mm_player_t *)data;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->video_stream_cb);
/* send prerolled pkt */
- player->video_stream_prerolled = FALSE;
+ player->video_stream_prerolled = false;
__mmplayer_video_stream_decoded_render_cb(object, buffer, pad, data);
/* not to send prerolled pkt again */
- player->video_stream_prerolled = TRUE;
+ player->video_stream_prerolled = true;
}
static void
-__mmplayer_video_stream_decoded_render_cb(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_video_stream_decoded_render_cb(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mm_player_t *player = (mm_player_t *)data;
MMPlayerVideoStreamDataType *stream = NULL;
GstMemory *mem = NULL;
MMPLAYER_RETURN_IF_FAIL(player->video_stream_cb);
if (player->video_stream_prerolled) {
- player->video_stream_prerolled = FALSE;
+ player->video_stream_prerolled = false;
LOGD("skip the prerolled pkt not to send it again");
return;
}
if (stream->bo[0])
_mmplayer_video_stream_release_bo(player, stream->bo[0]);
}
- g_free(stream);
+ MMPLAYER_FREEIF(stream);
return;
}
player->video360_pitch_radians <= M_PI_2 &&
player->video360_pitch_radians >= -M_PI_2) {
g_object_set(G_OBJECT(videobin[MMPLAYER_V_360].gst),
- "pose-yaw", (int) (player->video360_yaw_radians * 180.0 / M_PI),
- "pose-pitch", (int) (player->video360_pitch_radians * 180.0 / M_PI), NULL);
+ "pose-yaw", (int)(player->video360_yaw_radians * 180.0 / M_PI),
+ "pose-pitch", (int)(player->video360_pitch_radians * 180.0 / M_PI), NULL);
} else if (player->video360_metadata.init_view_heading || player->video360_metadata.init_view_pitch) {
g_object_set(G_OBJECT(videobin[MMPLAYER_V_360].gst),
"pose-yaw", player->video360_metadata.init_view_heading,
return MM_ERROR_PLAYER_INTERNAL;
}
-static gchar*
+static gchar *
__mmplayer_get_videosink_factory_name(mm_player_t *player, MMDisplaySurfaceType surface_type)
{
gchar *factory_name = NULL;
* - video overlay surface(arm/x86) : tizenwlsink
*/
static int
-__mmplayer_gst_create_video_sink_bin(mm_player_t* player, GstCaps* caps, MMDisplaySurfaceType surface_type)
+__mmplayer_gst_create_video_sink_bin(mm_player_t *player, GstCaps *caps, MMDisplaySurfaceType surface_type)
{
GstPad *pad = NULL;
GList *element_bucket = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- videobin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_V_NUM);
+ videobin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_V_NUM);
if (!videobin)
return MM_ERROR_PLAYER_NO_FREE_SPACE;
return MM_ERROR_PLAYER_INTERNAL;
}
-static int __mmplayer_gst_create_plain_text_elements(mm_player_t* player)
+static int
+__mmplayer_gst_create_plain_text_elements(mm_player_t *player)
{
GList *element_bucket = NULL;
MMPlayerGstElement *textbin = player->pipeline->textbin;
"signal-handoffs", TRUE, "max-lateness", FAKE_SINK_MAX_LATENESS, NULL);
if (!player->play_subtitle) {
- LOGD("add textbin sink as sink element of whole pipeline.\n");
+ LOGD("add textbin sink as sink element of whole pipeline.");
__mmplayer_add_sink(player, GST_ELEMENT(textbin[MMPLAYER_T_FAKE_SINK].gst));
}
/* adding created elements to bin */
- LOGD("adding created elements to bin\n");
+ LOGD("adding created elements to bin");
if (!__mmplayer_gst_element_add_bucket_to_bin(GST_BIN(textbin[MMPLAYER_T_BIN].gst), element_bucket)) {
- LOGE("failed to add elements\n");
+ LOGE("failed to add elements");
goto ERROR;
}
GST_OBJECT_FLAG_UNSET(textbin[MMPLAYER_T_FAKE_SINK].gst, GST_ELEMENT_FLAG_SINK);
/* linking elements in the bucket by added order. */
- LOGD("Linking elements in the bucket by added order.\n");
+ LOGD("Linking elements in the bucket by added order.");
if (__mmplayer_gst_element_link_bucket(element_bucket) == -1) {
- LOGE("failed to link elements\n");
+ LOGE("failed to link elements");
goto ERROR;
}
gst_object_unref(pad);
if (!ghostpad) {
- LOGE("failed to create ghostpad of textbin\n");
+ LOGE("failed to create ghostpad of textbin");
goto ERROR;
}
if (!gst_element_add_pad(textbin[MMPLAYER_T_BIN].gst, ghostpad)) {
- LOGE("failed to add ghostpad to textbin\n");
+ LOGE("failed to add ghostpad to textbin");
gst_object_unref(ghostpad);
goto ERROR;
}
return MM_ERROR_PLAYER_INTERNAL;
}
-static int __mmplayer_gst_create_text_sink_bin(mm_player_t* player)
+static int
+__mmplayer_gst_create_text_sink_bin(mm_player_t *player)
{
MMPlayerGstElement *textbin = NULL;
GList *element_bucket = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* alloc handles */
- textbin = (MMPlayerGstElement*)g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_T_NUM);
+ textbin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_T_NUM);
if (!textbin) {
- LOGE("failed to allocate memory for textbin\n");
+ LOGE("failed to allocate memory for textbin");
return MM_ERROR_PLAYER_NO_FREE_SPACE;
}
textbin[MMPLAYER_T_BIN].id = MMPLAYER_T_BIN;
textbin[MMPLAYER_T_BIN].gst = gst_bin_new("textbin");
if (!textbin[MMPLAYER_T_BIN].gst) {
- LOGE("failed to create textbin\n");
+ LOGE("failed to create textbin");
goto ERROR;
}
case MM_DISPLAY_SURFACE_NULL:
case MM_DISPLAY_SURFACE_REMOTE:
if (__mmplayer_gst_create_plain_text_elements(player) != MM_ERROR_NONE) {
- LOGE("failed to make plain text elements\n");
+ LOGE("failed to make plain text elements");
goto ERROR;
}
break;
ERROR:
- LOGD("ERROR : releasing textbin\n");
+ LOGD("ERROR : releasing textbin");
g_list_free(element_bucket);
for (i = 1; i < MMPLAYER_T_NUM; i++) {
/* NOTE : skip bin */
if (textbin[i].gst) {
- GstObject* parent = NULL;
+ GstObject *parent = NULL;
parent = gst_element_get_parent(textbin[i].gst);
if (!parent) {
return MM_ERROR_PLAYER_INTERNAL;
}
-
static int
-__mmplayer_gst_create_text_pipeline(mm_player_t* player)
+__mmplayer_gst_create_text_pipeline(mm_player_t *player)
{
- MMPlayerGstElement* mainbin = NULL;
- MMPlayerGstElement* textbin = NULL;
+ MMPlayerGstElement *mainbin = NULL;
+ MMPlayerGstElement *textbin = NULL;
MMHandleType attrs = 0;
GstElement *subsrc = NULL;
GstElement *subparse = NULL;
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("cannot get content attribute\n");
+ LOGE("cannot get content attribute");
return MM_ERROR_PLAYER_INTERNAL;
}
mm_attrs_get_string_by_name(attrs, "subtitle_uri", &subtitle_uri);
if (!subtitle_uri || strlen(subtitle_uri) < 1) {
- LOGE("subtitle uri is not proper filepath.\n");
+ LOGE("subtitle uri is not proper filepath.");
return MM_ERROR_PLAYER_INVALID_URI;
}
return MM_ERROR_PLAYER_INVALID_URI;
}
- SECURE_LOGD("subtitle file path is [%s].\n", subtitle_uri);
+ SECURE_LOGD("subtitle file path is [%s].", subtitle_uri);
MMPLAYER_SUBTITLE_INFO_LOCK(player);
player->subtitle_language_list = NULL;
/* create the subtitle source */
subsrc = gst_element_factory_make("filesrc", "subtitle_source");
if (!subsrc) {
- LOGE("failed to create filesrc element\n");
+ LOGE("failed to create filesrc element");
goto ERROR;
}
g_object_set(G_OBJECT(subsrc), "location", subtitle_uri, NULL);
mainbin[MMPLAYER_M_SUBSRC].gst = subsrc;
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subsrc)) {
- LOGW("failed to add queue\n");
+ LOGW("failed to add queue");
gst_object_unref(mainbin[MMPLAYER_M_SUBSRC].gst);
mainbin[MMPLAYER_M_SUBSRC].gst = NULL;
mainbin[MMPLAYER_M_SUBSRC].id = MMPLAYER_M_NUM;
/* subparse */
subparse = gst_element_factory_make("subparse", "subtitle_parser");
if (!subparse) {
- LOGE("failed to create subparse element\n");
+ LOGE("failed to create subparse element");
goto ERROR;
}
charset = util_get_charset(subtitle_uri);
if (charset) {
- LOGD("detected charset is %s\n", charset);
+ LOGD("detected charset is %s", charset);
g_object_set(G_OBJECT(subparse), "subtitle-encoding", charset, NULL);
}
mainbin[MMPLAYER_M_SUBPARSE].gst = subparse;
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), subparse)) {
- LOGW("failed to add subparse\n");
+ LOGW("failed to add subparse");
gst_object_unref(mainbin[MMPLAYER_M_SUBPARSE].gst);
mainbin[MMPLAYER_M_SUBPARSE].gst = NULL;
mainbin[MMPLAYER_M_SUBPARSE].id = MMPLAYER_M_NUM;
}
if (!gst_element_link_pads(subsrc, "src", subparse, "sink")) {
- LOGW("failed to link subsrc and subparse\n");
+ LOGW("failed to link subsrc and subparse");
goto ERROR;
}
player->play_subtitle = TRUE;
player->adjust_subtitle_pos = 0;
- LOGD("play subtitle using subtitle file\n");
+ LOGD("play subtitle using subtitle file");
if (player->pipeline->textbin == NULL) {
if (MM_ERROR_NONE != __mmplayer_gst_create_text_sink_bin(player)) {
- LOGE("failed to create text sink bin. continuing without text\n");
+ LOGE("failed to create text sink bin. continuing without text");
goto ERROR;
}
textbin = player->pipeline->textbin;
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), GST_ELEMENT(textbin[MMPLAYER_T_BIN].gst))) {
- LOGW("failed to add textbin\n");
+ LOGW("failed to add textbin");
/* release signal */
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_TEXTBIN);
}
if (!gst_element_link_pads(subparse, "src", textbin[MMPLAYER_T_BIN].gst, "text_sink")) {
- LOGW("failed to link subparse and textbin\n");
+ LOGW("failed to link subparse and textbin");
goto ERROR;
}
}
gboolean
-__mmplayer_update_subtitle(GstElement* object, GstBuffer *buffer, GstPad *pad, gpointer data)
+__mmplayer_update_subtitle(GstElement *object, GstBuffer *buffer, GstPad *pad, gpointer data)
{
- mm_player_t* player = (mm_player_t*) data;
+ mm_player_t *player = (mm_player_t *)data;
MMMessageParamType msg = {0, };
GstClockTime duration = 0;
gpointer text = NULL;
duration = GST_BUFFER_DURATION(buffer);
if (player->set_mode.subtitle_off) {
- LOGD("subtitle is OFF.\n");
+ LOGD("subtitle is OFF.");
return TRUE;
}
if (!text || (text_size == 0)) {
- LOGD("There is no subtitle to be displayed.\n");
+ LOGD("There is no subtitle to be displayed.");
return TRUE;
}
- msg.data = (void *) text;
+ msg.data = (void *)text;
msg.subtitle.duration = GST_TIME_AS_MSECONDS(duration);
- LOGD("update subtitle : [%ld msec] %s\n'", msg.subtitle.duration, (char*)msg.data);
+ LOGD("update subtitle : [%ld msec] %s", msg.subtitle.duration, (char *)msg.data);
MMPLAYER_POST_MSG(player, MM_MESSAGE_UPDATE_SUBTITLE, &msg);
gst_buffer_unmap(buffer, &mapinfo);
static GstPadProbeReturn
__mmplayer_subtitle_adjust_position_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
- mm_player_t *player = (mm_player_t *) u_data;
+ mm_player_t *player = (mm_player_t *)u_data;
GstClockTime cur_timestamp = 0;
gint64 adjusted_timestamp = 0;
GstBuffer *buffer = gst_pad_probe_info_get_buffer(info);
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
if (player->set_mode.subtitle_off) {
- LOGD("subtitle is OFF.\n");
+ LOGD("subtitle is OFF.");
return TRUE;
}
}
cur_timestamp = GST_BUFFER_TIMESTAMP(buffer);
- adjusted_timestamp = (gint64) cur_timestamp +((gint64) player->adjust_subtitle_pos * G_GINT64_CONSTANT(1000000));
+ adjusted_timestamp = (gint64)cur_timestamp + ((gint64)player->adjust_subtitle_pos * G_GINT64_CONSTANT(1000000));
if (adjusted_timestamp < 0) {
LOGD("adjusted_timestamp under zero");
return GST_PAD_PROBE_OK;
}
-static int __mmplayer_gst_adjust_subtitle_position(mm_player_t* player, int format, int position)
+
+static int
+__mmplayer_gst_adjust_subtitle_position(mm_player_t *player, int format, int position)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player->play_subtitle, MM_ERROR_NOT_SUPPORT_API);
if (position == 0) {
- LOGD("nothing to do\n");
+ LOGD("nothing to do");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
default:
{
- LOGW("invalid format.\n");
+ LOGW("invalid format.");
MMPLAYER_FLEAVE();
return MM_ERROR_INVALID_ARGUMENT;
}
* @see
*/
static int
-__mmplayer_gst_create_pipeline(mm_player_t* player)
+__mmplayer_gst_create_pipeline(mm_player_t *player)
{
int ret = MM_ERROR_NONE;
MMPlayerGstElement *mainbin = NULL;
goto INIT_ERROR;
}
- player->pipeline = (MMPlayerGstPipelineInfo*) g_malloc0(sizeof(MMPlayerGstPipelineInfo));
+ player->pipeline = (MMPlayerGstPipelineInfo *)g_malloc0(sizeof(MMPlayerGstPipelineInfo));
if (player->pipeline == NULL)
goto INIT_ERROR;
/* create mainbin */
- mainbin = (MMPlayerGstElement*) g_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_M_NUM);
+ mainbin = (MMPlayerGstElement *)g_try_malloc0(sizeof(MMPlayerGstElement) * MMPLAYER_M_NUM);
if (mainbin == NULL)
goto INIT_ERROR;
}
/* Note : check whether subtitle atrribute uri is set. If uri is set, then try to play subtitle file */
- if (__mmplayer_check_subtitle(player)) {
- if (__mmplayer_gst_create_text_pipeline(player) != MM_ERROR_NONE)
- LOGE("failed to create text pipeline");
- }
+ if (__mmplayer_check_subtitle(player)
+ && (__mmplayer_gst_create_text_pipeline(player) != MM_ERROR_NONE))
+ LOGE("failed to create text pipeline");
/* add bus watch */
ret = __mmplayer_gst_add_bus_watch(player);
}
static void
-__mmplayer_reset_gapless_state(mm_player_t* player)
+__mmplayer_reset_gapless_state(mm_player_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player
}
static int
-__mmplayer_gst_destroy_pipeline(mm_player_t* player)
+__mmplayer_gst_destroy_pipeline(mm_player_t *player)
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
/* cleanup gst stuffs */
if (player->pipeline) {
- MMPlayerGstElement* mainbin = player->pipeline->mainbin;
- GstTagList* tag_list = player->pipeline->tag_list;
+ MMPlayerGstElement *mainbin = player->pipeline->mainbin;
+ GstTagList *tag_list = player->pipeline->tag_list;
/* first we need to disconnect all signal hander */
__mmplayer_release_signal_connection(player, MM_PLAYER_SIGNAL_TYPE_ALL);
if (mainbin) {
- MMPlayerGstElement* audiobin = player->pipeline->audiobin;
- MMPlayerGstElement* videobin = player->pipeline->videobin;
- MMPlayerGstElement* textbin = player->pipeline->textbin;
+ MMPlayerGstElement *audiobin = player->pipeline->audiobin;
+ MMPlayerGstElement *videobin = player->pipeline->videobin;
+ MMPlayerGstElement *textbin = player->pipeline->textbin;
GstBus *bus = gst_pipeline_get_bus(GST_PIPELINE(mainbin[MMPLAYER_M_PIPE].gst));
gst_bus_set_sync_handler(bus, NULL, NULL, NULL);
gst_object_unref(bus);
timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
ret = __mmplayer_gst_set_state(player, mainbin[MMPLAYER_M_PIPE].gst, GST_STATE_NULL, FALSE, timeout);
if (ret != MM_ERROR_NONE) {
- LOGE("fail to change state to NULL\n");
+ LOGE("fail to change state to NULL");
return MM_ERROR_PLAYER_INTERNAL;
}
- LOGW("succeeded in changing state to NULL\n");
+ LOGW("succeeded in changing state to NULL");
gst_object_unref(GST_OBJECT(mainbin[MMPLAYER_M_PIPE].gst));
gst_caps_unref(player->v_stream_caps);
player->v_stream_caps = NULL;
}
+
if (player->a_stream_caps) {
gst_caps_unref(player->a_stream_caps);
player->a_stream_caps = NULL;
player->bufmgr = NULL;
}
- LOGW("finished destroy pipeline\n");
+ LOGW("finished destroy pipeline");
MMPLAYER_FLEAVE();
return ret;
}
-static int __mmplayer_gst_realize(mm_player_t* player)
+static int
+__mmplayer_gst_realize(mm_player_t *player)
{
gint timeout = 0;
int ret = MM_ERROR_NONE;
ret = __mmplayer_gst_create_pipeline(player);
if (ret) {
- LOGE("failed to create pipeline\n");
+ LOGE("failed to create pipeline");
return ret;
}
return ret;
}
-static int __mmplayer_gst_unrealize(mm_player_t* player)
+static int
+__mmplayer_gst_unrealize(mm_player_t *player)
{
int ret = MM_ERROR_NONE;
/* destroy pipeline */
ret = __mmplayer_gst_destroy_pipeline(player);
if (ret != MM_ERROR_NONE) {
- LOGE("failed to destory pipeline\n");
+ LOGE("failed to destory pipeline");
return ret;
}
}
static int
-__mmplayer_gst_set_message_callback(mm_player_t* player, MMMessageCallback callback, gpointer user_param)
+__mmplayer_gst_set_message_callback(mm_player_t *player, MMMessageCallback callback, gpointer user_param)
{
MMPLAYER_FENTER();
if (!player) {
- LOGW("set_message_callback is called with invalid player handle\n");
+ LOGW("set_message_callback is called with invalid player handle");
return MM_ERROR_PLAYER_NOT_INITIALIZED;
}
player->msg_cb = callback;
player->msg_cb_param = user_param;
- LOGD("msg_cb : %p msg_cb_param : %p\n", callback, user_param);
+ LOGD("msg_cb : %p msg_cb_param : %p", callback, user_param);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-int __mmplayer_parse_profile(const char *uri, void *param, MMPlayerParseProfile* data)
+int
+__mmplayer_parse_profile(const char *uri, void *param, MMPlayerParseProfile *data)
{
int ret = MM_ERROR_NONE;
char *path = NULL;
ret = MM_ERROR_PLAYER_PERMISSION_DENIED;
/* dump parse result */
- SECURE_LOGW("incoming uri : %s\n", uri);
- LOGD("uri_type : %d, mem : %p, mem_size : %d, urgent : %s\n",
+ SECURE_LOGW("incoming uri : %s", uri);
+ LOGD("uri_type : %d, mem : %p, mem_size : %d, urgent : %s",
data->uri_type, data->input_mem.buf, data->input_mem.len, data->urgent);
MMPLAYER_FLEAVE();
MMPLAYER_FENTER();
if (user_data == NULL) {
- LOGE("- user_data is null\n");
+ LOGE("- user_data is null");
return FALSE;
}
player = (mm_player_t *)user_data;
int ret = MM_ERROR_PLAYER_INTERNAL;
bool enabled = false;
- mm_player_t* player = MM_PLAYER_CAST(handle);
+ mm_player_t *player = MM_PLAYER_CAST(handle);
MMPLAYER_FENTER();
player->attrs = _mmplayer_construct_attribute(handle);
if (!player->attrs) {
- LOGE("Failed to construct attributes\n");
+ LOGE("Failed to construct attributes");
return ret;
}
/* initialize gstreamer with configured parameter */
if (!__mmplayer_init_gstreamer(player)) {
- LOGE("Initializing gstreamer failed\n");
+ LOGE("Initializing gstreamer failed");
_mmplayer_deconstruct_attribute(handle);
return ret;
}
ret = _mmplayer_initialize_video_capture(player);
if (ret != MM_ERROR_NONE) {
- LOGE("failed to initialize video capture\n");
+ LOGE("failed to initialize video capture");
goto ERROR;
}
ERROR:
/* free lock */
g_mutex_clear(&player->fsink_lock);
-
/* free update tag lock */
g_mutex_clear(&player->update_tag_lock);
-
g_queue_free(player->bus_msg_q);
-
/* free gapless play thread */
if (player->gapless_play_thread) {
MMPLAYER_GAPLESS_PLAY_THREAD_LOCK(player);
}
static gboolean
-__mmplayer_init_gstreamer(mm_player_t* player)
+__mmplayer_init_gstreamer(mm_player_t *player)
{
static gboolean initialized = FALSE;
static const int max_argc = 50;
- gint* argc = NULL;
- gchar** argv = NULL;
- gchar** argv2 = NULL;
+ gint *argc = NULL;
+ gchar **argv = NULL;
+ gchar **argv2 = NULL;
GError *err = NULL;
int i = 0;
int arg_count = 0;
if (initialized) {
- LOGD("gstreamer already initialized.\n");
+ LOGD("gstreamer already initialized.");
return TRUE;
}
/* alloc */
argc = malloc(sizeof(int));
- argv = malloc(sizeof(gchar*) * max_argc);
- argv2 = malloc(sizeof(gchar*) * max_argc);
+ argv = malloc(sizeof(gchar *) * max_argc);
+ argv2 = malloc(sizeof(gchar *) * max_argc);
if (!argc || !argv || !argv2)
goto ERROR;
- memset(argv, 0, sizeof(gchar*) * max_argc);
- memset(argv2, 0, sizeof(gchar*) * max_argc);
+ memset(argv, 0, sizeof(gchar *) * max_argc);
+ memset(argv2, 0, sizeof(gchar *) * max_argc);
/* add initial */
*argc = 1;
(*argc)++;
}
- LOGD("initializing gstreamer with following parameter\n");
- LOGD("argc : %d\n", *argc);
+ LOGD("initializing gstreamer with following parameter");
+ LOGD("argc : %d", *argc);
arg_count = *argc;
for (i = 0; i < arg_count; i++) {
argv2[i] = argv[i];
- LOGD("argv[%d] : %s\n", i, argv2[i]);
+ LOGD("argv[%d] : %s", i, argv2[i]);
}
/* initializing gstreamer */
if (!gst_init_check(argc, &argv, &err)) {
- LOGE("Could not initialize GStreamer: %s\n", err ? err->message : "unknown error occurred");
+ LOGE("Could not initialize GStreamer: %s", err ? err->message : "unknown error occurred");
if (err)
g_error_free(err);
}
/* release */
for (i = 0; i < arg_count; i++) {
- //LOGD("release - argv[%d] : %s\n", i, argv2[i]);
+ //LOGD("release - argv[%d] : %s", i, argv2[i]);
MMPLAYER_FREEIF(argv2[i]);
}
/* release */
for (i = 0; i < arg_count; i++) {
- LOGD("free[%d] : %s\n", i, argv2[i]);
+ LOGD("free[%d] : %s", i, argv2[i]);
MMPLAYER_FREEIF(argv2[i]);
}
}
static void
-__mmplayer_check_async_state_transition(mm_player_t* player)
+__mmplayer_check_async_state_transition(mm_player_t *player)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
- GstElement * element = NULL;
+ GstElement *element = NULL;
gboolean async = FALSE;
/* check player handle */
/* wait for state transition */
element = player->pipeline->mainbin[MMPLAYER_M_PIPE].gst;
- ret = gst_element_get_state(element, &element_state, &element_pending_state, 1*GST_SECOND);
+ ret = gst_element_get_state(element, &element_state, &element_pending_state, 1 * GST_SECOND);
if (ret == GST_STATE_CHANGE_FAILURE) {
- LOGE(" [%s] state : %s pending : %s \n",
+ LOGE(" [%s] state : %s pending : %s",
GST_ELEMENT_NAME(element),
gst_element_state_get_name(element_state),
gst_element_state_get_name(element_pending_state));
return;
}
- LOGD("[%s] element state has changed\n", GST_ELEMENT_NAME(element));
+ LOGD("[%s] element state has changed", GST_ELEMENT_NAME(element));
return;
}
int
_mmplayer_destroy(MMHandleType handle)
{
- mm_player_t* player = MM_PLAYER_CAST(handle);
+ mm_player_t *player = MM_PLAYER_CAST(handle);
MMPLAYER_FENTER();
MMPLAYER_GAPLESS_PLAY_THREAD_SIGNAL(player);
MMPLAYER_GAPLESS_PLAY_THREAD_UNLOCK(player);
- LOGD("waitting for gapless play thread exit\n");
+ LOGD("waitting for gapless play thread exit");
g_thread_join(player->gapless_play_thread);
g_mutex_clear(&player->gapless_play_thread_mutex);
g_cond_clear(&player->gapless_play_thread_cond);
- LOGD("gapless play thread released\n");
+ LOGD("gapless play thread released");
}
_mmplayer_release_video_capture(player);
/* de-initialize resource manager */
if (MM_RESOURCE_MANAGER_ERROR_NONE != mm_resource_manager_destroy(
player->resource_manager))
- LOGE("failed to deinitialize resource manager\n");
+ LOGE("failed to deinitialize resource manager");
/* release pipeline */
if (MM_ERROR_NONE != __mmplayer_gst_destroy_pipeline(player)) {
- LOGE("failed to destory pipeline\n");
+ LOGE("failed to destory pipeline");
return MM_ERROR_PLAYER_INTERNAL;
}
int
_mmplayer_realize(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
char *uri = NULL;
void *param = NULL;
MMHandleType attrs = 0;
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("fail to get attributes.\n");
+ LOGE("fail to get attributes.");
return MM_ERROR_PLAYER_INTERNAL;
}
mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
mm_attrs_get_data_by_name(attrs, "profile_user_param", ¶m);
if (player->profile.uri_type == MM_PLAYER_URI_TYPE_NONE) {
- ret = __mmplayer_parse_profile((const char*)uri, param, &player->profile);
+ ret = __mmplayer_parse_profile((const char *)uri, param, &player->profile);
if (ret != MM_ERROR_NONE) {
LOGE("failed to parse profile");
}
if (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_MMS) {
- LOGW("mms protocol is not supported format.\n");
+ LOGW("mms protocol is not supported format.");
return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
}
/* realize pipeline */
ret = __mmplayer_gst_realize(player);
if (ret != MM_ERROR_NONE)
- LOGE("fail to realize the player.\n");
+ LOGE("fail to realize the player.");
MMPLAYER_BUS_MSG_THREAD_SIGNAL(player);
int
_mmplayer_unrealize(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
ret = mm_resource_manager_mark_for_release(player->resource_manager,
player->video_decoder_resource);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
- LOGE("failed to mark decoder resource for release, ret(0x%x)\n", ret);
+ LOGE("failed to mark decoder resource for release, ret(0x%x)", ret);
else
player->video_decoder_resource = NULL;
}
ret = mm_resource_manager_mark_for_release(player->resource_manager,
player->video_overlay_resource);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
- LOGE("failed to mark overlay resource for release, ret(0x%x)\n", ret);
+ LOGE("failed to mark overlay resource for release, ret(0x%x)", ret);
else
player->video_overlay_resource = NULL;
}
ret = mm_resource_manager_commit(player->resource_manager);
if (ret != MM_RESOURCE_MANAGER_ERROR_NONE)
- LOGE("failed to commit resource releases, ret(0x%x)\n", ret);
+ LOGE("failed to commit resource releases, ret(0x%x)", ret);
}
} else
LOGE("failed and don't change asm state to stop");
int
_mmplayer_set_message_callback(MMHandleType hplayer, MMMessageCallback callback, gpointer user_param)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
int
-_mmplayer_get_state(MMHandleType hplayer, int* state)
+_mmplayer_get_state(MMHandleType hplayer, int *state)
{
- mm_player_t *player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(state, MM_ERROR_INVALID_ARGUMENT);
int
_mmplayer_set_volume(MMHandleType hplayer, MMPlayerVolumeType volume)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* vol_element = NULL;
+ mm_player_t *player = (mm_player_t *)hplayer;
+ GstElement *vol_element = NULL;
int i = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD("volume [L]=%f:[R]=%f\n",
+ LOGD("volume [L]=%f:[R]=%f",
volume.level[MM_VOLUME_CHANNEL_LEFT], volume.level[MM_VOLUME_CHANNEL_RIGHT]);
/* invalid factor range or not */
for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++) {
if (volume.level[i] < MM_VOLUME_FACTOR_MIN || volume.level[i] > MM_VOLUME_FACTOR_MAX) {
- LOGE("Invalid factor!(valid factor:0~1.0)\n");
+ LOGE("Invalid factor!(valid factor:0~1.0)");
return MM_ERROR_INVALID_ARGUMENT;
}
}
/* check pipeline handle */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("audiobin is not created yet\n");
- LOGD("but, current stored volume will be set when it's created.\n");
+ LOGD("audiobin is not created yet");
+ LOGD("but, current stored volume will be set when it's created.");
/* NOTE : stored volume will be used in create_audiobin
* returning MM_ERROR_NONE here makes application to able to
vol_element = player->pipeline->audiobin[MMPLAYER_A_VOL].gst;
if (vol_element) {
- LOGD("volume is set [%f]\n", player->sound.volume);
+ LOGD("volume is set [%f]", player->sound.volume);
g_object_set(vol_element, "volume", player->sound.volume, NULL);
}
return MM_ERROR_NONE;
}
-
int
-_mmplayer_get_volume(MMHandleType hplayer, MMPlayerVolumeType* volume)
+_mmplayer_get_volume(MMHandleType hplayer, MMPlayerVolumeType *volume)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int i = 0;
MMPLAYER_FENTER();
int
_mmplayer_set_mute(MMHandleType hplayer, int mute)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* vol_element = NULL;
+ mm_player_t *player = (mm_player_t *)hplayer;
+ GstElement *vol_element = NULL;
MMPLAYER_FENTER();
/* mute value shoud 0 or 1 */
if (mute != 0 && mute != 1) {
- LOGE("bad mute value\n");
+ LOGE("bad mute value");
/* FIXIT : definitly, we need _BAD_PARAM error code */
return MM_ERROR_INVALID_ARGUMENT;
/* just hold mute value if pipeline is not ready */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. holding mute value\n");
+ LOGD("pipeline is not ready. holding mute value");
return MM_ERROR_NONE;
}
/* NOTE : volume will only created when the bt is enabled */
if (vol_element) {
- LOGD("mute : %d\n", mute);
+ LOGD("mute : %d", mute);
g_object_set(vol_element, "mute", mute, NULL);
} else
- LOGD("volume elemnet is not created. using volume in audiosink\n");
+ LOGD("volume elemnet is not created. using volume in audiosink");
MMPLAYER_FLEAVE();
}
int
-_mmplayer_get_mute(MMHandleType hplayer, int* pmute)
+_mmplayer_get_mute(MMHandleType hplayer, int *pmute)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
/* just hold mute value if pipeline is not ready */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. returning stored value\n");
+ LOGD("pipeline is not ready. returning stored value");
*pmute = player->sound.mute;
return MM_ERROR_NONE;
}
int
_mmplayer_set_videostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
player->video_stream_changed_cb = callback;
player->video_stream_changed_cb_user_param = user_param;
- LOGD("Handle value is %p : %p\n", player, player->video_stream_changed_cb);
+ LOGD("Handle value is %p : %p", player, player->video_stream_changed_cb);
MMPLAYER_FLEAVE();
int
_mmplayer_set_audiostream_changed_cb(MMHandleType hplayer, mm_player_stream_changed_callback callback, void *user_param)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
player->audio_stream_changed_cb = callback;
player->audio_stream_changed_cb_user_param = user_param;
- LOGD("Handle value is %p : %p\n", player, player->audio_stream_changed_cb);
+ LOGD("Handle value is %p : %p", player, player->audio_stream_changed_cb);
MMPLAYER_FLEAVE();
int
_mmplayer_set_audiostream_cb(MMHandleType hplayer, bool sync, mm_player_audio_stream_callback callback, void *user_param)
{
- mm_player_t *player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
int
_mmplayer_set_videostream_cb(MMHandleType hplayer, mm_player_video_stream_callback callback, void *user_param)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
player->video_stream_cb = callback;
player->video_stream_cb_user_param = user_param;
- LOGD("Stream cb Handle value is %p : %p, enable:%d\n", player, player->video_stream_cb, player->set_mode.media_packet_video_stream);
+ LOGD("Stream cb Handle value is %p : %p, enable:%d", player, player->video_stream_cb, player->set_mode.media_packet_video_stream);
MMPLAYER_FLEAVE();
int
_mmplayer_start(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
gint ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
/* start pipeline */
ret = __mmplayer_gst_start(player);
if (ret != MM_ERROR_NONE)
- LOGE("failed to start player.\n");
+ LOGE("failed to start player.");
if ((player->streamer) && (player->streamer->buffering_state & MM_PLAYER_BUFFERING_IN_PROGRESS)) {
LOGD("force playing start even during buffering");
* Because GST_ERROR_MESSAGE is posted by other plugin internally.
*/
int
-__mmplayer_handle_missed_plugin(mm_player_t* player)
+__mmplayer_handle_missed_plugin(mm_player_t *player)
{
MMMessageParamType msg_param;
memset(&msg_param, 0, sizeof(MMMessageParamType));
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD("not_supported_codec = 0x%02x, can_support_codec = 0x%02x\n",
+ LOGD("not_supported_codec = 0x%02x, can_support_codec = 0x%02x",
player->not_supported_codec, player->can_support_codec);
if (player->not_found_demuxer) {
memset(&msg_param, 0, sizeof(MMMessageParamType));
if (player->not_supported_codec == MISSING_PLUGIN_AUDIO) {
- LOGW("not found AUDIO codec, posting error code to application.\n");
+ LOGW("not found AUDIO codec, posting error code to application.");
msg_param.code = MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s", player->unlinked_audio_mime);
} else if (player->not_supported_codec == MISSING_PLUGIN_VIDEO) {
- LOGW("not found VIDEO codec, posting error code to application.\n");
+ LOGW("not found VIDEO codec, posting error code to application.");
msg_param.code = MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
msg_param.data = g_strdup_printf("%s", player->unlinked_video_mime);
return MM_ERROR_NONE;
} else {
// no any supported codec case
- LOGW("not found any codec, posting error code to application.\n");
+ LOGW("not found any codec, posting error code to application.");
if (player->not_supported_codec == MISSING_PLUGIN_AUDIO) {
msg_param.code = MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
return MM_ERROR_NONE;
}
-static void __mmplayer_check_pipeline(mm_player_t* player)
+static void
+__mmplayer_check_pipeline(mm_player_t *player)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
gint timeout = 0;
int ret = MM_ERROR_NONE;
- if (player->gapless.reconfigure) {
- LOGW("pipeline is under construction.\n");
+ if (!player->gapless.reconfigure)
+ return;
- MMPLAYER_PLAYBACK_LOCK(player);
- MMPLAYER_PLAYBACK_UNLOCK(player);
+ LOGW("pipeline is under construction.");
- timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
+ MMPLAYER_PLAYBACK_LOCK(player);
+ MMPLAYER_PLAYBACK_UNLOCK(player);
- /* wait for state transition */
- ret = gst_element_get_state(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &element_state, &element_pending_state, timeout * GST_SECOND);
+ timeout = MMPLAYER_STATE_CHANGE_TIMEOUT(player);
- if (ret == GST_STATE_CHANGE_FAILURE)
- LOGE("failed to change pipeline state within %d sec\n", timeout);
- }
+ /* wait for state transition */
+ ret = gst_element_get_state(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, &element_state, &element_pending_state, timeout * GST_SECOND);
+ if (ret == GST_STATE_CHANGE_FAILURE)
+ LOGE("failed to change pipeline state within %d sec", timeout);
}
/* NOTE : it should be able to call 'stop' anytime*/
int
_mmplayer_stop(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
ret = __mmplayer_gst_stop(player);
if (ret != MM_ERROR_NONE)
- LOGE("failed to stop player.\n");
+ LOGE("failed to stop player.");
MMPLAYER_FLEAVE();
int
_mmplayer_pause(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
gint64 pos_nsec = 0;
gboolean async = FALSE;
gint ret = MM_ERROR_NONE;
* elements
*/
if (!gst_element_query_position(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &pos_nsec))
- LOGW("getting current position failed in paused\n");
+ LOGW("getting current position failed in paused");
player->last_position = pos_nsec;
ret = __mmplayer_gst_pause(player, async);
if (ret != MM_ERROR_NONE)
- LOGE("failed to pause player. ret : 0x%x\n", ret);
+ LOGE("failed to pause player. ret : 0x%x", ret);
if (MMPLAYER_PREV_STATE(player) == MM_PLAYER_STATE_READY && MMPLAYER_CURRENT_STATE(player) == MM_PLAYER_STATE_PAUSED) {
if (MM_ERROR_NONE != _mmplayer_update_video_param(player, "display_rotation"))
int
_mmplayer_abort_pause(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
return ret;
}
-
int
_mmplayer_resume(MMHandleType hplayer)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
gboolean async = FALSE;
ret = __mmplayer_gst_resume(player, async);
if (ret != MM_ERROR_NONE)
- LOGE("failed to resume player.\n");
+ LOGE("failed to resume player.");
if ((player->streamer) && (player->streamer->buffering_state & MM_PLAYER_BUFFERING_IN_PROGRESS)) {
LOGD("force resume even during buffering");
int
_mmplayer_set_playspeed(MMHandleType hplayer, float rate, bool streaming)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
gint64 pos_nsec = 0;
int ret = MM_ERROR_NONE;
int mute = FALSE;
/* If the position is reached at start potion during fast backward, EOS is posted.
* So, This EOS have to be classified with it which is posted at reaching the end of stream.
- * */
+ */
player->playback_rate = rate;
current_state = MMPLAYER_CURRENT_STATE(player);
(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE),
GST_SEEK_TYPE_SET, start,
GST_SEEK_TYPE_SET, stop)) {
- LOGE("failed to set speed playback\n");
+ LOGE("failed to set speed playback");
return MM_ERROR_PLAYER_SEEK;
}
- LOGD("succeeded to set speed playback as %0.1f\n", rate);
+ LOGD("succeeded to set speed playback as %0.1f", rate);
MMPLAYER_FLEAVE();
int
_mmplayer_set_position(MMHandleType hplayer, gint64 position)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
int
_mmplayer_get_position(MMHandleType hplayer, gint64 *position)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_get_duration(MMHandleType hplayer, gint64 *duration)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_get_buffer_position(MMHandleType hplayer, int *start_pos, int *end_pos)
{
- mm_player_t *player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
int
_mmplayer_adjust_subtitle_postion(MMHandleType hplayer, int format, int position)
{
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
}
static gboolean
-__mmplayer_is_midi_type(gchar* str_caps)
+__mmplayer_is_midi_type(gchar *str_caps)
{
if ((g_strrstr(str_caps, "audio/midi")) ||
(g_strrstr(str_caps, "application/x-gst_ff-mmf")) ||
(g_strrstr(str_caps, "audio/mobile-xmf")) ||
(g_strrstr(str_caps, "audio/xmf")) ||
(g_strrstr(str_caps, "audio/mxmf"))) {
- LOGD("midi\n");
+ LOGD("midi");
return TRUE;
}
}
static void
-__mmplayer_set_audio_attrs(mm_player_t* player, GstCaps* caps)
+__mmplayer_set_audio_attrs(mm_player_t *player, GstCaps *caps)
{
- GstStructure* caps_structure = NULL;
+ GstStructure *caps_structure = NULL;
gint samplerate = 0;
gint channels = 0;
gst_structure_get_int(caps_structure, "channels", &channels);
mm_attrs_set_int_by_name(player->attrs, "content_audio_channels", channels);
- LOGD("audio samplerate : %d channels : %d\n", samplerate, channels);
+ LOGD("audio samplerate : %d channels : %d", samplerate, channels);
}
static void
-__mmplayer_update_content_type_info(mm_player_t* player)
+__mmplayer_update_content_type_info(mm_player_t *player)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player && player->type);
void
__mmplayer_typefind_have_type(GstElement *tf, guint probability,
-GstCaps *caps, gpointer data)
+ GstCaps *caps, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- GstPad* pad = NULL;
+ mm_player_t *player = (mm_player_t *)data;
+ GstPad *pad = NULL;
MMPLAYER_FENTER();
/* store type string */
MMPLAYER_FREEIF(player->type);
player->type = gst_caps_to_string(caps);
- if (player->type) {
- LOGD("[handle: %p] media type %s found, probability %d%% / %d\n",
+ if (player->type)
+ LOGD("[handle: %p] media type %s found, probability %d%% / %d",
player, player->type, probability, gst_caps_get_size(caps));
- }
if ((!MMPLAYER_IS_RTSP_STREAMING(player)) &&
(g_strrstr(player->type, "audio/x-raw-int"))) {
- LOGE("not support media format\n");
+ LOGE("not support media format");
if (player->msg_posted == FALSE) {
MMMessageParamType msg_param;
pad = gst_element_get_static_pad(tf, "src");
if (!pad) {
- LOGE("fail to get typefind src pad.\n");
+ LOGE("fail to get typefind src pad.");
return;
}
if (!__mmplayer_gst_create_decoder(player, pad, caps)) {
gboolean async = FALSE;
- LOGE("failed to autoplug %s\n", player->type);
+ LOGE("failed to autoplug %s", player->type);
mm_attrs_get_int_by_name(player->attrs, "profile_prepare_async", &async);
}
GstElement *
-__mmplayer_gst_make_decodebin(mm_player_t* player)
+__mmplayer_gst_make_decodebin(mm_player_t *player)
{
GstElement *decodebin = NULL;
decodebin = gst_element_factory_make("decodebin", NULL);
if (!decodebin) {
- LOGE("fail to create decodebin\n");
+ LOGE("fail to create decodebin");
goto ERROR;
}
return decodebin;
}
-static GstElement*
+static GstElement *
__mmplayer_gst_make_queue2(mm_player_t *player)
{
- GstElement* queue2 = NULL;
+ GstElement *queue2 = NULL;
gint64 dur_bytes = 0L;
guint max_buffer_size_bytes = 0;
MMPlayerGstElement *mainbin = NULL;
/* NOTE : in case of ts streaming, player cannot get the correct duration info *
* skip the pull mode(file or ring buffering) setting. */
if (!g_strrstr(player->type, "video/mpegts")) {
- max_buffer_size_bytes = (type == MUXED_BUFFER_TYPE_FILE) ? (player->ini.http_max_size_bytes) : (5*1024*1024);
+ max_buffer_size_bytes = (type == MUXED_BUFFER_TYPE_FILE) ? (player->ini.http_max_size_bytes) : (5 * 1024 * 1024);
LOGD("max_buffer_size_bytes = %d", max_buffer_size_bytes);
__mm_player_streaming_set_queue2(player->streamer,
}
gboolean
-__mmplayer_gst_create_decoder(mm_player_t* player, GstPad *srcpad, const GstCaps *caps)
+__mmplayer_gst_create_decoder(mm_player_t *player, GstPad *srcpad, const GstCaps *caps)
{
- MMPlayerGstElement* mainbin = NULL;
- GstElement* decodebin = NULL;
- GstElement* queue2 = NULL;
- GstPad* sinkpad = NULL;
- GstPad* qsrcpad = NULL;
+ MMPlayerGstElement *mainbin = NULL;
+ GstElement *decodebin = NULL;
+ GstElement *queue2 = NULL;
+ GstPad *sinkpad = NULL;
+ GstPad *qsrcpad = NULL;
gint init_buffering_time = player->streamer->buffering_req.prebuffer_time;
MMPLAYER_FENTER();
}
if (!gst_bin_add(GST_BIN(mainbin[MMPLAYER_M_PIPE].gst), decodebin)) {
- LOGE("failed to add decodebin\n");
+ LOGE("failed to add decodebin");
goto ERROR;
}
if (MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING(player) || MMPLAYER_IS_DASH_STREAMING(player)) {
gdouble high_percent = 0.0;
- init_buffering_time = (init_buffering_time != 0) ? (init_buffering_time) : (player->ini.http_buffering_time);
+ init_buffering_time = (init_buffering_time != 0) ? init_buffering_time : player->ini.http_buffering_time;
high_percent = (gdouble)(init_buffering_time * 100) / GET_MAX_BUFFER_TIME(player->streamer);
LOGD("decodebin setting - bytes: %d, time: %d ms, per: 1~%d",
}
if (GST_STATE_CHANGE_FAILURE == gst_element_sync_state_with_parent(decodebin)) {
- LOGE("failed to sync decodebin state with parent\n");
+ LOGE("failed to sync decodebin state with parent");
goto ERROR;
}
}
static int
-__mmplayer_check_not_supported_codec(mm_player_t* player, const gchar* factory_class, const gchar* mime)
+__mmplayer_check_not_supported_codec(mm_player_t *player, const gchar *factory_class, const gchar *mime)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(mime, MM_ERROR_INVALID_ARGUMENT);
- LOGD("class : %s, mime : %s \n", factory_class, mime);
+ LOGD("class : %s, mime : %s", factory_class, mime);
/* add missing plugin */
/* NOTE : msl should check missing plugin for image mime type.
*/
if (!(player->pipeline->mainbin[MMPLAYER_M_DEMUX].gst)) {
if (!(player->can_support_codec | player->videodec_linked | player->audiodec_linked)) {
- LOGD("not found demuxer\n");
+ LOGD("not found demuxer");
player->not_found_demuxer = TRUE;
player->unlinked_demuxer_mime = g_strdup_printf("%s", mime);
if (!g_strrstr(factory_class, "Demuxer")) {
if ((g_str_has_prefix(mime, "video")) || (g_str_has_prefix(mime, "image"))) {
- LOGD("can support codec=0x%X, vdec_linked=%d, adec_linked=%d\n",
+ LOGD("can support codec=0x%X, vdec_linked=%d, adec_linked=%d",
player->can_support_codec, player->videodec_linked, player->audiodec_linked);
/* check that clip have multi tracks or not */
if ((player->can_support_codec & FOUND_PLUGIN_VIDEO) && (player->videodec_linked)) {
- LOGD("video plugin is already linked\n");
+ LOGD("video plugin is already linked");
} else {
- LOGW("add VIDEO to missing plugin\n");
+ LOGW("add VIDEO to missing plugin");
player->not_supported_codec |= MISSING_PLUGIN_VIDEO;
player->unlinked_video_mime = g_strdup_printf("%s", mime);
}
} else if (g_str_has_prefix(mime, "audio")) {
if ((player->can_support_codec & FOUND_PLUGIN_AUDIO) && (player->audiodec_linked)) {
- LOGD("audio plugin is already linked\n");
+ LOGD("audio plugin is already linked");
} else {
- LOGW("add AUDIO to missing plugin\n");
+ LOGW("add AUDIO to missing plugin");
player->not_supported_codec |= MISSING_PLUGIN_AUDIO;
player->unlinked_audio_mime = g_strdup_printf("%s", mime);
}
return MM_ERROR_NONE;
}
-
static void
__mmplayer_pipeline_complete(GstElement *decodebin, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mm_player_t *player = (mm_player_t *)data;
MMPLAYER_FENTER();
LOGD("num of uri list = %d, current uri idx %d", num_of_list, uri_idx);
for (uri_idx++; uri_idx < num_of_list; uri_idx++) {
uri = g_list_nth_data(player->uri_info.uri_list, uri_idx);
- if (uri == NULL) {
+ if (!uri) {
LOGW("next uri does not exist");
continue;
}
- if (__mmplayer_parse_profile((const char*)uri, NULL, &profile) != MM_ERROR_NONE) {
+ if (__mmplayer_parse_profile((const char *)uri, NULL, &profile) != MM_ERROR_NONE) {
LOGE("failed to parse profile");
continue;
}
LOGD("checking for gapless play option");
if (player->pipeline->textbin) {
- LOGE("subtitle path is enabled. gapless play is not supported.\n");
+ LOGE("subtitle path is enabled. gapless play is not supported.");
goto ERROR;
}
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("fail to get attributes.\n");
+ LOGE("fail to get attributes.");
goto ERROR;
}
/* decrease play count */
/* we succeeded to rewind. update play count and then wait for next EOS */
count--;
-
mm_attrs_set_int_by_name(attrs, "profile_play_count", count);
-
/* commit attribute */
if (mm_attrs_commit_all(attrs))
LOGE("failed to commit attribute");
+
} else if (count != REPEAT_COUNT_INFINITELY) {
LOGD("there is no next uri and no repeat");
goto ERROR;
}
-
LOGD("looping cnt %d", count);
} else {
/* gapless playback path */
goto ERROR;
}
}
-
return TRUE;
ERROR:
player->is_external_subtitle_added_now = FALSE;
player->not_supported_codec = MISSING_PLUGIN_NONE;
player->can_support_codec = FOUND_PLUGIN_NONE;
- player->pending_seek.is_pending = FALSE;
+ player->pending_seek.is_pending = false;
player->pending_seek.pos = 0;
player->msg_posted = FALSE;
player->has_many_types = FALSE;
mm_attrs_get_string_by_name(attrs, "profile_uri", &uri);
- if (__mmplayer_parse_profile((const char*)uri, NULL, &player->profile) != MM_ERROR_NONE) {
+ if (__mmplayer_parse_profile((const char *)uri, NULL, &player->profile) != MM_ERROR_NONE) {
LOGE("failed to parse profile");
msg_param.code = MM_ERROR_PLAYER_INVALID_URI;
goto ERROR;
return;
}
-int _mmplayer_set_file_buffering_path(MMHandleType hplayer, const char* file_path)
+int
+_mmplayer_set_file_buffering_path(MMHandleType hplayer, const char *file_path)
{
int result = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if (file_path) {
- player->http_file_buffering_path = (gchar*)file_path;
- LOGD("temp file path: %s\n", player->http_file_buffering_path);
+ player->http_file_buffering_path = (gchar *)file_path;
+ LOGD("temp file path: %s", player->http_file_buffering_path);
}
MMPLAYER_FLEAVE();
return result;
}
-int _mmplayer_set_uri(MMHandleType hplayer, const char* uri)
+int
+_mmplayer_set_uri(MMHandleType hplayer, const char *uri)
{
int result = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
mm_attrs_set_string_by_name(player->attrs, "profile_uri", uri);
if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit the original uri.\n");
+ LOGE("failed to commit the original uri.");
result = MM_ERROR_PLAYER_INTERNAL;
} else {
if (_mmplayer_set_next_uri(hplayer, uri, TRUE) != MM_ERROR_NONE)
- LOGE("failed to add the original uri in the uri list.\n");
+ LOGE("failed to add the original uri in the uri list.");
}
MMPLAYER_FLEAVE();
return result;
}
-int _mmplayer_set_next_uri(MMHandleType hplayer, const char* uri, bool is_first_path)
+int
+_mmplayer_set_next_uri(MMHandleType hplayer, const char *uri, bool is_first_path)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
guint num_of_list = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(uri, MM_ERROR_INVALID_ARGUMENT);
if (player->pipeline && player->pipeline->textbin) {
- LOGE("subtitle path is enabled.\n");
+ LOGE("subtitle path is enabled.");
return MM_ERROR_PLAYER_INVALID_STATE;
}
num_of_list = g_list_length(player->uri_info.uri_list);
- if (is_first_path == TRUE) {
+ if (is_first_path) {
if (num_of_list == 0) {
player->uri_info.uri_list = g_list_append(player->uri_info.uri_list, g_strdup(uri));
LOGD("add original path : %s", uri);
return MM_ERROR_NONE;
}
-int _mmplayer_get_next_uri(MMHandleType hplayer, char** uri)
+int
+_mmplayer_get_next_uri(MMHandleType hplayer, char **uri)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
char *next_uri = NULL;
guint num_of_list = 0;
uri_idx = 0;
next_uri = g_list_nth_data(player->uri_info.uri_list, uri_idx);
- LOGE("next uri idx : %d, uri = %s\n", uri_idx, next_uri);
+ LOGE("next uri idx : %d, uri = %s", uri_idx, next_uri);
*uri = g_strdup(next_uri);
}
}
static void
-__mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad* pad,
-GstCaps *caps, gpointer data)
+__mmplayer_gst_decode_unknown_type(GstElement *elem, GstPad *pad,
+ GstCaps *caps, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- const gchar* klass = NULL;
- const gchar* mime = NULL;
- gchar* caps_str = NULL;
+ mm_player_t *player = (mm_player_t *)data;
+ const gchar *klass = NULL;
+ const gchar *mime = NULL;
+ gchar *caps_str = NULL;
klass = gst_element_factory_get_metadata(gst_element_get_factory(elem), GST_ELEMENT_METADATA_KLASS);
mime = gst_structure_get_name(gst_caps_get_structure(caps, 0));
}
static gboolean
-__mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad* pad,
-GstCaps * caps, gpointer data)
+__mmplayer_gst_decode_autoplug_continue(GstElement *bin, GstPad *pad,
+ GstCaps *caps, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- const char* mime = NULL;
+ mm_player_t *player = (mm_player_t *)data;
+ const char *mime = NULL;
gboolean ret = TRUE;
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
mime = gst_structure_get_name(gst_caps_get_structure(caps, 0));
if (g_str_has_prefix(mime, "audio")) {
- GstStructure* caps_structure = NULL;
+ GstStructure *caps_structure = NULL;
gint samplerate = 0;
gint channels = 0;
gchar *caps_str = NULL;
}
static int
-__mmplayer_check_codec_info(mm_player_t* player, const char* klass, GstCaps* caps, char* factory_name)
+__mmplayer_check_codec_info(mm_player_t *player, const char *klass, GstCaps *caps, char *factory_name)
{
int ret = MM_ERROR_NONE;
int idx = 0;
/* acquire resources for video playing */
if (mm_resource_manager_commit(player->resource_manager)
!= MM_RESOURCE_MANAGER_ERROR_NONE) {
- LOGE("could not acquire resources for video decoding\n");
+ LOGE("could not acquire resources for video decoding");
ret = MM_ERROR_PLAYER_INTERNAL;
goto DONE;
}
}
gint
-__mmplayer_gst_decode_autoplug_select(GstElement *bin, GstPad* pad,
-GstCaps* caps, GstElementFactory* factory, gpointer data)
+__mmplayer_gst_decode_autoplug_select(GstElement *bin, GstPad *pad,
+ GstCaps *caps, GstElementFactory *factory, gpointer data)
{
/* NOTE : GstAutoplugSelectResult is defined in gstplay-enum.h but not exposed
We are defining our own and will be removed when it actually exposed */
} GstAutoplugSelectResult;
GstAutoplugSelectResult result = GST_AUTOPLUG_SELECT_TRY;
- mm_player_t* player = (mm_player_t*)data;
+ mm_player_t *player = (mm_player_t *)data;
- gchar* factory_name = NULL;
- gchar* caps_str = NULL;
- const gchar* klass = NULL;
+ gchar *factory_name = NULL;
+ gchar *caps_str = NULL;
+ const gchar *klass = NULL;
gint idx = 0;
factory_name = GST_OBJECT_NAME(factory);
* So, those plugins should be skipped for error handling.
*/
if (g_strrstr(klass, "Codec/Decoder/Image")) {
- LOGD("skipping [%s] by not required\n", factory_name);
+ LOGD("skipping [%s] by not required", factory_name);
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
if ((MMPLAYER_IS_MS_BUFF_SRC(player)) &&
(g_strrstr(klass, "Codec/Demuxer") || (g_strrstr(klass, "Codec/Parser")))) {
// TO CHECK : subtitle if needed, add subparse exception.
- LOGD("skipping parser/demuxer [%s] in es player by not required\n", factory_name);
+ LOGD("skipping parser/demuxer [%s] in es player by not required", factory_name);
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
if (g_strrstr(factory_name, "mpegpsdemux")) {
- LOGD("skipping PS container - not support\n");
+ LOGD("skipping PS container - not support");
result = GST_AUTOPLUG_SELECT_SKIP;
goto DONE;
}
}
static void
-__mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad* new_pad,
-gpointer data)
+__mmplayer_gst_decode_pad_removed(GstElement *elem, GstPad *new_pad,
+ gpointer data)
{
- //mm_player_t* player = (mm_player_t*)data;
- GstCaps* caps = NULL;
+ //mm_player_t *player = (mm_player_t *)data;
+ GstCaps *caps = NULL;
- LOGD("[Decodebin2] pad-removed signal\n");
+ LOGD("[Decodebin2] pad-removed signal");
caps = gst_pad_query_caps(new_pad, NULL);
- if (caps) {
- gchar* caps_str = NULL;
- caps_str = gst_caps_to_string(caps);
+ if (!caps) {
+ LOGW("query caps is NULL");
+ return;
+ }
- LOGD("pad removed caps : %s from %s", caps_str, GST_ELEMENT_NAME(elem));
+ gchar *caps_str = NULL;
+ caps_str = gst_caps_to_string(caps);
- MMPLAYER_FREEIF(caps_str);
- gst_caps_unref(caps);
- }
+ LOGD("pad removed caps : %s from %s", caps_str, GST_ELEMENT_NAME(elem));
+
+ MMPLAYER_FREEIF(caps_str);
+ gst_caps_unref(caps);
}
static void
__mmplayer_gst_decode_drained(GstElement *bin, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
+ mm_player_t *player = (mm_player_t *)data;
GstIterator *iter = NULL;
GValue item = { 0, };
GstPad *pad = NULL;
void
__mmplayer_gst_element_added(GstElement *bin, GstElement *element, gpointer data)
{
- mm_player_t* player = (mm_player_t*)data;
- const gchar* klass = NULL;
- gchar* factory_name = NULL;
+ mm_player_t *player = (mm_player_t *)data;
+ const gchar *klass = NULL;
+ gchar *factory_name = NULL;
klass = gst_element_factory_get_metadata(gst_element_get_factory(element), GST_ELEMENT_METADATA_KLASS);
factory_name = GST_OBJECT_NAME(gst_element_get_factory(element));
- LOGD("new elem klass: %s, factory_name: %s, new elem name : %s\n", klass, factory_name, GST_ELEMENT_NAME(element));
+ LOGD("new elem klass: %s, factory_name: %s, new elem name : %s", klass, factory_name, GST_ELEMENT_NAME(element));
if (__mmplayer_add_dump_buffer_probe(player, element))
LOGD("add buffer probe");
//<-
if (g_strrstr(klass, "Codec/Decoder/Audio")) {
- gchar* selected = NULL;
+ gchar *selected = NULL;
selected = g_strdup(GST_ELEMENT_NAME(element));
player->audio_decoders = g_list_append(player->audio_decoders, selected);
}
//-> temp code
if (g_strrstr(klass, "Parser")) {
- gchar* selected = NULL;
+ gchar *selected = NULL;
selected = g_strdup(factory_name);
player->parsers = g_list_append(player->parsers, selected);
// to support trust-zone only
if (g_strrstr(factory_name, "asfdemux")) {
- LOGD("set file-location %s\n", player->profile.uri);
+ LOGD("set file-location %s", player->profile.uri);
g_object_set(G_OBJECT(element), "file-location", player->profile.uri, NULL);
} else if (g_strrstr(factory_name, "legacyh264parse")) {
- LOGD("[%s] output-format to legacyh264parse\n", "mssdemux");
+ LOGD("[%s] output-format to legacyh264parse", "mssdemux");
g_object_set(G_OBJECT(element), "output-format", 1, NULL); /* NALU/Byte Stream format */
} else if (g_strrstr(factory_name, "mpegaudioparse")) {
if ((MMPLAYER_IS_HTTP_STREAMING(player)) &&
}
static void
-__mmplayer_release_misc(mm_player_t* player)
+__mmplayer_release_misc(mm_player_t *player)
{
int i;
bool cur_mode = player->set_mode.rich_audio;
player->video_stream_cb = NULL;
player->video_stream_cb_user_param = NULL;
- player->video_stream_prerolled = FALSE;
+ player->video_stream_prerolled = false;
player->audio_stream_render_cb = NULL;
player->audio_stream_cb_user_param = NULL;
player->http_content_size = 0;
player->not_supported_codec = MISSING_PLUGIN_NONE;
player->can_support_codec = FOUND_PLUGIN_NONE;
- player->pending_seek.is_pending = FALSE;
+ player->pending_seek.is_pending = false;
player->pending_seek.pos = 0;
player->msg_posted = FALSE;
player->has_many_types = FALSE;
}
static void
-__mmplayer_release_misc_post(mm_player_t* player)
+__mmplayer_release_misc_post(mm_player_t *player)
{
char *original_uri = NULL;
MMPLAYER_FENTER();
if (player->attrs) {
mm_attrs_set_string_by_name(player->attrs, "profile_uri", original_uri);
- LOGD("restore original uri = %s\n", original_uri);
+ LOGD("restore original uri = %s", original_uri);
if (mm_attrs_commit_all(player->attrs))
- LOGE("failed to commit the original uri.\n");
+ LOGE("failed to commit the original uri.");
}
GList *uri_list = player->uri_info.uri_list;
}
gboolean
-__mmplayer_check_subtitle(mm_player_t* player)
+__mmplayer_check_subtitle(mm_player_t *player)
{
MMHandleType attrs = 0;
char *subtitle_uri = NULL;
}
void
-__mmplayer_cancel_eos_timer(mm_player_t* player)
+__mmplayer_cancel_eos_timer(mm_player_t *player)
{
MMPLAYER_RETURN_IF_FAIL(player);
}
static void
-__mmplayer_add_sink(mm_player_t* player, GstElement* sink)
+__mmplayer_add_sink(mm_player_t *player, GstElement *sink)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
MMPLAYER_RETURN_IF_FAIL(sink);
- player->sink_elements =
- g_list_append(player->sink_elements, sink);
+ player->sink_elements = g_list_append(player->sink_elements, sink);
MMPLAYER_FLEAVE();
}
static void
-__mmplayer_del_sink(mm_player_t* player, GstElement* sink)
+__mmplayer_del_sink(mm_player_t *player, GstElement *sink)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
MMPLAYER_RETURN_IF_FAIL(sink);
- player->sink_elements =
- g_list_remove(player->sink_elements, sink);
+ player->sink_elements = g_list_remove(player->sink_elements, sink);
MMPLAYER_FLEAVE();
}
void
-__mmplayer_add_signal_connection(mm_player_t* player, GObject* object,
- MMPlayerSignalType type, const gchar* signal, GCallback cb_funct, gpointer u_data)
+__mmplayer_add_signal_connection(mm_player_t *player, GObject *object,
+ MMPlayerSignalType type, const gchar *signal, GCallback cb_funct, gpointer u_data)
{
- MMPlayerSignalItem* item = NULL;
+ MMPlayerSignalItem *item = NULL;
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(player);
return;
}
- item = (MMPlayerSignalItem*)g_malloc(sizeof(MMPlayerSignalItem));
+ item = (MMPlayerSignalItem *)g_try_malloc(sizeof(MMPlayerSignalItem));
if (!item) {
LOGE("cannot connect signal [%s]", signal);
return;
* g_signal_handler_disconnect(instance, id);
*/
static void
-__mmplayer_release_signal_connection(mm_player_t* player, MMPlayerSignalType type)
+__mmplayer_release_signal_connection(mm_player_t *player, MMPlayerSignalType type)
{
- GList* sig_list = NULL;
- MMPlayerSignalItem* item = NULL;
+ GList *sig_list = NULL;
+ MMPlayerSignalItem *item = NULL;
MMPLAYER_FENTER();
return;
}
-int _mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay)
+int
+_mmplayer_change_videosink(MMHandleType handle, MMDisplaySurfaceType surface_type, void *display_overlay)
{
- mm_player_t* player = 0;
+ mm_player_t *player = 0;
int prev_display_surface_type = 0;
void *prev_display_overlay = NULL;
}
/* Note : if silent is true, then subtitle would not be displayed. :*/
-int _mmplayer_set_subtitle_silent(MMHandleType hplayer, int silent)
+int
+_mmplayer_set_subtitle_silent(MMHandleType hplayer, int silent)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
player->set_mode.subtitle_off = silent;
- LOGD("subtitle is %s.\n", player->set_mode.subtitle_off ? "ON" : "OFF");
+ LOGD("subtitle is %s.", player->set_mode.subtitle_off ? "ON" : "OFF");
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-int _mmplayer_sync_subtitle_pipeline(mm_player_t* player)
+int
+_mmplayer_sync_subtitle_pipeline(mm_player_t *player)
{
- MMPlayerGstElement* mainbin = NULL;
- MMPlayerGstElement* textbin = NULL;
+ MMPlayerGstElement *mainbin = NULL;
+ MMPlayerGstElement *textbin = NULL;
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
GstState current_state = GST_STATE_VOID_PENDING;
GstState element_state = GST_STATE_VOID_PENDING;
ret = gst_element_get_state(mainbin[MMPLAYER_M_SUBSRC].gst, &element_state, &element_pending_state, 5 * GST_SECOND);
if (GST_STATE_CHANGE_FAILURE == ret) {
- LOGE("fail to state change.\n");
+ LOGE("fail to state change.");
result = MM_ERROR_PLAYER_INTERNAL;
goto ERROR;
}
// seek to current position
if (!gst_element_query_position(mainbin[MMPLAYER_M_PIPE].gst, GST_FORMAT_TIME, &time)) {
result = MM_ERROR_PLAYER_INVALID_STATE;
- LOGE("gst_element_query_position failed, invalid state\n");
+ LOGE("gst_element_query_position failed, invalid state");
goto ERROR;
}
}
static int
-__mmplayer_change_external_subtitle_language(mm_player_t* player, const char* filepath)
+__mmplayer_change_external_subtitle_language(mm_player_t *player, const char *filepath)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_FAILURE;
GstState current_state = GST_STATE_VOID_PENDING;
MMHandleType attrs = 0;
- MMPlayerGstElement* mainbin = NULL;
- MMPlayerGstElement* textbin = NULL;
+ MMPlayerGstElement *mainbin = NULL;
+ MMPlayerGstElement *textbin = NULL;
- gchar* subtitle_uri = NULL;
+ gchar *subtitle_uri = NULL;
int result = MM_ERROR_NONE;
const gchar *charset = NULL;
current_state = GST_STATE(mainbin[MMPLAYER_M_PIPE].gst);
if (current_state < GST_STATE_READY) {
result = MM_ERROR_PLAYER_INVALID_STATE;
- LOGE("Pipeline is not in proper state\n");
+ LOGE("Pipeline is not in proper state");
goto EXIT;
}
attrs = MMPLAYER_GET_ATTRS(player);
if (!attrs) {
- LOGE("cannot get content attribute\n");
+ LOGE("cannot get content attribute");
result = MM_ERROR_PLAYER_INTERNAL;
goto EXIT;
}
mm_attrs_get_string_by_name(attrs, "subtitle_uri", &subtitle_uri);
if (!subtitle_uri || strlen(subtitle_uri) < 1) {
- LOGE("subtitle uri is not proper filepath\n");
+ LOGE("subtitle uri is not proper filepath");
result = MM_ERROR_PLAYER_INVALID_URI;
goto EXIT;
}
goto EXIT;
}
- LOGD("old subtitle file path is [%s]\n", subtitle_uri);
- LOGD("new subtitle file path is [%s]\n", filepath);
+ LOGD("old subtitle file path is [%s]", subtitle_uri);
+ LOGD("new subtitle file path is [%s]", filepath);
if (!strcmp(filepath, subtitle_uri)) {
- LOGD("No need to swtich subtitle, as input filepath is same as current filepath\n");
+ LOGD("No need to swtich subtitle, as input filepath is same as current filepath");
goto EXIT;
} else {
mm_attrs_set_string_by_name(player->attrs, "subtitle_uri", filepath);
if (mm_attrs_commit_all(player->attrs)) {
- LOGE("failed to commit.\n");
+ LOGE("failed to commit.");
goto EXIT;
}
}
charset = util_get_charset(filepath);
if (charset) {
- LOGD("detected charset is %s\n", charset);
+ LOGD("detected charset is %s", charset);
g_object_set(G_OBJECT(mainbin[MMPLAYER_M_SUBPARSE].gst), "subtitle-encoding", charset, NULL);
}
}
/* API to switch between external subtitles */
-int _mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char* filepath)
+int
+_mmplayer_set_external_subtitle_path(MMHandleType hplayer, const char *filepath)
{
int result = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
char *path = NULL;
MMPLAYER_FENTER();
}
static int
-__mmplayer_change_selector_pad(mm_player_t* player, MMPlayerTrackType type, int index)
+__mmplayer_change_selector_pad(mm_player_t *player, MMPlayerTrackType type, int index)
{
int result = MM_ERROR_NONE;
- gchar* change_pad_name = NULL;
- GstPad* sinkpad = NULL;
- MMPlayerGstElement* mainbin = NULL;
+ gchar *change_pad_name = NULL;
+ GstPad *sinkpad = NULL;
+ MMPlayerGstElement *mainbin = NULL;
enum MainElementID elem_idx = MMPLAYER_M_NUM;
- GstCaps* caps = NULL;
+ GstCaps *caps = NULL;
gint total_track_num = 0;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player && player->pipeline && player->pipeline->mainbin,
MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD("Change Track(%d) to %d\n", type, index);
+ LOGD("Change Track(%d) to %d", type, index);
mainbin = player->pipeline->mainbin;
elem_idx = MMPLAYER_M_T_INPUT_SELECTOR;
} else {
/* Changing Video Track is not supported. */
- LOGE("Track Type Error\n");
+ LOGE("Track Type Error");
goto EXIT;
}
if (mainbin[elem_idx].gst == NULL) {
result = MM_ERROR_PLAYER_NO_OP;
- LOGD("Req track doesn't exist\n");
+ LOGD("Req track doesn't exist");
goto EXIT;
}
total_track_num = player->selector[type].total_track_num;
if (total_track_num <= 0) {
result = MM_ERROR_PLAYER_NO_OP;
- LOGD("Language list is not available \n");
+ LOGD("Language list is not available");
goto EXIT;
}
if ((index < 0) || (index >= total_track_num)) {
result = MM_ERROR_INVALID_ARGUMENT;
- LOGD("Not a proper index : %d \n", index);
+ LOGD("Not a proper index : %d", index);
goto EXIT;
}
change_pad_name = g_strdup_printf("sink_%u", index);
if (change_pad_name == NULL) {
result = MM_ERROR_PLAYER_INTERNAL;
- LOGD("Pad does not exists\n");
+ LOGD("Pad does not exists");
goto EXIT;
}
- LOGD("new active pad name: %s\n", change_pad_name);
+ LOGD("new active pad name: %s", change_pad_name);
sinkpad = gst_element_get_static_pad(mainbin[elem_idx].gst, change_pad_name);
if (sinkpad == NULL) {
goto EXIT;
}
- LOGD("Set Active Pad - %s:%s\n", GST_DEBUG_PAD_NAME(sinkpad));
+ LOGD("Set Active Pad - %s:%s", GST_DEBUG_PAD_NAME(sinkpad));
g_object_set(mainbin[elem_idx].gst, "active-pad", sinkpad, NULL);
caps = gst_pad_get_current_caps(sinkpad);
__mmplayer_set_audio_attrs(player, caps);
EXIT:
-
MMPLAYER_FREEIF(change_pad_name);
return result;
}
-int _mmplayer_change_track_language(MMHandleType hplayer, MMPlayerTrackType type, int index)
+int
+ _mmplayer_change_track_language(MMHandleType hplayer, MMPlayerTrackType type, int index)
{
int result = MM_ERROR_NONE;
- mm_player_t* player = NULL;
- MMPlayerGstElement* mainbin = NULL;
+ mm_player_t *player = NULL;
+ MMPlayerGstElement *mainbin = NULL;
gint current_active_index = 0;
GstState current_state = GST_STATE_VOID_PENDING;
- GstEvent* event = NULL;
+ GstEvent *event = NULL;
gint64 time = 0;
MMPLAYER_FENTER();
- player = (mm_player_t*)hplayer;
+ player = (mm_player_t *)hplayer;
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if (!player->pipeline) {
- LOGE("Track %d pre setting -> %d\n", type, index);
+ LOGE("Track %d pre setting -> %d", type, index);
player->selector[type].active_pad_index = index;
goto EXIT;
current_state = GST_STATE(mainbin[MMPLAYER_M_PIPE].gst);
if (current_state < GST_STATE_PAUSED) {
result = MM_ERROR_PLAYER_INVALID_STATE;
- LOGW("Pipeline not in porper state\n");
+ LOGW("Pipeline not in porper state");
goto EXIT;
}
result = __mmplayer_change_selector_pad(player, type, index);
if (result != MM_ERROR_NONE) {
- LOGE("change selector pad error\n");
+ LOGE("change selector pad error");
goto EXIT;
}
player->selector[type].active_pad_index = index;
if (current_state == GST_STATE_PLAYING) {
- event = gst_event_new_seek(player->playback_rate, GST_FORMAT_TIME, (GstSeekFlags)(GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP), GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
+ event = gst_event_new_seek(player->playback_rate, GST_FORMAT_TIME,
+ (GstSeekFlags)(GST_SEEK_FLAG_SEGMENT | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP),
+ GST_SEEK_TYPE_SET, time, GST_SEEK_TYPE_NONE, -1);
if (event) {
__mmplayer_gst_send_event_to_sink(player, event);
} else {
return result;
}
-int _mmplayer_get_subtitle_silent(MMHandleType hplayer, int* silent)
+int
+_mmplayer_get_subtitle_silent(MMHandleType hplayer, int *silent)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
*silent = player->set_mode.subtitle_off;
- LOGD("subtitle is %s.\n", silent ? "ON" : "OFF");
+ LOGD("subtitle is %s.", silent ? "ON" : "OFF");
MMPLAYER_FLEAVE();
if (g_strrstr(factory_name, player->ini.dump_element_keyword[idx])) {
LOGD("dump [%s] sink pad", player->ini.dump_element_keyword[idx]);
mm_player_dump_t *dump_s;
- dump_s = g_malloc(sizeof(mm_player_dump_t));
-
+ dump_s = g_try_malloc(sizeof(mm_player_dump_t));
if (dump_s == NULL) {
LOGE("malloc fail");
return FALSE;
dump_s->dump_pad = gst_element_get_static_pad(element, "sink");
if (dump_s->dump_pad) {
- memset(dump_file_name, 0x00, PLAYER_INI_MAX_STRLEN*2);
- snprintf(dump_file_name, PLAYER_INI_MAX_STRLEN*2, "%s/%s_sink_pad.dump", player->ini.dump_element_path, player->ini.dump_element_keyword[idx]);
+ memset(dump_file_name, 0x00, PLAYER_INI_MAX_STRLEN * 2);
+ snprintf(dump_file_name, PLAYER_INI_MAX_STRLEN * 2, "%s/%s_sink_pad.dump", player->ini.dump_element_path, player->ini.dump_element_keyword[idx]);
dump_s->dump_element_file = fopen(dump_file_name, "w+");
dump_s->probe_handle_id = gst_pad_add_probe(dump_s->dump_pad, GST_PAD_PROBE_TYPE_BUFFER, __mmplayer_dump_buffer_probe_cb, dump_s->dump_element_file, NULL);
/* add list for removed buffer probe and close FILE */
LOGD("%s sink pad added buffer probe for dump", factory_name);
return TRUE;
} else {
- g_free(dump_s);
- dump_s = NULL;
+ MMPLAYER_FREEIF(dump_s);
LOGE("failed to get %s sink pad added", factory_name);
}
}
static GstPadProbeReturn
__mmplayer_dump_buffer_probe_cb(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
- FILE *dump_data = (FILE *) u_data;
+ FILE *dump_data = (FILE *)u_data;
// int written = 0;
GstBuffer *buffer = gst_pad_probe_info_get_buffer(info);
GstMapInfo probe_info = GST_MAP_INFO_INIT;
- MMPLAYER_RETURN_VAL_IF_FAIL(dump_data, FALSE);
+ MMPLAYER_RETURN_VAL_IF_FAIL(dump_data, GST_PAD_PROBE_PASS);
gst_buffer_map(buffer, &probe_info, GST_MAP_READ);
static void
__mmplayer_release_dump_list(GList *dump_list)
{
- if (dump_list) {
- GList *d_list = dump_list;
- for (; d_list; d_list = g_list_next(d_list)) {
- mm_player_dump_t *dump_s = d_list->data;
- if (dump_s->dump_pad) {
- if (dump_s->probe_handle_id)
- gst_pad_remove_probe(dump_s->dump_pad, dump_s->probe_handle_id);
- }
- if (dump_s->dump_element_file) {
- fclose(dump_s->dump_element_file);
- dump_s->dump_element_file = NULL;
- }
- MMPLAYER_FREEIF(dump_s);
+ GList *d_list = dump_list;
+
+ if (!d_list)
+ return;
+
+ for (; d_list; d_list = g_list_next(d_list)) {
+ mm_player_dump_t *dump_s = d_list->data;
+ if (dump_s->dump_pad) {
+ if (dump_s->probe_handle_id)
+ gst_pad_remove_probe(dump_s->dump_pad, dump_s->probe_handle_id);
+ }
+ if (dump_s->dump_element_file) {
+ fclose(dump_s->dump_element_file);
+ dump_s->dump_element_file = NULL;
}
- g_list_free(dump_list);
- dump_list = NULL;
+ MMPLAYER_FREEIF(dump_s);
}
+ g_list_free(dump_list);
+ dump_list = NULL;
}
int
-_mmplayer_has_closed_caption(MMHandleType hplayer, bool* exist)
+_mmplayer_has_closed_caption(MMHandleType hplayer, bool *exist)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
MMPLAYER_RETURN_VAL_IF_FAIL(exist, MM_ERROR_INVALID_ARGUMENT);
- *exist = player->has_closed_caption;
+ *exist = (bool)player->has_closed_caption;
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
-void _mm_player_video_stream_internal_buffer_unref(void *buffer)
+void
+_mm_player_video_stream_internal_buffer_unref(void *buffer)
{
MMPLAYER_FENTER();
if (buffer) {
MMPLAYER_FLEAVE();
}
-int _mmplayer_get_timeout(MMHandleType hplayer, int *timeout)
+int
+_mmplayer_get_timeout(MMHandleType hplayer, int *timeout)
{
- mm_player_t *player = (mm_player_t *) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(timeout, MM_ERROR_COMMON_INVALID_ARGUMENT);
if (MMPLAYER_IS_STREAMING(player))
- *timeout = player->ini.live_state_change_timeout;
+ *timeout = (int)player->ini.live_state_change_timeout;
else
- *timeout = player->ini.localplayback_state_change_timeout;
+ *timeout = (int)player->ini.localplayback_state_change_timeout;
LOGD("timeout = %d", *timeout);
return MM_ERROR_NONE;
}
-int _mmplayer_get_num_of_video_out_buffers(MMHandleType hplayer, int *num, int *extra_num)
+int
+_mmplayer_get_num_of_video_out_buffers(MMHandleType hplayer, int *num, int *extra_num)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
*num = player->video_num_buffers;
*extra_num = player->video_extra_num_buffers;
- LOGD("state %d, num %d(%d)\n", MMPLAYER_CURRENT_STATE(player), *num, *extra_num);
+ LOGD("state %d, num %d(%d)", MMPLAYER_CURRENT_STATE(player), *num, *extra_num);
MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
static void
-__mmplayer_initialize_storage_info(mm_player_t* player, MMPlayerPathType path_type)
+__mmplayer_initialize_storage_info(mm_player_t *player, MMPlayerPathType path_type)
{
int i = 0;
MMPLAYER_FENTER();
MMPLAYER_FLEAVE();
}
-int _mmplayer_manage_external_storage_state(MMHandleType hplayer, int id, int state)
+int
+_mmplayer_manage_external_storage_state(MMHandleType hplayer, int id, int state)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*)hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMMessageParamType msg_param = {0, };
MMPLAYER_FENTER();
return MM_ERROR_NONE;
/* FIXME: text path should be handled seperately. */
- if (((player->storage_info[MMPLAYER_PATH_VOD].type == STORAGE_TYPE_EXTERNAL) && (player->storage_info[MMPLAYER_PATH_VOD].id == id)) ||
- ((player->storage_info[MMPLAYER_PATH_TEXT].type == STORAGE_TYPE_EXTERNAL) && (player->storage_info[MMPLAYER_PATH_TEXT].id == id))) {
+ if (((player->storage_info[MMPLAYER_PATH_VOD].type == STORAGE_TYPE_EXTERNAL)
+ && (player->storage_info[MMPLAYER_PATH_VOD].id == id)) ||
+ ((player->storage_info[MMPLAYER_PATH_TEXT].type == STORAGE_TYPE_EXTERNAL)
+ && (player->storage_info[MMPLAYER_PATH_TEXT].id == id))) {
LOGW("external storage is removed");
if (player->msg_posted == FALSE) {
return ret;
}
-int _mmplayer_get_adaptive_variant_info(MMHandleType hplayer, int *num, char **var_info)
+int
+_mmplayer_get_adaptive_variant_info(MMHandleType hplayer, int *num, char **var_info)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int idx = 0, total = 0;
gchar *result = NULL, *tmp = NULL;
return ret;
}
-int _mmplayer_set_max_adaptive_variant_limit(MMHandleType hplayer, int bandwidth, int width, int height)
+int
+_mmplayer_set_max_adaptive_variant_limit(MMHandleType hplayer, int bandwidth, int width, int height)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
-int _mmplayer_get_max_adaptive_variant_limit(MMHandleType hplayer, int *bandwidth, int *width, int *height)
+int
+_mmplayer_get_max_adaptive_variant_limit(MMHandleType hplayer, int *bandwidth, int *width, int *height)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
return ret;
}
-int _mmplayer_set_streaming_buffering_time(MMHandleType hplayer, int buffer_ms, int rebuffer_ms)
+int
+_mmplayer_set_streaming_buffering_time(MMHandleType hplayer, int buffer_ms, int rebuffer_ms)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
}
-int _mmplayer_get_streaming_buffering_time(MMHandleType hplayer, int *buffer_ms, int *rebuffer_ms)
+int
+_mmplayer_get_streaming_buffering_time(MMHandleType hplayer, int *buffer_ms, int *rebuffer_ms)
{
int ret = MM_ERROR_NONE;
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMPLAYER_FENTER();
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
return ret;
}
-int _mmplayer_set_codec_type(MMHandleType hplayer, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type)
+int
+_mmplayer_set_codec_type(MMHandleType hplayer, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type)
{
#define IDX_FIRST_SW_CODEC 0
- mm_player_t* player = (mm_player_t*) hplayer;
- const char* attr_name = (stream_type == MM_PLAYER_STREAM_TYPE_AUDIO) ? (MM_PLAYER_AUDIO_CODEC_TYPE) : (MM_PLAYER_VIDEO_CODEC_TYPE);
+ mm_player_t *player = (mm_player_t *)hplayer;
+ const char *attr_name = (stream_type == MM_PLAYER_STREAM_TYPE_AUDIO) ? (MM_PLAYER_AUDIO_CODEC_TYPE) : (MM_PLAYER_VIDEO_CODEC_TYPE);
MMHandleType attrs = 0;
MMPLAYER_FENTER();
int
_mmplayer_set_replaygain_enabled(MMHandleType hplayer, bool enabled)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* rg_vol_element = NULL;
+ mm_player_t *player = (mm_player_t *)hplayer;
+ GstElement *rg_vol_element = NULL;
MMPLAYER_FENTER();
/* just hold rgvolume enable value if pipeline is not ready */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. holding rgvolume enable value\n");
+ LOGD("pipeline is not ready. holding rgvolume enable value");
return MM_ERROR_NONE;
}
int
_mmplayer_is_replaygain_enabled(MMHandleType hplayer, bool *enabled)
{
- mm_player_t* player = (mm_player_t*) hplayer;
- GstElement* rg_vol_element = NULL;
+ mm_player_t *player = (mm_player_t *)hplayer;
+ GstElement *rg_vol_element = NULL;
gboolean enable = FALSE;
MMPLAYER_FENTER();
/* just hold enable_rg value if pipeline is not ready */
if (!player->pipeline || !player->pipeline->audiobin) {
- LOGD("pipeline is not ready. holding rgvolume value (%d)\n", player->sound.rg_enable);
+ LOGD("pipeline is not ready. holding rgvolume value (%d)", player->sound.rg_enable);
*enabled = player->sound.rg_enable;
return MM_ERROR_NONE;
}
}
g_object_get(rg_vol_element, "enable-rgvolume", &enable, NULL);
- *enabled = enable;
+ *enabled = (bool)enable;
MMPLAYER_FLEAVE();
int
_mmplayer_set_video_roi_area(MMHandleType hplayer, double scale_x, double scale_y, double scale_width, double scale_height)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
MMHandleType attrs = 0;
void *handle = NULL;
int ret = MM_ERROR_NONE;
int
_mmplayer_get_video_roi_area(MMHandleType hplayer, double *scale_x, double *scale_y, double *scale_width, double *scale_height)
{
- mm_player_t* player = (mm_player_t*) hplayer;
+ mm_player_t *player = (mm_player_t *)hplayer;
int ret = MM_ERROR_NONE;
MMPLAYER_FENTER();
player->streaming_type = __mmplayer_get_stream_service_type(player);
/* check duration is OK */
- if (dur_nsec == 0 && !MMPLAYER_IS_LIVE_STREAMING(player)) {
+ if (dur_nsec == 0 && !MMPLAYER_IS_LIVE_STREAMING(player))
/* FIXIT : find another way to get duration here. */
LOGW("finally it's failed to get duration from pipeline. progressbar will not work correctely!");
- }
return ret;
}
decoder. Below code only valid when we are not using 'resampler' just before
'audioconverter'. */
GstCaps *caps_a = NULL;
- GstPad* pad = NULL;
+ GstPad *pad = NULL;
gint samplerate = 0, channels = 0;
- GstStructure* p = NULL;
+ GstStructure *p = NULL;
LOGD("try to update audio attrs");
}
caps_a = gst_pad_get_current_caps(pad);
-
if (!caps_a) {
LOGW("not ready to get audio caps");
gst_object_unref(pad);
LOGD("try to update video attrs");
GstCaps *caps_v = NULL;
- GstPad* pad = NULL;
+ GstPad *pad = NULL;
gint tmpNu, tmpDe;
gint width, height;
- GstStructure* p = NULL;
+ GstStructure *p = NULL;
MMPLAYER_RETURN_VAL_IF_FAIL(player->pipeline->videobin, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(player->pipeline->videobin[MMPLAYER_V_SINK].gst, FALSE);
return ret;
}
+
static void
-__mmplayer_copy_uri_and_set_type(MMPlayerParseProfile* data, const char *uri, int uri_type)
+__mmplayer_copy_uri_and_set_type(MMPlayerParseProfile *data, const char *uri, int uri_type)
{
strncpy(data->uri, uri, MM_MAX_URL_LEN - 1);
data->uri_type = uri_type;
}
+
static int
-__mmplayer_set_mem_uri(MMPlayerParseProfile* data, char *path, void *param)
+__mmplayer_set_mem_uri(MMPlayerParseProfile *data, char *path, void *param)
{
int ret = MM_ERROR_PLAYER_INVALID_URI;
int mem_size = 0;
}
}
- LOGD("ext: %s, mem_size: %d, mmap(param): %p\n", ext, mem_size, param);
+ LOGD("ext: %s, mem_size: %d, mmap(param): %p", ext, mem_size, param);
if (mem_size && param) {
if (data->input_mem.buf)
}
static int
-__mmplayer_set_file_uri(MMPlayerParseProfile* data, const char *uri)
+__mmplayer_set_file_uri(MMPlayerParseProfile *data, const char *uri)
{
gchar *location = NULL;
GError *err = NULL;
(err != NULL) ? err->message : "unknown error");
if (err)
g_error_free(err);
- if (location)
- g_free(location);
+
+ MMPLAYER_FREEIF(location);
data->uri_type = MM_PLAYER_URI_TYPE_NONE;
return MM_ERROR_PLAYER_INVALID_URI;
if (ret == MM_ERROR_NONE) {
g_snprintf(data->uri, MM_MAX_URL_LEN, "file://%s", path);
if (util_is_sdp_file(path)) {
- LOGD("uri is actually a file but it's sdp file. giving it to rtspsrc\n");
+ LOGD("uri is actually a file but it's sdp file. giving it to rtspsrc");
data->uri_type = MM_PLAYER_URI_TYPE_URL_RTSP;
} else {
data->uri_type = MM_PLAYER_URI_TYPE_FILE;
} else if (ret == MM_ERROR_PLAYER_PERMISSION_DENIED) {
data->uri_type = MM_PLAYER_URI_TYPE_NO_PERMISSION;
} else {
- LOGE("invalid uri, could not play..\n");
+ LOGE("invalid uri, could not play..");
data->uri_type = MM_PLAYER_URI_TYPE_NONE;
}
- if (location)
- g_free(location);
+ MMPLAYER_FREEIF(location);
return ret;
}
-static MMPlayerVideoStreamDataType*
+static MMPlayerVideoStreamDataType *
__mmplayer_create_stream_from_pad(GstPad *pad)
{
GstCaps *caps = NULL;
return NULL;
}
- stream = (MMPlayerVideoStreamDataType *)g_malloc0(sizeof(MMPlayerVideoStreamDataType));
+ stream = (MMPlayerVideoStreamDataType *)g_try_malloc0(sizeof(MMPlayerVideoStreamDataType));
if (!stream) {
LOGE("failed to alloc mem for video data");
return NULL;
mm_attrs_set_string_by_name(player->attrs, "content_audio_codec", audio_codec);
if (mm_attrs_commit_all(player->attrs))
- LOGE("failed to update attributes\n");
+ LOGE("failed to update attributes");
- LOGD("set audio codec type with caps\n");
+ LOGD("set audio codec type with caps");
}
return;
projects / platform / core / multimedia / libmm-player.git / blobdiff