/*
* libmm-player
*
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ * Copyright(c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
* Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
*
- * Licensed under the Apache License, Version 2.0 (the "License");
+ * Licensed under the Apache License, Version 2.0(the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static GstPadProbeReturn __mmplayer_video_capture_probe (GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
+static GstPadProbeReturn __mmplayer_video_capture_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data);
static int __mmplayer_get_video_frame_from_buffer(mm_player_t* player, GstPad *pad, GstBuffer *buffer);
static gpointer __mmplayer_capture_thread(gpointer data);
static void __csc_tiled_to_linear_crop(unsigned char *yuv420_dest, unsigned char *nv12t_src, int yuv420_width, int yuv420_height, int left, int top, int right, int buttom);
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
-| |
+| |
========================================================================================== */
int
_mmplayer_initialize_video_capture(mm_player_t* player)
{
int ret = MM_ERROR_NONE;
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* create capture mutex */
g_mutex_init(&player->capture_thread_mutex);
/* create video capture thread */
player->capture_thread =
- g_thread_try_new ("capture_thread",__mmplayer_capture_thread, (gpointer)player, NULL);
+ g_thread_try_new("capture_thread", __mmplayer_capture_thread, (gpointer)player, NULL);
- if ( ! player->capture_thread )
- {
+ if (!player->capture_thread) {
ret = MM_ERROR_PLAYER_RESOURCE_LIMIT;
goto ERROR;
}
ERROR:
/* capture thread */
- g_mutex_clear(&player->capture_thread_mutex );
+ g_mutex_clear(&player->capture_thread_mutex);
- g_cond_clear (&player->capture_thread_cond );
+ g_cond_clear(&player->capture_thread_cond);
return ret;
}
int
_mmplayer_release_video_capture(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
/* release capture thread */
g_mutex_lock(&player->capture_thread_mutex);
player->capture_thread_exit = TRUE;
- g_cond_signal( &player->capture_thread_cond );
+ g_cond_signal(&player->capture_thread_cond);
g_mutex_unlock(&player->capture_thread_mutex);
LOGD("waitting for capture thread exit");
- g_thread_join ( player->capture_thread );
- g_mutex_clear(&player->capture_thread_mutex );
- g_cond_clear(&player->capture_thread_cond );
+ g_thread_join(player->capture_thread);
+ g_mutex_clear(&player->capture_thread_mutex);
+ g_cond_clear(&player->capture_thread_cond);
LOGD("capture thread released");
return MM_ERROR_NONE;
/* capturing or not */
if (player->video_capture_cb_probe_id || player->capture.data
- || player->captured.data[0] || player->captured.data[1]
- )
- {
+ || player->captured.data[0] || player->captured.data[1]) {
LOGW("capturing... we can't do any more");
return MM_ERROR_PLAYER_INVALID_STATE;
}
gint surface_type = 0;
- mm_attrs_get_int_by_name (player->attrs, "display_surface_type", &surface_type);
+ mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &surface_type);
/* check if video pipeline is linked or not */
- if (!player->pipeline->videobin)
- {
- if (surface_type == MM_DISPLAY_SURFACE_REMOTE && player->video_fakesink)
+ if (!player->pipeline->videobin) {
+ if (surface_type == MM_DISPLAY_SURFACE_REMOTE && player->video_fakesink) {
LOGD("it is evas surface type.");
- else
- {
+ } else {
LOGW("not ready to capture");
return MM_ERROR_PLAYER_INVALID_STATE;
}
}
if (player->pipeline->videobin)
- pad = gst_element_get_static_pad(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "sink" );
+ pad = gst_element_get_static_pad(player->pipeline->videobin[MMPLAYER_V_SINK].gst, "sink");
else // evas surface
- pad = gst_element_get_static_pad (player->video_fakesink, "sink");
+ pad = gst_element_get_static_pad(player->video_fakesink, "sink");
- if (player->state != MM_PLAYER_STATE_PLAYING)
- {
- if (player->state == MM_PLAYER_STATE_PAUSED) // get last buffer from video sink
- {
+ if (player->state != MM_PLAYER_STATE_PLAYING) {
+ if (player->state == MM_PLAYER_STATE_PAUSED) {
+ // get last buffer from video sink
GstSample *sample = NULL;
gst_element_get_state(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst, NULL, NULL, 5 * GST_SECOND); //5 seconds
else // evas surface
g_object_get(player->video_fakesink, "last-sample", &sample, NULL);
- if (sample)
- {
+ if (sample) {
GstBuffer *buf = NULL;
buf = gst_sample_get_buffer(sample);
if (buf)
- {
ret = __mmplayer_get_video_frame_from_buffer(player, pad, buf);
- }
else
- {
LOGW("failed to get video frame");
- }
gst_sample_unref(sample);
}
return ret;
- }
- else
- {
+ } else {
LOGW("invalid state(%d) to capture", player->state);
return MM_ERROR_PLAYER_INVALID_STATE;
}
}
int
-__mmplayer_handle_orientation (mm_player_t* player, int orientation, int format)
+__mmplayer_handle_orientation(mm_player_t* player, int orientation, int format)
{
- unsigned char *src_buffer = NULL;
- int ret = MM_ERROR_NONE;
- unsigned char *dst_frame = NULL;
- unsigned int dst_width = 0;
- unsigned int dst_height = 0;
- unsigned int dst_size = 0;
- mm_util_img_rotate_type rot_enum = MM_UTIL_ROTATE_NUM;
+ unsigned char *src_buffer = NULL;
+ int ret = MM_ERROR_NONE;
+ unsigned char *dst_frame = NULL;
+ unsigned int dst_width = 0;
+ unsigned int dst_height = 0;
+ unsigned int dst_size = 0;
+ mm_util_img_rotate_type rot_enum = MM_UTIL_ROTATE_NUM;
player->capture.orientation = orientation;
- if (orientation == 90 || orientation == 270)
- {
+ if (orientation == 90 || orientation == 270) {
dst_width = player->captured.height[0];
dst_height = player->captured.width[0];
- LOGD ("interchange width & height");
- }
- else if (orientation == 180)
- {
+ LOGD("interchange width & height");
+ } else if (orientation == 180) {
dst_width = player->captured.width[0];
dst_height = player->captured.height[0];
- }
- else if (orientation == 0)
- {
- LOGE ("no need handle orientation : %d", orientation);
+ } else if (orientation == 0) {
+ LOGE("no need handle orientation : %d", orientation);
player->capture.width = player->captured.width[0];
player->capture.height = player->captured.height[0];
return MM_ERROR_NONE;
- }
- else
- {
- LOGE ("wrong orientation value...");
- }
+ } else
+ LOGE("wrong orientation value...");
/* height & width will be interchanged for 90 and 270 orientation */
- ret = mm_util_get_image_size(format, dst_width, dst_height, &dst_size);
- if (ret != MM_ERROR_NONE)
- {
+ ret = mm_util_get_image_size(format, dst_width, dst_height, &dst_size);
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to get destination frame size");
return ret;
- }
+ }
- LOGD ("before rotation : dst_width = %d and dst_height = %d", dst_width, dst_height);
+ LOGD("before rotation : dst_width = %d and dst_height = %d", dst_width, dst_height);
- dst_frame = (unsigned char*) malloc (dst_size);
- if (!dst_frame)
- {
- LOGE("failed to allocate memory");
- return MM_ERROR_PLAYER_NO_FREE_SPACE;
- }
+ dst_frame = (unsigned char*) malloc(dst_size);
+ if (!dst_frame) {
+ LOGE("failed to allocate memory");
+ return MM_ERROR_PLAYER_NO_FREE_SPACE;
+ }
- src_buffer = (unsigned char*)player->capture.data;
+ src_buffer = (unsigned char*)player->capture.data;
/* convert orientation degree into enum here */
- switch(orientation)
- {
- case 0:
- rot_enum = MM_UTIL_ROTATE_0;
+ switch (orientation) {
+ case 0:
+ rot_enum = MM_UTIL_ROTATE_0;
break;
- case 90:
- rot_enum = MM_UTIL_ROTATE_90;
+ case 90:
+ rot_enum = MM_UTIL_ROTATE_90;
break;
- case 180:
- rot_enum = MM_UTIL_ROTATE_180;
+ case 180:
+ rot_enum = MM_UTIL_ROTATE_180;
break;
- case 270:
- rot_enum = MM_UTIL_ROTATE_270;
+ case 270:
+ rot_enum = MM_UTIL_ROTATE_270;
break;
- default:
- LOGE("wrong rotate value");
+ default:
+ LOGE("wrong rotate value");
break;
}
- LOGD ("source buffer for rotation = %p and rotation = %d", src_buffer, rot_enum);
+ LOGD("source buffer for rotation = %p and rotation = %d", src_buffer, rot_enum);
- ret = mm_util_rotate_image (src_buffer,
+ ret = mm_util_rotate_image(src_buffer,
player->captured.width[0], player->captured.height[0], format,
dst_frame, &dst_width, &dst_height, rot_enum);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to do rotate image");
free(dst_frame);
return ret;
- }
+ }
- LOGD ("after rotation same stride: dst_width = %d and dst_height = %d", dst_width, dst_height);
+ LOGD("after rotation same stride: dst_width = %d and dst_height = %d", dst_width, dst_height);
- g_free (src_buffer);
+ g_free(src_buffer);
- player->capture.data = dst_frame;
- player->capture.size = dst_size;
+ player->capture.data = dst_frame;
+ player->capture.size = dst_size;
player->capture.orientation = orientation;
player->capture.width = dst_width;
- player->capture.height= dst_height;
+ player->capture.height = dst_height;
- player->captured.width[0] = player->captured.stride_width[0] = dst_width;
- player->captured.height[0] = player->captured.stride_height[0] = dst_height;
+ player->captured.width[0] = player->captured.stride_width[0] = dst_width;
+ player->captured.height[0] = player->captured.stride_height[0] = dst_height;
- return ret;
+ return ret;
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, NULL);
g_mutex_lock(&player->capture_thread_mutex);
- while (!player->capture_thread_exit)
- {
+ while (!player->capture_thread_exit) {
LOGD("capture thread started. waiting for signal");
- g_cond_wait(&player->capture_thread_cond, &player->capture_thread_mutex );
+ g_cond_wait(&player->capture_thread_cond, &player->capture_thread_mutex);
- if ( player->capture_thread_exit )
- {
+ if (player->capture_thread_exit) {
LOGD("exiting capture thread");
goto EXIT;
}
/* NOTE: Don't use MMPLAYER_CMD_LOCK() here.
* Because deadlock can be happened if other player api is used in message callback.
*/
- if (player->video_cs == MM_PLAYER_COLORSPACE_NV12_TILED)
- {
+ if (player->video_cs == MM_PLAYER_COLORSPACE_NV12_TILED) {
/* Colorspace conversion : NV12T-> NV12-> RGB888 */
int ret = 0;
int linear_y_plane_size;
linear_uv_plane_size = (width * height / 2);
linear_y_plane = (unsigned char*) g_try_malloc(linear_y_plane_size);
- if (linear_y_plane == NULL)
- {
+ if (linear_y_plane == NULL) {
msg.code = MM_ERROR_PLAYER_NO_FREE_SPACE;
goto ERROR;
}
linear_uv_plane = (unsigned char*) g_try_malloc(linear_uv_plane_size);
- if (linear_uv_plane == NULL)
- {
+ if (linear_uv_plane == NULL) {
msg.code = MM_ERROR_PLAYER_NO_FREE_SPACE;
goto ERROR;
}
/* NV12 tiled to linear */
__csc_tiled_to_linear_crop(linear_y_plane,
- player->captured.data[0], width, height, 0,0,0,0);
+ player->captured.data[0], width, height, 0, 0, 0, 0);
__csc_tiled_to_linear_crop(linear_uv_plane,
- player->captured.data[1], width, height / 2, 0,0,0,0);
+ player->captured.data[1], width, height / 2, 0, 0, 0, 0);
MMPLAYER_FREEIF(player->captured.data[0]);
MMPLAYER_FREEIF(player->captured.data[1]);
src_buffer = (unsigned char*) g_try_malloc(linear_y_plane_size+linear_uv_plane_size);
- if (src_buffer == NULL)
- {
+ if (src_buffer == NULL) {
msg.code = MM_ERROR_PLAYER_NO_FREE_SPACE;
goto ERROR;
}
ret = __mm_player_convert_colorspace(player, src_buffer, MM_UTIL_IMG_FMT_NV12,
width, height, MM_UTIL_IMG_FMT_RGB888);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to convert nv12 linear");
goto ERROR;
}
MMPLAYER_FREEIF(linear_y_plane);
MMPLAYER_FREEIF(linear_uv_plane);
} else if (MM_PLAYER_COLORSPACE_NV12 == player->video_cs) {
- #define MM_ALIGN(x, a) (((x) + (a) - 1) & ~((a) - 1))
+ #define MM_ALIGN(x, a) (((x) +(a) - 1) & ~((a) - 1))
int ret = 0;
char *src_buffer = NULL;
/* using original width otherwises, app can't know aligned to resize */
/* NV12 -> RGB888 */
ret = __mm_player_convert_colorspace(player, (unsigned char*)src_buffer, MM_UTIL_IMG_FMT_NV12,
width_align, player->captured.height[0], MM_UTIL_IMG_FMT_RGB888);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to convert nv12 linear");
goto ERROR;
}
}
- ret = _mmplayer_get_video_rotate_angle ((MMHandleType)player, &orientation);
- if (ret != MM_ERROR_NONE)
- {
+ ret = _mmplayer_get_video_rotate_angle((MMHandleType)player, &orientation);
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to get rotation angle");
goto ERROR;
}
- LOGD ("orientation value = %d", orientation);
+ LOGD("orientation value = %d", orientation);
- ret = __mmplayer_handle_orientation (player, orientation, MM_UTIL_IMG_FMT_RGB888);
- if (ret != MM_ERROR_NONE)
- {
+ ret = __mmplayer_handle_orientation(player, orientation, MM_UTIL_IMG_FMT_RGB888);
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to convert nv12 linear");
goto ERROR;
}
// msg.captured_frame.height = player->capture.height;
// msg.captured_frame.orientation = player->capture.orientation;
- if (player->cmd >= MMPLAYER_COMMAND_START)
- {
- MMPLAYER_POST_MSG( player, MM_MESSAGE_VIDEO_CAPTURED, &msg );
+ if (player->cmd >= MMPLAYER_COMMAND_START) {
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_VIDEO_CAPTURED, &msg);
LOGD("returned from capture message callback");
}
//MMPLAYER_FREEIF(player->capture.data);
continue;
ERROR:
- if (player->video_cs == MM_PLAYER_COLORSPACE_NV12_TILED)
- {
+ if (player->video_cs == MM_PLAYER_COLORSPACE_NV12_TILED) {
/* clean */
MMPLAYER_FREEIF(linear_y_plane);
MMPLAYER_FREEIF(linear_uv_plane);
msg.union_type = MM_MSG_UNION_CODE;
- MMPLAYER_POST_MSG( player, MM_MESSAGE_VIDEO_NOT_CAPTURED, &msg );
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_VIDEO_NOT_CAPTURED, &msg);
}
EXIT:
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- MMPLAYER_RETURN_VAL_IF_FAIL ( buffer, MM_ERROR_INVALID_ARGUMENT );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(buffer, MM_ERROR_INVALID_ARGUMENT);
/* get fourcc */
caps = gst_pad_get_current_caps(pad);
- MMPLAYER_RETURN_VAL_IF_FAIL ( caps, MM_ERROR_INVALID_ARGUMENT );
+ MMPLAYER_RETURN_VAL_IF_FAIL(caps, MM_ERROR_INVALID_ARGUMENT);
MMPLAYER_LOG_GST_CAPS_TYPE(caps);
- structure = gst_caps_get_structure (caps, 0);
+ structure = gst_caps_get_structure(caps, 0);
- MMPLAYER_RETURN_VAL_IF_FAIL (structure != NULL, MM_ERROR_PLAYER_INTERNAL);
+ MMPLAYER_RETURN_VAL_IF_FAIL(structure != NULL, MM_ERROR_PLAYER_INTERNAL);
/* init capture image buffer */
memset(&player->capture, 0x00, sizeof(MMPlayerVideoCapture));
- gst_structure_get_int (structure, "width", &src_width);
- gst_structure_get_int (structure, "height", &src_height);
+ gst_structure_get_int(structure, "width", &src_width);
+ gst_structure_get_int(structure, "height", &src_height);
/* check rgb or yuv */
- if (gst_structure_has_name(structure, "video/x-raw"))
- {
+ if (gst_structure_has_name(structure, "video/x-raw")) {
/* NV12T */
const gchar *gst_format = gst_structure_get_string(structure, "format");
- if(!g_strcmp0(gst_format, "ST12") || !g_strcmp0(gst_format, "SN12"))
- {
+ if (!g_strcmp0(gst_format, "ST12") || !g_strcmp0(gst_format, "SN12")) {
guint n;
tbm_bo_handle y_hnd;
tbm_bo_handle uv_hnd;
- LOGI ("captured format is %s\n", gst_format);
+ LOGI("captured format is %s\n", gst_format);
MMVideoBuffer *proved = NULL;
- if(!g_strcmp0(gst_format, "ST12"))
+ if (!g_strcmp0(gst_format, "ST12"))
player->video_cs = MM_PLAYER_COLORSPACE_NV12_TILED;
else
player->video_cs = MM_PLAYER_COLORSPACE_NV12;
gst_memory_map(memory, &mapinfo, GST_MAP_READ);
proved = (MMVideoBuffer *)mapinfo.data;
- if ( !proved || !proved->data[0] || !proved->data[1] ) {
+ if (!proved || !proved->data[0] || !proved->data[1]) {
LOGE("fail to gst_memory_map");
return MM_ERROR_PLAYER_INTERNAL;
}
yplane_size = proved->size[0];
uvplane_size = proved->size[1];
- LOGI ("yplane_size=%d, uvplane_size=%d", yplane_size, uvplane_size);
+ LOGI("yplane_size=%d, uvplane_size=%d", yplane_size, uvplane_size);
player->captured.data[0] = g_try_malloc(yplane_size);
- if ( !player->captured.data[0] ) {
+ if (!player->captured.data[0]) {
gst_memory_unmap(memory, &mapinfo);
return MM_ERROR_SOUND_NO_FREE_SPACE;
}
#if 0
player->captured.data[1] = g_try_malloc(uvplane_size);
#else
- if(uvplane_size < proved->stride_width[1] * proved->stride_height[1]) {
+ if (uvplane_size < proved->stride_width[1] * proved->stride_height[1]) {
player->captured.data[1] =
g_try_malloc(proved->stride_width[1] * proved->stride_height[1]);
- }
- else
+ } else
player->captured.data[1] = g_try_malloc(uvplane_size);
#endif
- if ( !player->captured.data[1] ) {
+ if (!player->captured.data[1]) {
gst_memory_unmap(memory, &mapinfo);
return MM_ERROR_SOUND_NO_FREE_SPACE;
}
LOGD("Buffer type %d", proved->type);
- if(proved->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
+ if (proved->type == MM_VIDEO_BUFFER_TYPE_TBM_BO) {
tbm_bo_ref(proved->handle.bo[0]);
tbm_bo_ref(proved->handle.bo[1]);
y_hnd = tbm_bo_get_handle(proved->handle.bo[0], TBM_DEVICE_CPU);
LOGD("source y : %p, size %d", y_hnd.ptr, yplane_size);
- if(y_hnd.ptr) {
+ if (y_hnd.ptr)
memcpy(player->captured.data[0], y_hnd.ptr, yplane_size);
- }
uv_hnd = tbm_bo_get_handle(proved->handle.bo[1], TBM_DEVICE_CPU);
- LOGD("source uv : %p, size %d",uv_hnd.ptr, uvplane_size);
- if(uv_hnd.ptr) {
+ LOGD("source uv : %p, size %d", uv_hnd.ptr, uvplane_size);
+ if (uv_hnd.ptr)
memcpy(player->captured.data[1], uv_hnd.ptr, uvplane_size);
- }
+
tbm_bo_unref(proved->handle.bo[0]);
tbm_bo_unref(proved->handle.bo[1]);
}
gst_memory_unmap(memory, &mapinfo);
goto DONE;
- }
- else
- {
+ } else {
GstVideoInfo format_info;
gst_video_info_from_caps(&format_info, caps);
- switch(GST_VIDEO_INFO_FORMAT(&format_info))
- {
- case GST_VIDEO_FORMAT_I420:
- src_fmt = MM_UTIL_IMG_FMT_I420;
- break;
- case GST_VIDEO_FORMAT_BGRA:
- src_fmt = MM_UTIL_IMG_FMT_BGRA8888;
- break;
- case GST_VIDEO_FORMAT_BGRx:
- src_fmt = MM_UTIL_IMG_FMT_BGRX8888;
- break;
- default:
- goto UNKNOWN;
- break;
+ switch (GST_VIDEO_INFO_FORMAT(&format_info)) {
+ case GST_VIDEO_FORMAT_I420:
+ src_fmt = MM_UTIL_IMG_FMT_I420;
+ break;
+ case GST_VIDEO_FORMAT_BGRA:
+ src_fmt = MM_UTIL_IMG_FMT_BGRA8888;
+ break;
+ case GST_VIDEO_FORMAT_BGRx:
+ src_fmt = MM_UTIL_IMG_FMT_BGRX8888;
+ break;
+ default:
+ goto UNKNOWN;
+ break;
}
}
- }
- else
- {
+ } else
goto UNKNOWN;
- }
gst_buffer_map(buffer, &mapinfo, GST_MAP_READ);
__mm_player_convert_colorspace(player, mapinfo.data, src_fmt, src_width, src_height, dst_fmt);
DONE:
/* do convert colorspace */
- g_cond_signal( &player->capture_thread_cond );
+ g_cond_signal(&player->capture_thread_cond);
MMPLAYER_FLEAVE();
}
static GstPadProbeReturn
-__mmplayer_video_capture_probe (GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
+__mmplayer_video_capture_probe(GstPad *pad, GstPadProbeInfo *info, gpointer u_data)
{
mm_player_t* player = (mm_player_t*) u_data;
GstBuffer *buffer = NULL;
int ret = MM_ERROR_NONE;
- MMPLAYER_RETURN_VAL_IF_FAIL (info->data, GST_PAD_PROBE_REMOVE);
+ MMPLAYER_RETURN_VAL_IF_FAIL(info->data, GST_PAD_PROBE_REMOVE);
MMPLAYER_FENTER();
buffer = gst_pad_probe_info_get_buffer(info);
ret = __mmplayer_get_video_frame_from_buffer(player, pad, buffer);
- if ( ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to get video frame");
return GST_PAD_PROBE_REMOVE;
}
/* remove probe to be called at one time */
- if (player->video_capture_cb_probe_id)
- {
+ if (player->video_capture_cb_probe_id) {
gst_pad_remove_probe(pad, player->video_capture_cb_probe_id);
player->video_capture_cb_probe_id = 0;
}
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_INTERNAL);
ret = mm_util_get_image_size(dst_fmt, src_w, src_h, &dst_size);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to get image size for capture, %d\n", ret);
return MM_ERROR_PLAYER_INTERNAL;
}
dst_data = (unsigned char*)g_malloc0(dst_size);
- if (!dst_data)
- {
+ if (!dst_data) {
LOGE("no free space to capture\n");
g_free(dst_data);
return MM_ERROR_PLAYER_NO_FREE_SPACE;
ret = mm_util_convert_colorspace(src_data, src_w, src_h, src_fmt, dst_data, dst_fmt);
- if (ret != MM_ERROR_NONE)
- {
+ if (ret != MM_ERROR_NONE) {
LOGE("failed to convert for capture, %d\n", ret);
g_free(dst_data);
return MM_ERROR_PLAYER_INTERNAL;
static int
__tile_4x2_read(int x_size, int y_size, int x_pos, int y_pos)
{
- int pixel_x_m1, pixel_y_m1;
- int roundup_x;
- int linear_addr0, linear_addr1, bank_addr ;
- int x_addr;
- int trans_addr;
-
- pixel_x_m1 = x_size -1;
- pixel_y_m1 = y_size -1;
-
- roundup_x = ((pixel_x_m1 >> 7) + 1);
-
- x_addr = x_pos >> 2;
-
- if ((y_size <= y_pos+32) && ( y_pos < y_size) &&
- (((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
- linear_addr0 = (((y_pos & 0x1f) <<4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 6) & 0x3f));
-
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- } else {
- linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
- linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x + ((x_addr >> 5) & 0x7f));
-
- if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
- bank_addr = ((x_addr >> 4) & 0x1);
- else
- bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
- }
-
- linear_addr0 = linear_addr0 << 2;
- trans_addr = (linear_addr1 <<13) | (bank_addr << 11) | linear_addr0;
-
- return trans_addr;
+ int pixel_x_m1, pixel_y_m1;
+ int roundup_x;
+ int linear_addr0, linear_addr1, bank_addr ;
+ int x_addr;
+ int trans_addr;
+
+ pixel_x_m1 = x_size -1;
+ pixel_y_m1 = y_size -1;
+
+ roundup_x = ((pixel_x_m1 >> 7) + 1);
+
+ x_addr = x_pos >> 2;
+
+ if ((y_size <= y_pos+32) && (y_pos < y_size) &&
+ (((pixel_y_m1 >> 5) & 0x1) == 0) && (((y_pos >> 5) & 0x1) == 0)) {
+ linear_addr0 = (((y_pos & 0x1f) <<4) | (x_addr & 0xf));
+ linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x +((x_addr >> 6) & 0x3f));
+
+ if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
+ bank_addr = ((x_addr >> 4) & 0x1);
+ else
+ bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
+ } else {
+ linear_addr0 = (((y_pos & 0x1f) << 4) | (x_addr & 0xf));
+ linear_addr1 = (((y_pos >> 6) & 0xff) * roundup_x +((x_addr >> 5) & 0x7f));
+
+ if (((x_addr >> 5) & 0x1) == ((y_pos >> 5) & 0x1))
+ bank_addr = ((x_addr >> 4) & 0x1);
+ else
+ bank_addr = 0x2 | ((x_addr >> 4) & 0x1);
+ }
+
+ linear_addr0 = linear_addr0 << 2;
+ trans_addr = (linear_addr1 <<13) | (bank_addr << 11) | linear_addr0;
+
+ return trans_addr;
}
/*
*/
static void
__csc_tiled_to_linear_crop(unsigned char *yuv420_dest, unsigned char *nv12t_src, int yuv420_width, int yuv420_height,
- int left, int top, int right, int buttom)
+ int left, int top, int right, int buttom)
{
- int i, j;
- int tiled_offset = 0, tiled_offset1 = 0;
- int linear_offset = 0;
- int temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0;
-
- temp3 = yuv420_width-right;
- temp1 = temp3-left;
- /* real width is greater than or equal 256 */
- if (temp1 >= 256) {
- for (i=top; i<yuv420_height-buttom; i=i+1) {
- j = left;
- temp3 = (j>>8)<<8;
- temp3 = temp3>>6;
- temp4 = i>>5;
- if (temp4 & 0x1) {
- /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
- tiled_offset = temp4-1;
- temp1 = ((yuv420_width+127)>>7)<<7;
- tiled_offset = tiled_offset*(temp1>>6);
- tiled_offset = tiled_offset+temp3;
- tiled_offset = tiled_offset+2;
- temp1 = (temp3>>2)<<2;
- tiled_offset = tiled_offset+temp1;
- tiled_offset = tiled_offset<<11;
- tiled_offset1 = tiled_offset+2048*2;
- temp4 = 8;
- } else {
- temp2 = ((yuv420_height+31)>>5)<<5;
- if ((i+32)<temp2) {
- /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
- temp1 = temp3+2;
- temp1 = (temp1>>2)<<2;
- tiled_offset = temp3+temp1;
- temp1 = ((yuv420_width+127)>>7)<<7;
- tiled_offset = tiled_offset+temp4*(temp1>>6);
- tiled_offset = tiled_offset<<11;
- tiled_offset1 = tiled_offset+2048*6;
- temp4 = 8;
- } else {
- /* even2 fomula: x+x_block_num*y */
- temp1 = ((yuv420_width+127)>>7)<<7;
- tiled_offset = temp4*(temp1>>6);
- tiled_offset = tiled_offset+temp3;
- tiled_offset = tiled_offset<<11;
- tiled_offset1 = tiled_offset+2048*2;
- temp4 = 4;
- }
- }
-
- temp1 = i&0x1F;
- tiled_offset = tiled_offset+64*(temp1);
- tiled_offset1 = tiled_offset1+64*(temp1);
- temp2 = yuv420_width-left-right;
- linear_offset = temp2*(i-top);
- temp3 = ((j+256)>>8)<<8;
- temp3 = temp3-j;
- temp1 = left&0x3F;
- if (temp3 > 192) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+temp1, 64-temp1);
- temp2 = ((left+63)>>6)<<6;
- temp3 = ((yuv420_width-right)>>6)<<6;
- if (temp2 == temp3) {
- temp2 = yuv420_width-right-(64-temp1);
- }
- memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1, 64);
- memcpy(yuv420_dest+linear_offset+192-temp1, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+256-temp1;
- } else if (temp3 > 128) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+2048+temp1, 64-temp1);
- memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1, 64);
- memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+192-temp1;
- } else if (temp3 > 64) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+temp1, 64-temp1);
- memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+128-temp1;
- } else if (temp3 > 0) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+2048+temp1, 64-temp1);
- linear_offset = linear_offset+64-temp1;
- }
-
- tiled_offset = tiled_offset+temp4*2048;
- j = (left>>8)<<8;
- j = j + 256;
- temp2 = yuv420_width-right-256;
- for (; j<=temp2; j=j+256) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- tiled_offset1 = tiled_offset1+temp4*2048;
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
- tiled_offset = tiled_offset+temp4*2048;
- memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, 64);
- linear_offset = linear_offset+256;
- }
-
- tiled_offset1 = tiled_offset1+temp4*2048;
- temp2 = yuv420_width-right-j;
- if (temp2 > 192) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
- memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, temp2-192);
- } else if (temp2 > 128) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
- memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, temp2-128);
- } else if (temp2 > 64) {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, temp2-64);
- } else {
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
- }
- }
- } else if (temp1 >= 64) {
- for (i=top; i<(yuv420_height-buttom); i=i+1) {
- j = left;
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- temp2 = ((j+64)>>6)<<6;
- temp2 = temp2-j;
- linear_offset = temp1*(i-top);
- temp4 = j&0x3;
- tiled_offset = tiled_offset+temp4;
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
- linear_offset = linear_offset+temp2;
- j = j+temp2;
- if ((j+64) <= temp3) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- linear_offset = linear_offset+64;
- j = j+64;
- }
- if ((j+64) <= temp3) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
- linear_offset = linear_offset+64;
- j = j+64;
- }
- if (j < temp3) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- temp2 = temp3-j;
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
- }
- }
- } else {
- for (i=top; i<(yuv420_height-buttom); i=i+1) {
- linear_offset = temp1*(i-top);
- for (j=left; j<(yuv420_width-right); j=j+2) {
- tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
- temp4 = j&0x3;
- tiled_offset = tiled_offset+temp4;
- memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 2);
- linear_offset = linear_offset+2;
- }
- }
- }
+ int i, j;
+ int tiled_offset = 0, tiled_offset1 = 0;
+ int linear_offset = 0;
+ int temp1 = 0, temp2 = 0, temp3 = 0, temp4 = 0;
+
+ temp3 = yuv420_width-right;
+ temp1 = temp3-left;
+ /* real width is greater than or equal 256 */
+ if (temp1 >= 256) {
+ for (i = top; i < yuv420_height-buttom; i = i+1) {
+ j = left;
+ temp3 = (j>>8)<<8;
+ temp3 = temp3>>6;
+ temp4 = i>>5;
+ if (temp4 & 0x1) {
+ /* odd fomula: 2+x+(x>>2)<<2+x_block_num*(y-1) */
+ tiled_offset = temp4-1;
+ temp1 = ((yuv420_width+127)>>7)<<7;
+ tiled_offset = tiled_offset*(temp1>>6);
+ tiled_offset = tiled_offset+temp3;
+ tiled_offset = tiled_offset+2;
+ temp1 = (temp3>>2)<<2;
+ tiled_offset = tiled_offset+temp1;
+ tiled_offset = tiled_offset<<11;
+ tiled_offset1 = tiled_offset+2048*2;
+ temp4 = 8;
+ } else {
+ temp2 = ((yuv420_height+31)>>5)<<5;
+ if ((i+32) < temp2) {
+ /* even1 fomula: x+((x+2)>>2)<<2+x_block_num*y */
+ temp1 = temp3+2;
+ temp1 = (temp1>>2)<<2;
+ tiled_offset = temp3+temp1;
+ temp1 = ((yuv420_width+127)>>7)<<7;
+ tiled_offset = tiled_offset+temp4*(temp1>>6);
+ tiled_offset = tiled_offset<<11;
+ tiled_offset1 = tiled_offset+2048*6;
+ temp4 = 8;
+ } else {
+ /* even2 fomula: x+x_block_num*y */
+ temp1 = ((yuv420_width+127)>>7)<<7;
+ tiled_offset = temp4*(temp1>>6);
+ tiled_offset = tiled_offset+temp3;
+ tiled_offset = tiled_offset<<11;
+ tiled_offset1 = tiled_offset+2048*2;
+ temp4 = 4;
+ }
+ }
+
+ temp1 = i&0x1F;
+ tiled_offset = tiled_offset+64*(temp1);
+ tiled_offset1 = tiled_offset1+64*(temp1);
+ temp2 = yuv420_width-left-right;
+ linear_offset = temp2*(i-top);
+ temp3 = ((j+256)>>8)<<8;
+ temp3 = temp3-j;
+ temp1 = left&0x3F;
+ if (temp3 > 192) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+temp1, 64-temp1);
+ temp2 = ((left+63)>>6)<<6;
+ temp3 = ((yuv420_width-right)>>6)<<6;
+ if (temp2 == temp3)
+ temp2 = yuv420_width-right-(64-temp1);
+ memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1, 64);
+ memcpy(yuv420_dest+linear_offset+192-temp1, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+256-temp1;
+ } else if (temp3 > 128) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset+2048+temp1, 64-temp1);
+ memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1, 64);
+ memcpy(yuv420_dest+linear_offset+128-temp1, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+192-temp1;
+ } else if (temp3 > 64) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+temp1, 64-temp1);
+ memcpy(yuv420_dest+linear_offset+64-temp1, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+128-temp1;
+ } else if (temp3 > 0) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset1+2048+temp1, 64-temp1);
+ linear_offset = linear_offset+64-temp1;
+ }
+
+ tiled_offset = tiled_offset+temp4*2048;
+ j = (left>>8)<<8;
+ j = j + 256;
+ temp2 = yuv420_width-right-256;
+ for (; j <= temp2; j = j+256) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ tiled_offset1 = tiled_offset1+temp4*2048;
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
+ tiled_offset = tiled_offset+temp4*2048;
+ memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, 64);
+ linear_offset = linear_offset+256;
+ }
+
+ tiled_offset1 = tiled_offset1+temp4*2048;
+ temp2 = yuv420_width-right-j;
+ if (temp2 > 192) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, 64);
+ memcpy(yuv420_dest+linear_offset+192, nv12t_src+tiled_offset1+2048, temp2-192);
+ } else if (temp2 > 128) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, 64);
+ memcpy(yuv420_dest+linear_offset+128, nv12t_src+tiled_offset1, temp2-128);
+ } else if (temp2 > 64) {
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ memcpy(yuv420_dest+linear_offset+64, nv12t_src+tiled_offset+2048, temp2-64);
+ } else
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
+ }
+ } else if (temp1 >= 64) {
+ for (i = top; i < (yuv420_height-buttom); i = i+1) {
+ j = left;
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ temp2 = ((j+64)>>6)<<6;
+ temp2 = temp2-j;
+ linear_offset = temp1*(i-top);
+ temp4 = j&0x3;
+ tiled_offset = tiled_offset+temp4;
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
+ linear_offset = linear_offset+temp2;
+ j = j+temp2;
+ if ((j+64) <= temp3) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ linear_offset = linear_offset+64;
+ j = j+64;
+ }
+ if ((j+64) <= temp3) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 64);
+ linear_offset = linear_offset+64;
+ j = j+64;
+ }
+ if (j < temp3) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ temp2 = temp3-j;
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, temp2);
+ }
+ }
+ } else {
+ for (i = top; i < (yuv420_height-buttom); i = i+1) {
+ linear_offset = temp1*(i-top);
+ for (j = left; j < (yuv420_width-right); j = j+2) {
+ tiled_offset = __tile_4x2_read(yuv420_width, yuv420_height, j, i);
+ temp4 = j&0x3;
+ tiled_offset = tiled_offset+temp4;
+ memcpy(yuv420_dest+linear_offset, nv12t_src+tiled_offset, 2);
+ linear_offset = linear_offset+2;
+ }
+ }
+ }
}
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static gint __gst_transform_gsterror( mm_player_t* player, GstMessage * message, GError* error);
+static gint __gst_transform_gsterror(mm_player_t* player, GstMessage * message, GError* error);
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
-| |
+| |
========================================================================================== */
int
__mmplayer_check_state(mm_player_t* player, enum PlayerCommandState command)
MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- //LOGD("incomming command : %d \n", command );
+ //LOGD("incomming command : %d \n", command);
current_state = MMPLAYER_CURRENT_STATE(player);
pending_state = MMPLAYER_PENDING_STATE(player);
MMPLAYER_PRINT_STATE(player);
- switch( command )
+ switch (command) {
+ case MMPLAYER_COMMAND_CREATE:
{
- case MMPLAYER_COMMAND_CREATE:
- {
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_NULL;
-
- if ( current_state == MM_PLAYER_STATE_NULL ||
- current_state == MM_PLAYER_STATE_READY ||
- current_state == MM_PLAYER_STATE_PAUSED ||
- current_state == MM_PLAYER_STATE_PLAYING )
- goto NO_OP;
- }
- break;
-
- case MMPLAYER_COMMAND_DESTROY:
- {
- /* destroy can called anytime */
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_NULL;
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_NONE;
- }
- break;
-
- case MMPLAYER_COMMAND_REALIZE:
- {
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_READY;
+ if (current_state == MM_PLAYER_STATE_NULL ||
+ current_state == MM_PLAYER_STATE_READY ||
+ current_state == MM_PLAYER_STATE_PAUSED ||
+ current_state == MM_PLAYER_STATE_PLAYING)
+ goto NO_OP;
+ }
+ break;
- if ( pending_state != MM_PLAYER_STATE_NONE )
- {
- goto INVALID_STATE;
- }
- else
- {
- /* need ready state to realize */
- if ( current_state == MM_PLAYER_STATE_READY )
- goto NO_OP;
+ case MMPLAYER_COMMAND_DESTROY:
+ {
+ /* destroy can called anytime */
- if ( current_state != MM_PLAYER_STATE_NULL )
- goto INVALID_STATE;
- }
- }
- break;
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_NONE;
+ }
+ break;
- case MMPLAYER_COMMAND_UNREALIZE:
- {
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_NULL;
+ case MMPLAYER_COMMAND_REALIZE:
+ {
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_READY;
- if ( current_state == MM_PLAYER_STATE_NULL )
+ if (pending_state != MM_PLAYER_STATE_NONE) {
+ goto INVALID_STATE;
+ } else {
+ /* need ready state to realize */
+ if (current_state == MM_PLAYER_STATE_READY)
goto NO_OP;
- }
- break;
- case MMPLAYER_COMMAND_START:
- {
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PLAYING;
-
- if ( pending_state == MM_PLAYER_STATE_NONE )
- {
- if ( current_state == MM_PLAYER_STATE_PLAYING )
- goto NO_OP;
- else if ( current_state != MM_PLAYER_STATE_READY &&
- current_state != MM_PLAYER_STATE_PAUSED )
- goto INVALID_STATE;
- }
- else if ( pending_state == MM_PLAYER_STATE_PLAYING )
- {
- 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
- {
+ if (current_state != MM_PLAYER_STATE_NULL)
goto INVALID_STATE;
- }
}
- break;
+ }
+ break;
- case MMPLAYER_COMMAND_STOP:
- {
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_READY;
+ case MMPLAYER_COMMAND_UNREALIZE:
+ {
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_NULL;
- if ( current_state == MM_PLAYER_STATE_READY )
- goto NO_OP;
+ if (current_state == MM_PLAYER_STATE_NULL)
+ goto NO_OP;
+ }
+ break;
- /* need playing/paused state to stop */
- if ( current_state != MM_PLAYER_STATE_PLAYING &&
- current_state != MM_PLAYER_STATE_PAUSED )
- goto INVALID_STATE;
- }
- break;
+ case MMPLAYER_COMMAND_START:
+ {
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PLAYING;
- case MMPLAYER_COMMAND_PAUSE:
- {
- if ( MMPLAYER_IS_LIVE_STREAMING( player ) )
+ if (pending_state == MM_PLAYER_STATE_NONE) {
+ if (current_state == MM_PLAYER_STATE_PLAYING)
goto NO_OP;
+ else if (current_state != MM_PLAYER_STATE_READY &&
+ current_state != MM_PLAYER_STATE_PAUSED)
+ goto INVALID_STATE;
+ } else if (pending_state == MM_PLAYER_STATE_PLAYING) {
+ 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
+ goto INVALID_STATE;
+ }
+ break;
- if (player->doing_seek)
- goto NOT_COMPLETED_SEEK;
+ case MMPLAYER_COMMAND_STOP:
+ {
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_READY;
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PAUSED;
+ if (current_state == MM_PLAYER_STATE_READY)
+ goto NO_OP;
- if ( pending_state == MM_PLAYER_STATE_NONE )
- {
- if ( current_state == MM_PLAYER_STATE_PAUSED )
- goto NO_OP;
- else if ( current_state != MM_PLAYER_STATE_PLAYING && current_state != MM_PLAYER_STATE_READY ) // support loading state of broswer
- goto INVALID_STATE;
- }
- else if ( pending_state == MM_PLAYER_STATE_PAUSED )
- {
- goto ALREADY_GOING;
- }
- else if ( pending_state == MM_PLAYER_STATE_PLAYING )
- {
- if ( current_state == MM_PLAYER_STATE_PAUSED ) {
- LOGD("player is PAUSED going to PLAYING, just change the pending state as PAUSED");
- } else {
- goto INVALID_STATE;
- }
- }
- }
- break;
+ /* need playing/paused state to stop */
+ if (current_state != MM_PLAYER_STATE_PLAYING &&
+ current_state != MM_PLAYER_STATE_PAUSED)
+ goto INVALID_STATE;
+ }
+ break;
- case MMPLAYER_COMMAND_RESUME:
- {
+ case MMPLAYER_COMMAND_PAUSE:
+ {
+ if (MMPLAYER_IS_LIVE_STREAMING(player))
+ goto NO_OP;
- if (player->doing_seek)
- goto NOT_COMPLETED_SEEK;
+ if (player->doing_seek)
+ goto NOT_COMPLETED_SEEK;
- MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PLAYING;
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PAUSED;
- if ( pending_state == MM_PLAYER_STATE_NONE )
- {
- if ( current_state == MM_PLAYER_STATE_PLAYING )
- goto NO_OP;
- else if ( current_state != MM_PLAYER_STATE_PAUSED )
- goto INVALID_STATE;
- }
- else if ( pending_state == MM_PLAYER_STATE_PLAYING )
- {
- 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");
- }
+ if (pending_state == MM_PLAYER_STATE_NONE) {
+ if (current_state == MM_PLAYER_STATE_PAUSED)
+ goto NO_OP;
+ else if (current_state != MM_PLAYER_STATE_PLAYING && current_state != MM_PLAYER_STATE_READY) // support loading state of broswer
+ goto INVALID_STATE;
+ } else if (pending_state == MM_PLAYER_STATE_PAUSED) {
+ goto ALREADY_GOING;
+ } else if (pending_state == MM_PLAYER_STATE_PLAYING) {
+ if (current_state == MM_PLAYER_STATE_PAUSED)
+ LOGD("player is PAUSED going to PLAYING, just change the pending state as PAUSED");
else
- {
goto INVALID_STATE;
- }
}
+ }
+ break;
+
+ case MMPLAYER_COMMAND_RESUME:
+ {
+
+ if (player->doing_seek)
+ goto NOT_COMPLETED_SEEK;
+
+ MMPLAYER_TARGET_STATE(player) = MM_PLAYER_STATE_PLAYING;
+
+ if (pending_state == MM_PLAYER_STATE_NONE) {
+ if (current_state == MM_PLAYER_STATE_PLAYING)
+ goto NO_OP;
+ else if (current_state != MM_PLAYER_STATE_PAUSED)
+ goto INVALID_STATE;
+ } else if (pending_state == MM_PLAYER_STATE_PLAYING) {
+ 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
+ goto INVALID_STATE;
+ }
break;
- default:
+ default:
break;
}
player->cmd = command;
}
int
-__mmplayer_gst_set_state (mm_player_t* player, GstElement * element, GstState state, gboolean async, gint timeout)
+__mmplayer_gst_set_state(mm_player_t* player, GstElement * element, GstState state, gboolean async, gint timeout)
{
GstState element_state = GST_STATE_VOID_PENDING;
GstState element_pending_state = GST_STATE_VOID_PENDING;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- MMPLAYER_RETURN_VAL_IF_FAIL ( element, MM_ERROR_INVALID_ARGUMENT );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(element, MM_ERROR_INVALID_ARGUMENT);
LOGD("setting [%s] element state to : %s\n", GST_ELEMENT_NAME(element), gst_element_state_get_name(state));
/* set state */
ret = gst_element_set_state(element, state);
- if ( ret == GST_STATE_CHANGE_FAILURE )
- {
+ if (ret == GST_STATE_CHANGE_FAILURE) {
LOGE("failed to set [%s] state\n", GST_ELEMENT_NAME(element));
/* dump state of all element */
- __mmplayer_dump_pipeline_state( player );
+ __mmplayer_dump_pipeline_state(player);
return MM_ERROR_PLAYER_INTERNAL;
}
/* return here so state transition to be done in async mode */
- if ( async )
- {
+ if (async) {
LOGD("async state transition. not waiting for state complete.\n");
return MM_ERROR_NONE;
}
/* wait for state transition */
- ret = gst_element_get_state( element, &element_state, &element_pending_state, timeout * GST_SECOND );
+ ret = gst_element_get_state(element, &element_state, &element_pending_state, timeout * GST_SECOND);
- if ( ret == GST_STATE_CHANGE_FAILURE || ( state != element_state ) )
- {
+ if (ret == GST_STATE_CHANGE_FAILURE || (state != element_state)) {
LOGE("failed to change [%s] element state to [%s] within %d sec\n",
GST_ELEMENT_NAME(element),
- gst_element_state_get_name(state), timeout );
+ gst_element_state_get_name(state), timeout);
LOGE(" [%s] state : %s pending : %s \n",
GST_ELEMENT_NAME(element),
gst_element_state_get_name(element_state),
- gst_element_state_get_name(element_pending_state) );
+ gst_element_state_get_name(element_pending_state));
/* dump state of all element */
- __mmplayer_dump_pipeline_state( player );
+ __mmplayer_dump_pipeline_state(player);
return MM_ERROR_PLAYER_INTERNAL;
}
MMPLAYER_FENTER();
- source = g_main_context_find_source_by_id (context, source_id);
+ source = g_main_context_find_source_by_id(context, source_id);
- if (source != NULL)
- {
+ if (source != NULL) {
LOGW("context: %p, source id: %d, source: %p", context, source_id, source);
g_source_destroy(source);
}
}
gboolean
-__mmplayer_dump_pipeline_state( mm_player_t* player )
+__mmplayer_dump_pipeline_state(mm_player_t* player)
{
GstIterator*iter = NULL;
gboolean done = FALSE;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL ( player &&
+ MMPLAYER_RETURN_VAL_IF_FAIL(player &&
player->pipeline &&
player->pipeline->mainbin,
- FALSE );
+ FALSE);
- iter = gst_bin_iterate_recurse(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst) );
+ iter = gst_bin_iterate_recurse(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst));
- if ( iter != NULL )
- {
+ if (iter != NULL) {
while (!done) {
- switch ( gst_iterator_next (iter, &item) )
- {
- case GST_ITERATOR_OK:
+ switch (gst_iterator_next(iter, &item)) {
+ case GST_ITERATOR_OK:
element = g_value_get_object(&item);
- gst_element_get_state(element,&state, &pending,time);
+ gst_element_get_state(element, &state, &pending, time);
- factory = gst_element_get_factory (element) ;
+ factory = gst_element_get_factory(element) ;
if (factory)
- {
LOGE("%s:%s : From:%s To:%s refcount : %d\n", GST_OBJECT_NAME(factory) , GST_ELEMENT_NAME(element) ,
gst_element_state_get_name(state), gst_element_state_get_name(pending) , GST_OBJECT_REFCOUNT_VALUE(element));
- }
- g_value_reset (&item);
- break;
- case GST_ITERATOR_RESYNC:
- gst_iterator_resync (iter);
- break;
- case GST_ITERATOR_ERROR:
- done = TRUE;
- break;
- case GST_ITERATOR_DONE:
- done = TRUE;
- break;
- }
+ g_value_reset(&item);
+ break;
+ case GST_ITERATOR_RESYNC:
+ gst_iterator_resync(iter);
+ break;
+ case GST_ITERATOR_ERROR:
+ done = TRUE;
+ break;
+ case GST_ITERATOR_DONE:
+ done = TRUE;
+ break;
+ }
}
}
element = GST_ELEMENT(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst);
- gst_element_get_state(element,&state, &pending,time);
+ gst_element_get_state(element, &state, &pending, time);
- factory = gst_element_get_factory (element) ;
+ factory = gst_element_get_factory(element) ;
- if (factory)
- {
+ if (factory) {
LOGE("%s:%s : From:%s To:%s refcount : %d\n",
GST_OBJECT_NAME(factory),
GST_ELEMENT_NAME(element),
gst_element_state_get_name(state),
gst_element_state_get_name(pending),
- GST_OBJECT_REFCOUNT_VALUE(element) );
+ GST_OBJECT_REFCOUNT_VALUE(element));
}
g_value_unset(&item);
- if ( iter )
- gst_iterator_free (iter);
+ if (iter)
+ gst_iterator_free(iter);
MMPLAYER_FLEAVE();
}
const gchar *
-__get_state_name ( int state )
+__get_state_name(int state)
{
- switch ( state )
- {
- case MM_PLAYER_STATE_NULL:
- return "NULL";
- case MM_PLAYER_STATE_READY:
- return "READY";
- case MM_PLAYER_STATE_PAUSED:
- return "PAUSED";
- case MM_PLAYER_STATE_PLAYING:
- return "PLAYING";
- case MM_PLAYER_STATE_NONE:
- return "NONE";
- default:
- return "INVAID";
+ switch (state) {
+ case MM_PLAYER_STATE_NULL:
+ return "NULL";
+ case MM_PLAYER_STATE_READY:
+ return "READY";
+ case MM_PLAYER_STATE_PAUSED:
+ return "PAUSED";
+ case MM_PLAYER_STATE_PLAYING:
+ return "PLAYING";
+ case MM_PLAYER_STATE_NONE:
+ return "NONE";
+ default:
+ return "INVAID";
}
}
gboolean
-__is_rtsp_streaming ( mm_player_t* player )
+__is_rtsp_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_RTSP ) ? TRUE : FALSE;
+ return (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_RTSP) ? TRUE : FALSE;
}
gboolean
-__is_wfd_streaming ( mm_player_t* player )
+__is_wfd_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_WFD ) ? TRUE : FALSE;
+ return (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_WFD) ? TRUE : FALSE;
}
gboolean
-__is_http_streaming ( mm_player_t* player )
+__is_http_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_HTTP ) ? TRUE : FALSE;
+ return (player->profile.uri_type == MM_PLAYER_URI_TYPE_URL_HTTP) ? TRUE : FALSE;
}
gboolean
-__is_streaming ( mm_player_t* player )
+__is_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( __is_http_progressive_down( player ) || __is_rtsp_streaming ( player ) || __is_wfd_streaming ( player ) || __is_http_streaming ( player )
- || __is_http_live_streaming ( player ) || __is_dash_streaming ( player ) || __is_smooth_streaming(player) ) ? TRUE : FALSE;
+ return (__is_http_progressive_down(player) || __is_rtsp_streaming(player) || __is_wfd_streaming(player) || __is_http_streaming(player)
+ || __is_http_live_streaming(player) || __is_dash_streaming(player) || __is_smooth_streaming(player)) ? TRUE : FALSE;
}
gboolean
-__is_live_streaming ( mm_player_t* player )
+__is_live_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( __is_rtsp_streaming ( player ) && player->streaming_type == STREAMING_SERVICE_LIVE ) ? TRUE : FALSE;
+ return (__is_rtsp_streaming(player) && player->streaming_type == STREAMING_SERVICE_LIVE) ? TRUE : FALSE;
}
gboolean
-__is_http_live_streaming( mm_player_t* player )
+__is_http_live_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( player->profile.uri_type == MM_PLAYER_URI_TYPE_HLS ) ? TRUE : FALSE;
+ return (player->profile.uri_type == MM_PLAYER_URI_TYPE_HLS) ? TRUE : FALSE;
}
gboolean
-__is_dash_streaming ( mm_player_t* player )
+__is_dash_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( player->profile.uri_type == MM_PLAYER_URI_TYPE_DASH ) ? TRUE : FALSE;
+ return (player->profile.uri_type == MM_PLAYER_URI_TYPE_DASH) ? TRUE : FALSE;
}
gboolean
-__is_smooth_streaming ( mm_player_t* player )
+__is_smooth_streaming(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL ( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ( player->profile.uri_type == MM_PLAYER_URI_TYPE_SS ) ? TRUE : FALSE;
+ return (player->profile.uri_type == MM_PLAYER_URI_TYPE_SS) ? TRUE : FALSE;
}
gboolean
__is_http_progressive_down(mm_player_t* player)
{
- MMPLAYER_RETURN_VAL_IF_FAIL( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return ((player->pd_mode) ? TRUE:FALSE);
+ return ((player->pd_mode) ? TRUE : FALSE);
}
/* if retval is FALSE, it will be dropped for perfomance. */
{
gboolean retval = FALSE;
- if ( !(player->pipeline && player->pipeline->mainbin) )
- {
+ if (!(player->pipeline && player->pipeline->mainbin)) {
LOGE("player pipeline handle is null");
return TRUE;
}
- switch (GST_MESSAGE_TYPE (message))
- {
- case GST_MESSAGE_TAG:
- case GST_MESSAGE_EOS:
- case GST_MESSAGE_ERROR:
- case GST_MESSAGE_WARNING:
- case GST_MESSAGE_CLOCK_LOST:
- case GST_MESSAGE_NEW_CLOCK:
- case GST_MESSAGE_ELEMENT:
- case GST_MESSAGE_DURATION_CHANGED:
- case GST_MESSAGE_ASYNC_START:
+ switch (GST_MESSAGE_TYPE(message)) {
+ case GST_MESSAGE_TAG:
+ case GST_MESSAGE_EOS:
+ case GST_MESSAGE_ERROR:
+ case GST_MESSAGE_WARNING:
+ case GST_MESSAGE_CLOCK_LOST:
+ case GST_MESSAGE_NEW_CLOCK:
+ case GST_MESSAGE_ELEMENT:
+ case GST_MESSAGE_DURATION_CHANGED:
+ case GST_MESSAGE_ASYNC_START:
+ retval = TRUE;
+ break;
+ case GST_MESSAGE_ASYNC_DONE:
+ case GST_MESSAGE_STATE_CHANGED:
+ /* we only handle messages from pipeline */
+ if ((message->src == (GstObject *)player->pipeline->mainbin[MMPLAYER_M_PIPE].gst) && (!player->gapless.reconfigure))
retval = TRUE;
- break;
- case GST_MESSAGE_ASYNC_DONE:
- case GST_MESSAGE_STATE_CHANGED:
- /* we only handle messages from pipeline */
- if(( message->src == (GstObject *)player->pipeline->mainbin[MMPLAYER_M_PIPE].gst ) && (!player->gapless.reconfigure))
- retval = TRUE;
- else
- retval = FALSE;
- break;
- case GST_MESSAGE_BUFFERING:
- {
- gint buffer_percent = 0;
-
- gst_message_parse_buffering (message, &buffer_percent);
-
- if ((MMPLAYER_IS_STREAMING(player)) &&
- (player->streamer) &&
- (player->streamer->is_buffering == TRUE) &&
- (buffer_percent == MAX_BUFFER_PERCENT))
- {
- LOGD (">>> [%s] Buffering DONE is detected !!\n", GST_OBJECT_NAME(GST_MESSAGE_SRC(message)));
- player->streamer->is_buffering_done = TRUE;
- }
+ else
+ retval = FALSE;
+ break;
+ case GST_MESSAGE_BUFFERING:
+ {
+ gint buffer_percent = 0;
- retval = TRUE;
- break;
+ gst_message_parse_buffering(message, &buffer_percent);
+
+ if ((MMPLAYER_IS_STREAMING(player)) &&
+ (player->streamer) &&
+ (player->streamer->is_buffering == TRUE) &&
+ (buffer_percent == MAX_BUFFER_PERCENT)) {
+ LOGD(">>> [%s] Buffering DONE is detected !!\n", GST_OBJECT_NAME(GST_MESSAGE_SRC(message)));
+ player->streamer->is_buffering_done = TRUE;
}
- default:
- retval = FALSE;
- break;
+
+ retval = TRUE;
+ break;
+ }
+ default:
+ retval = FALSE;
+ break;
}
return retval;
gboolean
__mmplayer_post_message(mm_player_t* player, enum MMMessageType msgtype, MMMessageParamType* param)
{
- MMPLAYER_RETURN_VAL_IF_FAIL( player, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- if ( !player->msg_cb )
- {
+ if (!player->msg_cb)
return FALSE;
- }
//LOGD("Message (type : %d) will be posted using msg-cb(%p). \n", msgtype, player->msg_cb);
}
gboolean
-__mmplayer_handle_gst_error ( mm_player_t* player, GstMessage * message, GError* error )
+__mmplayer_handle_gst_error(mm_player_t* player, GstMessage * message, GError* error)
{
MMMessageParamType msg_param;
gchar *msg_src_element;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL( player, FALSE );
- MMPLAYER_RETURN_VAL_IF_FAIL( error, FALSE );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
+ MMPLAYER_RETURN_VAL_IF_FAIL(error, FALSE);
/* NOTE : do somthing necessary inside of __gst_handle_XXX_error. not here */
- memset (&msg_param, 0, sizeof(MMMessageParamType));
-
- if ( error->domain == GST_CORE_ERROR )
- {
- msg_param.code = __gst_handle_core_error( player, error->code );
- }
- else if ( error->domain == GST_LIBRARY_ERROR )
- {
- msg_param.code = __gst_handle_library_error( player, error->code );
- }
- else if ( error->domain == GST_RESOURCE_ERROR )
- {
- msg_param.code = __gst_handle_resource_error( player, error->code );
- }
- else if ( error->domain == GST_STREAM_ERROR )
- {
- msg_param.code = __gst_handle_stream_error( player, error, message );
- }
- else
- {
+ memset(&msg_param, 0, sizeof(MMMessageParamType));
+
+ if (error->domain == GST_CORE_ERROR) {
+ msg_param.code = __gst_handle_core_error(player, error->code);
+ } else if (error->domain == GST_LIBRARY_ERROR) {
+ msg_param.code = __gst_handle_library_error(player, error->code);
+ } else if (error->domain == GST_RESOURCE_ERROR) {
+ msg_param.code = __gst_handle_resource_error(player, error->code);
+ } else if (error->domain == GST_STREAM_ERROR) {
+ msg_param.code = __gst_handle_stream_error(player, error, message);
+ } else {
LOGW("This error domain is not defined.\n");
/* we treat system error as an internal error */
msg_param.code = MM_ERROR_PLAYER_INVALID_STREAM;
}
- if ( message->src )
- {
- msg_src_element = GST_ELEMENT_NAME( GST_ELEMENT_CAST( message->src ) );
+ if (message->src) {
+ msg_src_element = GST_ELEMENT_NAME(GST_ELEMENT_CAST(message->src));
msg_param.data = (void *) error->message;
LOGE("-Msg src : [%s] Domain : [%s] Error : [%s] Code : [%d] is tranlated to error code : [0x%x]\n",
- msg_src_element, g_quark_to_string (error->domain), error->message, error->code, msg_param.code);
+ msg_src_element, g_quark_to_string(error->domain), error->message, error->code, msg_param.code);
}
/* no error */
return TRUE;
/* post error to application */
- if ( ! player->msg_posted )
- {
- MMPLAYER_POST_MSG( player, MM_MESSAGE_ERROR, &msg_param );
+ if (!player->msg_posted) {
+ MMPLAYER_POST_MSG(player, MM_MESSAGE_ERROR, &msg_param);
/* don't post more if one was sent already */
player->msg_posted = TRUE;
- }
- else
- {
+ } else
LOGD("skip error post because it's sent already.\n");
- }
MMPLAYER_FLEAVE();
}
gint
-__gst_handle_core_error( mm_player_t* player, int code )
+__gst_handle_core_error(mm_player_t* player, int code)
{
gint trans_err = MM_ERROR_NONE;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- switch ( code )
- {
- case GST_CORE_ERROR_MISSING_PLUGIN:
- return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
- case GST_CORE_ERROR_STATE_CHANGE:
- case GST_CORE_ERROR_SEEK:
- case GST_CORE_ERROR_NOT_IMPLEMENTED:
- case GST_CORE_ERROR_FAILED:
- case GST_CORE_ERROR_TOO_LAZY:
- case GST_CORE_ERROR_PAD:
- case GST_CORE_ERROR_THREAD:
- case GST_CORE_ERROR_NEGOTIATION:
- case GST_CORE_ERROR_EVENT:
- case GST_CORE_ERROR_CAPS:
- case GST_CORE_ERROR_TAG:
- case GST_CORE_ERROR_CLOCK:
- case GST_CORE_ERROR_DISABLED:
- default:
- trans_err = MM_ERROR_PLAYER_INVALID_STREAM;
+ switch (code) {
+ case GST_CORE_ERROR_MISSING_PLUGIN:
+ return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
+ case GST_CORE_ERROR_STATE_CHANGE:
+ case GST_CORE_ERROR_SEEK:
+ case GST_CORE_ERROR_NOT_IMPLEMENTED:
+ case GST_CORE_ERROR_FAILED:
+ case GST_CORE_ERROR_TOO_LAZY:
+ case GST_CORE_ERROR_PAD:
+ case GST_CORE_ERROR_THREAD:
+ case GST_CORE_ERROR_NEGOTIATION:
+ case GST_CORE_ERROR_EVENT:
+ case GST_CORE_ERROR_CAPS:
+ case GST_CORE_ERROR_TAG:
+ case GST_CORE_ERROR_CLOCK:
+ case GST_CORE_ERROR_DISABLED:
+ default:
+ trans_err = MM_ERROR_PLAYER_INVALID_STREAM;
break;
}
}
gint
-__gst_handle_library_error( mm_player_t* player, int code )
+__gst_handle_library_error(mm_player_t* player, int code)
{
gint trans_err = MM_ERROR_NONE;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- switch ( code )
- {
- case GST_LIBRARY_ERROR_FAILED:
- case GST_LIBRARY_ERROR_TOO_LAZY:
- case GST_LIBRARY_ERROR_INIT:
- case GST_LIBRARY_ERROR_SHUTDOWN:
- case GST_LIBRARY_ERROR_SETTINGS:
- case GST_LIBRARY_ERROR_ENCODE:
- default:
- trans_err = MM_ERROR_PLAYER_INVALID_STREAM;
+ switch (code) {
+ case GST_LIBRARY_ERROR_FAILED:
+ case GST_LIBRARY_ERROR_TOO_LAZY:
+ case GST_LIBRARY_ERROR_INIT:
+ case GST_LIBRARY_ERROR_SHUTDOWN:
+ case GST_LIBRARY_ERROR_SETTINGS:
+ case GST_LIBRARY_ERROR_ENCODE:
+ default:
+ trans_err = MM_ERROR_PLAYER_INVALID_STREAM;
break;
}
}
gint
-__gst_handle_resource_error( mm_player_t* player, int code )
+__gst_handle_resource_error(mm_player_t* player, int code)
{
gint trans_err = MM_ERROR_NONE;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- switch ( code )
- {
- case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
- trans_err = MM_ERROR_PLAYER_NO_FREE_SPACE;
- break;
- case GST_RESOURCE_ERROR_NOT_FOUND:
- case GST_RESOURCE_ERROR_OPEN_READ:
- if ( MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING ( player )
- || MMPLAYER_IS_RTSP_STREAMING(player))
- {
- trans_err = MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL;
- break;
- }
- case GST_RESOURCE_ERROR_READ:
- if ( MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING ( player )
- || MMPLAYER_IS_RTSP_STREAMING(player))
- {
- trans_err = MM_ERROR_PLAYER_STREAMING_FAIL;
- break;
- }
- case GST_RESOURCE_ERROR_WRITE:
- case GST_RESOURCE_ERROR_FAILED:
- case GST_RESOURCE_ERROR_SEEK:
- case GST_RESOURCE_ERROR_TOO_LAZY:
- case GST_RESOURCE_ERROR_BUSY:
- case GST_RESOURCE_ERROR_OPEN_WRITE:
- case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
- case GST_RESOURCE_ERROR_CLOSE:
- case GST_RESOURCE_ERROR_SYNC:
- case GST_RESOURCE_ERROR_SETTINGS:
- default:
- trans_err = MM_ERROR_PLAYER_INTERNAL;
+ switch (code) {
+ case GST_RESOURCE_ERROR_NO_SPACE_LEFT:
+ trans_err = MM_ERROR_PLAYER_NO_FREE_SPACE;
break;
+ case GST_RESOURCE_ERROR_NOT_FOUND:
+ case GST_RESOURCE_ERROR_OPEN_READ:
+ if (MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING(player)
+ || MMPLAYER_IS_RTSP_STREAMING(player)) {
+ trans_err = MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL;
+ break;
+ }
+ case GST_RESOURCE_ERROR_READ:
+ if (MMPLAYER_IS_HTTP_STREAMING(player) || MMPLAYER_IS_HTTP_LIVE_STREAMING(player)
+ || MMPLAYER_IS_RTSP_STREAMING(player)) {
+ trans_err = MM_ERROR_PLAYER_STREAMING_FAIL;
+ break;
+ }
+ case GST_RESOURCE_ERROR_WRITE:
+ case GST_RESOURCE_ERROR_FAILED:
+ case GST_RESOURCE_ERROR_SEEK:
+ case GST_RESOURCE_ERROR_TOO_LAZY:
+ case GST_RESOURCE_ERROR_BUSY:
+ case GST_RESOURCE_ERROR_OPEN_WRITE:
+ case GST_RESOURCE_ERROR_OPEN_READ_WRITE:
+ case GST_RESOURCE_ERROR_CLOSE:
+ case GST_RESOURCE_ERROR_SYNC:
+ case GST_RESOURCE_ERROR_SETTINGS:
+ default:
+ trans_err = MM_ERROR_PLAYER_INTERNAL;
+ break;
}
MMPLAYER_FLEAVE();
}
gint
-__gst_handle_stream_error( mm_player_t* player, GError* error, GstMessage * message )
+__gst_handle_stream_error(mm_player_t* player, GError* error, GstMessage * message)
{
gint trans_err = MM_ERROR_NONE;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL( player, MM_ERROR_PLAYER_NOT_INITIALIZED );
- MMPLAYER_RETURN_VAL_IF_FAIL( error, MM_ERROR_INVALID_ARGUMENT );
- MMPLAYER_RETURN_VAL_IF_FAIL ( message, MM_ERROR_INVALID_ARGUMENT );
-
- switch ( error->code )
- {
- case GST_STREAM_ERROR_FAILED:
- case GST_STREAM_ERROR_TYPE_NOT_FOUND:
- case GST_STREAM_ERROR_DECODE:
- case GST_STREAM_ERROR_WRONG_TYPE:
- case GST_STREAM_ERROR_DECRYPT:
- case GST_STREAM_ERROR_DECRYPT_NOKEY:
- case GST_STREAM_ERROR_CODEC_NOT_FOUND:
- trans_err = __gst_transform_gsterror( player, message, error );
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(error, MM_ERROR_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(message, MM_ERROR_INVALID_ARGUMENT);
+
+ switch (error->code) {
+ case GST_STREAM_ERROR_FAILED:
+ case GST_STREAM_ERROR_TYPE_NOT_FOUND:
+ case GST_STREAM_ERROR_DECODE:
+ case GST_STREAM_ERROR_WRONG_TYPE:
+ case GST_STREAM_ERROR_DECRYPT:
+ case GST_STREAM_ERROR_DECRYPT_NOKEY:
+ case GST_STREAM_ERROR_CODEC_NOT_FOUND:
+ trans_err = __gst_transform_gsterror(player, message, error);
break;
- case GST_STREAM_ERROR_NOT_IMPLEMENTED:
- case GST_STREAM_ERROR_TOO_LAZY:
- case GST_STREAM_ERROR_ENCODE:
- case GST_STREAM_ERROR_DEMUX:
- case GST_STREAM_ERROR_MUX:
- case GST_STREAM_ERROR_FORMAT:
- default:
- trans_err = MM_ERROR_PLAYER_INVALID_STREAM;
+ case GST_STREAM_ERROR_NOT_IMPLEMENTED:
+ case GST_STREAM_ERROR_TOO_LAZY:
+ case GST_STREAM_ERROR_ENCODE:
+ case GST_STREAM_ERROR_DEMUX:
+ case GST_STREAM_ERROR_MUX:
+ case GST_STREAM_ERROR_FORMAT:
+ default:
+ trans_err = MM_ERROR_PLAYER_INVALID_STREAM;
break;
}
/* NOTE : decide gstreamer state whether there is some playable track or not. */
static gint
-__gst_transform_gsterror( mm_player_t* player, GstMessage * message, GError* error )
+__gst_transform_gsterror(mm_player_t* player, GstMessage * message, GError* error)
{
gchar *src_element_name = NULL;
GstElement *src_element = NULL;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL ( message, MM_ERROR_INVALID_ARGUMENT );
- MMPLAYER_RETURN_VAL_IF_FAIL ( message->src, MM_ERROR_INVALID_ARGUMENT );
- MMPLAYER_RETURN_VAL_IF_FAIL ( error, MM_ERROR_INVALID_ARGUMENT );
+ MMPLAYER_RETURN_VAL_IF_FAIL(message, MM_ERROR_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(message->src, MM_ERROR_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(error, MM_ERROR_INVALID_ARGUMENT);
src_element = GST_ELEMENT_CAST(message->src);
- if ( !src_element )
+ if (!src_element)
goto INTERNAL_ERROR;
src_element_name = GST_ELEMENT_NAME(src_element);
- if ( !src_element_name )
+ if (!src_element_name)
goto INTERNAL_ERROR;
factory = gst_element_get_factory(src_element);
- if ( !factory )
+ if (!factory)
goto INTERNAL_ERROR;
- klass = gst_element_factory_get_metadata (factory, GST_ELEMENT_METADATA_KLASS);
- if ( !klass )
+ klass = gst_element_factory_get_metadata(factory, GST_ELEMENT_METADATA_KLASS);
+ if (!klass)
goto INTERNAL_ERROR;
LOGD("error code=%d, msg=%s, src element=%s, class=%s\n",
if (player->pipeline->mainbin[MMPLAYER_M_A_INPUT_SELECTOR].gst) {
int msg_src_pos = 0;
gint active_pad_index = player->selector[MM_PLAYER_TRACK_TYPE_AUDIO].active_pad_index;
- LOGD ("current active pad index -%d", active_pad_index);
+ LOGD("current active pad index -%d", active_pad_index);
if (src_element_name) {
int idx = 0;
if (player->audio_decoders) {
GList *adec = player->audio_decoders;
- for ( ;adec ; adec = g_list_next(adec)) {
+ for (; adec ; adec = g_list_next(adec)) {
gchar *name = adec->data;
LOGD("found audio decoder name = %s", name);
}
//-> check!! if needed or not
- switch ( error->code )
+ switch (error->code) {
+ case GST_STREAM_ERROR_DECODE:
{
- case GST_STREAM_ERROR_DECODE:
- {
- /* Demuxer can't parse one track because it's corrupted.
- * So, the decoder for it is not linked.
- * But, it has one playable track.
- */
- if ( g_strrstr(klass, "Demux") )
- {
- if ( player->can_support_codec == FOUND_PLUGIN_VIDEO )
- {
- return MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
- }
- else if ( player->can_support_codec == FOUND_PLUGIN_AUDIO )
- {
+ /* Demuxer can't parse one track because it's corrupted.
+ * So, the decoder for it is not linked.
+ * But, it has one playable track.
+ */
+ if (g_strrstr(klass, "Demux")) {
+ if (player->can_support_codec == FOUND_PLUGIN_VIDEO) {
+ return MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
+ } else if (player->can_support_codec == FOUND_PLUGIN_AUDIO) {
+ return MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
+ } else {
+ if (player->pipeline->audiobin) // PCM
return MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
- }
else
- {
- if ( player->pipeline->audiobin ) // PCM
- {
- return MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
- }
- else
- {
- goto CODEC_NOT_FOUND;
- }
- }
+ goto CODEC_NOT_FOUND;
}
- return MM_ERROR_PLAYER_INVALID_STREAM;
}
+ return MM_ERROR_PLAYER_INVALID_STREAM;
+ }
break;
- case GST_STREAM_ERROR_CODEC_NOT_FOUND:
- case GST_STREAM_ERROR_TYPE_NOT_FOUND:
- case GST_STREAM_ERROR_WRONG_TYPE:
- return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
-
- case GST_STREAM_ERROR_FAILED:
- {
- /* Decoder Custom Message */
- if ( strstr(error->message, "ongoing") )
- {
- if ( strncasecmp(klass, "audio", 5) )
- {
- if ( ( player->can_support_codec & FOUND_PLUGIN_VIDEO ) )
- {
- LOGD("Video can keep playing.\n");
- return MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
- }
- else
- {
- goto CODEC_NOT_FOUND;
- }
+ case GST_STREAM_ERROR_CODEC_NOT_FOUND:
+ case GST_STREAM_ERROR_TYPE_NOT_FOUND:
+ case GST_STREAM_ERROR_WRONG_TYPE:
+ return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
- }
- else if ( strncasecmp(klass, "video", 5) )
- {
- if ( ( player->can_support_codec & FOUND_PLUGIN_AUDIO ) )
- {
- LOGD("Audio can keep playing.\n");
- return MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
- }
- else
- {
- goto CODEC_NOT_FOUND;
- }
- }
+ case GST_STREAM_ERROR_FAILED:
+ {
+ /* Decoder Custom Message */
+ if (strstr(error->message, "ongoing")) {
+ if (strncasecmp(klass, "audio", 5)) {
+ if ((player->can_support_codec & FOUND_PLUGIN_VIDEO)) {
+ LOGD("Video can keep playing.\n");
+ return MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND;
+ } else
+ goto CODEC_NOT_FOUND;
+
+ } else if (strncasecmp(klass, "video", 5)) {
+ if ((player->can_support_codec & FOUND_PLUGIN_AUDIO)) {
+ LOGD("Audio can keep playing.\n");
+ return MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND;
+ } else
+ goto CODEC_NOT_FOUND;
}
- return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
}
+ return MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT;
+ }
break;
- case GST_STREAM_ERROR_DECRYPT:
- case GST_STREAM_ERROR_DECRYPT_NOKEY:
- {
- LOGE("decryption error, [%s] failed, reason : [%s]\n", src_element_name, error->message);
-
- if ( strstr(error->message, "rights expired") )
- {
- return MM_ERROR_PLAYER_DRM_EXPIRED;
- }
- else if ( strstr(error->message, "no rights") )
- {
- return MM_ERROR_PLAYER_DRM_NO_LICENSE;
- }
- else if ( strstr(error->message, "has future rights") )
- {
- return MM_ERROR_PLAYER_DRM_FUTURE_USE;
- }
- else if ( strstr(error->message, "opl violation") )
- {
- return MM_ERROR_PLAYER_DRM_OUTPUT_PROTECTION;
- }
- return MM_ERROR_PLAYER_DRM_NOT_AUTHORIZED;
- }
+ case GST_STREAM_ERROR_DECRYPT:
+ case GST_STREAM_ERROR_DECRYPT_NOKEY:
+ {
+ LOGE("decryption error, [%s] failed, reason : [%s]\n", src_element_name, error->message);
+
+ if (strstr(error->message, "rights expired"))
+ return MM_ERROR_PLAYER_DRM_EXPIRED;
+ else if (strstr(error->message, "no rights"))
+ return MM_ERROR_PLAYER_DRM_NO_LICENSE;
+ else if (strstr(error->message, "has future rights"))
+ return MM_ERROR_PLAYER_DRM_FUTURE_USE;
+ else if (strstr(error->message, "opl violation"))
+ return MM_ERROR_PLAYER_DRM_OUTPUT_PROTECTION;
+ return MM_ERROR_PLAYER_DRM_NOT_AUTHORIZED;
+ }
break;
- default:
+ default:
break;
}
int
__mmplayer_get_video_angle(mm_player_t* player, int *user_angle, int *org_angle)
{
- int user_angle_type= 0;
+ int user_angle_type = 0;
gchar *org_orient = NULL;
MMHandleType attrs = MMPLAYER_GET_ATTRS(player);
- if ( !attrs )
- {
+ if (!attrs) {
LOGE("cannot get content attribute");
return MM_ERROR_PLAYER_INTERNAL;
}
mm_attrs_get_int_by_name(attrs, "display_rotation", &user_angle_type);
/* get angle with user type */
- switch(user_angle_type)
- {
- case MM_DISPLAY_ROTATION_NONE:
- *user_angle = 0;
- break;
- case MM_DISPLAY_ROTATION_90: // counter-clockwise 90
- *user_angle = 270;
- break;
- case MM_DISPLAY_ROTATION_180:
- *user_angle = 180;
- break;
- case MM_DISPLAY_ROTATION_270: // clockwise 90
- *user_angle = 90;
- break;
+ switch (user_angle_type) {
+ case MM_DISPLAY_ROTATION_NONE:
+ *user_angle = 0;
+ break;
+ case MM_DISPLAY_ROTATION_90: /* counter-clockwise 90 */
+ *user_angle = 270;
+ break;
+ case MM_DISPLAY_ROTATION_180:
+ *user_angle = 180;
+ break;
+ case MM_DISPLAY_ROTATION_270: /* clockwise 90 */
+ *user_angle = 90;
+ break;
}
/* get original orientation */
mm_attrs_get_string_by_name(attrs, "content_video_orientation", &org_orient);
- if (org_orient)
- {
- if (!strcmp (org_orient, "rotate-90"))
+ if (org_orient) {
+ if (!strcmp(org_orient, "rotate-90"))
*org_angle = 90;
- else if (!strcmp (org_orient, "rotate-180"))
+ else if (!strcmp(org_orient, "rotate-180"))
*org_angle = 180;
- else if (!strcmp (org_orient, "rotate-270"))
+ else if (!strcmp(org_orient, "rotate-270"))
*org_angle = 270;
else
- LOGD ("original rotation is %s", org_orient);
- }
- else
- {
- LOGD ("content_video_orientation get fail");
- }
+ LOGD("original rotation is %s", org_orient);
+ } else
+ LOGD("content_video_orientation get fail");
LOGD("check user angle: %d, orientation: %d", *user_angle, *org_angle);
/*
* libmm-player
*
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ * Copyright(c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, heechul jeon <heechul.jeon@samsung.co>,
* YoungHwan An <younghwan_.an@samsung.com>, Eunhae Choi <eunhae1.choi@samsung.com>
*
- * Licensed under the Apache License, Version 2.0 (the "License");
+ * Licensed under the Apache License, Version 2.0(the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
/*---------------------------------------------------------------------------
| LOCAL FUNCTION PROTOTYPES: |
---------------------------------------------------------------------------*/
-static int __parse_media_format (MMPlayerVideoStreamInfo * video, MMPlayerAudioStreamInfo * audio, media_format_h format);
-static int __convert_media_format_video_mime_to_str (MMPlayerVideoStreamInfo * video, media_format_mimetype_e mime);
-static int __convert_media_format_audio_mime_to_str (MMPlayerAudioStreamInfo * audio, media_format_mimetype_e mime);
+static int __parse_media_format(MMPlayerVideoStreamInfo * video, MMPlayerAudioStreamInfo * audio, media_format_h format);
+static int __convert_media_format_video_mime_to_str(MMPlayerVideoStreamInfo * video, media_format_mimetype_e mime);
+static int __convert_media_format_audio_mime_to_str(MMPlayerAudioStreamInfo * audio, media_format_mimetype_e mime);
/*===========================================================================================
| |
| FUNCTION DEFINITIONS |
-| |
+| |
========================================================================================== */
static int
-__convert_media_format_video_mime_to_str (MMPlayerVideoStreamInfo * video,
- media_format_mimetype_e mime)
+__convert_media_format_video_mime_to_str(MMPlayerVideoStreamInfo * video,
+ media_format_mimetype_e mime)
{
- MMPLAYER_RETURN_VAL_IF_FAIL (video, MM_ERROR_INVALID_ARGUMENT);
-
- switch (mime) {
- case MEDIA_FORMAT_MPEG4_SP:
- video->mime = g_strdup ("video/mpeg");
- video->version = 4;
- break;
- case MEDIA_FORMAT_H264_SP:
+ MMPLAYER_RETURN_VAL_IF_FAIL(video, MM_ERROR_INVALID_ARGUMENT);
+
+ switch (mime) {
+ case MEDIA_FORMAT_MPEG4_SP:
+ video->mime = g_strdup("video/mpeg");
+ video->version = 4;
+ break;
+ case MEDIA_FORMAT_H264_SP:
case MEDIA_FORMAT_H264_MP:
case MEDIA_FORMAT_H264_HP:
- video->mime = g_strdup ("video/x-h264");
- break;
- default:
- video->mime = g_strdup ("unknown");
- break;
- }
-
- return MM_ERROR_NONE;
+ video->mime = g_strdup("video/x-h264");
+ break;
+ default:
+ video->mime = g_strdup("unknown");
+ break;
+ }
+
+ return MM_ERROR_NONE;
}
static int
-__convert_media_format_audio_mime_to_str (MMPlayerAudioStreamInfo * audio,
- media_format_mimetype_e mime)
+__convert_media_format_audio_mime_to_str(MMPlayerAudioStreamInfo * audio,
+ media_format_mimetype_e mime)
{
- MMPLAYER_RETURN_VAL_IF_FAIL (audio, MM_ERROR_INVALID_ARGUMENT);
-
- switch (mime) {
- case MEDIA_FORMAT_AAC:
- audio->mime = g_strdup ("audio/mpeg");
- audio->version = 2;
- break;
- default:
- audio->mime = g_strdup ("unknown");
- break;
- }
-
- return MM_ERROR_NONE;
+ MMPLAYER_RETURN_VAL_IF_FAIL(audio, MM_ERROR_INVALID_ARGUMENT);
+
+ switch (mime) {
+ case MEDIA_FORMAT_AAC:
+ audio->mime = g_strdup("audio/mpeg");
+ audio->version = 2;
+ break;
+ default:
+ audio->mime = g_strdup("unknown");
+ break;
+ }
+
+ return MM_ERROR_NONE;
}
static int
-__parse_media_format (MMPlayerVideoStreamInfo * video,
- MMPlayerAudioStreamInfo * audio, media_format_h format)
+__parse_media_format(MMPlayerVideoStreamInfo * video,
+ MMPlayerAudioStreamInfo * audio, media_format_h format)
{
- if (audio) {
- media_format_mimetype_e mime;
- int channel;
- int samplerate;
- int avg_bps;
-
- if (media_format_get_audio_info (format, &mime, &channel, &samplerate, NULL,
- &avg_bps) != MEDIA_FORMAT_ERROR_NONE) {
- LOGE ("media_format_get_audio_info failed");
- return MM_ERROR_PLAYER_INTERNAL;
- }
-
- __convert_media_format_audio_mime_to_str (audio, mime);
- audio->sample_rate = samplerate;
- audio->channels = channel;
-//video->user_info = ;
- }
-
- if (video) {
+ if (audio) {
+ media_format_mimetype_e mime;
+ int channel;
+ int samplerate;
+ int avg_bps;
+
+ if (media_format_get_audio_info(format, &mime, &channel, &samplerate, NULL,
+ &avg_bps) != MEDIA_FORMAT_ERROR_NONE) {
+ LOGE("media_format_get_audio_info failed");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ __convert_media_format_audio_mime_to_str(audio, mime);
+ audio->sample_rate = samplerate;
+ audio->channels = channel;
+ //video->user_info = ;
+ }
+
+ if (video) {
#define DEFAULT_FRAMERATE_NUM 30
#define DEFAULT_FRAMERATE_DEN 1
- media_format_mimetype_e mime;
- int width = 0;
- int height = 0;
- int avg_bps = 0;
- int frame_rate = 0;
-
- if (media_format_get_video_info (format, &mime, &width, &height, &avg_bps,
- NULL) != MEDIA_FORMAT_ERROR_NONE) {
- LOGE ("media_format_get_video_info failed");
- return MM_ERROR_PLAYER_INTERNAL;
- }
-
- if (media_format_get_video_frame_rate(format, &frame_rate)) {
- LOGW ("failed to get video frame rate, will be set 30.");
- }
- LOGD ("frame_rate %d", frame_rate);
-
- __convert_media_format_video_mime_to_str (video, mime);
-
- video->width = width;
- video->height = height;
- video->framerate_num = (frame_rate>0)?(frame_rate):(DEFAULT_FRAMERATE_NUM);
- video->framerate_den = DEFAULT_FRAMERATE_DEN;
- }
-
- return MM_ERROR_NONE;
+ media_format_mimetype_e mime;
+ int width = 0;
+ int height = 0;
+ int avg_bps = 0;
+ int frame_rate = 0;
+
+ if (media_format_get_video_info(format, &mime, &width, &height, &avg_bps,
+ NULL) != MEDIA_FORMAT_ERROR_NONE) {
+ LOGE("media_format_get_video_info failed");
+ return MM_ERROR_PLAYER_INTERNAL;
+ }
+
+ if (media_format_get_video_frame_rate(format, &frame_rate))
+ LOGW("failed to get video frame rate, will be set 30.");
+
+ LOGD("frame_rate %d", frame_rate);
+
+ __convert_media_format_video_mime_to_str(video, mime);
+
+ video->width = width;
+ video->height = height;
+ video->framerate_num = (frame_rate > 0) ? (frame_rate) : (DEFAULT_FRAMERATE_NUM);
+ video->framerate_den = DEFAULT_FRAMERATE_DEN;
+ }
+
+ return MM_ERROR_NONE;
}
static gboolean
__mmplayer_update_video_info(MMHandleType hplayer, media_format_h fmt)
{
- mm_player_t *player = (mm_player_t *) hplayer;
- gboolean ret = FALSE;
- GstStructure *str = NULL;
- media_format_mimetype_e mimetype = 0;
- gint cur_width = 0, width = 0;
- gint cur_height = 0, height = 0;
-
- MMPLAYER_FENTER ();
-
- MMPLAYER_RETURN_VAL_IF_FAIL (player, FALSE);
- MMPLAYER_RETURN_VAL_IF_FAIL (fmt, FALSE);
-
- if (player->v_stream_caps)
- {
- str = gst_caps_get_structure (player->v_stream_caps, 0);
- if ( !gst_structure_get_int (str, "width", &cur_width))
- {
- LOGD ("missing 'width' field in video caps");
- }
-
- if ( !gst_structure_get_int (str, "height", &cur_height))
- {
- LOGD ("missing 'height' field in video caps");
- }
-
- media_format_get_video_info(fmt, &mimetype, &width, &height, NULL, NULL);
- if ((cur_width != width) || (cur_height != height))
- {
- LOGW ("resolution is changed %dx%d -> %dx%d",
- cur_width, cur_height, width, height);
- _mmplayer_set_video_info(hplayer, fmt);
- ret = TRUE;
- }
- }
-
- MMPLAYER_FLEAVE ();
- return ret;
+ mm_player_t *player = (mm_player_t *) hplayer;
+ gboolean ret = FALSE;
+ GstStructure *str = NULL;
+ media_format_mimetype_e mimetype = 0;
+ gint cur_width = 0, width = 0;
+ gint cur_height = 0, height = 0;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
+ MMPLAYER_RETURN_VAL_IF_FAIL(fmt, FALSE);
+
+ if (player->v_stream_caps) {
+ str = gst_caps_get_structure(player->v_stream_caps, 0);
+ if (!gst_structure_get_int(str, "width", &cur_width))
+ LOGD("missing 'width' field in video caps");
+
+ if (!gst_structure_get_int(str, "height", &cur_height))
+ LOGD("missing 'height' field in video caps");
+
+ media_format_get_video_info(fmt, &mimetype, &width, &height, NULL, NULL);
+ if ((cur_width != width) || (cur_height != height)) {
+ LOGW("resolution is changed %dx%d -> %dx%d",
+ cur_width, cur_height, width, height);
+ _mmplayer_set_video_info(hplayer, fmt);
+ ret = TRUE;
+ }
+ }
+
+ MMPLAYER_FLEAVE();
+ return ret;
}
int
_mmplayer_set_media_stream_buffer_status_cb(MMHandleType hplayer,
- MMPlayerStreamType type,
- mm_player_media_stream_buffer_status_callback callback,
- void *user_param)
+ MMPlayerStreamType type,
+ mm_player_media_stream_buffer_status_callback callback,
+ void *user_param)
{
mm_player_t *player = (mm_player_t *) hplayer;
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
return MM_ERROR_INVALID_ARGUMENT;
- if (player->media_stream_buffer_status_cb[type])
- {
+ if (player->media_stream_buffer_status_cb[type]) {
if (!callback)
- {
- LOGD ("[type:%d] will be clear.\n", type);
- }
+ LOGD("[type:%d] will be clear.\n", type);
else
- {
- LOGD ("[type:%d] will be overwritten.\n", type);
- }
+ LOGD("[type:%d] will be overwritten.\n", type);
}
player->media_stream_buffer_status_cb[type] = callback;
player->buffer_cb_user_param = user_param;
- LOGD ("player handle %p, type %d, callback %p\n", player, type,
+ LOGD("player handle %p, type %d, callback %p\n", player, type,
player->media_stream_buffer_status_cb[type]);
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
int
_mmplayer_set_media_stream_seek_data_cb(MMHandleType hplayer,
- MMPlayerStreamType type,
- mm_player_media_stream_seek_data_callback callback,
- void *user_param)
+ MMPlayerStreamType type,
+ mm_player_media_stream_seek_data_callback callback,
+ void *user_param)
{
mm_player_t *player = (mm_player_t *) hplayer;
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
return MM_ERROR_INVALID_ARGUMENT;
- if (player->media_stream_seek_data_cb[type])
- {
+ if (player->media_stream_seek_data_cb[type]) {
if (!callback)
- {
- LOGD ("[type:%d] will be clear.\n", type);
- }
+ LOGD("[type:%d] will be clear.\n", type);
else
- {
- LOGD ("[type:%d] will be overwritten.\n", type);
- }
+ LOGD("[type:%d] will be overwritten.\n", type);
}
player->media_stream_seek_data_cb[type] = callback;
player->buffer_cb_user_param = user_param;
- LOGD ("player handle %p, type %d, callback %p\n", player, type,
+ LOGD("player handle %p, type %d, callback %p\n", player, type,
player->media_stream_seek_data_cb[type]);
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
static GstElement*
-__mmplayer_get_source_element (mm_player_t *player, MMPlayerStreamType type)
+__mmplayer_get_source_element(mm_player_t *player, MMPlayerStreamType type)
{
enum MainElementID elemId = MMPLAYER_M_NUM;
if (player && player->pipeline && player->pipeline->mainbin) {
-
/* get elem according to the stream type */
if (type == MM_PLAYER_STREAM_TYPE_AUDIO) {
- if (player->pipeline->mainbin[MMPLAYER_M_2ND_SRC].gst) {
+ if (player->pipeline->mainbin[MMPLAYER_M_2ND_SRC].gst)
elemId = MMPLAYER_M_2ND_SRC;
- } else if (g_strrstr (GST_ELEMENT_NAME (player->pipeline->mainbin[MMPLAYER_M_SRC].gst), "audio_appsrc")) {
+ else if (g_strrstr(GST_ELEMENT_NAME(player->pipeline->mainbin[MMPLAYER_M_SRC].gst), "audio_appsrc"))
elemId = MMPLAYER_M_SRC;
- }
- }
- else if (type == MM_PLAYER_STREAM_TYPE_VIDEO) {
+ } else if (type == MM_PLAYER_STREAM_TYPE_VIDEO) {
elemId = MMPLAYER_M_SRC;
- }
- else if (type == MM_PLAYER_STREAM_TYPE_TEXT) {
+ } else if (type == MM_PLAYER_STREAM_TYPE_TEXT) {
elemId = MMPLAYER_M_SUBSRC;
}
mm_player_t *player = (mm_player_t *) hplayer;
GstElement *element = NULL;
- MMPLAYER_FENTER ();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if ((type < MM_PLAYER_STREAM_TYPE_AUDIO) ||
(type > MM_PLAYER_STREAM_TYPE_TEXT) ||
(max_size == 0)) {
- LOGE ("Invalid param type:%d, max_size:%d", type, max_size);
+ LOGE("Invalid param type:%d, max_size:%d", type, max_size);
return MM_ERROR_INVALID_ARGUMENT;
}
- LOGD ("type %d, max_size %llu\n", type, max_size);
+ LOGD("type %d, max_size %llu\n", type, max_size);
if ((element = __mmplayer_get_source_element(player, type))) {
- LOGD ("update max_size of %s\n", GST_ELEMENT_NAME(element));
+ LOGD("update max_size of %s\n", GST_ELEMENT_NAME(element));
g_object_set(G_OBJECT(element), "max-bytes", max_size, NULL);
}
player->media_stream_buffer_max_size[type] = max_size;
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
{
mm_player_t *player = (mm_player_t *) hplayer;
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL (max_size, MM_ERROR_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(max_size, MM_ERROR_INVALID_ARGUMENT);
if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
return MM_ERROR_INVALID_ARGUMENT;
*max_size = player->media_stream_buffer_max_size[type];
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
mm_player_t *player = (mm_player_t *) hplayer;
GstElement *element = NULL;
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
if ((type < MM_PLAYER_STREAM_TYPE_AUDIO) || (type > MM_PLAYER_STREAM_TYPE_TEXT)) {
- LOGE ("Invalid param type:%d", type);
+ LOGE("Invalid param type:%d", type);
return MM_ERROR_INVALID_ARGUMENT;
}
- LOGD ("type %d, min_per %u\n", type, min_percent);
+ LOGD("type %d, min_per %u\n", type, min_percent);
if ((element = __mmplayer_get_source_element(player, type))) {
- LOGD ("update min_per of %s\n", GST_ELEMENT_NAME(element));
+ LOGD("update min_per of %s\n", GST_ELEMENT_NAME(element));
g_object_set(G_OBJECT(element), "min-percent", min_percent, NULL);
}
player->media_stream_buffer_min_percent[type] = min_percent;
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
{
mm_player_t *player = (mm_player_t *) hplayer;
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL (min_percent, MM_ERROR_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(min_percent, MM_ERROR_INVALID_ARGUMENT);
if ((type < MM_PLAYER_STREAM_TYPE_DEFAULT) || (type > MM_PLAYER_STREAM_TYPE_TEXT))
return MM_ERROR_INVALID_ARGUMENT;
*min_percent = player->media_stream_buffer_min_percent[type];
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
guint64 max_bytes = 0;
guint current_level_per = 0;
- MMPLAYER_FENTER ();
- MMPLAYER_RETURN_VAL_IF_FAIL ( player && element, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player && element, MM_ERROR_PLAYER_NOT_INITIALIZED);
- if (player->media_stream_buffer_max_size[type] > 0) {
+ if (player->media_stream_buffer_max_size[type] > 0)
max_bytes = player->media_stream_buffer_max_size[type];
- } else {
+ else
g_object_get(G_OBJECT(element), "max-bytes", &max_bytes, NULL);
- }
if (max_bytes == 0) {
- LOGW ("buffer max size is zero.");
+ LOGW("buffer max size is zero.");
return MM_ERROR_NONE;
}
g_object_get(G_OBJECT(element), "current-level-bytes", ¤t_level_bytes, NULL);
if (max_bytes <= current_level_bytes) {
- LOGE ("no available buffer space. type %d, max %lld, curr %lld", type, max_bytes, current_level_bytes);
+ LOGE("no available buffer space. type %d, max %lld, curr %lld", type, max_bytes, current_level_bytes);
return MM_ERROR_PLAYER_BUFFER_SPACE;
}
if (MMPLAYER_CURRENT_STATE(player) != MM_PLAYER_STATE_PLAYING) {
- if (!player->media_stream_buffer_status_cb[type]) {
+ if (!player->media_stream_buffer_status_cb[type])
return MM_ERROR_NONE;
- }
current_level_per = (guint)(gst_util_guint64_to_gdouble(current_level_bytes)/gst_util_guint64_to_gdouble(max_bytes)*100);
- LOGD ("type %d, min_per %u, curr_per %u max %lld cur %lld\n",
+ LOGD("type %d, min_per %u, curr_per %u max %lld cur %lld\n",
type, player->media_stream_buffer_min_percent[type],
current_level_per,
player->media_stream_buffer_max_size[type],
player->media_stream_buffer_status_cb[type](type, MM_PLAYER_MEDIA_STREAM_BUFFER_UNDERRUN, current_level_bytes, player->buffer_cb_user_param);
}
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return MM_ERROR_NONE;
}
int
-_mmplayer_submit_packet (MMHandleType hplayer, media_packet_h packet)
+_mmplayer_submit_packet(MMHandleType hplayer, media_packet_h packet)
{
- int ret = MM_ERROR_NONE;
- GstBuffer *_buffer = NULL;
- mm_player_t *player = (mm_player_t *) hplayer;
- guint8 *buf = NULL;
- uint64_t size = 0;
- GstElement* element = NULL;
- MMPlayerStreamType streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
- media_format_h fmt = NULL;
- bool flag = FALSE;
- bool is_eos = FALSE;
-
- MMPLAYER_RETURN_VAL_IF_FAIL (packet, MM_ERROR_INVALID_ARGUMENT);
- MMPLAYER_RETURN_VAL_IF_FAIL ( player &&
- player->pipeline &&
- player->pipeline->mainbin &&
- player->pipeline->mainbin[MMPLAYER_M_SRC].gst,
- MM_ERROR_PLAYER_INTERNAL );
-
- /* get stream type if audio or video */
- media_packet_is_audio (packet, &flag);
- if (flag) {
- streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
- } else {
- media_packet_is_video (packet, &flag);
- if (flag)
- streamtype = MM_PLAYER_STREAM_TYPE_VIDEO;
- else
- streamtype = MM_PLAYER_STREAM_TYPE_TEXT;
- }
-
- element = __mmplayer_get_source_element(player, streamtype);
- if (!element) {
- LOGE ("there is no source element of type %d", streamtype);
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto ERROR;
- }
-
- /* check buffer level */
- ret = __mmplayer_check_buffer_level (player, element, streamtype);
- if (ret != MM_ERROR_NONE)
- return ret;
-
- /* get data */
- if (media_packet_get_buffer_data_ptr (packet, (void **) &buf) != MEDIA_PACKET_ERROR_NONE) {
- LOGE("failed to get buffer data ptr");
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto ERROR;
- }
-
- if (media_packet_get_buffer_size (packet, &size) != MEDIA_PACKET_ERROR_NONE) {
- LOGE("failed to get buffer size");
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto ERROR;
- }
-
- if (buf != NULL && size > 0) {
- GstMapInfo buff_info = GST_MAP_INFO_INIT;
- uint64_t pts = 0;
-
- /* get size */
- _buffer = gst_buffer_new_and_alloc (size);
-
- if (!_buffer) {
- LOGE("failed to allocate memory for push buffer\n");
- ret = MM_ERROR_PLAYER_NO_FREE_SPACE;
- goto ERROR;
- }
-
- if (gst_buffer_map (_buffer, &buff_info, GST_MAP_READWRITE)) {
-
- memcpy (buff_info.data, buf, size);
- buff_info.size = size;
-
- gst_buffer_unmap (_buffer, &buff_info);
- }
-
- if (streamtype == MM_PLAYER_STREAM_TYPE_VIDEO) {
- /* get format to check video format */
- media_packet_get_format (packet, &fmt);
- if (fmt) {
- if (__mmplayer_update_video_info(hplayer, fmt)) {
- LOGD("update video caps");
- g_object_set(G_OBJECT(player->pipeline->mainbin[MMPLAYER_M_SRC].gst),
- "caps", player->v_stream_caps, NULL);
- }
- media_format_unref(fmt);
- }
- }
-
- /* get pts */
- if (media_packet_get_pts (packet, &pts) != MEDIA_PACKET_ERROR_NONE) {
- LOGE("failed to get pts info");
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto ERROR;
- }
- GST_BUFFER_PTS (_buffer) = (GstClockTime)pts;
- gst_app_src_push_buffer (GST_APP_SRC (element), _buffer);
- }
-
- /* check eos */
- if (media_packet_is_end_of_stream(packet, &is_eos) != MEDIA_PACKET_ERROR_NONE) {
- LOGE("failed to get eos info");
- ret = MM_ERROR_PLAYER_INTERNAL;
- goto ERROR;
- }
-
- if (is_eos) {
- LOGW ("we got eos of stream type(%d)", streamtype);
- g_signal_emit_by_name (element, "end-of-stream", &ret);
- }
+ int ret = MM_ERROR_NONE;
+ GstBuffer *_buffer = NULL;
+ mm_player_t *player = (mm_player_t *) hplayer;
+ guint8 *buf = NULL;
+ uint64_t size = 0;
+ GstElement* element = NULL;
+ MMPlayerStreamType streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
+ media_format_h fmt = NULL;
+ bool flag = FALSE;
+ bool is_eos = FALSE;
+
+ MMPLAYER_RETURN_VAL_IF_FAIL(packet, MM_ERROR_INVALID_ARGUMENT);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player &&
+ player->pipeline &&
+ player->pipeline->mainbin &&
+ player->pipeline->mainbin[MMPLAYER_M_SRC].gst,
+ MM_ERROR_PLAYER_INTERNAL);
+
+ /* get stream type if audio or video */
+ media_packet_is_audio(packet, &flag);
+ if (flag) {
+ streamtype = MM_PLAYER_STREAM_TYPE_AUDIO;
+ } else {
+ media_packet_is_video(packet, &flag);
+ if (flag)
+ streamtype = MM_PLAYER_STREAM_TYPE_VIDEO;
+ else
+ streamtype = MM_PLAYER_STREAM_TYPE_TEXT;
+ }
+
+ element = __mmplayer_get_source_element(player, streamtype);
+ if (!element) {
+ LOGE("there is no source element of type %d", streamtype);
+ ret = MM_ERROR_PLAYER_INTERNAL;
+ goto ERROR;
+ }
+
+ /* check buffer level */
+ ret = __mmplayer_check_buffer_level(player, element, streamtype);
+ if (ret != MM_ERROR_NONE)
+ return ret;
+
+ /* get data */
+ if (media_packet_get_buffer_data_ptr(packet, (void **) &buf) != MEDIA_PACKET_ERROR_NONE) {
+ LOGE("failed to get buffer data ptr");
+ ret = MM_ERROR_PLAYER_INTERNAL;
+ goto ERROR;
+ }
+
+ if (media_packet_get_buffer_size(packet, &size) != MEDIA_PACKET_ERROR_NONE) {
+ LOGE("failed to get buffer size");
+ ret = MM_ERROR_PLAYER_INTERNAL;
+ goto ERROR;
+ }
+
+ if (buf != NULL && size > 0) {
+ GstMapInfo buff_info = GST_MAP_INFO_INIT;
+ uint64_t pts = 0;
+
+ /* get size */
+ _buffer = gst_buffer_new_and_alloc(size);
+
+ if (!_buffer) {
+ LOGE("failed to allocate memory for push buffer\n");
+ ret = MM_ERROR_PLAYER_NO_FREE_SPACE;
+ goto ERROR;
+ }
+
+ if (gst_buffer_map(_buffer, &buff_info, GST_MAP_READWRITE)) {
+ memcpy(buff_info.data, buf, size);
+ buff_info.size = size;
+
+ gst_buffer_unmap(_buffer, &buff_info);
+ }
+
+ if (streamtype == MM_PLAYER_STREAM_TYPE_VIDEO) {
+ /* get format to check video format */
+ media_packet_get_format(packet, &fmt);
+ if (fmt) {
+ if (__mmplayer_update_video_info(hplayer, fmt)) {
+ LOGD("update video caps");
+ g_object_set(G_OBJECT(player->pipeline->mainbin[MMPLAYER_M_SRC].gst),
+ "caps", player->v_stream_caps, NULL);
+ }
+ media_format_unref(fmt);
+ }
+ }
+
+ /* get pts */
+ if (media_packet_get_pts(packet, &pts) != MEDIA_PACKET_ERROR_NONE) {
+ LOGE("failed to get pts info");
+ ret = MM_ERROR_PLAYER_INTERNAL;
+ goto ERROR;
+ }
+ GST_BUFFER_PTS(_buffer) = (GstClockTime)pts;
+ gst_app_src_push_buffer(GST_APP_SRC(element), _buffer);
+ }
+
+ /* check eos */
+ if (media_packet_is_end_of_stream(packet, &is_eos) != MEDIA_PACKET_ERROR_NONE) {
+ LOGE("failed to get eos info");
+ ret = MM_ERROR_PLAYER_INTERNAL;
+ goto ERROR;
+ }
+
+ if (is_eos) {
+ LOGW("we got eos of stream type(%d)", streamtype);
+ g_signal_emit_by_name(element, "end-of-stream", &ret);
+ }
ERROR:
- return ret;
+ return ret;
}
static int
-__mmplayer_video_caps_new (MMHandleType hplayer, MMPlayerVideoStreamInfo * video,
- const char *fieldname, ...)
+__mmplayer_video_caps_new(MMHandleType hplayer, MMPlayerVideoStreamInfo * video,
+ const char *fieldname, ...)
{
- int cap_size;
- GstCaps *caps = NULL;
- GstStructure *structure = NULL;
- va_list var_args;
- mm_player_t *player = MM_PLAYER_CAST (hplayer);
-
- MMPLAYER_FENTER ();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL (video, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- LOGD ("width=%d height=%d framerate num=%d, den=%d",
- video->width, video->height, video->framerate_num, video->framerate_den);
-
- caps = gst_caps_new_simple (video->mime,
- "width", G_TYPE_INT, video->width,
- "height", G_TYPE_INT, video->height,
- "framerate", GST_TYPE_FRACTION, video->framerate_num, video->framerate_den, NULL);
-
- for (cap_size = 0; cap_size < gst_caps_get_size (caps); cap_size++) {
- va_start (var_args, fieldname);
- structure = gst_caps_get_structure (caps, cap_size);
- gst_structure_set_valist (structure, fieldname, var_args);
- va_end (var_args);
- }
-
- if (video->extradata_size) {
- GstBuffer *buf = NULL;
- GstMapInfo buff_info = GST_MAP_INFO_INIT;
-
- buf = gst_buffer_new_and_alloc (video->extradata_size);
-
- if (gst_buffer_map (buf, &buff_info, GST_MAP_READ)) {
- memcpy (buff_info.data, video->codec_extradata, video->extradata_size);
- buff_info.size = video->extradata_size;
- gst_buffer_unmap (buf, &buff_info);
- }
-
- gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
- gst_buffer_unref (buf);
- }
-
- if (player->v_stream_caps)
- {
- LOGW ("caps will be updated ");
-
- gst_caps_unref(player->v_stream_caps);
- player->v_stream_caps = NULL;
- }
-
- player->v_stream_caps = gst_caps_copy (caps);
- MMPLAYER_LOG_GST_CAPS_TYPE (player->v_stream_caps);
- gst_caps_unref (caps);
-
- MMPLAYER_FLEAVE ();
-
- return MM_ERROR_NONE;
+ int cap_size;
+ GstCaps *caps = NULL;
+ GstStructure *structure = NULL;
+ va_list var_args;
+ mm_player_t *player = MM_PLAYER_CAST(hplayer);
+
+ MMPLAYER_FENTER();
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(video, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ LOGD("width=%d height=%d framerate num=%d, den=%d",
+ video->width, video->height, video->framerate_num, video->framerate_den);
+
+ caps = gst_caps_new_simple(video->mime,
+ "width", G_TYPE_INT, video->width,
+ "height", G_TYPE_INT, video->height,
+ "framerate", GST_TYPE_FRACTION, video->framerate_num, video->framerate_den, NULL);
+
+ for (cap_size = 0; cap_size < gst_caps_get_size(caps); cap_size++) {
+ va_start(var_args, fieldname);
+ structure = gst_caps_get_structure(caps, cap_size);
+ gst_structure_set_valist(structure, fieldname, var_args);
+ va_end(var_args);
+ }
+
+ if (video->extradata_size) {
+ GstBuffer *buf = NULL;
+ GstMapInfo buff_info = GST_MAP_INFO_INIT;
+
+ buf = gst_buffer_new_and_alloc(video->extradata_size);
+
+ if (gst_buffer_map(buf, &buff_info, GST_MAP_READ)) {
+ memcpy(buff_info.data, video->codec_extradata, video->extradata_size);
+ buff_info.size = video->extradata_size;
+ gst_buffer_unmap(buf, &buff_info);
+ }
+
+ gst_caps_set_simple(caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
+ gst_buffer_unref(buf);
+ }
+
+ if (player->v_stream_caps) {
+ LOGW("caps will be updated ");
+
+ gst_caps_unref(player->v_stream_caps);
+ player->v_stream_caps = NULL;
+ }
+
+ player->v_stream_caps = gst_caps_copy(caps);
+ MMPLAYER_LOG_GST_CAPS_TYPE(player->v_stream_caps);
+ gst_caps_unref(caps);
+
+ MMPLAYER_FLEAVE();
+
+ return MM_ERROR_NONE;
}
static void
__mmplayer_set_uri_type(mm_player_t *player)
{
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
player->profile.uri_type = MM_PLAYER_URI_TYPE_MS_BUFF;
player->es_player_push_mode = TRUE;
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
return;
}
int
-_mmplayer_set_video_info (MMHandleType hplayer, media_format_h format)
+_mmplayer_set_video_info(MMHandleType hplayer, media_format_h format)
{
- mm_player_t *player = MM_PLAYER_CAST (hplayer);
- MMPlayerVideoStreamInfo video = { 0, };
- int ret = MM_ERROR_NONE;
- gboolean drc = FALSE;
-
- MMPLAYER_FENTER ();
-
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- __mmplayer_set_uri_type(player);
-
- ret = __parse_media_format (&video, NULL, format);
- if(ret != MM_ERROR_NONE)
- return ret;
-
- mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_DRC_MODE, &drc);
-
- if (strstr (video.mime, "video/mpeg")) {
- __mmplayer_video_caps_new (hplayer, &video,
- "mpegversion", G_TYPE_INT, video.version,
- "systemstream", G_TYPE_BOOLEAN, FALSE,
- "adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
- } else if (strstr (video.mime, "video/x-h264")) {
- //if (info.colordepth)
- {
- // __mmplayer_video_caps_new(hplayer, &info,
- // "colordepth", G_TYPE_INT, info.colordepth, NULL);
- }
- //else
- {
- __mmplayer_video_caps_new (hplayer, &video,
- "stream-format", G_TYPE_STRING, "byte-stream",
- "alignment", G_TYPE_STRING, "au",
- "adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
- }
- }
+ mm_player_t *player = MM_PLAYER_CAST(hplayer);
+ MMPlayerVideoStreamInfo video = { 0, };
+ int ret = MM_ERROR_NONE;
+ gboolean drc = FALSE;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ __mmplayer_set_uri_type(player);
+
+ ret = __parse_media_format(&video, NULL, format);
+ if (ret != MM_ERROR_NONE)
+ return ret;
+
+ mm_attrs_get_int_by_name(player->attrs, MM_PLAYER_DRC_MODE, &drc);
+
+ if (strstr(video.mime, "video/mpeg")) {
+ __mmplayer_video_caps_new(hplayer, &video,
+ "mpegversion", G_TYPE_INT, video.version,
+ "systemstream", G_TYPE_BOOLEAN, FALSE,
+ "adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
+ } else if (strstr(video.mime, "video/x-h264")) {
+ /*
+ if (info.colordepth) {
+ __mmplayer_video_caps_new(hplayer, &info,
+ "colordepth", G_TYPE_INT, info.colordepth, NULL);
+ } else
+ */
+ {
+ __mmplayer_video_caps_new(hplayer, &video,
+ "stream-format", G_TYPE_STRING, "byte-stream",
+ "alignment", G_TYPE_STRING, "au",
+ "adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
+ }
+ }
#if 0
- else if (strstr (info->mime, "video/x-wmv")) {
- __mmplayer_video_caps_new (hplayer, &info,
- "wmvversion", G_TYPE_INT, info.version, NULL);
- } else if (strstr (info.mime, "video/x-pn-realvideo")) {
- __mmplayer_video_caps_new (hplayer, &info,
- "rmversion", G_TYPE_INT, info.version, NULL);
- } else if (strstr (info.mime, "video/x-msmpeg")) {
- __mmplayer_video_caps_new (hplayer, &info,
- "msmpegversion", G_TYPE_INT, info.version, NULL);
- } else if (strstr (info.mime, "video/x-h265")) {
- if (info.colordepth) {
- __mmplayer_video_caps_new (hplayer, &info,
- "colordepth", G_TYPE_INT, info.colordepth, NULL);
- } else {
- __mmplayer_video_caps_new (hplayer, &info, NULL);
- }
- } else {
- __mmplayer_video_caps_new (hplayer, &info, NULL);
- }
+ else if (strstr(info->mime, "video/x-wmv")) {
+ __mmplayer_video_caps_new(hplayer, &info,
+ "wmvversion", G_TYPE_INT, info.version, NULL);
+ } else if (strstr(info.mime, "video/x-pn-realvideo")) {
+ __mmplayer_video_caps_new(hplayer, &info,
+ "rmversion", G_TYPE_INT, info.version, NULL);
+ } else if (strstr(info.mime, "video/x-msmpeg")) {
+ __mmplayer_video_caps_new(hplayer, &info,
+ "msmpegversion", G_TYPE_INT, info.version, NULL);
+ } else if (strstr(info.mime, "video/x-h265")) {
+ if (info.colordepth)
+ __mmplayer_video_caps_new(hplayer, &info,
+ "colordepth", G_TYPE_INT, info.colordepth, NULL);
+ else
+ __mmplayer_video_caps_new(hplayer, &info, NULL);
+ } else
+ __mmplayer_video_caps_new(hplayer, &info, NULL);
#endif
- g_free ((char *) video.mime);
+ g_free((char *) video.mime);
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
- return MM_ERROR_NONE;
+ return MM_ERROR_NONE;
}
int
-_mmplayer_set_audio_info (MMHandleType hplayer, media_format_h format)
+_mmplayer_set_audio_info(MMHandleType hplayer, media_format_h format)
{
- mm_player_t *player = MM_PLAYER_CAST (hplayer);
- GstCaps *caps = NULL;
- MMPlayerAudioStreamInfo audio = { 0, };
- int ret = MM_ERROR_NONE;
-
- MMPLAYER_FENTER ();
-
- MMPLAYER_RETURN_VAL_IF_FAIL (hplayer, MM_ERROR_PLAYER_NOT_INITIALIZED);
-
- __mmplayer_set_uri_type(player);
-
- ret = __parse_media_format (NULL, &audio, format);
- if(ret != MM_ERROR_NONE)
- return ret;
-
- audio.user_info = 0; //test
-
- LOGD ("set audio player[%p] info [%p] version=%d rate=%d channel=%d",
- player, audio, audio.version, audio.sample_rate, audio.channels);
-
- if (strstr (audio.mime, "audio/mpeg")) {
- if (audio.version == 1) { // mp3
- caps = gst_caps_new_simple ("audio/mpeg",
- "channels", G_TYPE_INT, audio.channels,
- "rate", G_TYPE_INT, audio.sample_rate,
- "mpegversion", G_TYPE_INT, audio.version,
- "layer", G_TYPE_INT, audio.user_info, NULL);
- } else { // aac
- gchar *format = NULL;
-
- if (audio.user_info == 0)
- format = g_strdup ("raw");
- else if (audio.user_info == 1)
- format = g_strdup ("adts");
- else if (audio.user_info == 2)
- format = g_strdup ("adif");
-
- caps = gst_caps_new_simple ("audio/mpeg",
- "channels", G_TYPE_INT, audio.channels,
- "rate", G_TYPE_INT, audio.sample_rate,
- "mpegversion", G_TYPE_INT, audio.version,
- "stream-format", G_TYPE_STRING, format, NULL);
-
- g_free (format);
- format = NULL;
- }
- }
+ mm_player_t *player = MM_PLAYER_CAST(hplayer);
+ GstCaps *caps = NULL;
+ MMPlayerAudioStreamInfo audio = { 0, };
+ int ret = MM_ERROR_NONE;
+
+ MMPLAYER_FENTER();
+
+ MMPLAYER_RETURN_VAL_IF_FAIL(hplayer, MM_ERROR_PLAYER_NOT_INITIALIZED);
+
+ __mmplayer_set_uri_type(player);
+
+ ret = __parse_media_format(NULL, &audio, format);
+ if (ret != MM_ERROR_NONE)
+ return ret;
+
+ audio.user_info = 0; //test
+
+ LOGD("set audio player[%p] info [%p] version=%d rate=%d channel=%d",
+ player, audio, audio.version, audio.sample_rate, audio.channels);
+
+ if (strstr(audio.mime, "audio/mpeg")) {
+ if (audio.version == 1) { // mp3
+ caps = gst_caps_new_simple("audio/mpeg",
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate,
+ "mpegversion", G_TYPE_INT, audio.version,
+ "layer", G_TYPE_INT, audio.user_info, NULL);
+ } else { // aac
+ gchar *format = NULL;
+
+ if (audio.user_info == 0)
+ format = g_strdup("raw");
+ else if (audio.user_info == 1)
+ format = g_strdup("adts");
+ else if (audio.user_info == 2)
+ format = g_strdup("adif");
+
+ caps = gst_caps_new_simple("audio/mpeg",
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate,
+ "mpegversion", G_TYPE_INT, audio.version,
+ "stream-format", G_TYPE_STRING, format, NULL);
+
+ g_free(format);
+ format = NULL;
+ }
+ }
#if 0
- else if (strstr (audio.mime, "audio/x-raw-int")) {
- caps = gst_caps_new_simple ("audio/x-raw-int",
- "width", G_TYPE_INT, audio.width,
- "depth", G_TYPE_INT, audio.depth,
- "endianness", G_TYPE_INT, audio.endianness,
- "signed", G_TYPE_BOOLEAN, audio.signedness,
- "channels", G_TYPE_INT, audio.channels,
- "rate", G_TYPE_INT, audio.sample_rate, NULL);
- } else {
- caps = gst_caps_new_simple (audio.mime,
- "channels", G_TYPE_INT, audio.channels,
- "rate", G_TYPE_INT, audio.sample_rate, NULL);
- }
+ else if (strstr(audio.mime, "audio/x-raw-int")) {
+ caps = gst_caps_new_simple("audio/x-raw-int",
+ "width", G_TYPE_INT, audio.width,
+ "depth", G_TYPE_INT, audio.depth,
+ "endianness", G_TYPE_INT, audio.endianness,
+ "signed", G_TYPE_BOOLEAN, audio.signedness,
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate, NULL);
+ } else {
+ caps = gst_caps_new_simple(audio.mime,
+ "channels", G_TYPE_INT, audio.channels,
+ "rate", G_TYPE_INT, audio.sample_rate, NULL);
+ }
#endif
- if (audio.extradata_size) {
- GstBuffer *buf = NULL;
- GstMapInfo buff_info = GST_MAP_INFO_INIT;
+ if (audio.extradata_size) {
+ GstBuffer *buf = NULL;
+ GstMapInfo buff_info = GST_MAP_INFO_INIT;
- buf = gst_buffer_new_and_alloc (audio.extradata_size);
+ buf = gst_buffer_new_and_alloc(audio.extradata_size);
- if (gst_buffer_map (buf, &buff_info, GST_MAP_READ)) {
- memcpy (buff_info.data, audio.codec_extradata, audio.extradata_size);
- gst_buffer_unmap (buf, &buff_info);
- }
+ if (gst_buffer_map(buf, &buff_info, GST_MAP_READ)) {
+ memcpy(buff_info.data, audio.codec_extradata, audio.extradata_size);
+ gst_buffer_unmap(buf, &buff_info);
+ }
- gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
- gst_buffer_unref (buf);
- }
+ gst_caps_set_simple(caps, "codec_data", GST_TYPE_BUFFER, buf, NULL);
+ gst_buffer_unref(buf);
+ }
- g_free ((char *) audio.mime);
+ g_free((char *) audio.mime);
- player->a_stream_caps = gst_caps_copy (caps);
- gst_caps_unref (caps);
+ player->a_stream_caps = gst_caps_copy(caps);
+ gst_caps_unref(caps);
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
- return MM_ERROR_NONE;
+ return MM_ERROR_NONE;
}
int
-_mmplayer_set_subtitle_info (MMHandleType hplayer,
- MMPlayerSubtitleStreamInfo * subtitle)
+_mmplayer_set_subtitle_info(MMHandleType hplayer,
+ MMPlayerSubtitleStreamInfo * subtitle)
{
#if 0 //todo
+ mm_player_t *player = MM_PLAYER_CAST(hplayer);
+ GstCaps *caps = NULL;
- mm_player_t *player = MM_PLAYER_CAST (hplayer);
- GstCaps *caps = NULL;
-
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- MMPLAYER_RETURN_VAL_IF_FAIL (info, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(info, MM_ERROR_PLAYER_NOT_INITIALIZED);
- LOGD ("set subtitle player[%p] info [%p]", player, info);
+ LOGD("set subtitle player[%p] info [%p]", player, info);
- caps = gst_caps_new_simple (info->mime, NULL, NULL); // TO CHECK
- if (NULL == caps)
- return FALSE;
+ caps = gst_caps_new_simple(info->mime, NULL, NULL); // TO CHECK
+ if (NULL == caps)
+ return FALSE;
- if (strstr (info->mime, "application/x-xsub")) {
- gst_caps_set_simple (caps, "codec_tag", G_TYPE_UINT, info->codec_tag, NULL);
- } else if (strstr (info->mime, "application/x-smpte-text")) {
- if (info->context) {
- gst_caps_set_simple (caps, "ttml_priv_data", G_TYPE_POINTER,
- info->context, NULL);
- }
- }
+ if (strstr(info->mime, "application/x-xsub")) {
+ gst_caps_set_simple(caps, "codec_tag", G_TYPE_UINT, info->codec_tag, NULL);
+ } else if (strstr(info->mime, "application/x-smpte-text")) {
+ if (info->context) {
+ gst_caps_set_simple(caps, "ttml_priv_data", G_TYPE_POINTER,
+ info->context, NULL);
+ }
+ }
- player->s_stream_caps = gst_caps_copy (caps);
+ player->s_stream_caps = gst_caps_copy(caps);
- gst_caps_unref (caps);
+ gst_caps_unref(caps);
#endif
- MMPLAYER_FLEAVE ();
+ MMPLAYER_FLEAVE();
- return MM_ERROR_NONE;
+ return MM_ERROR_NONE;
}
int
_mmplayer_set_media_stream_dynamic_resolution(MMHandleType hplayer, bool drc)
{
- mm_player_t *player = MM_PLAYER_CAST (hplayer);
+ mm_player_t *player = MM_PLAYER_CAST(hplayer);
int ret = MM_ERROR_NONE;
- MMPLAYER_FENTER ();
+ MMPLAYER_FENTER();
- MMPLAYER_RETURN_VAL_IF_FAIL (player, MM_ERROR_PLAYER_NOT_INITIALIZED);
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
- mm_attrs_set_int_by_name (player->attrs, MM_PLAYER_DRC_MODE, (int)drc);
- if (player->v_stream_caps)
- {
- gst_caps_set_simple (player->v_stream_caps,
+ mm_attrs_set_int_by_name(player->attrs, MM_PLAYER_DRC_MODE, (int)drc);
+ if (player->v_stream_caps) {
+ gst_caps_set_simple(player->v_stream_caps,
"adaptive-streaming", G_TYPE_BOOLEAN, drc, NULL);
- MMPLAYER_LOG_GST_CAPS_TYPE (player->v_stream_caps);
+ MMPLAYER_LOG_GST_CAPS_TYPE(player->v_stream_caps);
}
- MMPLAYER_FLEAVE ();
- return ret;
-
+ MMPLAYER_FLEAVE();
+ return ret;
}
+
static void __mm_player_ini_check_ini_status(void);
/* macro */
-#define MMPLAYER_INI_GET_STRING( x_dict, x_item, x_ini, x_default ) \
-do \
-{ \
+#define MMPLAYER_INI_GET_STRING(x_dict, x_item, x_ini, x_default) \
+do { \
gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
- \
- if ( str && \
- ( strlen( str ) > 0 ) && \
- ( strlen( str ) < PLAYER_INI_MAX_STRLEN ) ) \
- { \
- strncpy ( x_item, str, PLAYER_INI_MAX_STRLEN-1 ); \
- } \
+ if (str && \
+ (strlen(str) > 0) && \
+ (strlen(str) < PLAYER_INI_MAX_STRLEN)) \
+ strncpy(x_item, str, PLAYER_INI_MAX_STRLEN-1); \
else \
- { \
- strncpy ( x_item, x_default, PLAYER_INI_MAX_STRLEN-1 ); \
- } \
-}while(0)
-
-#define MMPLAYER_INI_GET_COLOR( x_dict, x_item, x_ini, x_default ) \
-do \
-{ \
- gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
- \
- if ( str && \
- ( strlen( str ) > 0 ) && \
- ( strlen( str ) < PLAYER_INI_MAX_STRLEN ) ) \
- { \
- x_item = (guint) strtoul(str, NULL, 16); \
- } \
- else \
- { \
- x_item = (guint) strtoul(x_default, NULL, 16); \
- } \
-}while(0)
+ strncpy(x_item, x_default, PLAYER_INI_MAX_STRLEN-1); \
+} while (0)
+
+#define MMPLAYER_INI_GET_COLOR(x_dict, x_item, x_ini, x_default) \
+do { \
+ gchar* str = iniparser_getstring(x_dict, x_ini, x_default); \
+ if (str && \
+ (strlen(str) > 0) && \
+ (strlen(str) < PLAYER_INI_MAX_STRLEN)) \
+ x_item = (guint) strtoul(str, NULL, 16); \
+ else \
+ x_item = (guint) strtoul(x_default, NULL, 16); \
+} while (0)
/* x_ini is the list of index to set TRUE at x_list[index] */
-#define MMPLAYER_INI_GET_BOOLEAN_FROM_LIST( x_dict, x_list, x_list_max, x_ini, x_default ) \
-do \
-{ \
+#define MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(x_dict, x_list, x_list_max, x_ini, x_default) \
+do { \
int index = 0; \
const char *delimiters = " ,"; \
char *usr_ptr = NULL; \
char *token = NULL; \
gchar temp_arr[PLAYER_INI_MAX_STRLEN] = {0}; \
- MMPLAYER_INI_GET_STRING( x_dict, temp_arr, x_ini, x_default); \
- token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
- while (token) \
- { \
+ MMPLAYER_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
+ token = strtok_r(temp_arr, delimiters, &usr_ptr); \
+ while (token) { \
index = atoi(token); \
if (index < 0 || index > x_list_max -1) \
- { \
LOGW("%d is not valid index\n", index); \
- } \
else \
- { \
x_list[index] = TRUE; \
- } \
- token = strtok_r( NULL, delimiters, &usr_ptr ); \
+ token = strtok_r(NULL, delimiters, &usr_ptr); \
} \
-}while(0)
+} while (0)
/* x_ini is the list of value to be set at x_list[index] */
-#define MMPLAYER_INI_GET_INT_FROM_LIST( x_dict, x_list, x_list_max, x_ini, x_default ) \
-do \
-{ \
+#define MMPLAYER_INI_GET_INT_FROM_LIST(x_dict, x_list, x_list_max, x_ini, x_default) \
+do { \
int index = 0; \
int value = 0; \
const char *delimiters = " ,"; \
char *token = NULL; \
gchar temp_arr[PLAYER_INI_MAX_STRLEN] = {0}; \
MMPLAYER_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
- token = strtok_r( temp_arr, delimiters, &usr_ptr ); \
- while (token) \
- { \
- if ( index > x_list_max -1) \
- { \
+ token = strtok_r(temp_arr, delimiters, &usr_ptr); \
+ while (token) { \
+ if (index > x_list_max -1) { \
LOGE("%d is not valid index\n", index); \
break; \
- } \
- else \
- { \
+ } else { \
value = atoi(token); \
x_list[index] = value; \
index++; \
} \
- token = strtok_r( NULL, delimiters, &usr_ptr ); \
+ token = strtok_r(NULL, delimiters, &usr_ptr); \
} \
-}while(0)
+} while (0)
int
mm_player_ini_load(mm_player_ini_t* ini)
dict = iniparser_load(MM_PLAYER_INI_DEFAULT_PATH);
/* if no file exists. create one with set of default values */
- if ( !dict )
- {
+ if (!dict) {
#ifdef MM_PLAYER_DEFAULT_INI
LOGD("No inifile found. player will create default inifile.\n");
- if ( FALSE == __generate_default_ini() )
- {
+ if (FALSE == __generate_default_ini())
LOGW("Creating default inifile failed. Player will use default values.\n");
- }
else
- {
- /* load default ini */
- dict = iniparser_load(MM_PLAYER_INI_DEFAULT_PATH);
- }
+ dict = iniparser_load(MM_PLAYER_INI_DEFAULT_PATH); /* load default ini */
#else
LOGD("No ini file found. \n");
return MM_ERROR_FILE_NOT_FOUND;
}
/* get ini values */
- memset( ini, 0, sizeof(mm_player_ini_t) );
+ memset(ini, 0, sizeof(mm_player_ini_t));
- if ( dict ) /* if dict is available */
- {
+ if (dict) {
+ /* if dict is available */
/* general */
ini->disable_segtrap = iniparser_getboolean(dict, "general:disable segtrap", DEFAULT_DISABLE_SEGTRAP);
ini->skip_rescan = iniparser_getboolean(dict, "general:skip rescan", DEFAULT_SKIP_RESCAN);
MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_overlay, "general:videosink element overlay", DEFAULT_VIDEOSINK_OVERLAY);
MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_evas, "general:videosink element evas", DEFAULT_VIDEOSINK_EVAS);
MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_fake, "general:videosink element fake", DEFAULT_VIDEOSINK_FAKE);
- MMPLAYER_INI_GET_STRING(dict, ini->audioresampler_element, "general:audio resampler element", DEFAULT_AUDIORESAMPLER );
- MMPLAYER_INI_GET_STRING(dict, ini->audiosink_element, "general:audiosink element", DEFAULT_AUDIOSINK );
+ MMPLAYER_INI_GET_STRING(dict, ini->audioresampler_element, "general:audio resampler element", DEFAULT_AUDIORESAMPLER);
+ MMPLAYER_INI_GET_STRING(dict, ini->audiosink_element, "general:audiosink element", DEFAULT_AUDIOSINK);
MMPLAYER_INI_GET_STRING(dict, ini->videocodec_element_hw, "general:video codec element hw", DEFAULT_VIDEOCODEC_HW);
- MMPLAYER_INI_GET_STRING(dict, ini->videoconverter_element, "general:video converter element", DEFAULT_VIDEO_CONVERTER );
+ MMPLAYER_INI_GET_STRING(dict, ini->videoconverter_element, "general:video converter element", DEFAULT_VIDEO_CONVERTER);
__get_element_list(ini,
iniparser_getstring(dict, "general:element exclude keyword", DEFAULT_EXCLUDE_KEYWORD), KEYWORD_EXCLUDE);
- MMPLAYER_INI_GET_STRING(dict, ini->gst_param[0], "general:gstparam1", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING(dict, ini->gst_param[1], "general:gstparam2", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING(dict, ini->gst_param[2], "general:gstparam3", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING(dict, ini->gst_param[3], "general:gstparam4", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING(dict, ini->gst_param[4], "general:gstparam5", DEFAULT_GST_PARAM );
+ MMPLAYER_INI_GET_STRING(dict, ini->gst_param[0], "general:gstparam1", DEFAULT_GST_PARAM);
+ MMPLAYER_INI_GET_STRING(dict, ini->gst_param[1], "general:gstparam2", DEFAULT_GST_PARAM);
+ MMPLAYER_INI_GET_STRING(dict, ini->gst_param[2], "general:gstparam3", DEFAULT_GST_PARAM);
+ MMPLAYER_INI_GET_STRING(dict, ini->gst_param[3], "general:gstparam4", DEFAULT_GST_PARAM);
+ MMPLAYER_INI_GET_STRING(dict, ini->gst_param[4], "general:gstparam5", DEFAULT_GST_PARAM);
/* http streaming */
- MMPLAYER_INI_GET_STRING( dict, ini->httpsrc_element, "http streaming:httpsrc element", DEFAULT_HTTPSRC );
+ MMPLAYER_INI_GET_STRING(dict, ini->httpsrc_element, "http streaming:httpsrc element", DEFAULT_HTTPSRC);
ini->http_use_file_buffer = iniparser_getboolean(dict, "http streaming:http use file buffer", DEFAULT_HTTP_USE_FILE_BUFFER);
ini->http_ring_buffer_size = iniparser_getint(dict, "http streaming:http ring buffer size", DEFAULT_HTTP_RING_BUFFER_SIZE);
ini->http_buffering_limit = iniparser_getdouble(dict, "http streaming:http buffering high limit", DEFAULT_HTTP_BUFFERING_LIMIT);
iniparser_getstring(dict, "general:dump element keyword", DEFAULT_EXCLUDE_KEYWORD), KEYWORD_DUMP);
MMPLAYER_INI_GET_STRING(dict, ini->dump_element_path, "general:dump element path", DEFAULT_DUMP_ELEMENT_PATH);
- }
- else /* if dict is not available just fill the structure with default value */
- {
+ } else {
+ /* if dict is not available just fill the structure with default value */
LOGW("failed to load ini. using hardcoded default\n");
/* general */
ini->disable_segtrap = DEFAULT_DISABLE_SEGTRAP;
ini->skip_rescan = DEFAULT_SKIP_RESCAN;
- strncpy( ini->videosink_element_overlay, DEFAULT_VIDEOSINK_OVERLAY, PLAYER_INI_MAX_STRLEN - 1 );
- strncpy( ini->videosink_element_evas, DEFAULT_VIDEOSINK_EVAS, PLAYER_INI_MAX_STRLEN - 1 );
- strncpy( ini->videosink_element_fake, DEFAULT_VIDEOSINK_FAKE, PLAYER_INI_MAX_STRLEN - 1 );
+ strncpy(ini->videosink_element_overlay, DEFAULT_VIDEOSINK_OVERLAY, PLAYER_INI_MAX_STRLEN - 1);
+ strncpy(ini->videosink_element_evas, DEFAULT_VIDEOSINK_EVAS, PLAYER_INI_MAX_STRLEN - 1);
+ strncpy(ini->videosink_element_fake, DEFAULT_VIDEOSINK_FAKE, PLAYER_INI_MAX_STRLEN - 1);
ini->generate_dot = DEFAULT_GENERATE_DOT;
ini->use_system_clock = DEFAULT_USE_SYSTEM_CLOCK;
ini->live_state_change_timeout = DEFAULT_LIVE_STATE_CHANGE_TIMEOUT;
ini->num_of_video_bo = DEFAULT_NUM_OF_VIDEO_BO;
ini->video_bo_timeout = DEFAULT_TIMEOUT_OF_VIDEO_BO;
- strncpy( ini->audioresampler_element, DEFAULT_AUDIORESAMPLER, PLAYER_INI_MAX_STRLEN -1 );
- strncpy( ini->audiosink_element, DEFAULT_AUDIOSINK, PLAYER_INI_MAX_STRLEN -1 );
- strncpy( ini->videocodec_element_hw, DEFAULT_VIDEOCODEC_HW, PLAYER_INI_MAX_STRLEN - 1 );
- strncpy( ini->videoconverter_element, DEFAULT_VIDEO_CONVERTER, PLAYER_INI_MAX_STRLEN -1 );
+ strncpy(ini->audioresampler_element, DEFAULT_AUDIORESAMPLER, PLAYER_INI_MAX_STRLEN -1);
+ strncpy(ini->audiosink_element, DEFAULT_AUDIOSINK, PLAYER_INI_MAX_STRLEN -1);
+ strncpy(ini->videocodec_element_hw, DEFAULT_VIDEOCODEC_HW, PLAYER_INI_MAX_STRLEN - 1);
+ strncpy(ini->videoconverter_element, DEFAULT_VIDEO_CONVERTER, PLAYER_INI_MAX_STRLEN -1);
__get_element_list(ini, DEFAULT_EXCLUDE_KEYWORD, KEYWORD_EXCLUDE);
- strncpy( ini->gst_param[0], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1 );
- strncpy( ini->gst_param[1], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1 );
- strncpy( ini->gst_param[2], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1 );
- strncpy( ini->gst_param[3], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1 );
- strncpy( ini->gst_param[4], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1 );
+ strncpy(ini->gst_param[0], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
+ strncpy(ini->gst_param[1], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
+ strncpy(ini->gst_param[2], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
+ strncpy(ini->gst_param[3], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
+ strncpy(ini->gst_param[4], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
/* http streaming */
- strncpy( ini->httpsrc_element, DEFAULT_HTTPSRC, PLAYER_INI_MAX_STRLEN - 1 );
+ strncpy(ini->httpsrc_element, DEFAULT_HTTPSRC, PLAYER_INI_MAX_STRLEN - 1);
ini->http_buffering_limit = DEFAULT_HTTP_BUFFERING_LIMIT;
ini->http_use_file_buffer = DEFAULT_HTTP_USE_FILE_BUFFER;
ini->http_ring_buffer_size = DEFAULT_HTTP_RING_BUFFER_SIZE;
}
/* free dict as we got our own structure */
- iniparser_freedict (dict);
+ iniparser_freedict(dict);
/* dump structure */
LOGD("player settings -----------------------------------\n");
LOGD("gst param4 : %s\n", ini->gst_param[3]);
LOGD("gst param5 : %s\n", ini->gst_param[4]);
- for ( idx = 0; ini->exclude_element_keyword[idx][0] != '\0'; idx++ )
- {
+ for (idx = 0; ini->exclude_element_keyword[idx][0] != '\0'; idx++)
LOGD("exclude_element_keyword [%d] : %s\n", idx, ini->exclude_element_keyword[idx]);
- }
- for ( idx = 0; ini->dump_element_keyword[idx][0] != '\0'; idx++ )
- {
+ for (idx = 0; ini->dump_element_keyword[idx][0] != '\0'; idx++)
LOGD("dump_element_keyword [%d] : %s\n", idx, ini->dump_element_keyword[idx]);
- }
/* http streaming */
LOGD("httpsrc element : %s\n", ini->httpsrc_element);
dictionary * dict_audioeffect = NULL;
dict_audioeffect = iniparser_load(MM_PLAYER_INI_DEFAULT_AUDIOEFFECT_PATH);
- if ( !dict_audioeffect )
- {
+ if (!dict_audioeffect) {
LOGE("No audio effect ini file found. \n");
return MM_ERROR_FILE_NOT_FOUND;
}
/* audio effect element name */
- MMPLAYER_INI_GET_STRING( dict_audioeffect, ini->audioeffect_element, "audio effect:audio effect element", DEFAULT_AUDIO_EFFECT_ELEMENT );
- if (!ini->audioeffect_element[0])
- {
+ MMPLAYER_INI_GET_STRING(dict_audioeffect, ini->audioeffect_element, "audio effect:audio effect element", DEFAULT_AUDIO_EFFECT_ELEMENT);
+ if (!ini->audioeffect_element[0]) {
LOGW("could not parse name of audio effect. \n");
- iniparser_freedict (dict_audioeffect);
+ iniparser_freedict(dict_audioeffect);
/* NOTE : in this case, we are not going to create audio filter element */
return MM_ERROR_NONE;
}
/* audio effect (Preset)*/
ini->use_audio_effect_preset = iniparser_getboolean(dict_audioeffect, "audio effect:audio effect preset", DEFAULT_USE_AUDIO_EFFECT_PRESET);
- if (ini->use_audio_effect_preset)
- {
- MMPLAYER_INI_GET_BOOLEAN_FROM_LIST( dict_audioeffect, ini->audio_effect_preset_list, MM_AUDIO_EFFECT_PRESET_NUM,
- "audio effect:audio effect preset list", DEFAULT_AUDIO_EFFECT_PRESET_LIST );
- MMPLAYER_INI_GET_BOOLEAN_FROM_LIST( dict_audioeffect, ini->audio_effect_preset_earphone_only_list, MM_AUDIO_EFFECT_PRESET_NUM,
- "audio effect:audio effect preset earphone only", DEFAULT_AUDIO_EFFECT_PRESET_LIST_EARPHONE_ONLY );
+ if (ini->use_audio_effect_preset) {
+ MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_preset_list, MM_AUDIO_EFFECT_PRESET_NUM,
+ "audio effect:audio effect preset list", DEFAULT_AUDIO_EFFECT_PRESET_LIST);
+ MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_preset_earphone_only_list, MM_AUDIO_EFFECT_PRESET_NUM,
+ "audio effect:audio effect preset earphone only", DEFAULT_AUDIO_EFFECT_PRESET_LIST_EARPHONE_ONLY);
}
/* audio effect user (EQ / Extension effects) */
ini->use_audio_effect_custom = iniparser_getboolean(dict_audioeffect, "audio effect:audio effect custom", DEFAULT_USE_AUDIO_EFFECT_CUSTOM);
- if (ini->use_audio_effect_custom)
- {
- MMPLAYER_INI_GET_BOOLEAN_FROM_LIST( dict_audioeffect, ini->audio_effect_custom_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
- "audio effect:audio effect custom list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST );
- MMPLAYER_INI_GET_BOOLEAN_FROM_LIST( dict_audioeffect, ini->audio_effect_custom_earphone_only_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
- "audio effect:audio effect custom earphone only", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST_EARPHONE_ONLY );
+ if (ini->use_audio_effect_custom) {
+ MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
+ "audio effect:audio effect custom list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST);
+ MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_earphone_only_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
+ "audio effect:audio effect custom earphone only", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST_EARPHONE_ONLY);
/* audio effect custom : EQ */
- if (ini->audio_effect_custom_list[MM_AUDIO_EFFECT_CUSTOM_EQ])
- {
+ if (ini->audio_effect_custom_list[MM_AUDIO_EFFECT_CUSTOM_EQ]) {
ini->audio_effect_custom_eq_band_num = iniparser_getint(dict_audioeffect, "audio effect:audio effect custom eq band num",
DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM);
if (ini->audio_effect_custom_eq_band_num < DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM ||
- ini->audio_effect_custom_eq_band_num > MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX)
- {
+ ini->audio_effect_custom_eq_band_num > MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX) {
LOGE("audio_effect_custom_eq_band_num(%d) is not valid range(%d - %d), set the value %d",
ini->audio_effect_custom_eq_band_num, DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM, MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX, DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM);
ini->audio_effect_custom_eq_band_num = DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM;
- iniparser_freedict (dict_audioeffect);
+ iniparser_freedict(dict_audioeffect);
return MM_ERROR_PLAYER_INTERNAL;
- }
- else
- {
- if (ini->audio_effect_custom_eq_band_num)
- {
- MMPLAYER_INI_GET_INT_FROM_LIST( dict_audioeffect, ini->audio_effect_custom_eq_band_width, MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX,
- "audio effect:audio effect custom eq band width", DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_WIDTH );
- MMPLAYER_INI_GET_INT_FROM_LIST( dict_audioeffect, ini->audio_effect_custom_eq_band_freq, MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX,
- "audio effect:audio effect custom eq band freq", DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_FREQ );
+ } else {
+ if (ini->audio_effect_custom_eq_band_num) {
+ MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_eq_band_width, MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX,
+ "audio effect:audio effect custom eq band width", DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_WIDTH);
+ MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_eq_band_freq, MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX,
+ "audio effect:audio effect custom eq band freq", DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_FREQ);
}
}
}
DEFAULT_AUDIO_EFFECT_CUSTOM_EXT_NUM);
/* Min/Max value list of EQ / Extension effects */
- if (ini->audio_effect_custom_eq_band_num || ini->audio_effect_custom_ext_num)
- {
-
- MMPLAYER_INI_GET_INT_FROM_LIST( dict_audioeffect, ini->audio_effect_custom_min_level_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
- "audio effect:audio effect custom min list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST );
- MMPLAYER_INI_GET_INT_FROM_LIST( dict_audioeffect, ini->audio_effect_custom_max_level_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
- "audio effect:audio effect custom max list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST );
+ if (ini->audio_effect_custom_eq_band_num || ini->audio_effect_custom_ext_num) {
+ MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_min_level_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
+ "audio effect:audio effect custom min list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST);
+ MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_max_level_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
+ "audio effect:audio effect custom max list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST);
}
}
/* audio effect element name */
- MMPLAYER_INI_GET_STRING(dict_audioeffect, ini->audioeffect_element_custom, "audio effect:audio effect element custom", DEFAULT_AUDIO_EFFECT_ELEMENT );
+ MMPLAYER_INI_GET_STRING(dict_audioeffect, ini->audioeffect_element_custom, "audio effect:audio effect element custom", DEFAULT_AUDIO_EFFECT_ELEMENT);
if (!ini->audioeffect_element_custom[0])
- {
LOGW("no secondary audio effect \n");
- }
else
- {
LOGD("audioeffect element custom : %s\n", ini->audioeffect_element_custom);
- }
/* dump structure */
LOGD("audioeffect element : %s\n", ini->audioeffect_element);
LOGD("audio effect custom mode : %d\n", ini->use_audio_effect_custom);
#if 0 // debug
int i;
- for (i=0; i<MM_AUDIO_EFFECT_PRESET_NUM; i++)
- {
+ for (i = 0; i < MM_AUDIO_EFFECT_PRESET_NUM; i++)
LOGD("audio_effect_preset_list: %d (is it for earphone only?(%d))\n", ini->audio_effect_preset_list[i], ini->audio_effect_preset_earphone_only_list[i]);
- }
- for (i=0; i<MM_AUDIO_EFFECT_CUSTOM_NUM; i++)
- {
+
+ for (i = 0; i < MM_AUDIO_EFFECT_CUSTOM_NUM; i++)
LOGD("audio_effect_custom_list : %d (is it for earphone only?(%d))\n", ini->audio_effect_custom_list[i], ini->audio_effect_custom_earphone_only_list[i]);
- }
- LOGD("audio_effect_custom : eq_band_num(%d), ext_num(%d)\n", ini->audio_effect_custom_eq_band_num, ini->audio_effect_custom_ext_num );
+ LOGD("audio_effect_custom : eq_band_num(%d), ext_num(%d)\n", ini->audio_effect_custom_eq_band_num, ini->audio_effect_custom_ext_num);
LOGD("audio_effect_custom_EQ : width(Hz) / central frequency(Hz)");
- for (i=0; i<ini->audio_effect_custom_eq_band_num; i++)
- {
+ for (i = 0; i < ini->audio_effect_custom_eq_band_num; i++)
LOGD(" EQ band index(%d) : %8d / %8d", i, ini->audio_effect_custom_eq_band_width[i], ini->audio_effect_custom_eq_band_freq[i]);
- }
- for (i=0; i<MM_AUDIO_EFFECT_CUSTOM_NUM; i++)
- {
+ for (i = 0; i < MM_AUDIO_EFFECT_CUSTOM_NUM; i++)
LOGD("audio_effect_custom_level_min_max(idx:%d) : Min(%d), Max(%d)\n", i, ini->audio_effect_custom_min_level_list[i], ini->audio_effect_custom_max_level_list[i]);
- }
#endif
- iniparser_freedict (dict_audioeffect);
+ iniparser_freedict(dict_audioeffect);
return MM_ERROR_NONE;
{
struct stat ini_buff;
- if ( g_stat(MM_PLAYER_INI_DEFAULT_PATH, &ini_buff) < 0 )
- {
+ if (g_stat(MM_PLAYER_INI_DEFAULT_PATH, &ini_buff) < 0) {
LOGW("failed to get player ini status\n");
- }
- else
- {
- if ( ini_buff.st_size < 5 )
- {
- LOGW("player.ini file size=%d, Corrupted! So, Removed\n", (int)ini_buff.st_size);
+ } else {
+ if (ini_buff.st_size < 5) {
+ LOGW("player.ini file size=%d, Corrupted!So, Removed\n", (int)ini_buff.st_size);
- if ( g_remove( MM_PLAYER_INI_DEFAULT_PATH ) == -1)
- {
+ if (g_remove(MM_PLAYER_INI_DEFAULT_PATH) == -1)
LOGE("failed to delete corrupted ini");
- }
}
}
}
/* create new file */
fp = fopen(MM_PLAYER_INI_DEFAULT_PATH, "wt");
- if ( !fp )
- {
+ if (!fp)
return FALSE;
- }
/* writing default ini file */
- if ( strlen(default_ini) != fwrite(default_ini, 1, strlen(default_ini), fp) )
- {
+ if (strlen(default_ini) != fwrite(default_ini, 1, strlen(default_ini), fp)) {
fclose(fp);
return FALSE;
}
#endif
static
-void __get_element_list(mm_player_ini_t* ini, gchar* str, int keyword_type)
+void __get_element_list(mm_player_ini_t* ini, gchar* str, int keyword_type)
{
gchar** list = NULL;
gchar** walk = NULL;
gint i = 0;
gchar* strtmp = NULL;
- if ( ! str )
+ if (!str)
return;
- if ( strlen( str ) < 1 )
+ if (strlen(str) < 1)
return;
- strtmp = g_strdup (str);
+ strtmp = g_strdup(str);
/* trimming. it works inplace */
- g_strstrip( strtmp );
+ g_strstrip(strtmp);
/* split */
- list = g_strsplit( strtmp, ",", 10 );
+ list = g_strsplit(strtmp, ",", 10);
- if ( !list )
- {
+ if (!list) {
if (strtmp)
g_free(strtmp);
}
/* copy list */
- switch (keyword_type)
+ switch (keyword_type) {
+ case KEYWORD_EXCLUDE:
{
- case KEYWORD_EXCLUDE:
- {
- for( walk = list; *walk; walk++ )
- {
- strncpy( ini->exclude_element_keyword[i], *walk, (PLAYER_INI_MAX_STRLEN - 1) );
+ for (walk = list; *walk; walk++) {
+ strncpy(ini->exclude_element_keyword[i], *walk, (PLAYER_INI_MAX_STRLEN - 1));
- g_strstrip( ini->exclude_element_keyword[i] );
+ g_strstrip(ini->exclude_element_keyword[i]);
- ini->exclude_element_keyword[i][PLAYER_INI_MAX_STRLEN -1]= '\0';
+ ini->exclude_element_keyword[i][PLAYER_INI_MAX_STRLEN -1] = '\0';
- i++;
- }
- /* mark last item to NULL */
- ini->exclude_element_keyword[i][0] = '\0';
-
- break;
+ i++;
}
- case KEYWORD_DUMP:
- {
- for( walk = list; *walk; walk++ )
- {
- strncpy( ini->dump_element_keyword[i], *walk, (PLAYER_INI_MAX_STRLEN - 1) );
+ /* mark last item to NULL */
+ ini->exclude_element_keyword[i][0] = '\0';
- g_strstrip( ini->dump_element_keyword[i] );
+ break;
+ }
+ case KEYWORD_DUMP:
+ {
+ for (walk = list; *walk; walk++) {
+ strncpy(ini->dump_element_keyword[i], *walk, (PLAYER_INI_MAX_STRLEN - 1));
- ini->dump_element_keyword[i][PLAYER_INI_MAX_STRLEN -1]= '\0';
+ g_strstrip(ini->dump_element_keyword[i]);
- i++;
- }
- /* mark last item to NULL */
- ini->dump_element_keyword[i][0] = '\0';
+ ini->dump_element_keyword[i][PLAYER_INI_MAX_STRLEN -1] = '\0';
- break;
+ i++;
}
- default:
- break;
+ /* mark last item to NULL */
+ ini->dump_element_keyword[i][0] = '\0';
+
+ break;
+ }
+ default:
+ break;
}
- g_strfreev( list );
+ g_strfreev(list);
if (strtmp)
- g_free (strtmp);
+ g_free(strtmp);
}
#endif
#define TO_THE_END 0
-typedef struct{
+typedef struct {
gint byte_in_rate; // byte
gint byte_out_rate; // byte
gdouble time_rate; // second
guint buffer_criteria; // byte
-}streaming_bitrate_info_t;
+} streaming_bitrate_info_t;
-typedef struct{
+typedef struct {
gint64 position; // ns
gint64 duration; // ns
guint64 content_size; // bytes
-}streaming_content_info_t;
+} streaming_content_info_t;
-typedef struct{
+typedef struct {
guint buffering_bytes; // bytes
gdouble buffering_time; // second
gdouble percent_byte;
gdouble percent_time;
-}streaming_buffer_info_t;
+} streaming_buffer_info_t;
static void streaming_check_buffer_percent(gdouble in_low, gdouble in_high, gdouble *out_low, gdouble *out_high);
static void streaming_set_buffer_percent(mm_player_streaming_t* streamer, BufferType type, gdouble low_percent, gdouble high_percent_byte, gdouble high_percent_time);
-static void streaming_set_queue2_queue_type (mm_player_streaming_t* streamer, muxed_buffer_type_e type, gchar * file_path, guint64 content_size);
+static void streaming_set_queue2_queue_type(mm_player_streaming_t* streamer, muxed_buffer_type_e type, gchar * file_path, guint64 content_size);
static void streaming_set_buffer_size(mm_player_streaming_t* streamer, BufferType type, guint buffering_bytes, gdouble buffering_time);
static void streaming_update_buffering_status(mm_player_streaming_t* streamer, GstMessage *buffering_msg, gint64 position);
-static void streaming_get_current_bitrate_info( mm_player_streaming_t* streamer,
+static void streaming_get_current_bitrate_info(mm_player_streaming_t* streamer,
GstMessage *buffering_msg,
streaming_content_info_t content_info,
streaming_bitrate_info_t* bitrate_info);
static void
-streaming_handle_fixed_buffering_mode( mm_player_streaming_t* streamer,
+streaming_handle_fixed_buffering_mode(mm_player_streaming_t* streamer,
gint byte_out_rate,
gdouble fixed_buffering_time,
streaming_buffer_info_t* buffer_info);
static void
-streaming_handle_adaptive_buffering_mode( mm_player_streaming_t* streamer,
+streaming_handle_adaptive_buffering_mode(mm_player_streaming_t* streamer,
streaming_content_info_t content_info,
streaming_bitrate_info_t bitrate_info,
streaming_buffer_info_t* buffer_info,
gint expected_play_time);
static void
-streaming_update_buffer_setting ( mm_player_streaming_t* streamer,
+streaming_update_buffer_setting(mm_player_streaming_t* streamer,
GstMessage *buffering_msg,
guint64 content_size,
gint64 position,
gint64 duration);
mm_player_streaming_t *
-__mm_player_streaming_create (void)
+__mm_player_streaming_create(void)
{
mm_player_streaming_t *streamer = NULL;
MMPLAYER_FENTER();
- streamer = (mm_player_streaming_t *) malloc (sizeof (mm_player_streaming_t));
- if (!streamer)
- {
- LOGE ("fail to create streaming player handle..\n");
+ streamer = (mm_player_streaming_t *) malloc(sizeof(mm_player_streaming_t));
+ if (!streamer) {
+ LOGE("fail to create streaming player handle..\n");
return NULL;
}
}
static void
-streaming_buffer_initialize (streaming_buffer_t* buffer_handle, gboolean buffer_init)
+streaming_buffer_initialize(streaming_buffer_t* buffer_handle, gboolean buffer_init)
{
if (buffer_init)
buffer_handle->buffer = NULL;
}
-void __mm_player_streaming_initialize (mm_player_streaming_t* streamer)
+void __mm_player_streaming_initialize(mm_player_streaming_t* streamer)
{
MMPLAYER_FENTER();
return;
}
-void __mm_player_streaming_deinitialize (mm_player_streaming_t* streamer)
+void __mm_player_streaming_deinitialize(mm_player_streaming_t* streamer)
{
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer);
return;
}
-void __mm_player_streaming_destroy (mm_player_streaming_t* streamer)
+void __mm_player_streaming_destroy(mm_player_streaming_t* streamer)
{
MMPLAYER_FENTER();
- if(streamer)
- {
- g_free (streamer);
+ if (streamer) {
+ g_free(streamer);
streamer = NULL;
}
* 2. average bitrage * 3 is next.
* 3. if there are no updated bitrate, use default buffering limit.
*/
- if (max_bitrate > 0 && streamer->buffer_max_bitrate != max_bitrate)
- {
+ if (max_bitrate > 0 && streamer->buffer_max_bitrate != max_bitrate) {
LOGD("set maximum bitrate(%dbps).\n", max_bitrate);
streamer->buffer_max_bitrate = max_bitrate;
- if (streamer->buffering_req.is_pre_buffering == FALSE)
- {
+ if (streamer->buffering_req.is_pre_buffering == FALSE) {
streamer->need_update = TRUE;
- }
- else
- {
+ } else {
LOGD("pre-buffering...\n");
if (IS_MUXED_BUFFERING_MODE(streamer))
}
}
- if (avg_bitrate > 0 && streamer->buffer_avg_bitrate != avg_bitrate)
- {
+ if (avg_bitrate > 0 && streamer->buffer_avg_bitrate != avg_bitrate) {
LOGD("set averate bitrate(%dbps).\n", avg_bitrate);
streamer->buffer_avg_bitrate = avg_bitrate;
- if (streamer->buffering_req.is_pre_buffering == FALSE)
- {
+ if (streamer->buffering_req.is_pre_buffering == FALSE) {
streamer->need_update = TRUE;
- }
- else
- {
+ } else {
LOGD("pre-buffering...\n");
if (IS_MUXED_BUFFERING_MODE(streamer))
MMPLAYER_RETURN_IF_FAIL(out_low && out_high);
if (in_low <= MIN_BUFFER_PERCENT || in_low >= MAX_BUFFER_PERCENT)
- {
LOGW("buffer low percent is out of range. use defaut value.");
- }
else
- {
buffer_low_percent = in_low;
- }
if (in_high <= MIN_BUFFER_PERCENT || in_high >= MAX_BUFFER_PERCENT)
- {
LOGW("buffer high percent is out of range. use defaut value.");
- }
else
- {
buffer_high_percent = in_high;
- }
if (buffer_high_percent <= buffer_low_percent)
buffer_high_percent = buffer_low_percent + 1.0;
- LOGD("set buffer percent to %2.3f ~ %2.3f.", buffer_low_percent, buffer_high_percent);
+ LOGD("set buffer percent to %2.3f ~ %2.3f.", buffer_low_percent, buffer_high_percent);
*out_low = buffer_low_percent;
*out_high = buffer_high_percent;
}
static void
-streaming_set_buffer_percent( mm_player_streaming_t* streamer,
+streaming_set_buffer_percent(mm_player_streaming_t* streamer,
BufferType type,
gdouble low_percent,
gdouble high_percent_byte,
MMPLAYER_RETURN_IF_FAIL(type < BUFFER_TYPE_MAX);
buffer_handle = &(streamer->buffer_handle[type]);
- if (!(buffer_handle && buffer_handle->buffer))
- {
+ if (!(buffer_handle && buffer_handle->buffer)) {
LOGE("buffer_handle->buffer is NULL!");
return;
}
factory_name = GST_OBJECT_NAME(gst_element_get_factory(buffer_handle->buffer));
- if (!factory_name)
- {
+ if (!factory_name) {
LOGE("Fail to get factory name!");
return;
}
if ((confirmed_low == DEFAULT_BUFFER_LOW_PERCENT) ||
(buffer_handle->buffer_low_percent != confirmed_low))
- {
- g_object_set (G_OBJECT(buffer_handle->buffer), "low-percent", (gint)confirmed_low, NULL);
- }
+ g_object_set(G_OBJECT(buffer_handle->buffer), "low-percent", (gint)confirmed_low, NULL);
if ((confirmed_high == DEFAULT_BUFFER_HIGH_PERCENT) ||
(buffer_handle->buffer_high_percent != confirmed_high))
- {
- g_object_set (G_OBJECT(buffer_handle->buffer), "high-percent", (gint)confirmed_high, NULL);
- }
+ g_object_set(G_OBJECT(buffer_handle->buffer), "high-percent", (gint)confirmed_high, NULL);
buffer_handle->buffer_low_percent = confirmed_low;
buffer_handle->buffer_high_percent = confirmed_high;
}
static void
-streaming_set_queue2_queue_type (mm_player_streaming_t* streamer, muxed_buffer_type_e type, gchar * file_path, guint64 content_size)
+streaming_set_queue2_queue_type(mm_player_streaming_t* streamer, muxed_buffer_type_e type, gchar * file_path, guint64 content_size)
{
streaming_buffer_t* buffer_handle = NULL;
guint64 storage_available_size = 0L; //bytes
buffer_handle = &(streamer->buffer_handle[BUFFER_TYPE_MUXED]);
- if (!(buffer_handle && buffer_handle->buffer))
- {
+ if (!(buffer_handle && buffer_handle->buffer)) {
LOGE("buffer_handle->buffer is NULL!");
return;
}
factory_name = GST_OBJECT_NAME(gst_element_get_factory(buffer_handle->buffer));
- if (!factory_name)
- {
+ if (!factory_name) {
LOGE("Fail to get factory name!");
return;
}
LOGD("target buffer elem : %s", GST_ELEMENT_NAME(buffer_handle->buffer));
- if (!g_strrstr(factory_name, "queue2"))
- {
+ if (!g_strrstr(factory_name, "queue2")) {
LOGD("only queue2 can use file buffer. not decodebin2 or multiQ\n");
return;
}
- if ((type == MUXED_BUFFER_TYPE_MEM_QUEUE) || (!g_strrstr(factory_name, "queue2")))
- {
+ if ((type == MUXED_BUFFER_TYPE_MEM_QUEUE) || (!g_strrstr(factory_name, "queue2"))) {
LOGD("use memory queue for buffering. streaming is played on push-based. \n"
"buffering position would not be updated.\n"
"buffered data would be flushed after played.\n"
}
LOGD("[Queue2] buffering type : %d. streaming is played on pull-based. \n", type);
- if (type == MUXED_BUFFER_TYPE_FILE && file_path && strlen(file_path)>0) {
- if (statfs((const char *)file_path, &buf) < 0)
- {
- LOGW ("[Queue2] fail to get available storage capacity. set mem ring buffer instead of file buffer.\n");
- buffer_size = (guint64)((streamer->ring_buffer_size>0)?(streamer->ring_buffer_size):DEFAULT_RING_BUFFER_SIZE);
- }
- else
- {
+ if (type == MUXED_BUFFER_TYPE_FILE && file_path && strlen(file_path) > 0) {
+ if (statfs((const char *)file_path, &buf) < 0) {
+ LOGW("[Queue2] fail to get available storage capacity. set mem ring buffer instead of file buffer.\n");
+ buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE);
+ } else {
storage_available_size = (guint64)buf.f_bavail * (guint64)buf.f_bsize; //bytes
- LOGD ("[Queue2] the number of available blocks : %"G_GUINT64_FORMAT
+ LOGD("[Queue2] the number of available blocks : %"G_GUINT64_FORMAT
", the block size is %"G_GUINT64_FORMAT".\n",
(guint64)buf.f_bavail, (guint64)buf.f_bsize);
- LOGD ("[Queue2] calculated available storage size is %"
+ LOGD("[Queue2] calculated available storage size is %"
G_GUINT64_FORMAT" Bytes.\n", storage_available_size);
if (content_size <= 0 || content_size >= storage_available_size)
g_snprintf(file_buffer_name, MM_MAX_URL_LEN, "%sXXXXXX", file_path);
SECURE_LOGD("[Queue2] the buffering file name is %s.\n", file_buffer_name);
- g_object_set (G_OBJECT(buffer_handle->buffer), "temp-template", file_buffer_name, NULL);
+ g_object_set(G_OBJECT(buffer_handle->buffer), "temp-template", file_buffer_name, NULL);
}
- } else {
- buffer_size = (guint64)((streamer->ring_buffer_size>0)?(streamer->ring_buffer_size):DEFAULT_RING_BUFFER_SIZE);
- }
+ } else
+ buffer_size = (guint64)((streamer->ring_buffer_size > 0) ? (streamer->ring_buffer_size) : DEFAULT_RING_BUFFER_SIZE);
- LOGW ("[Queue2] set ring buffer size: %lld\n", buffer_size);
- g_object_set (G_OBJECT(buffer_handle->buffer), "ring-buffer-max-size", buffer_size, NULL);
+ LOGW("[Queue2] set ring buffer size: %lld\n", buffer_size);
+ g_object_set(G_OBJECT(buffer_handle->buffer), "ring-buffer-max-size", buffer_size, NULL);
MMPLAYER_FLEAVE();
return;
buffer_handle = &(streamer->buffer_handle[type]);
- if (buffer_handle && buffer_handle->buffer)
- {
- if (g_strrstr(GST_ELEMENT_NAME(buffer_handle->buffer), "multiqueue"))
- {
+ if (buffer_handle && buffer_handle->buffer) {
+ if (g_strrstr(GST_ELEMENT_NAME(buffer_handle->buffer), "multiqueue")) {
if (buffering_time <= 0)
buffering_time = GET_CURRENT_BUFFERING_TIME(buffer_handle);
- g_object_set (G_OBJECT(buffer_handle->buffer),
- "max-size-bytes", GET_MAX_BUFFER_BYTES(streamer), /* mq size is fixed, control it with high/low percent value*/
+ g_object_set(G_OBJECT(buffer_handle->buffer),
+ "max-size-bytes", GET_MAX_BUFFER_BYTES(streamer), /* mq size is fixed, control it with high/low percent value*/
"max-size-time", ((guint)ceil(buffering_time) * GST_SECOND),
- "max-size-buffers", 0, NULL); /* disable */
+ "max-size-buffers", 0, NULL); /* disable */
buffer_handle->buffering_time = buffering_time;
buffer_handle->buffering_bytes = GET_MAX_BUFFER_BYTES(streamer);
LOGD("max-size-time : %f", buffering_time);
- }
- else /* queue2 */
- {
+ } else {
+ /* queue2 */
if (buffer_handle->is_live)
- {
- g_object_set (G_OBJECT(buffer_handle->buffer),
+ g_object_set(G_OBJECT(buffer_handle->buffer),
"max-size-bytes", buffering_bytes,
"max-size-time", (guint64)(buffering_time*GST_SECOND),
"max-size-buffers", 0,
"use-rate-estimate", TRUE, NULL);
- }
else
- {
- g_object_set (G_OBJECT(buffer_handle->buffer),
+ g_object_set(G_OBJECT(buffer_handle->buffer),
"max-size-bytes", buffering_bytes,
"max-size-time", (guint64)0,
"max-size-buffers", 0,
"use-rate-estimate", FALSE, NULL);
- }
buffer_handle->buffering_bytes = buffering_bytes;
buffer_handle->buffering_time = buffering_time;
return;
}
-void __mm_player_streaming_set_queue2( mm_player_streaming_t* streamer,
+void __mm_player_streaming_set_queue2(mm_player_streaming_t* streamer,
GstElement* buffer,
gboolean use_buffering,
guint buffering_bytes,
MMPLAYER_FENTER();
MMPLAYER_RETURN_IF_FAIL(streamer);
- if (buffer)
- {
- LOGD("USE-BUFFERING : %s", (use_buffering)?"OOO":"XXX");
+ if (buffer) {
+ LOGD("USE-BUFFERING : %s", (use_buffering) ? "OOO" : "XXX");
streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer = buffer;
- if (use_buffering)
- {
+ if (use_buffering) {
streamer->streaming_buffer_type = BUFFER_TYPE_MUXED;
- if (content_size > 0)
- {
+ if (content_size > 0) {
if (streamer->buffering_req.initial_second > 0)
- streamer->buffering_req.is_pre_buffering = TRUE;
+ streamer->buffering_req.is_pre_buffering = TRUE;
else
streamer->buffering_req.initial_second = (gint)ceil(buffering_time);
- }
- else
- {
+ } else {
LOGD("live streaming without mq");
streamer->buffer_handle[BUFFER_TYPE_MUXED].is_live = TRUE;
}
}
- g_object_set ( G_OBJECT (streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), "use-buffering", use_buffering, NULL );
+ g_object_set(G_OBJECT(streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), "use-buffering", use_buffering, NULL);
}
- streaming_set_buffer_size (streamer, BUFFER_TYPE_MUXED, buffering_bytes, buffering_time);
- streaming_set_buffer_percent (streamer, BUFFER_TYPE_MUXED, low_percent, high_percent, 0);
- streaming_set_queue2_queue_type (streamer, type, file_path, content_size);
+ streaming_set_buffer_size(streamer, BUFFER_TYPE_MUXED, buffering_bytes, buffering_time);
+ streaming_set_buffer_percent(streamer, BUFFER_TYPE_MUXED, low_percent, high_percent, 0);
+ streaming_set_queue2_queue_type(streamer, type, file_path, content_size);
MMPLAYER_FLEAVE();
return;
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL ( streamer && decodebin );
+ MMPLAYER_RETURN_IF_FAIL(streamer && decodebin);
buffer_handle = &(streamer->buffer_handle[BUFFER_TYPE_DEMUXED]);
- if ((streamer->need_sync) && (streamer->streaming_buffer_type == BUFFER_TYPE_DEMUXED))
- {
- g_object_set (G_OBJECT(decodebin),
+ if ((streamer->need_sync) && (streamer->streaming_buffer_type == BUFFER_TYPE_DEMUXED)) {
+ g_object_set(G_OBJECT(decodebin),
"max-size-bytes", buffer_handle->buffering_bytes,
"max-size-time", (guint64)(ceil(buffer_handle->buffering_time) * GST_SECOND),
"low-percent", (gint)buffer_handle->buffer_low_percent,
streamer->need_sync = FALSE;
}
-void __mm_player_streaming_set_multiqueue( mm_player_streaming_t* streamer,
+void __mm_player_streaming_set_multiqueue(mm_player_streaming_t* streamer,
GstElement* buffer,
gboolean use_buffering,
gdouble buffering_time,
buffer_handle = &(streamer->buffer_handle[BUFFER_TYPE_DEMUXED]);
pre_buffering_time = (gdouble)streamer->buffering_req.initial_second;
- if (buffer)
- {
+ if (buffer) {
buffer_handle->buffer = buffer;
- if (use_buffering)
- {
+ if (use_buffering) {
streamer->streaming_buffer_type = BUFFER_TYPE_DEMUXED;
// during prebuffering by requirement, buffer setting should not be changed.
streamer->buffering_req.is_pre_buffering = TRUE;
}
- g_object_set ( G_OBJECT (buffer_handle->buffer), "use-buffering", use_buffering, NULL );
+ g_object_set(G_OBJECT(buffer_handle->buffer), "use-buffering", use_buffering, NULL);
}
- LOGD ("pre_buffering: %2.2f, during playing: %2.2f\n", pre_buffering_time, buffering_time);
+ LOGD("pre_buffering: %2.2f, during playing: %2.2f\n", pre_buffering_time, buffering_time);
- if (pre_buffering_time <= 0.0)
- {
+ if (pre_buffering_time <= 0.0) {
pre_buffering_time = GET_DEFAULT_PLAYING_TIME(streamer);
streamer->buffering_req.initial_second = (gint)ceil(buffering_time);
}
high_percent = (pre_buffering_time * 100) / GET_MAX_BUFFER_TIME(streamer);
- LOGD ("high_percent %2.3f %%\n", high_percent);
+ LOGD("high_percent %2.3f %%\n", high_percent);
- streaming_set_buffer_size (streamer, BUFFER_TYPE_DEMUXED, GET_MAX_BUFFER_BYTES(streamer), GET_MAX_BUFFER_TIME(streamer));
- streaming_set_buffer_percent (streamer, BUFFER_TYPE_DEMUXED, low_percent, 0, high_percent);
+ streaming_set_buffer_size(streamer, BUFFER_TYPE_DEMUXED, GET_MAX_BUFFER_BYTES(streamer), GET_MAX_BUFFER_TIME(streamer));
+ streaming_set_buffer_percent(streamer, BUFFER_TYPE_DEMUXED, low_percent, 0, high_percent);
streamer->need_sync = TRUE;
}
static void
-streaming_get_current_bitrate_info( mm_player_streaming_t* streamer,
+streaming_get_current_bitrate_info(mm_player_streaming_t* streamer,
GstMessage *buffering_msg,
streaming_content_info_t content_info,
streaming_bitrate_info_t* bitrate_info)
if ((buffering_msg == NULL) ||
((streamer->buffer_handle[BUFFER_TYPE_DEMUXED].buffer != NULL) &&
(streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer != NULL) &&
- (buffering_msg->src == (GstObject *)streamer->buffer_handle[BUFFER_TYPE_DEMUXED].buffer)))
- {
- query = gst_query_new_buffering (GST_FORMAT_PERCENT);
-
- if (gst_element_query ((streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), query))
- {
- gst_query_parse_buffering_stats (query, &mode, &in_rate, &out_rate, &buffering_left);
- }
+ (buffering_msg->src == (GstObject *)streamer->buffer_handle[BUFFER_TYPE_DEMUXED].buffer))) {
+ query = gst_query_new_buffering(GST_FORMAT_PERCENT);
- gst_query_unref (query);
- }
- else
- {
- gst_message_parse_buffering_stats (buffering_msg, &mode, &in_rate, &out_rate, &buffering_left);
- }
+ if (gst_element_query((streamer->buffer_handle[BUFFER_TYPE_MUXED].buffer), query))
+ gst_query_parse_buffering_stats(query, &mode, &in_rate, &out_rate, &buffering_left);
+ gst_query_unref(query);
+ } else
+ gst_message_parse_buffering_stats(buffering_msg, &mode, &in_rate, &out_rate, &buffering_left);
- LOGD ("Streaming Info : in %d, out %d, left %lld\n", in_rate, out_rate, buffering_left);
+ LOGD("Streaming Info : in %d, out %d, left %lld\n", in_rate, out_rate, buffering_left);
if ((content_info.content_size > 0) && (content_info.duration > 0) && ((content_info.duration/GST_SECOND) > 0))
estimated_content_bitrate = GET_BIT_FROM_BYTE((guint)(content_info.content_size / (content_info.duration/GST_SECOND)));
- if (streamer->buffer_max_bitrate > 0)
- {
+ if (streamer->buffer_max_bitrate > 0) {
streamer->buffer_max_bitrate = MAX(streamer->buffer_max_bitrate, streamer->buffer_avg_bitrate);
streamer->buffer_max_bitrate = MAX(streamer->buffer_max_bitrate, estimated_content_bitrate);
else
out_rate = GET_BYTE_FROM_BIT(streamer->buffer_max_bitrate/3);
- LOGD ("(max)content_max_byte_rate %d, byte_out_rate %d\n", buffer_criteria, out_rate);
- }
- else if (streamer->buffer_avg_bitrate > 0)
- {
+ LOGD("(max)content_max_byte_rate %d, byte_out_rate %d\n", buffer_criteria, out_rate);
+ } else if (streamer->buffer_avg_bitrate > 0) {
buffer_criteria = GET_BYTE_FROM_BIT(streamer->buffer_avg_bitrate * 3);
- out_rate = GET_BYTE_FROM_BIT(MAX(streamer->buffer_avg_bitrate,estimated_content_bitrate));
+ out_rate = GET_BYTE_FROM_BIT(MAX(streamer->buffer_avg_bitrate, estimated_content_bitrate));
- LOGD ("(avg)content_max_byte_rate %d, byte_out_rate %d\n", buffer_criteria, out_rate);
- }
- else
- {
- LOGW ("There is no content bitrate information\n");
- }
+ LOGD("(avg)content_max_byte_rate %d, byte_out_rate %d\n", buffer_criteria, out_rate);
+ } else
+ LOGW("There is no content bitrate information\n");
if ((in_rate > 0) && (out_rate > 0))
buffer_buffering_time = (gdouble)out_rate / (gdouble)in_rate;
}
static void
-streaming_handle_fixed_buffering_mode( mm_player_streaming_t* streamer,
+streaming_handle_fixed_buffering_mode(mm_player_streaming_t* streamer,
gint byte_out_rate,
gdouble fixed_buffering_time,
streaming_buffer_info_t* buffer_info)
buffer_handle = &(streamer->buffer_handle[streamer->streaming_buffer_type]);
buffering_time = fixed_buffering_time;
- LOGD ("buffering time: %2.2f sec, out rate: %d\n", buffering_time, byte_out_rate);
+ LOGD("buffering time: %2.2f sec, out rate: %d\n", buffering_time, byte_out_rate);
- if ((buffering_time > 0) && (byte_out_rate > 0))
- {
+ if ((buffering_time > 0) && (byte_out_rate > 0)) {
buffering_bytes = GET_NEW_BUFFERING_BYTE(byte_out_rate * buffering_time);
- }
- else
- {
+ } else {
if (buffering_time <= 0)
buffering_time = GET_CURRENT_BUFFERING_TIME(buffer_handle);
- LOGW ("content bitrate is not updated yet.\n");
+ LOGW("content bitrate is not updated yet.\n");
buffering_bytes = GET_CURRENT_BUFFERING_BYTE(buffer_handle);
}
GET_PERCENT(buffering_time, GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_handle->buffer_high_percent, per_time);
GET_PERCENT(buffering_bytes, GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_handle->buffer_high_percent, per_byte);
- LOGD ("bytes %d, time %f, per_byte %f, per_time %f\n",
+ LOGD("bytes %d, time %f, per_byte %f, per_time %f\n",
buffering_bytes, buffering_time, per_byte, per_time);
(*buffer_info).buffering_bytes = buffering_bytes;
}
static void
-streaming_handle_adaptive_buffering_mode( mm_player_streaming_t* streamer,
+streaming_handle_adaptive_buffering_mode(mm_player_streaming_t* streamer,
streaming_content_info_t content_info,
streaming_bitrate_info_t bitrate_info,
streaming_buffer_info_t* buffer_info,
MMPLAYER_RETURN_IF_FAIL(streamer);
MMPLAYER_RETURN_IF_FAIL(buffer_info);
- LOGD ("pos %lld, dur %lld, size %lld, in/out:%d/%d, buffer_criteria:%d, time_rate:%f, need:%d sec\n",
+ LOGD("pos %lld, dur %lld, size %lld, in/out:%d/%d, buffer_criteria:%d, time_rate:%f, need:%d sec\n",
content_info.position, content_info.duration, content_info.content_size,
bitrate_info.byte_in_rate, bitrate_info.byte_out_rate,
bitrate_info.buffer_criteria, bitrate_info.time_rate, expected_play_time);
if (((expected_play_time == TO_THE_END) && (content_info.position <= 0)) ||
(content_info.duration <= 0) ||
- (content_info.content_size <= 0))
- {
- LOGW ("keep previous setting.\n");
+ (content_info.content_size <= 0)) {
+ LOGW("keep previous setting.\n");
return;
}
- if ((bitrate_info.byte_out_rate <= 0) || (bitrate_info.buffer_criteria == 0))
- {
- LOGW ("keep previous setting.\n");
+ if ((bitrate_info.byte_out_rate <= 0) || (bitrate_info.buffer_criteria == 0)) {
+ LOGW("keep previous setting.\n");
return;
}
buffer_handle = &(streamer->buffer_handle[streamer->streaming_buffer_type]);
- if (bitrate_info.byte_in_rate < bitrate_info.byte_out_rate)
- {
+ if (bitrate_info.byte_in_rate < bitrate_info.byte_out_rate) {
if (expected_play_time != TO_THE_END)
portion = (double)(expected_play_time * GST_SECOND) / (double)content_info.duration;
else
buffering_bytes = GET_NEW_BUFFERING_BYTE(((double)content_info.content_size * portion) \
* (1 - (double)bitrate_info.byte_in_rate/(double)bitrate_info.byte_out_rate));
- }
- else
- {
+ } else {
/* buffering_bytes will be set as streamer->default_val.buffering_time *
* receiving rate is bigger than avg content bitrate
* so there is no reason to buffering. if the buffering msg is posted
* in-rate or contents bitrate has wrong value. */
- LOGW ("don't need to do buffering.\n");
+ LOGW("don't need to do buffering.\n");
}
if (buffering_bytes > 0)
buffer_buffering_time = (gdouble)buffering_bytes / (gdouble)bitrate_info.byte_out_rate;
- if (content_info.position <= 0)
- {
+ if (content_info.position <= 0) {
/* if the buffer is filled under 50%, MSL use the original default buffering time.
if not, MSL use just 2 sec as a default buffering time. (to reduce initial buffering time) */
default_buffering_time = streamer->default_val.buffering_time - ((gdouble)streamer->buffering_percent/50);
- }
- else
- {
+ } else
default_buffering_time = streamer->default_val.buffering_time;
- }
- if (buffer_buffering_time < default_buffering_time)
- {
- LOGD ("adjusted time: %2.2f -> %2.2f\n", buffer_buffering_time, default_buffering_time);
- LOGD ("adjusted bytes : %d or %d or %d\n",
+ if (buffer_buffering_time < default_buffering_time) {
+ LOGD("adjusted time: %2.2f -> %2.2f\n", buffer_buffering_time, default_buffering_time);
+ LOGD("adjusted bytes : %d or %d or %d\n",
buffering_bytes,
(gint)(bitrate_info.byte_out_rate * buffer_buffering_time),
(gint)(bitrate_info.buffer_criteria * buffer_buffering_time));
+ /* start monitoring the abmormal state */
if (content_info.position > 0)
- {
- /* start monitoring the abmormal state */
streamer->default_val.buffering_monitor = TRUE;
- }
buffer_buffering_time = default_buffering_time;
adj_buffering_bytes = GET_NEW_BUFFERING_BYTE(bitrate_info.byte_out_rate * (gint)ceil(buffer_buffering_time));
GET_PERCENT(buffering_bytes, GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_handle->buffer_high_percent, per_byte);
GET_PERCENT(buffer_buffering_time, GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_handle->buffer_high_percent, per_time);
- LOGD ("monitor %d, bytes %d, time %f, per_byte %f, per_time %f\n",
+ LOGD("monitor %d, bytes %d, time %f, per_byte %f, per_time %f\n",
streamer->default_val.buffering_monitor,
buffering_bytes, buffer_buffering_time, per_byte, per_time);
}
static void
-streaming_update_buffer_setting ( mm_player_streaming_t* streamer,
+streaming_update_buffer_setting(mm_player_streaming_t* streamer,
GstMessage *buffering_msg, // can be null
guint64 content_size,
gint64 position,
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL ( streamer );
+ MMPLAYER_RETURN_IF_FAIL(streamer);
memset(&buffer_info, 0x00, sizeof(streaming_buffer_info_t));
memset(&content_info, 0x00, sizeof(streaming_content_info_t));
streaming_get_current_bitrate_info(streamer, buffering_msg, content_info, &bitrate_info);
- LOGD ("buffering mode %d, new info in_r:%d, out_r:%d, cb:%d, bt:%f\n",
+ LOGD("buffering mode %d, new info in_r:%d, out_r:%d, cb:%d, bt:%f\n",
buffering_mode, bitrate_info.byte_in_rate, bitrate_info.byte_out_rate,
bitrate_info.buffer_criteria, bitrate_info.time_rate);
/* calculate buffer low/high percent */
low_percent = DEFAULT_BUFFER_LOW_PERCENT;
- /********************
- * (1) fixed mode *
- ********************/
-
- if (buffering_mode == MM_PLAYER_BUFFERING_MODE_FIXED)
- {
+ if (buffering_mode == MM_PLAYER_BUFFERING_MODE_FIXED) {
+ /********************
+ * (1) fixed mode *
+ ********************/
gdouble buffering_time = 0.0;
if (streamer->buffering_req.is_pre_buffering == TRUE)
buffering_time = (gdouble)streamer->buffering_req.runtime_second;
streaming_handle_fixed_buffering_mode(streamer, bitrate_info.byte_out_rate, buffering_time, &buffer_info);
- }
-
- /***********************************
- * (2) once mode for samsung link *
- ***********************************/
- else if (buffering_mode == MM_PLAYER_BUFFERING_MODE_SLINK)
- {
+ } else if (buffering_mode == MM_PLAYER_BUFFERING_MODE_SLINK) {
+ /***********************************
+ * (2) once mode for samsung link *
+ ***********************************/
streaming_handle_adaptive_buffering_mode(streamer, content_info, bitrate_info, &buffer_info, TO_THE_END);
- }
-
- /*********************************
- * (3) adaptive mode (default) *
- *********************************/
- else
- {
+ } else {
+ /*********************************
+ * (3) adaptive mode (default) *
+ *********************************/
gint expected_play_time = DEFAULT_PLAYING_TIME;
if (streamer->buffering_req.runtime_second > 0)
- {
expected_play_time = streamer->buffering_req.runtime_second;
- }
else if ((position == 0) && (streamer->is_buffering))
- {
expected_play_time = streamer->buffering_req.initial_second;
- }
if (expected_play_time <= 0)
expected_play_time = DEFAULT_PLAYING_TIME;
buffer_handle->buffering_time = buffer_info.buffering_time;
}
- LOGD ("adj buffer(%d) %d->%d bytes/%2.2f->%2.2f sec\n",
+ LOGD("adj buffer(%d) %d->%d bytes/%2.2f->%2.2f sec\n",
streamer->streaming_buffer_type,
GET_CURRENT_BUFFERING_BYTE(buffer_handle), buffer_info.buffering_bytes,
GET_CURRENT_BUFFERING_TIME(buffer_handle), buffer_info.buffering_time);
/* queue2 : bytes, multiqueue : time */
if (((GET_CURRENT_BUFFERING_BYTE(buffer_handle) < buffer_info.buffering_bytes) && IS_MUXED_BUFFERING_MODE(streamer)) ||
- ((GET_CURRENT_BUFFERING_TIME(buffer_handle) < buffer_info.buffering_time) && IS_DEMUXED_BUFFERING_MODE(streamer)))
- {
- if (duration > 0 && position > 0)
- {
+ ((GET_CURRENT_BUFFERING_TIME(buffer_handle) < buffer_info.buffering_time) && IS_DEMUXED_BUFFERING_MODE(streamer))) {
+ if (duration > 0 && position > 0) {
gdouble buffering_time_limit = (gdouble)(duration - position)/GST_SECOND;
if (buffer_info.buffering_time > buffering_time_limit)
playing_time = (gint)((position - streamer->default_val.prev_pos) / GST_SECOND);
- LOGD ("buffering monitor = %s\n", (streamer->default_val.buffering_monitor)?"ON":"OFF");
- LOGD ("playing_time ( %d sec) = %lld - %lld \n", playing_time, position, streamer->default_val.prev_pos);
- LOGD ("default time : %2.3f, prev buffering t : %2.3f\n",
+ LOGD("buffering monitor = %s\n", (streamer->default_val.buffering_monitor) ? "ON" : "OFF");
+ LOGD("playing_time (%d sec) = %lld - %lld \n", playing_time, position, streamer->default_val.prev_pos);
+ LOGD("default time : %2.3f, prev buffering t : %2.3f\n",
streamer->default_val.buffering_time, streamer->buffer_handle[streamer->streaming_buffer_type].buffering_time);
- if ((streamer->default_val.buffering_monitor) && (playing_time <= (gint)streamer->default_val.buffering_time))
- {
+ if ((streamer->default_val.buffering_monitor) && (playing_time <= (gint)streamer->default_val.buffering_time)) {
gint time_gap = 0;
time_gap = (gint)(streamer->default_val.buffering_time - DEFAULT_BUFFERING_TIME);
if (time_gap <= 0)
streamer->default_val.buffering_time += time_gap*2;
streamer->default_val.buffering_time = MIN(streamer->default_val.buffering_time, MAX_BUFFERING_TIME);
- }
- else
- {
+ } else
streamer->default_val.buffering_time = DEFAULT_BUFFERING_TIME;
- }
- LOGD ("new default min value %2.3f \n", streamer->default_val.buffering_time);
+ LOGD("new default min value %2.3f \n", streamer->default_val.buffering_time);
streamer->default_val.buffering_monitor = FALSE;
streamer->default_val.prev_pos = position;
MMPLAYER_RETURN_IF_FAIL(buffering_msg);
/* update when buffering has started. */
- if ( !streamer->is_buffering )
- {
+ if (!streamer->is_buffering) {
streamer->is_buffering = TRUE;
streamer->is_buffering_done = FALSE;
streamer->buffering_percent = -1;
- if (!streamer->buffering_req.is_pre_buffering)
- {
+ if (!streamer->buffering_req.is_pre_buffering) {
streamer->need_update = TRUE;
streaming_adjust_min_threshold(streamer, position);
}
}
/* update buffer percent */
- gst_message_parse_buffering (buffering_msg, &buffer_percent);
+ gst_message_parse_buffering(buffering_msg, &buffer_percent);
- if (streamer->buffering_percent < buffer_percent)
- {
- LOGD ("[%s] buffering %d%%....\n",
+ if (streamer->buffering_percent < buffer_percent) {
+ LOGD("[%s] buffering %d%%....\n",
GST_OBJECT_NAME(GST_MESSAGE_SRC(buffering_msg)), buffer_percent);
streamer->buffering_percent = buffer_percent;
- }
- else
- {
+ } else
increased_per = FALSE;
- }
- if ((streamer->buffering_percent == MAX_BUFFER_PERCENT) || (streamer->is_buffering_done == TRUE))
- {
+ if ((streamer->buffering_percent == MAX_BUFFER_PERCENT) || (streamer->is_buffering_done == TRUE)) {
streamer->is_buffering = FALSE;
streamer->buffering_req.is_pre_buffering = FALSE;
if (streamer->buffering_percent == MAX_BUFFER_PERCENT)
streamer->is_buffering_done = FALSE;
else
streamer->buffering_percent = MAX_BUFFER_PERCENT;
- }
- else
- {
+ } else {
/* need to update periodically in case of slink mode */
if ((increased_per == TRUE) &&
(buffer_percent%10 == 0) &&
(streamer->buffering_req.mode == MM_PLAYER_BUFFERING_MODE_SLINK) &&
- (streamer->buffering_req.is_pre_buffering == FALSE))
- {
+ (streamer->buffering_req.is_pre_buffering == FALSE)) {
/* Update buffer setting to reflect data receiving rate for slink mode */
streamer->need_update = TRUE;
}
}
}
-void __mm_player_streaming_buffering( mm_player_streaming_t* streamer,
- GstMessage *buffering_msg,
- guint64 content_size,
- gint64 position,
- gint64 duration)
+void __mm_player_streaming_buffering(mm_player_streaming_t* streamer,
+ GstMessage *buffering_msg,
+ guint64 content_size,
+ gint64 position,
+ gint64 duration)
{
MMPLAYER_FENTER();
- MMPLAYER_RETURN_IF_FAIL ( streamer );
- MMPLAYER_RETURN_IF_FAIL ( buffering_msg );
- MMPLAYER_RETURN_IF_FAIL ( GST_IS_MESSAGE ( buffering_msg ) );
- MMPLAYER_RETURN_IF_FAIL ( (GST_MESSAGE_TYPE ( buffering_msg ) == GST_MESSAGE_BUFFERING) );
+ MMPLAYER_RETURN_IF_FAIL(streamer);
+ MMPLAYER_RETURN_IF_FAIL(buffering_msg);
+ MMPLAYER_RETURN_IF_FAIL(GST_IS_MESSAGE(buffering_msg));
+ MMPLAYER_RETURN_IF_FAIL((GST_MESSAGE_TYPE(buffering_msg) == GST_MESSAGE_BUFFERING));
- if (buffering_msg)
- {
+ if (buffering_msg) {
if (position > (gint64)(streamer->buffering_req.initial_second * GST_SECOND))
streamer->buffering_req.is_pre_buffering = FALSE;
streaming_update_buffering_status(streamer, buffering_msg, position);
if (!streamer->need_update)
- {
- //LOGD ("don't need to update buffering stats during buffering.\n");
return;
- }
streamer->need_update = FALSE;
}
- streaming_update_buffer_setting (streamer, buffering_msg, content_size, position, duration);
+ streaming_update_buffer_setting(streamer, buffering_msg, content_size, position, duration);
return;
}
-
projects / platform / core / multimedia / libmm-player.git / commitdiff