#define __MM_PLAYER_INI_C__
/* includes here */
+#include <dlog.h>
#include <glib.h>
#include <stdlib.h>
#include "iniparser.h"
#include <mm_player_ini.h>
-#include "mm_debug.h"
#include <mm_error.h>
+#include <mm_player_utils.h>
#include <glib/gstdio.h>
-/* global variables here */
-static mm_player_ini_t g_player_ini;
-
/* internal functions, macros here */
+#ifdef MM_PLAYER_DEFAULT_INI
static gboolean __generate_default_ini(void);
-static void __get_string_list(gchar** out_list, gchar* str);
+#endif
+static void __get_element_list(mmplayer_ini_t *ini, gchar *str, int keyword_type);
-static void __mm_player_ini_force_setting(void);
static void __mm_player_ini_check_ini_status(void);
/* macro */
-#define MMPLAYER_INI_GET_STRING( x_item, x_ini, x_default ) \
-do \
-{ \
- gchar* str = iniparser_getstring(dict, x_ini, x_default); \
- \
- if ( str && \
- ( strlen( str ) > 1 ) && \
- ( strlen( str ) < PLAYER_INI_MAX_STRLEN ) ) \
- { \
- strcpy ( x_item, str ); \
- } \
- else \
- { \
- strcpy ( x_item, x_default ); \
- } \
-}while(0)
-
-int
-mm_player_ini_load(void)
+#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); \
+ 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)
+
+/* 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 { \
+ 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) { \
+ index = atoi(token); \
+ if (index < 0 || index > x_list_max -1) \
+ LOGW("%d is not valid index", index); \
+ else \
+ x_list[index] = TRUE; \
+ token = strtok_r(NULL, delimiters, &usr_ptr); \
+ } \
+ } 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 { \
+ int index = 0; \
+ int value = 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) { \
+ if (index > x_list_max -1) { \
+ LOGE("%d is not valid index", index); \
+ break; \
+ } else { \
+ value = atoi(token); \
+ x_list[index] = value; \
+ index++; \
+ } \
+ token = strtok_r(NULL, delimiters, &usr_ptr); \
+ } \
+ } while (0)
+
+int
+mm_player_ini_load(mmplayer_ini_t *ini)
{
- static gboolean loaded = FALSE;
- dictionary * dict = NULL;
+ dictionary *dict = NULL;
gint idx = 0;
- if ( loaded )
- return MM_ERROR_NONE;
-
- dict = NULL;
-
- /* disabling ini parsing for launching */
-#if 1 //debianize
- /* get player ini status because system will be crashed
- * if ini file is corrupted.
- */
- /* FIXIT : the api actually deleting illregular ini. but the function name said it's just checking. */
__mm_player_ini_check_ini_status();
/* first, try to load existing ini file */
dict = iniparser_load(MM_PLAYER_INI_DEFAULT_PATH);
/* if no file exists. create one with set of default values */
- if ( !dict )
- {
- #if 0
- debug_log("No inifile found. player will create default inifile.\n");
- if ( FALSE == __generate_default_ini() )
- {
- debug_warning("Creating default inifile failed. Player will use default values.\n");
- }
+ if (!dict) {
+#ifdef MM_PLAYER_DEFAULT_INI
+ LOGD("No inifile found. player will create default inifile.");
+ if (__generate_default_ini() == FALSE)
+ LOGW("Creating default inifile failed. Player will use default values.");
else
- {
- /* load default ini */
- dict = iniparser_load(MM_PLAYER_INI_DEFAULT_PATH);
- }
- #else
- debug_log("No inifile found. \n");
-
+ dict = iniparser_load(MM_PLAYER_INI_DEFAULT_PATH); /* load default ini */
+#else
+ LOGD("No ini file found. ");
return MM_ERROR_FILE_NOT_FOUND;
- #endif
- }
#endif
+ }
/* get ini values */
- memset( &g_player_ini, 0, sizeof(mm_player_ini_t) );
+ memset(ini, 0, sizeof(mmplayer_ini_t));
- if ( dict ) /* if dict is available */
- {
+ if (dict) {
+ /* if dict is available */
/* general */
- g_player_ini.use_decodebin = iniparser_getboolean(dict, "general:use decodebin", DEFAULT_USE_DECODEBIN);
- g_player_ini.use_audio_filter = iniparser_getboolean(dict, "features:audio filter", DEFAULT_USE_AUDIO_FILTER);
- g_player_ini.use_sink_handler = iniparser_getboolean(dict, "general:use sink handler", DEFAULT_USE_SINK_HANDLER);
- g_player_ini.disable_segtrap = iniparser_getboolean(dict, "general:disable segtrap", DEFAULT_DISABLE_SEGTRAP);
- g_player_ini.skip_rescan = iniparser_getboolean(dict, "general:skip rescan", DEFAULT_SKIP_RESCAN);
- g_player_ini.videosink_element = iniparser_getint(dict, "general:videosink element", DEFAULT_VIDEOSINK);
- g_player_ini.generate_dot = iniparser_getboolean(dict, "general:generate dot", DEFAULT_GENERATE_DOT);
- g_player_ini.provide_clock= iniparser_getboolean(dict, "general:provide clock", DEFAULT_PROVIDE_CLOCK);
- g_player_ini.live_state_change_timeout = iniparser_getint(dict, "general:live state change timeout", DEFAULT_LIVE_STATE_CHANGE_TIMEOUT);
- g_player_ini.localplayback_state_change_timeout = iniparser_getint(dict, "general:localplayback state change timeout", DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT);
- g_player_ini.eos_delay = iniparser_getint(dict, "general:eos delay", DEFAULT_EOS_DELAY);
- g_player_ini.async_start = iniparser_getboolean(dict, "general:async start", DEFAULT_ASYNC_START);
- g_player_ini.multiple_codec_supported = iniparser_getboolean(dict, "general:multiple codec supported", DEFAULT_MULTIPLE_CODEC_SUPPORTED);
-
- g_player_ini.delay_before_repeat = iniparser_getint(dict, "general:delay before repeat", DEFAULT_DELAY_BEFORE_REPEAT);
-
- MMPLAYER_INI_GET_STRING( g_player_ini.name_of_drmsrc, "general:drmsrc element", DEFAULT_DRMSRC );
- MMPLAYER_INI_GET_STRING( g_player_ini.name_of_audiosink, "general:audiosink element", DEFAULT_AUDIOSINK );
- MMPLAYER_INI_GET_STRING( g_player_ini.name_of_video_converter, "general:video converter element", DEFAULT_VIDEO_CONVERTER );
-
- __get_string_list( (gchar**) g_player_ini.exclude_element_keyword,
- iniparser_getstring(dict, "general:element exclude keyword", DEFAULT_EXCLUDE_KEYWORD));
-
- MMPLAYER_INI_GET_STRING( g_player_ini.gst_param[0], "general:gstparam1", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING( g_player_ini.gst_param[1], "general:gstparam2", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING( g_player_ini.gst_param[2], "general:gstparam3", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING( g_player_ini.gst_param[3], "general:gstparam4", DEFAULT_GST_PARAM );
- MMPLAYER_INI_GET_STRING( g_player_ini.gst_param[4], "general:gstparam5", DEFAULT_GST_PARAM );
+ ini->disable_segtrap = iniparser_getboolean(dict, "general:disable segtrap", DEFAULT_DISABLE_SEGTRAP);
+ ini->skip_rescan = iniparser_getboolean(dict, "general:skip rescan", DEFAULT_SKIP_RESCAN);
+ ini->generate_dot = iniparser_getboolean(dict, "general:generate dot", DEFAULT_GENERATE_DOT);
+ ini->use_system_clock = iniparser_getboolean(dict, "general:use system clock", DEFAULT_USE_SYSTEM_CLOCK);
+ ini->live_state_change_timeout = iniparser_getint(dict, "general:live state change timeout", DEFAULT_LIVE_STATE_CHANGE_TIMEOUT);
+ ini->localplayback_state_change_timeout = iniparser_getint(dict, "general:localplayback state change timeout", DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT);
+ ini->eos_delay = iniparser_getint(dict, "general:eos delay", DEFAULT_EOS_DELAY);
+ ini->async_start = iniparser_getboolean(dict, "general:async start", DEFAULT_ASYNC_START);
+ ini->video_playback_supported = iniparser_getboolean(dict, "general:video playback supported", DEFAULT_VIDEO_PLAYBACK_SUPPORTED);
+ ini->delay_before_repeat = iniparser_getint(dict, "general:delay before repeat", DEFAULT_DELAY_BEFORE_REPEAT);
+ ini->pcm_buffer_size = iniparser_getint(dict, "general:pcm buffer size", DEFAULT_PCM_BUFFER_SIZE);
+ ini->num_of_video_bo = iniparser_getint(dict, "general:video bo max", DEFAULT_NUM_OF_VIDEO_BO);
+ ini->video_bo_timeout = iniparser_getint(dict, "general:video bo timeout", DEFAULT_TIMEOUT_OF_VIDEO_BO);
+
+ MMPLAYER_INI_GET_STRING(dict, ini->audioresampler_element, "general:audio resampler element", DEFAULT_AUDIORESAMPLER);
+ MMPLAYER_INI_GET_STRING(dict, ini->audiocodec_element_hw, "general:audio codec element hw", DEFAULT_CODEC_HW);
+ MMPLAYER_INI_GET_STRING(dict, ini->audiosink_element, "general:audiosink element", DEFAULT_AUDIOSINK);
+ MMPLAYER_INI_GET_STRING(dict, ini->audio_offload_sink_element, "general:audio offload sink element", DEFAULT_AUDIO_OFFLOAD_SINK);
+
+ MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_overlay, "general:videosink element overlay", DEFAULT_VIDEOSINK_OVERLAY);
+ MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_fake, "general:videosink element fake", DEFAULT_VIDEOSINK_FAKE);
+ MMPLAYER_INI_GET_STRING(dict, ini->videocodec_element_hw, "general:video codec element hw", DEFAULT_CODEC_HW);
+ MMPLAYER_INI_GET_STRING(dict, ini->videoconverter_element, "general:video converter element", DEFAULT_VIDEO_CONVERTER);
+
+ __get_element_list(ini,
+ iniparser_getstring(dict, "general:audio codec element sw", DEFAULT_CODEC_SW), KEYWORD_A_SW_CODEC);
+
+ __get_element_list(ini,
+ iniparser_getstring(dict, "general:video codec element sw", DEFAULT_CODEC_SW), KEYWORD_V_SW_CODEC);
+
+ __get_element_list(ini,
+ iniparser_getstring(dict, "general:element exclude keyword", DEFAULT_EXCLUDE_KEYWORD), KEYWORD_EXCLUDE);
+
+ __get_element_list(ini,
+ iniparser_getstring(dict, "general:audio offload device type", DEFAULT_A_OFFLOAD_DEVICE_TYPE), KEYWORD_A_OFFLOAD);
+
+ __get_element_list(ini,
+ iniparser_getstring(dict, "general:unsupported codec keyword", DEFAULT_UNSUPPORTED_CODEC_KEYWORD), KEYWORD_UNSUPPORTED_CODEC);
+
+ 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( g_player_ini.name_of_httpsrc, "http streaming:httpsrc element", DEFAULT_HTTPSRC );
- MMPLAYER_INI_GET_STRING( g_player_ini.http_temp_template, "http streaming:http temp template", DEFAULT_HTTP_TEMP_TEMPLATE );
- g_player_ini.http_use_buffering = iniparser_getboolean(dict, "http streaming:http use buffering", DEFAULT_HTTP_USE_BUFFERING);
- g_player_ini.http_buffering_low_limit = iniparser_getint(dict, "http streaming:http buffering low limit", DEFAULT_HTTP_BUFFERING_LOW_LIMIT);
- g_player_ini.http_buffering_high_limit = iniparser_getint(dict, "http streaming:http buffering high limit", DEFAULT_HTTP_BUFFERING_HIGH_LIMIT);
- g_player_ini.http_max_size_bytes = iniparser_getint(dict, "http streaming:http max size bytes", DEFAULT_HTTP_MAX_SIZE_BYTES);
- g_player_ini.http_timeout = iniparser_getint(dict, "http streaming:http timeout", DEFAULT_HTTP_TIMEOUT);
- g_player_ini.http_blocksize = iniparser_getint(dict, "http streaming:http blocksize", DEFAULT_HTTP_BLOCKSIZE);
- g_player_ini.http_buffering_time = iniparser_getdouble(dict, "http streaming:http buffering time", DEFAULT_HTTP_BUFFERING_TIME);
-
- /* rtsp streaming */
- MMPLAYER_INI_GET_STRING( g_player_ini.name_of_rtspsrc, "rtsp streaming:rtspsrc element", DEFAULT_RTSPSRC );
- g_player_ini.rtsp_buffering_time = iniparser_getint(dict, "rtsp streaming:rtsp buffering time", DEFAULT_RTSP_BUFFERING);
- g_player_ini.rtsp_rebuffering_time = iniparser_getint(dict, "rtsp streaming:rtsp rebuffering time", DEFAULT_RTSP_REBUFFERING);
- g_player_ini.rtsp_audio_packet_drop_rate = iniparser_getint(dict, "rtsp streaming:rtsp audio packet drop rate", DEFAULT_RTSP_AUDIO_PACKET_DROP_RATE);
- g_player_ini.rtsp_video_packet_drop_rate = iniparser_getint(dict, "rtsp streaming:rtsp video packet drop rate", DEFAULT_RTSP_VIDEO_PACKET_DROP_RATE);
- g_player_ini.rtsp_do_typefinding = iniparser_getboolean(dict, "rtsp streaming:rtsp do typefinding", DEFAULT_RTSP_DO_TYPEFINDING);
- g_player_ini.rtsp_dump_video_frame = iniparser_getboolean(dict, "rtsp streaming:rtsp dump video frame", DEFAULT_RTSP_DUMP_VIDEO_FRAME);
- g_player_ini.rtsp_dump_audio_frame = iniparser_getboolean(dict, "rtsp streaming:rtsp dump audio frame", DEFAULT_RTSP_DUMP_AUDIO_FRAME);
- g_player_ini.rtsp_stack_debug = iniparser_getboolean(dict, "rtsp streaming:rtsp stack debug", DEFAULT_RTSP_STACK_DEBUG);
- g_player_ini.rtsp_error_concealment = iniparser_getboolean(dict, "rtsp streaming:rtsp error concealment", DEFAULT_RTSP_ERROR_CONCEALMENT);
-
- /* hw accelation */
- g_player_ini.use_video_hw_accel = iniparser_getboolean(dict, "hw accelation:use video hw accel", DEFAULT_USE_VIDEO_HW_ACCEL);
-
- /* priority */
- g_player_ini.use_priority_setting = iniparser_getboolean(dict, "priority:use priority setting", DEFAULT_USE_PRIORITY_SETTING);
- g_player_ini.demux_priority = iniparser_getint(dict, "priority:demux", DEFAULT_PRIORITY_DEMUX);
- g_player_ini.videosink_priority = iniparser_getint(dict, "priority:videosink", DEFAULT_PRIORITY_VIDEO_SINK);
- g_player_ini.audiosink_priority = iniparser_getint(dict, "priority:audiosink", DEFAULT_PRIORITY_AUDIO_SINK);
- g_player_ini.ringbuffer_priority = iniparser_getint(dict, "priority:ringbuffer", DEFAULT_PRIORITY_RINGBUFFER);
-
-
- /* subtitle */
- g_player_ini.use_subtitle_setting = iniparser_getboolean(dict, "subtitle:use subtitle setting", DEFAULT_USE_SUBTITLE_SETTING);
- MMPLAYER_INI_GET_STRING( g_player_ini.subtitle_uri, "subtitle:subtitle uri", DEFAULT_SUBTITLE_URI );
- g_player_ini.subtitle_silent = iniparser_getboolean(dict, "subtitle:use subtitle silent", DEFAULT_SUBTITLE_SILENT);
- }
- else /* if dict is not available just fill the structure with default value */
- {
- debug_warning("failed to load ini. using hardcoded default\n");
+ MMPLAYER_INI_GET_STRING(dict, ini->httpsrc_element, "http streaming:httpsrc element", DEFAULT_HTTPSRC);
+ ini->http_ring_buffer_size = iniparser_getint(dict, "http streaming:http ring buffer size", DEFAULT_HTTP_RING_BUFFER_SIZE);
+ ini->http_timeout = iniparser_getint(dict, "http streaming:http timeout", DEFAULT_HTTP_TIMEOUT);
- /* general */
- g_player_ini.use_decodebin = DEFAULT_USE_DECODEBIN;
- g_player_ini.use_sink_handler = DEFAULT_USE_SINK_HANDLER;
- g_player_ini.disable_segtrap = DEFAULT_DISABLE_SEGTRAP;
- g_player_ini.use_audio_filter = DEFAULT_USE_AUDIO_FILTER;
- g_player_ini.skip_rescan = DEFAULT_SKIP_RESCAN;
- g_player_ini.videosink_element = DEFAULT_VIDEOSINK;
- g_player_ini.generate_dot = DEFAULT_GENERATE_DOT;
- g_player_ini.provide_clock= DEFAULT_PROVIDE_CLOCK;
- g_player_ini.live_state_change_timeout = DEFAULT_LIVE_STATE_CHANGE_TIMEOUT;
- g_player_ini.localplayback_state_change_timeout = DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT;
- g_player_ini.eos_delay = DEFAULT_EOS_DELAY;
- g_player_ini.multiple_codec_supported = DEFAULT_MULTIPLE_CODEC_SUPPORTED;
- g_player_ini.async_start = DEFAULT_ASYNC_START;
- g_player_ini.delay_before_repeat = DEFAULT_DELAY_BEFORE_REPEAT;
-
-
- strcpy( g_player_ini.name_of_drmsrc, DEFAULT_DRMSRC );
- strcpy( g_player_ini.name_of_audiosink, DEFAULT_AUDIOSINK );
- strcpy( g_player_ini.name_of_video_converter, DEFAULT_VIDEO_CONVERTER);
-
- {
- __get_string_list( (gchar**) g_player_ini.exclude_element_keyword, DEFAULT_EXCLUDE_KEYWORD);
- }
+ /* dump buffer for debug */
+ __get_element_list(ini,
+ 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 */
+ LOGW("failed to load ini. using hardcoded default");
- strcpy( g_player_ini.gst_param[0], DEFAULT_GST_PARAM );
- strcpy( g_player_ini.gst_param[1], DEFAULT_GST_PARAM );
- strcpy( g_player_ini.gst_param[2], DEFAULT_GST_PARAM );
- strcpy( g_player_ini.gst_param[3], DEFAULT_GST_PARAM );
- strcpy( g_player_ini.gst_param[4], DEFAULT_GST_PARAM );
+ /* 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_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->localplayback_state_change_timeout = DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT;
+ ini->eos_delay = DEFAULT_EOS_DELAY;
+ ini->async_start = DEFAULT_ASYNC_START;
+ ini->delay_before_repeat = DEFAULT_DELAY_BEFORE_REPEAT;
+ ini->video_playback_supported = DEFAULT_VIDEO_PLAYBACK_SUPPORTED;
+ ini->pcm_buffer_size = DEFAULT_PCM_BUFFER_SIZE;
+ 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->audio_offload_sink_element, DEFAULT_AUDIO_OFFLOAD_SINK, PLAYER_INI_MAX_STRLEN - 1);
+ strncpy(ini->audiocodec_element_hw, DEFAULT_CODEC_HW, PLAYER_INI_MAX_STRLEN - 1);
+ strncpy(ini->videocodec_element_hw, DEFAULT_CODEC_HW, PLAYER_INI_MAX_STRLEN - 1);
+ strncpy(ini->videoconverter_element, DEFAULT_VIDEO_CONVERTER, PLAYER_INI_MAX_STRLEN - 1);
+
+ __get_element_list(ini, DEFAULT_CODEC_SW, KEYWORD_A_SW_CODEC);
+ __get_element_list(ini, DEFAULT_CODEC_SW, KEYWORD_V_SW_CODEC);
+ __get_element_list(ini, DEFAULT_A_OFFLOAD_DEVICE_TYPE, KEYWORD_A_OFFLOAD);
+ __get_element_list(ini, DEFAULT_EXCLUDE_KEYWORD, KEYWORD_EXCLUDE);
+ __get_element_list(ini, DEFAULT_UNSUPPORTED_CODEC_KEYWORD, KEYWORD_UNSUPPORTED_CODEC);
+
+ 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 */
- strcpy( g_player_ini.name_of_httpsrc, DEFAULT_HTTPSRC );
- strcpy( g_player_ini.http_temp_template, DEFAULT_HTTP_TEMP_TEMPLATE );
- g_player_ini.http_use_buffering = DEFAULT_HTTP_USE_BUFFERING;
- g_player_ini.http_buffering_low_limit = DEFAULT_HTTP_BUFFERING_LOW_LIMIT;
- g_player_ini.http_buffering_high_limit = DEFAULT_HTTP_BUFFERING_HIGH_LIMIT;
- g_player_ini.http_max_size_bytes = DEFAULT_HTTP_MAX_SIZE_BYTES;
- g_player_ini.http_timeout = DEFAULT_HTTP_TIMEOUT;
- g_player_ini.http_blocksize = DEFAULT_HTTP_BLOCKSIZE;
- g_player_ini.http_buffering_time = DEFAULT_HTTP_BUFFERING_TIME;
-
- /* rtsp streaming */
- strcpy( g_player_ini.name_of_rtspsrc, DEFAULT_RTSPSRC );
- g_player_ini.rtsp_buffering_time = DEFAULT_RTSP_BUFFERING;
- g_player_ini.rtsp_rebuffering_time = DEFAULT_RTSP_REBUFFERING;
- g_player_ini.rtsp_audio_packet_drop_rate = DEFAULT_RTSP_AUDIO_PACKET_DROP_RATE;
- g_player_ini.rtsp_video_packet_drop_rate = DEFAULT_RTSP_VIDEO_PACKET_DROP_RATE;
- g_player_ini.rtsp_do_typefinding = DEFAULT_RTSP_DO_TYPEFINDING;
- g_player_ini.rtsp_dump_video_frame = DEFAULT_RTSP_DUMP_VIDEO_FRAME;
- g_player_ini.rtsp_dump_audio_frame = DEFAULT_RTSP_DUMP_AUDIO_FRAME;
- g_player_ini.rtsp_stack_debug = DEFAULT_RTSP_STACK_DEBUG;
- g_player_ini.rtsp_error_concealment = DEFAULT_RTSP_ERROR_CONCEALMENT;
-
- /* hw accelation */
- g_player_ini.use_video_hw_accel = DEFAULT_USE_VIDEO_HW_ACCEL;
-
- /* priority */
- g_player_ini.use_priority_setting = DEFAULT_USE_PRIORITY_SETTING;
- g_player_ini.demux_priority = DEFAULT_PRIORITY_DEMUX;
- g_player_ini.videosink_priority = DEFAULT_PRIORITY_VIDEO_SINK;
- g_player_ini.audiosink_priority = DEFAULT_PRIORITY_AUDIO_SINK;
- g_player_ini.ringbuffer_priority = DEFAULT_PRIORITY_RINGBUFFER;
-
- /* subtitle */
- g_player_ini.use_subtitle_setting = DEFAULT_USE_SUBTITLE_SETTING;
- strcpy( g_player_ini.subtitle_uri, DEFAULT_SUBTITLE_URI );
- g_player_ini.subtitle_silent = DEFAULT_SUBTITLE_SILENT;
+ strncpy(ini->httpsrc_element, DEFAULT_HTTPSRC, PLAYER_INI_MAX_STRLEN - 1);
+ ini->http_ring_buffer_size = DEFAULT_HTTP_RING_BUFFER_SIZE;
+ ini->http_timeout = DEFAULT_HTTP_TIMEOUT;
+
+ /* dump buffer for debug */
+ __get_element_list(ini, DEFAULT_DUMP_ELEMENT_KEYWORD, KEYWORD_DUMP);
+ strncpy(ini->dump_element_path, DEFAULT_DUMP_ELEMENT_PATH, PLAYER_INI_MAX_STRLEN - 1);
}
/* free dict as we got our own structure */
- iniparser_freedict (dict);
-
- loaded = TRUE;
-
- /* The simulator uses a separate ini file. */
- //__mm_player_ini_force_setting();
-
+ iniparser_freedict(dict);
/* dump structure */
- debug_log("player settings -----------------------------------\n");
+ LOGD("player settings -----------------------------------");
/* general */
- debug_log("use_decodebin : %d\n", g_player_ini.use_decodebin);
- debug_log("use_audio_filter : %d\n", g_player_ini.use_audio_filter);
- debug_log("use_sink_handler : %d\n", g_player_ini.use_sink_handler);
- debug_log("disable_segtrap : %d\n", g_player_ini.disable_segtrap);
- debug_log("skip rescan : %d\n", g_player_ini.skip_rescan);
- debug_log("videosink element(0:v4l2sink, 1:ximagesink, 2:xvimagesink, 3:fakesink) : %d\n", g_player_ini.videosink_element);
- debug_log("generate_dot : %d\n", g_player_ini.generate_dot);
- debug_log("provide_clock : %d\n", g_player_ini.provide_clock);
- debug_log("live_state_change_timeout(sec) : %d\n", g_player_ini.live_state_change_timeout);
- debug_log("localplayback_state_change_timeout(sec) : %d\n", g_player_ini.localplayback_state_change_timeout);
- debug_log("eos_delay(msec) : %d\n", g_player_ini.eos_delay);
- debug_log("delay_before_repeat(msec) : %d\n", g_player_ini.delay_before_repeat);
- debug_log("name_of_drmsrc : %s\n", g_player_ini.name_of_drmsrc);
- debug_log("name_of_audiosink : %s\n", g_player_ini.name_of_audiosink);
- debug_log("name_of_video_converter : %s\n", g_player_ini.name_of_video_converter);
- debug_log("async_start : %d\n", g_player_ini.async_start);
- debug_log("multiple_codec_supported : %d\n", g_player_ini.multiple_codec_supported);
-
- debug_log("gst_param1 : %s\n", g_player_ini.gst_param[0]);
- debug_log("gst_param2 : %s\n", g_player_ini.gst_param[1]);
- debug_log("gst_param3 : %s\n", g_player_ini.gst_param[2]);
- debug_log("gst_param4 : %s\n", g_player_ini.gst_param[3]);
- debug_log("gst_param5 : %s\n", g_player_ini.gst_param[4]);
-
- for ( idx = 0; g_player_ini.exclude_element_keyword[idx][0] != '\0'; idx++ )
- {
- debug_log("exclude_element_keyword [%d] : %s\n", idx, g_player_ini.exclude_element_keyword[idx]);
- }
-
+ LOGD("disable segtrap : %d", ini->disable_segtrap);
+ LOGD("skip rescan : %d", ini->skip_rescan);
+ LOGD("videosink element overlay: %s", ini->videosink_element_overlay);
+ LOGD("videosink element fake: %s", ini->videosink_element_fake);
+ LOGD("video converter element : %s", ini->videoconverter_element);
+ LOGD("video codec element(hw) : %s", ini->videocodec_element_hw);
+ for (idx = 0; ini->videocodec_element_sw[idx][0] != '\0'; idx++)
+ LOGD("video codec element(sw%d) %s", idx, ini->videocodec_element_sw[idx]);
+ LOGD("audio codec element(hw) : %s", ini->audiocodec_element_hw);
+ for (idx = 0; ini->audiocodec_element_sw[idx][0] != '\0'; idx++)
+ LOGD("audio codec element(sw%d) %s", idx, ini->audiocodec_element_sw[idx]);
+ LOGD("audio resampler element : %s", ini->audioresampler_element);
+ LOGD("audiosink element : %s", ini->audiosink_element);
+ LOGD("audio offload sink element : %s", ini->audio_offload_sink_element);
+ for (idx = 0; ini->audio_offload_device_type[idx][0] != '\0'; idx++)
+ LOGD("audio_offload_device_type [%d] : %s", idx, ini->audio_offload_device_type[idx]);
+ LOGD("generate dot : %d", ini->generate_dot);
+ LOGD("use system clock(video only) : %d", ini->use_system_clock);
+ LOGD("live state change timeout(sec) : %d", ini->live_state_change_timeout);
+ LOGD("localplayback state change timeout(sec) : %d", ini->localplayback_state_change_timeout);
+ LOGD("eos_delay(msec) : %d", ini->eos_delay);
+ LOGD("delay before repeat(msec) : %d", ini->delay_before_repeat);
+ LOGD("async_start : %d", ini->async_start);
+ LOGD("video_playback_supported : %d", ini->video_playback_supported);
+ LOGD("pcm buffer size(bytes) : %d", ini->pcm_buffer_size);
+ LOGD("num of video bo : %d", ini->num_of_video_bo);
+ LOGD("video bo timeout : %d", ini->video_bo_timeout);
+ LOGD("gst param1 : %s", ini->gst_param[0]);
+ LOGD("gst param2 : %s", ini->gst_param[1]);
+ LOGD("gst param3 : %s", ini->gst_param[2]);
+ LOGD("gst param4 : %s", ini->gst_param[3]);
+ LOGD("gst param5 : %s", ini->gst_param[4]);
+
+ for (idx = 0; ini->exclude_element_keyword[idx][0] != '\0'; idx++)
+ LOGD("exclude_element_keyword [%d] : %s", idx, ini->exclude_element_keyword[idx]);
+
+ for (idx = 0; ini->dump_element_keyword[idx][0] != '\0'; idx++)
+ LOGD("dump_element_keyword [%d] : %s", idx, ini->dump_element_keyword[idx]);
+
+ for (idx = 0; ini->unsupported_codec_keyword[idx][0] != '\0'; idx++)
+ LOGD("unsupported_codec_keyword [%d] : %s", idx, ini->unsupported_codec_keyword[idx]);
+
/* http streaming */
- debug_log("name_of_httpsrc : %s\n", g_player_ini.name_of_httpsrc);
- debug_log("http_temp_template : %s \n", g_player_ini.http_temp_template);
- debug_log("http_use_buffering : %d \n", g_player_ini.http_use_buffering);
- debug_log("http_buffering_low_limit : %d \n", g_player_ini.http_buffering_low_limit);
- debug_log("http_buffering_high_limit : %d \n", g_player_ini.http_buffering_high_limit);
- debug_log("http_max_size_bytes : %d \n", g_player_ini.http_max_size_bytes);
- debug_log("http_timeout : %d \n", g_player_ini.http_timeout);
- debug_log("http_blocksize : %d \n", g_player_ini.http_blocksize);
- debug_log("http_buffering_time : %f \n", g_player_ini.http_buffering_time);
-
- /* rtsp streaming */
- debug_log("name_of_rtspsrc : %s\n", g_player_ini.name_of_rtspsrc);
- debug_log("rtsp_buffering_time(msec) : %d\n", g_player_ini.rtsp_buffering_time);
- debug_log("rtsp_rebuffering_time(msec) : %d\n", g_player_ini.rtsp_rebuffering_time);
- debug_log("rtsp_audio_packet_drop_rate : %d \n", g_player_ini.rtsp_audio_packet_drop_rate);
- debug_log("rtsp_video_packet_drop_rate : %d \n", g_player_ini.rtsp_video_packet_drop_rate);
- debug_log("rtsp_do_typefinding : %d \n", g_player_ini.rtsp_do_typefinding);
- debug_log("rtsp_dump_video_frame : %d \n", g_player_ini.rtsp_dump_video_frame);
- debug_log("rtsp_dump_audio_frame : %d \n", g_player_ini.rtsp_dump_audio_frame);
- debug_log("rtsp_stack_debug : %d \n", g_player_ini.rtsp_stack_debug);
- debug_log("rtsp_error_concealment : %d \n", g_player_ini.rtsp_error_concealment);
-
- /* hw accel */
- debug_log("use_video_hw_accel : %d\n", g_player_ini.use_video_hw_accel);
-
- /* priority */
- debug_log("use_priority_setting : %d\n", g_player_ini.use_priority_setting);
- debug_log("demux_priority : %d\n", g_player_ini.demux_priority);
- debug_log("audiosink_priority : %d\n", g_player_ini.audiosink_priority);
- debug_log("videosink_priority : %d\n", g_player_ini.videosink_priority);
- debug_log("ringbuffer_priority : %d\n", g_player_ini.ringbuffer_priority);
-
- /* subtitle */
- debug_log("use_subtitle_setting : %d\n", g_player_ini.use_subtitle_setting);
- debug_log("subtitle_uri : %s\n", g_player_ini.subtitle_uri);
- debug_log("subtitle_silent : %d\n", g_player_ini.subtitle_silent);
-
- debug_log("---------------------------------------------------\n");
+ LOGD("httpsrc element : %s", ini->httpsrc_element);
+ LOGD("http ring buffer size : %d", ini->http_ring_buffer_size);
+ LOGD("http timeout : %d", ini->http_timeout);
return MM_ERROR_NONE;
}
-
-static
-void __mm_player_ini_check_ini_status(void)
+int
+mm_player_audio_effect_ini_load(mmplayer_ini_t *ini)
{
- struct stat ini_buff;
-
- if ( g_stat(MM_PLAYER_INI_DEFAULT_PATH, &ini_buff) < 0 )
- {
- debug_warning("failed to get player ini status\n");
+ dictionary *dict_audioeffect = NULL;
+
+ dict_audioeffect = iniparser_load(MM_PLAYER_INI_DEFAULT_AUDIOEFFECT_PATH);
+ if (!dict_audioeffect) {
+ LOGE("No audio effect ini file found.");
+ return MM_ERROR_FILE_NOT_FOUND;
}
- else
- {
- if ( ini_buff.st_size < 5 )
- {
- debug_warning("player.ini file size=%d, Corrupted! So, Removed\n", (int)ini_buff.st_size);
-
- g_remove( MM_PLAYER_INI_DEFAULT_PATH );
+
+ /* 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]) {
+ LOGW("could not parse name of audio effect.");
+ 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);
+ }
+
+ /* 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);
+
+ /* 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) {
+ 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);
+ 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);
+ }
+ }
+ }
+
+ /* audio effect custom : Extension effects */
+ ini->audio_effect_custom_ext_num = iniparser_getint(dict_audioeffect, "audio effect:audio effect custom ext num",
+ 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);
}
}
-}
-static
-void __mm_player_ini_force_setting(void)
-{
- /* FIXIT : remove it when all other elements are available on simulator, SDK */
-
- #if ! defined(__arm__)
- debug_warning("player is running on simulator. force to use ximagesink\n");
- g_player_ini.videosink_element = PLAYER_INI_VSINK_XIMAGESINK;
- g_player_ini.use_audio_filter = FALSE;
-
- strcpy( g_player_ini.name_of_drmsrc, "filesrc" );
-
- // Force setting for simulator :+:091218
- strcpy( g_player_ini.name_of_audiosink, "alsasink" );
-
-
-// __get_string_list( (gchar**) g_player_ini.exclude_element_keyword, "");
-
- #endif
-
- #if defined(VDF_SDK) || defined (SEC_SDK)
- debug_warning("player is running on SDK.\n");
- debug_warning("So, it seems like that some plugin values are not same with those\n");
- debug_warning("which are written in default ini file.\n");
-
- g_player_ini.videosink_element = PLAYER_INI_VSINK_XIMAGESINK;
- g_player_ini.use_audio_filter = FALSE;
-
- strcpy( g_player_ini.name_of_drmsrc, "filesrc" );
- #endif
-
- #if defined(NEW_SOUND)
- strcpy (g_player_ini.name_of_audiosink, "soundsink"); // :+:090707
- #endif
-
- /* FIXIT : The HW quality of volans is not better than protector.
- * So, it can't use same timeout value because state change(resume) is sometimes failed in volans.
- * Thus, it should be set more than 10sec.
- */
- #if defined(_MM_PROJECT_VOLANS)
- g_player_ini.localplayback_state_change_timeout = 10;
- debug_log("localplayback_state_change_timeout is set as 30sec by force\n");
- #endif
-
- #if 0
- #if defined(_MM_PROJECT_VOLANS)
- debug_warning("player is running on VOLANS\n");
- g_player_ini.use_audio_filter = FALSE; // (+)090702, disabled temporally
- #endif
- #endif
-
+ /* audio effect element name */
+ 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");
+ else
+ LOGD("audioeffect element custom : %s", ini->audioeffect_element_custom);
+
+ /* dump structure */
+ LOGD("audioeffect element : %s", ini->audioeffect_element);
+ LOGD("audio effect preset mode : %d", ini->use_audio_effect_preset);
+ LOGD("audio effect custom mode : %d", ini->use_audio_effect_custom);
+#if 0 // debug
+ int i;
+ for (i = 0; i < MM_AUDIO_EFFECT_PRESET_NUM; i++)
+ LOGD("audio_effect_preset_list: %d (is it for earphone only?(%d))", ini->audio_effect_preset_list[i], ini->audio_effect_preset_earphone_only_list[i]);
+
+ for (i = 0; i < MM_AUDIO_EFFECT_CUSTOM_NUM; i++)
+ LOGD("audio_effect_custom_list : %d (is it for earphone only?(%d))", 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)", 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++)
+ 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++)
+ LOGD("audio_effect_custom_level_min_max(idx:%d) : Min(%d), Max(%d)", i, ini->audio_effect_custom_min_level_list[i], ini->audio_effect_custom_max_level_list[i]);
+#endif
+ iniparser_freedict(dict_audioeffect);
+
+ return MM_ERROR_NONE;
+
}
-mm_player_ini_t*
-mm_player_ini_get_structure(void)
+static void
+__mm_player_ini_check_ini_status(void)
{
- return &g_player_ini;
+ struct stat ini_buff;
+
+ if (g_stat(MM_PLAYER_INI_DEFAULT_PATH, &ini_buff) < 0) {
+ LOGW("failed to get player ini status");
+ } else {
+ if (ini_buff.st_size < 5) {
+ LOGW("player.ini file size=%d, Corrupted!So, Removed", (int)ini_buff.st_size);
+
+ if (g_remove(MM_PLAYER_INI_DEFAULT_PATH) == -1)
+ LOGE("failed to delete corrupted ini");
+ }
+ }
}
-static
-gboolean __generate_default_ini(void)
+#ifdef MM_PLAYER_DEFAULT_INI
+static gboolean
+__generate_default_ini(void)
{
- FILE* fp = NULL;
- gchar* default_ini = MM_PLAYER_DEFAULT_INI;
+ FILE *fp = NULL;
+ gchar *default_ini = MM_PLAYER_DEFAULT_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;
}
fclose(fp);
return TRUE;
}
+#endif
-static
-void __get_string_list(gchar** out_list, gchar* str)
+static void
+__get_element_list(mmplayer_ini_t *ini, gchar *str, int keyword_type)
{
- gchar** list = NULL;
- gchar** walk = NULL;
+ gchar **list = NULL;
+ gchar **walk = NULL;
gint i = 0;
- gchar* strtmp = NULL;
-
+ gchar *strtmp = NULL;
+ gchar (*ini_keyword)[PLAYER_INI_MAX_STRLEN] = {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 );
-
- if ( !list )
- {
- if (strtmp)
- g_free(strtmp);
+ list = g_strsplit(strtmp, ",", 10);
+ if (!list) {
+ MMPLAYER_FREEIF(strtmp);
return;
}
/* copy list */
- for( walk = list; *walk; walk++ )
- {
- strncpy( g_player_ini.exclude_element_keyword[i], *walk, (PLAYER_INI_MAX_STRLEN - 1) );
-
- g_strstrip( g_player_ini.exclude_element_keyword[i] );
-
- g_player_ini.exclude_element_keyword[i][PLAYER_INI_MAX_STRLEN - 1] = '\0';
+ switch (keyword_type) {
+ case KEYWORD_EXCLUDE:
+ ini_keyword = ini->exclude_element_keyword;
+ break;
+ case KEYWORD_DUMP:
+ ini_keyword = ini->dump_element_keyword;
+ break;
+ case KEYWORD_UNSUPPORTED_CODEC:
+ ini_keyword = ini->unsupported_codec_keyword;
+ break;
+ case KEYWORD_V_SW_CODEC:
+ ini_keyword = ini->videocodec_element_sw;
+ break;
+ case KEYWORD_A_SW_CODEC:
+ ini_keyword = ini->audiocodec_element_sw;
+ break;
+ case KEYWORD_A_OFFLOAD:
+ ini_keyword = ini->audio_offload_device_type;
+ break;
+ default:
+ goto EXIT;
+ break;
+ }
+ for (walk = list; *walk && ini_keyword[i]; walk++) {
+ strncpy(ini_keyword[i], *walk, (PLAYER_INI_MAX_STRLEN - 1));
+ g_strstrip(ini_keyword[i]);
+ ini_keyword[i][PLAYER_INI_MAX_STRLEN -1] = '\0';
i++;
}
/* mark last item to NULL */
- g_player_ini.exclude_element_keyword[i][0] = '\0';
+ if (ini_keyword[i]) {
+ ini_keyword[i][0] = '\0';
+ } else {
+ LOGE("too many keyword exist in list (%d)", i);
+ if (i > 0)
+ ini_keyword[i-1][0] = '\0';
+ }
- g_strfreev( list );
- if (strtmp)
- g_free (strtmp);
+EXIT:
+ g_strfreev(list);
+ MMPLAYER_FREEIF(strtmp);
}
#endif
-
-
-