#include <storage.h>
#include <tzplatform_config.h>
#include "mm_player_utils.h"
+#include "media_format.h"
#define MEDIA_PATH_EXTERNAL tzplatform_getenv(TZ_SYS_STORAGE) /* external storage, sd card, usb */
+#define FD_NUM_FOR_DEBUG 10
const gchar *
-__get_stream_type_name(int type)
+_mmplayer_get_stream_type_name(int type)
{
switch (type) {
case MM_PLAYER_STREAM_TYPE_AUDIO:
}
const gchar *
-__get_state_name(int state)
+_mmplayer_get_state_name(int state)
{
switch (state) {
case MM_PLAYER_STATE_NULL:
}
gboolean
-__is_rtsp_streaming(mm_player_t *player)
+_mmplayer_is_rtsp_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_http_streaming(mm_player_t *player)
+_mmplayer_is_http_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_streaming(mm_player_t *player)
+_mmplayer_is_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return (__is_rtsp_streaming(player) || __is_http_streaming(player)
- || __is_http_live_streaming(player) || __is_dash_streaming(player) || __is_smooth_streaming(player)) ? TRUE : FALSE;
+ return (_mmplayer_is_rtsp_streaming(player) || _mmplayer_is_http_streaming(player)
+ || _mmplayer_is_http_live_streaming(player) || _mmplayer_is_dash_streaming(player)
+ || _mmplayer_is_smooth_streaming(player)) ? TRUE : FALSE;
}
gboolean
-__is_live_streaming(mm_player_t *player)
+_mmplayer_is_live_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
- return (__is_rtsp_streaming(player) && player->streaming_type == STREAMING_SERVICE_LIVE) ? TRUE : FALSE;
+ return (_mmplayer_is_rtsp_streaming(player) && player->streaming_type == STREAMING_SERVICE_LIVE) ? TRUE : FALSE;
}
gboolean
-__is_http_live_streaming(mm_player_t *player)
+_mmplayer_is_http_live_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_dash_streaming(mm_player_t *player)
+_mmplayer_is_dash_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_smooth_streaming(mm_player_t *player)
+_mmplayer_is_smooth_streaming(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__is_ms_buff_src(mm_player_t *player)
+_mmplayer_is_ms_buff_src(mmplayer_t *player)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
}
gboolean
-__has_suffix(mm_player_t *player, const gchar *suffix)
+_mmplayer_has_suffix(mmplayer_t *player, const gchar *suffix)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
MMPLAYER_RETURN_VAL_IF_FAIL(suffix, FALSE);
gboolean ret = FALSE;
gchar *t_url = g_ascii_strdown(player->profile.uri, -1);
gchar *t_suffix = g_ascii_strdown(suffix, -1);
+ gchar *opt = strchr(t_url, '?');
- if (g_str_has_suffix(player->profile.uri, suffix))
- ret = TRUE;
+ if (opt)
+ *opt = '\0';
+
+ ret = g_str_has_suffix(t_url, t_suffix);
MMPLAYER_FREEIF(t_url);
MMPLAYER_FREEIF(t_suffix);
}
gboolean
-__mmplayer_post_message(mm_player_t *player, enum MMMessageType msgtype, MMMessageParamType *param)
+_mmplayer_is_videosink_ready(mmplayer_t *player, int surface_type)
+{
+ int curr_type = MM_DISPLAY_SURFACE_NUM;
+
+ if (!player ||
+ !player->pipeline ||
+ !player->pipeline->mainbin ||
+ !player->pipeline->videobin ||
+ !player->pipeline->videobin[MMPLAYER_V_BIN].gst ||
+ !player->pipeline->videobin[MMPLAYER_V_SINK].gst) {
+ LOGW("videosink is not ready yet");
+ return FALSE;
+ }
+
+ if (surface_type == MM_DISPLAY_SURFACE_NUM) /* don't care the surface type */
+ return TRUE;
+
+ mm_attrs_get_int_by_name(player->attrs, "display_surface_type", &curr_type);
+
+ if (curr_type != surface_type) {
+ LOGW("surface type is mismatched %d, %d", curr_type, surface_type);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+gboolean
+_mmplayer_post_message(mmplayer_t *player, enum MMMessageType msgtype, MMMessageParamType *param)
{
MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
if (!player->msg_cb)
return FALSE;
-
- //LOGD("Message (type : %d) will be posted using msg-cb(%p).", msgtype, player->msg_cb);
+#ifdef __DEBUG__
+ LOGD("Message (type : %d) will be posted using msg-cb(%p).", msgtype, player->msg_cb);
+#endif
player->msg_cb(msgtype, param, player->msg_cb_param);
}
gboolean
-__mmplayer_dump_pipeline_state(mm_player_t *player)
+_mmplayer_dump_pipeline_state(mmplayer_t *player)
{
GstIterator *iter = NULL;
gboolean done = FALSE;
player->pipeline->mainbin,
FALSE);
+ MMPLAYER_GENERATE_DOT_IF_ENABLED(player, "pipeline-status-error-dump");
+
iter = gst_bin_iterate_recurse(GST_BIN(player->pipeline->mainbin[MMPLAYER_M_PIPE].gst));
if (iter != NULL) {
switch (gst_iterator_next(iter, &item)) {
case GST_ITERATOR_OK:
element = g_value_get_object(&item);
- gst_element_get_state(element, &state, &pending, time);
-
- factory = gst_element_get_factory(element) ;
- if (factory)
- LOGE("%s:%s : From:%s To:%s refcount : %d", 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));
+ if (element) {
+ gst_element_get_state(element, &state, &pending, time);
+
+ factory = gst_element_get_factory(element) ;
+ if (factory)
+ LOGE("%s:%s : From:%s To:%s refcount : %d", 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:
}
int
-util_exist_file_path(const char *file_path)
+_mmplayer_exist_file_path(const char *file_path)
{
int fd = 0;
struct stat stat_results = {0, };
LOGE("failed to get file status");
} else if (stat_results.st_size == 0) {
LOGE("file size is zero");
+ if (fd < FD_NUM_FOR_DEBUG)
+ LOGW("close fd %d", fd);
close(fd);
return MM_ERROR_PLAYER_FILE_NOT_FOUND;
- } else
+ } else {
LOGW("file size : %lld bytes", (long long)stat_results.st_size);
+ }
+ if (fd < FD_NUM_FOR_DEBUG)
+ LOGW("close fd %d", fd);
close(fd);
return MM_ERROR_NONE;
}
char **
-util_get_cookie_list(const char *cookies)
+_mmplayer_get_cookie_list(const char *cookies)
{
char **cookie_list = NULL;
char *temp = NULL;
/* check the given path is indicating sdp file */
bool
-util_is_sdp_file(const char *path)
+_mmplayer_is_sdp_file(const char *path)
{
gboolean ret = FALSE;
gchar *uri = NULL;
}
const char *
-util_get_charset(const char *file_path)
+_mmplayer_get_charset(const char *file_path)
{
UCharsetDetector *ucsd;
const UCharsetMatch *ucm;
}
int
-util_get_pixtype(unsigned int fourcc)
+_mmplayer_get_pixtype(unsigned int fourcc)
{
int pixtype = MM_PIXEL_FORMAT_INVALID;
- /*
+#ifdef __DEBUG__
char *pfourcc = (char *)&fourcc;
LOGD("fourcc(%c%c%c%c)",
pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]);
- */
+#endif
switch (fourcc) {
case GST_MAKE_FOURCC('S', 'N', '1', '2'):
}
static int
-_util_storage_supported_cb(int storage_id, storage_type_e type,
+__mmplayer_storage_supported_cb(int storage_id, storage_type_e type,
storage_state_e state, const char *path, void *user_data)
{
- MMPlayerStorageInfo *storage_info = (MMPlayerStorageInfo *)user_data;
+ mmplayer_storage_info_t *storage_info = (mmplayer_storage_info_t *)user_data;
MMPLAYER_RETURN_VAL_IF_FAIL(storage_info, FALSE);
}
bool
-util_get_storage_info(const char *path, MMPlayerStorageInfo *storage_info)
+_mmplayer_get_storage_info(const char *path, mmplayer_storage_info_t *storage_info)
{
int ret = 0;
const char *file_path = path;
memset(storage_info->path, 0x00, MM_MAX_URL_LEN);
g_snprintf(storage_info->path, MM_MAX_URL_LEN, "%s", file_path);
- ret = storage_foreach_device_supported((storage_device_supported_cb)_util_storage_supported_cb, storage_info);
+ ret = storage_foreach_device_supported((storage_device_supported_cb)__mmplayer_storage_supported_cb, storage_info);
if (ret != STORAGE_ERROR_NONE) {
LOGE("failed to check supported storage 0x%x", ret);
return false;
LOGD("storage info %d:%d:%d", storage_info->type, storage_info->id, storage_info->state);
return true;
}
+
+media_format_mimetype_e _mmplayer_convert_audio_pcm_str_to_media_format_mime(const gchar *audio_pcm_str)
+{
+ if (!audio_pcm_str) {
+ LOGW("audio pcm str is NULL");
+ return MEDIA_FORMAT_MAX;
+ }
+
+ if (strstr(audio_pcm_str, "S16LE"))
+ return MEDIA_FORMAT_PCM_S16LE;
+ else if (strstr(audio_pcm_str, "S24LE"))
+ return MEDIA_FORMAT_PCM_S24LE;
+ else if (strstr(audio_pcm_str, "S32LE"))
+ return MEDIA_FORMAT_PCM_S32LE;
+ else if (strstr(audio_pcm_str, "S16BE"))
+ return MEDIA_FORMAT_PCM_S16BE;
+ else if (strstr(audio_pcm_str, "S24BE"))
+ return MEDIA_FORMAT_PCM_S24BE;
+ else if (strstr(audio_pcm_str, "S32BE"))
+ return MEDIA_FORMAT_PCM_S32BE;
+ else if (strstr(audio_pcm_str, "F32LE"))
+ return MEDIA_FORMAT_PCM_F32LE;
+ else if (strstr(audio_pcm_str, "F32BE"))
+ return MEDIA_FORMAT_PCM_F32BE;
+ else if (strstr(audio_pcm_str, "U16LE"))
+ return MEDIA_FORMAT_PCM_U16LE;
+ else if (strstr(audio_pcm_str, "U24LE"))
+ return MEDIA_FORMAT_PCM_U24LE;
+ else if (strstr(audio_pcm_str, "U32LE"))
+ return MEDIA_FORMAT_PCM_U32LE;
+ else if (strstr(audio_pcm_str, "U16BE"))
+ return MEDIA_FORMAT_PCM_U16BE;
+ else if (strstr(audio_pcm_str, "U24BE"))
+ return MEDIA_FORMAT_PCM_U24BE;
+ else if (strstr(audio_pcm_str, "U32BE"))
+ return MEDIA_FORMAT_PCM_U32BE;
+ else {
+ LOGW("Not supported audio pcm format str : %s", audio_pcm_str);
+ return MEDIA_FORMAT_MAX;
+ }
+}
+
+gboolean _mmplayer_use_uridecodebin3(mmplayer_t *player) /* MMPLAYER_USE_URIDECODEBIN3(player) */
+{
+ MMPLAYER_RETURN_VAL_IF_FAIL(player, FALSE);
+
+ if (MMPLAYER_IS_MS_BUFF_SRC(player))
+ return FALSE;
+
+ if (!player->ini.use_uridecodebin3)
+ return FALSE;
+
+ return TRUE;
+}
projects / platform / core / multimedia / libmm-player.git / blobdiff