src/mm_player_ini.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
   7  * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #ifndef __MM_PLAYER_INI_C__
  24 #define __MM_PLAYER_INI_C__
  25
  26 /* includes here */
  27 #include <dlog.h>
  28 #include <glib.h>
  29 #include <stdlib.h>
  30 #include "iniparser.h"
  31 #include <mm_player_ini.h>
  32 #include <mm_error.h>
  33 #include <mm_player_utils.h>
  34 #include <glib/gstdio.h>
  35
  36 /* internal functions, macros here */
  37 static void     __get_element_list(mmplayer_ini_t *ini, const gchar *str, int keyword_type);
  38
  39 static void __mm_player_ini_check_ini_status(void);
  40
  41 /* macro */
  42 #define MMPLAYER_INI_GET_STRING(x_dict, x_item, x_ini, x_default) \
  43         do { \
  44                 const gchar *str = iniparser_getstring(x_dict, x_ini, x_default); \
  45                 if (str &&  \
  46                         (strlen(str) > 0) && \
  47                         (strlen(str) < PLAYER_INI_MAX_STRLEN)) \
  48                         strncpy(x_item, str, PLAYER_INI_MAX_STRLEN-1); \
  49                 else \
  50                         strncpy(x_item, x_default, PLAYER_INI_MAX_STRLEN-1); \
  51         } while (0)
  52
  53 #define MMPLAYER_INI_GET_COLOR(x_dict, x_item, x_ini, x_default) \
  54         do { \
  55                 const gchar *str = iniparser_getstring(x_dict, x_ini, x_default); \
  56                 if (str &&  \
  57                         (strlen(str) > 0) && \
  58                         (strlen(str) < PLAYER_INI_MAX_STRLEN)) \
  59                         x_item = (guint) strtoul(str, NULL, 16); \
  60                 else \
  61                         x_item = (guint) strtoul(x_default, NULL, 16); \
  62         } while (0)
  63
  64 /* x_ini is the list of index to set TRUE at x_list[index] */
  65 #define MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(x_dict, x_list, x_list_max, x_ini, x_default) \
  66         do { \
  67                         int index = 0; \
  68                         const char *delimiters = " ,"; \
  69                         char *usr_ptr = NULL; \
  70                         char *token = NULL; \
  71                         gchar temp_arr[PLAYER_INI_MAX_STRLEN] = {0}; \
  72                         MMPLAYER_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
  73                         token = strtok_r(temp_arr, delimiters, &usr_ptr); \
  74                         while (token) { \
  75                                 index = atoi(token); \
  76                                 if (index < 0 || index > x_list_max -1) \
  77                                         LOGW("%d is not valid index", index); \
  78                                 else \
  79                                         x_list[index] = TRUE; \
  80                                 token = strtok_r(NULL, delimiters, &usr_ptr); \
  81                         } \
  82         } while (0)
  83
  84 /* x_ini is the list of value to be set at x_list[index] */
  85 #define MMPLAYER_INI_GET_INT_FROM_LIST(x_dict, x_list, x_list_max, x_ini, x_default) \
  86         do { \
  87                         int index = 0; \
  88                         int value = 0; \
  89                         const char *delimiters = " ,"; \
  90                         char *usr_ptr = NULL; \
  91                         char *token = NULL; \
  92                         gchar temp_arr[PLAYER_INI_MAX_STRLEN] = {0, }; \
  93                         MMPLAYER_INI_GET_STRING(x_dict, temp_arr, x_ini, x_default); \
  94                         token = strtok_r(temp_arr, delimiters, &usr_ptr); \
  95                         while (token) { \
  96                                 if (index > x_list_max -1) { \
  97                                         LOGE("%d is not valid index", index); \
  98                                         break; \
  99                                 } else { \
 100                                         value = atoi(token); \
 101                                         x_list[index] = value; \
 102                                         index++; \
 103                                 } \
 104                                 token = strtok_r(NULL, delimiters, &usr_ptr); \
 105                         } \
 106         } while (0)
 107
 108 int
 109 mm_player_ini_load(mmplayer_ini_t *ini)
 110 {
 111         dictionary *dict = NULL;
 112         gint idx = 0;
 113
 114         __mm_player_ini_check_ini_status();
 115
 116         /* first, try to load existing ini file */
 117         dict = iniparser_load(MM_PLAYER_INI_DEFAULT_PATH);
 118
 119         /* get ini values */
 120         memset(ini, 0, sizeof(mmplayer_ini_t));
 121
 122         if (dict) {
 123                 /* if dict is available */
 124                 /* general */
 125                 ini->disable_segtrap = iniparser_getboolean(dict, "general:disable segtrap", DEFAULT_DISABLE_SEGTRAP);
 126                 ini->skip_rescan = iniparser_getboolean(dict, "general:skip rescan", DEFAULT_SKIP_RESCAN);
 127                 ini->generate_dot = iniparser_getboolean(dict, "general:generate dot", DEFAULT_GENERATE_DOT);
 128                 ini->use_system_clock = iniparser_getboolean(dict, "general:use system clock", DEFAULT_USE_SYSTEM_CLOCK);
 129                 ini->live_state_change_timeout = iniparser_getint(dict, "general:live state change timeout", DEFAULT_LIVE_STATE_CHANGE_TIMEOUT);
 130                 ini->localplayback_state_change_timeout = iniparser_getint(dict, "general:localplayback state change timeout", DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT);
 131                 ini->eos_delay = iniparser_getint(dict, "general:eos delay", DEFAULT_EOS_DELAY);
 132                 ini->delay_before_repeat = iniparser_getint(dict, "general:delay before repeat", DEFAULT_DELAY_BEFORE_REPEAT);
 133                 ini->pcm_buffer_size = iniparser_getint(dict, "general:pcm buffer size", DEFAULT_PCM_BUFFER_SIZE);
 134                 ini->num_of_video_bo = iniparser_getint(dict, "general:video bo max", DEFAULT_NUM_OF_VIDEO_BO);
 135                 ini->video_bo_timeout = iniparser_getint(dict, "general:video bo timeout", DEFAULT_TIMEOUT_OF_VIDEO_BO);
 136                 ini->use_uridecodebin3 = iniparser_getboolean(dict, "general:use uridecodebin3", DEFAULT_USE_URIDECODEBIN3);
 137                 ini->support_audio_effect = iniparser_getboolean(dict, "general:support audio effect", DEFAULT_SUPPORT_AUDIO_EFFECT);
 138                 ini->support_pcm_exporting = iniparser_getboolean(dict, "general:support pcm exporting", DEFAULT_SUPPORT_PCM_EXPORTING);
 139                 ini->support_pitch_control = iniparser_getboolean(dict, "general:use pitch control", DEFAULT_SUPPORT_PITCH_CONTROL);
 140                 ini->support_replaygain_control = iniparser_getboolean(dict, "general:use replaygain control", DEFAULT_SUPPORT_REPLAYGAIN_CONTROL);
 141
 142                 MMPLAYER_INI_GET_STRING(dict, ini->audioresampler_element, "general:audio resampler element", DEFAULT_AUDIORESAMPLER);
 143                 MMPLAYER_INI_GET_STRING(dict, ini->audiocodec_element_hw, "general:audio codec element hw", DEFAULT_EMPTY_VALUE);
 144                 MMPLAYER_INI_GET_STRING(dict, ini->audiocodec_default_type, "general:audio codec default type", DEFAULT_EMPTY_VALUE);
 145                 MMPLAYER_INI_GET_STRING(dict, ini->videocodec_element_hw, "general:video codec element hw", DEFAULT_EMPTY_VALUE);
 146                 MMPLAYER_INI_GET_STRING(dict, ini->videocodec_default_type, "general:video codec default type", DEFAULT_EMPTY_VALUE);
 147
 148                 MMPLAYER_INI_GET_STRING(dict, ini->audiosink_element, "general:audiosink element", DEFAULT_AUDIOSINK);
 149                 MMPLAYER_INI_GET_STRING(dict, ini->audio_offload_sink_element, "general:audio offload sink element", DEFAULT_AUDIO_OFFLOAD_SINK);
 150
 151                 MMPLAYER_INI_GET_STRING(dict, ini->videoconverter_element, "general:video converter element", DEFAULT_VIDEO_CONVERTER);
 152                 MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_overlay, "general:videosink element overlay", DEFAULT_VIDEOSINK_OVERLAY);
 153                 MMPLAYER_INI_GET_STRING(dict, ini->videosink_element_fake, "general:videosink element fake", DEFAULT_VIDEOSINK_FAKE);
 154
 155                 __get_element_list(ini,
 156                         iniparser_getstring(dict, "general:audio codec element sw", DEFAULT_EMPTY_VALUE), KEYWORD_A_SW_CODEC);
 157
 158                 __get_element_list(ini,
 159                         iniparser_getstring(dict, "general:video codec element sw", DEFAULT_EMPTY_VALUE), KEYWORD_V_SW_CODEC);
 160
 161                 __get_element_list(ini,
 162                         iniparser_getstring(dict, "general:element exclude keyword", DEFAULT_EXCLUDE_KEYWORD), KEYWORD_EXCLUDE);
 163
 164                 __get_element_list(ini,
 165                         iniparser_getstring(dict, "general:audio offload device type", DEFAULT_A_OFFLOAD_DEVICE_TYPE), KEYWORD_A_OFFLOAD_DEVICE_TYPE);
 166
 167                 __get_element_list(ini,
 168                         iniparser_getstring(dict, "general:audio offload media format", DEFAULT_EMPTY_VALUE), KEYWORD_A_OFFLOAD_MEDIA_FORMAT);
 169
 170                 __get_element_list(ini,
 171                         iniparser_getstring(dict, "general:media stream input format", DEFAULT_EMPTY_VALUE), KEYWORD_MEDIA_STREAM_IN_FORMAT);
 172
 173                 __get_element_list(ini,
 174                         iniparser_getstring(dict, "general:unsupported codec keyword", DEFAULT_UNSUPPORTED_CODEC_KEYWORD), KEYWORD_UNSUPPORTED_CODEC);
 175
 176                 MMPLAYER_INI_GET_STRING(dict, ini->gst_param[0], "general:gstparam1", DEFAULT_GST_PARAM);
 177                 MMPLAYER_INI_GET_STRING(dict, ini->gst_param[1], "general:gstparam2", DEFAULT_GST_PARAM);
 178                 MMPLAYER_INI_GET_STRING(dict, ini->gst_param[2], "general:gstparam3", DEFAULT_GST_PARAM);
 179                 MMPLAYER_INI_GET_STRING(dict, ini->gst_param[3], "general:gstparam4", DEFAULT_GST_PARAM);
 180                 MMPLAYER_INI_GET_STRING(dict, ini->gst_param[4], "general:gstparam5", DEFAULT_GST_PARAM);
 181
 182                 /* http streaming */
 183                 MMPLAYER_INI_GET_STRING(dict, ini->httpsrc_element, "http streaming:httpsrc element", DEFAULT_HTTPSRC);
 184                 ini->http_ring_buffer_size = iniparser_getint(dict, "http streaming:http ring buffer size", DEFAULT_HTTP_RING_BUFFER_SIZE);
 185                 ini->http_timeout = iniparser_getint(dict, "http streaming:http timeout", DEFAULT_HTTP_TIMEOUT);
 186
 187                 /* dump buffer for debug */
 188                 __get_element_list(ini,
 189                         iniparser_getstring(dict, "general:dump element keyword", DEFAULT_EXCLUDE_KEYWORD), KEYWORD_DUMP);
 190
 191                 MMPLAYER_INI_GET_STRING(dict, ini->dump_element_path, "general:dump element path", DEFAULT_DUMP_ELEMENT_PATH);
 192         } else {
 193                 /* if dict is not available just fill the structure with default value */
 194                 LOGW("failed to load ini. using hardcoded default");
 195
 196                 /* general */
 197                 ini->disable_segtrap = DEFAULT_DISABLE_SEGTRAP;
 198                 ini->skip_rescan = DEFAULT_SKIP_RESCAN;
 199                 ini->generate_dot = DEFAULT_GENERATE_DOT;
 200                 ini->use_system_clock = DEFAULT_USE_SYSTEM_CLOCK;
 201                 ini->live_state_change_timeout = DEFAULT_LIVE_STATE_CHANGE_TIMEOUT;
 202                 ini->localplayback_state_change_timeout = DEFAULT_LOCALPLAYBACK_STATE_CHANGE_TIMEOUT;
 203                 ini->eos_delay = DEFAULT_EOS_DELAY;
 204                 ini->delay_before_repeat = DEFAULT_DELAY_BEFORE_REPEAT;
 205                 ini->pcm_buffer_size = DEFAULT_PCM_BUFFER_SIZE;
 206                 ini->num_of_video_bo = DEFAULT_NUM_OF_VIDEO_BO;
 207                 ini->video_bo_timeout = DEFAULT_TIMEOUT_OF_VIDEO_BO;
 208                 ini->use_uridecodebin3 = DEFAULT_USE_URIDECODEBIN3;
 209                 ini->support_audio_effect = DEFAULT_SUPPORT_AUDIO_EFFECT;
 210                 ini->support_pcm_exporting = DEFAULT_SUPPORT_PCM_EXPORTING;
 211                 ini->support_pitch_control = DEFAULT_SUPPORT_PITCH_CONTROL;
 212                 ini->support_replaygain_control = DEFAULT_SUPPORT_REPLAYGAIN_CONTROL;
 213
 214                 strncpy(ini->audioresampler_element, DEFAULT_AUDIORESAMPLER, PLAYER_INI_MAX_STRLEN - 1);
 215                 strncpy(ini->audiocodec_element_hw, DEFAULT_EMPTY_VALUE, PLAYER_INI_MAX_STRLEN - 1);
 216                 strncpy(ini->audiocodec_default_type, DEFAULT_EMPTY_VALUE, PLAYER_INI_MAX_STRLEN - 1);
 217                 strncpy(ini->videocodec_element_hw, DEFAULT_EMPTY_VALUE, PLAYER_INI_MAX_STRLEN - 1);
 218                 strncpy(ini->videocodec_default_type, DEFAULT_EMPTY_VALUE, PLAYER_INI_MAX_STRLEN - 1);
 219
 220                 strncpy(ini->audiosink_element, DEFAULT_AUDIOSINK, PLAYER_INI_MAX_STRLEN - 1);
 221                 strncpy(ini->audio_offload_sink_element, DEFAULT_AUDIO_OFFLOAD_SINK, PLAYER_INI_MAX_STRLEN - 1);
 222                 strncpy(ini->videoconverter_element, DEFAULT_VIDEO_CONVERTER, PLAYER_INI_MAX_STRLEN - 1);
 223                 strncpy(ini->videosink_element_overlay, DEFAULT_VIDEOSINK_OVERLAY, PLAYER_INI_MAX_STRLEN - 1);
 224                 strncpy(ini->videosink_element_fake, DEFAULT_VIDEOSINK_FAKE, PLAYER_INI_MAX_STRLEN - 1);
 225
 226                 __get_element_list(ini, DEFAULT_EMPTY_VALUE, KEYWORD_A_SW_CODEC);
 227                 __get_element_list(ini, DEFAULT_EMPTY_VALUE, KEYWORD_V_SW_CODEC);
 228                 __get_element_list(ini, DEFAULT_A_OFFLOAD_DEVICE_TYPE, KEYWORD_A_OFFLOAD_DEVICE_TYPE);
 229                 __get_element_list(ini, DEFAULT_EMPTY_VALUE, KEYWORD_A_OFFLOAD_MEDIA_FORMAT);
 230                 __get_element_list(ini, DEFAULT_EMPTY_VALUE, KEYWORD_MEDIA_STREAM_IN_FORMAT);
 231                 __get_element_list(ini, DEFAULT_EXCLUDE_KEYWORD, KEYWORD_EXCLUDE);
 232                 __get_element_list(ini, DEFAULT_UNSUPPORTED_CODEC_KEYWORD, KEYWORD_UNSUPPORTED_CODEC);
 233
 234                 strncpy(ini->gst_param[0], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
 235                 strncpy(ini->gst_param[1], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
 236                 strncpy(ini->gst_param[2], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
 237                 strncpy(ini->gst_param[3], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
 238                 strncpy(ini->gst_param[4], DEFAULT_GST_PARAM, PLAYER_INI_MAX_PARAM_STRLEN - 1);
 239
 240                 /* http streaming */
 241                 strncpy(ini->httpsrc_element, DEFAULT_HTTPSRC, PLAYER_INI_MAX_STRLEN - 1);
 242                 ini->http_ring_buffer_size = DEFAULT_HTTP_RING_BUFFER_SIZE;
 243                 ini->http_timeout = DEFAULT_HTTP_TIMEOUT;
 244
 245                 /* dump buffer for debug */
 246                 __get_element_list(ini, DEFAULT_DUMP_ELEMENT_KEYWORD, KEYWORD_DUMP);
 247                 strncpy(ini->dump_element_path, DEFAULT_DUMP_ELEMENT_PATH, PLAYER_INI_MAX_STRLEN - 1);
 248         }
 249
 250         /* free dict as we got our own structure */
 251         iniparser_freedict(dict);
 252
 253         /* dump structure */
 254         LOGD("player settings -----------------------------------");
 255
 256         /* general */
 257         LOGD("disable segtrap : %d", ini->disable_segtrap);
 258         LOGD("skip rescan : %d", ini->skip_rescan);
 259         LOGD("videosink element overlay: %s", ini->videosink_element_overlay);
 260         LOGD("videosink element fake: %s", ini->videosink_element_fake);
 261         LOGD("video converter element : %s", ini->videoconverter_element);
 262         LOGD("video codec element(hw) : %s", ini->videocodec_element_hw);
 263         for (idx = 0; ini->videocodec_element_sw[idx][0] != '\0'; idx++)
 264                 LOGD("video codec element(sw%d) %s", idx, ini->videocodec_element_sw[idx]);
 265         LOGD("audio codec element(hw) : %s", ini->audiocodec_element_hw);
 266         for (idx = 0; ini->audiocodec_element_sw[idx][0] != '\0'; idx++)
 267                 LOGD("audio codec element(sw%d) %s", idx, ini->audiocodec_element_sw[idx]);
 268         LOGD("audio resampler element : %s", ini->audioresampler_element);
 269         LOGD("audiosink element : %s", ini->audiosink_element);
 270         LOGD("audio offload sink element : %s", ini->audio_offload_sink_element);
 271         for (idx = 0; ini->audio_offload_device_type[idx][0] != '\0'; idx++)
 272                 LOGD("audio_offload_device_type [%d] : %s", idx, ini->audio_offload_device_type[idx]);
 273         for (idx = 0; ini->audio_offload_media_format[idx][0] != '\0'; idx++)
 274                 LOGD("audio_offload_media_format [%d] : %s", idx, ini->audio_offload_media_format[idx]);
 275         for (idx = 0; ini->media_stream_input_format[idx][0] != '\0'; idx++)
 276                 LOGD("media_stream_input_format [%d] : %s", idx, ini->media_stream_input_format[idx]);
 277         LOGD("generate dot : %d", ini->generate_dot);
 278         LOGD("use system clock(video only) : %d", ini->use_system_clock);
 279         LOGD("live state change timeout(sec) : %d", ini->live_state_change_timeout);
 280         LOGD("localplayback state change timeout(sec) : %d", ini->localplayback_state_change_timeout);
 281         LOGD("eos_delay(msec) : %d", ini->eos_delay);
 282         LOGD("delay before repeat(msec) : %d", ini->delay_before_repeat);
 283         LOGD("pcm buffer size(bytes) : %d", ini->pcm_buffer_size);
 284         LOGD("num of video bo : %d", ini->num_of_video_bo);
 285         LOGD("video bo timeout : %d", ini->video_bo_timeout);
 286         LOGD("gst param1 : %s", ini->gst_param[0]);
 287         LOGD("gst param2 : %s", ini->gst_param[1]);
 288         LOGD("gst param3 : %s", ini->gst_param[2]);
 289         LOGD("gst param4 : %s", ini->gst_param[3]);
 290         LOGD("gst param5 : %s", ini->gst_param[4]);
 291         LOGD("use uridecodebin3 : %d", ini->use_uridecodebin3);
 292
 293         for (idx = 0; ini->exclude_element_keyword[idx][0] != '\0'; idx++)
 294                 LOGD("exclude_element_keyword [%d] : %s", idx, ini->exclude_element_keyword[idx]);
 295
 296         for (idx = 0; ini->dump_element_keyword[idx][0] != '\0'; idx++)
 297                 LOGD("dump_element_keyword [%d] : %s", idx, ini->dump_element_keyword[idx]);
 298
 299         for (idx = 0; ini->unsupported_codec_keyword[idx][0] != '\0'; idx++)
 300                 LOGD("unsupported_codec_keyword [%d] : %s", idx, ini->unsupported_codec_keyword[idx]);
 301
 302         /* http streaming */
 303         LOGD("httpsrc element : %s", ini->httpsrc_element);
 304         LOGD("http ring buffer size : %d", ini->http_ring_buffer_size);
 305         LOGD("http timeout : %d", ini->http_timeout);
 306
 307         return MM_ERROR_NONE;
 308 }
 309
 310 int
 311 mm_player_audio_effect_ini_load(mmplayer_ini_t *ini)
 312 {
 313         dictionary *dict_audioeffect = NULL;
 314
 315         dict_audioeffect = iniparser_load(MM_PLAYER_INI_DEFAULT_AUDIOEFFECT_PATH);
 316         if (!dict_audioeffect) {
 317                 LOGE("No audio effect ini file found.");
 318                 return MM_ERROR_FILE_NOT_FOUND;
 319         }
 320
 321         /* audio effect element name */
 322         MMPLAYER_INI_GET_STRING(dict_audioeffect, ini->audioeffect_element, "audio effect:audio effect element", DEFAULT_AUDIO_EFFECT_ELEMENT);
 323         if (!ini->audioeffect_element[0]) {
 324                 LOGW("could not parse name of audio effect.");
 325                 iniparser_freedict(dict_audioeffect);
 326                 /* NOTE : in this case, we are not going to create audio filter element */
 327                 return MM_ERROR_NONE;
 328         }
 329
 330         /* audio effect (Preset)*/
 331         ini->use_audio_effect_preset = iniparser_getboolean(dict_audioeffect, "audio effect:audio effect preset", DEFAULT_USE_AUDIO_EFFECT_PRESET);
 332         if (ini->use_audio_effect_preset) {
 333                 MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_preset_list, MM_AUDIO_EFFECT_PRESET_NUM,
 334                                 "audio effect:audio effect preset list", DEFAULT_AUDIO_EFFECT_PRESET_LIST);
 335                 MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_preset_earphone_only_list, MM_AUDIO_EFFECT_PRESET_NUM,
 336                                 "audio effect:audio effect preset earphone only", DEFAULT_AUDIO_EFFECT_PRESET_LIST_EARPHONE_ONLY);
 337         }
 338
 339         /* audio effect user (EQ / Extension effects) */
 340         ini->use_audio_effect_custom = iniparser_getboolean(dict_audioeffect, "audio effect:audio effect custom", DEFAULT_USE_AUDIO_EFFECT_CUSTOM);
 341         if (ini->use_audio_effect_custom) {
 342                 MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
 343                                 "audio effect:audio effect custom list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST);
 344                 MMPLAYER_INI_GET_BOOLEAN_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_earphone_only_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
 345                                 "audio effect:audio effect custom earphone only", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST_EARPHONE_ONLY);
 346
 347                 /* audio effect custom : EQ */
 348                 if (ini->audio_effect_custom_list[MM_AUDIO_EFFECT_CUSTOM_EQ]) {
 349                         ini->audio_effect_custom_eq_band_num = iniparser_getint(dict_audioeffect, "audio effect:audio effect custom eq band num",
 350                                         DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM);
 351                         if (ini->audio_effect_custom_eq_band_num < DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM ||
 352                                         ini->audio_effect_custom_eq_band_num > MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX) {
 353                                 LOGE("audio_effect_custom_eq_band_num(%d) is not valid range(%d - %d), set the value %d",
 354                                         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);
 355                                 ini->audio_effect_custom_eq_band_num = DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_NUM;
 356
 357                                 iniparser_freedict(dict_audioeffect);
 358                                 return MM_ERROR_PLAYER_INTERNAL;
 359                         } else {
 360                                 if (ini->audio_effect_custom_eq_band_num) {
 361                                         MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_eq_band_width, MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX,
 362                                                         "audio effect:audio effect custom eq band width", DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_WIDTH);
 363                                         MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_eq_band_freq, MM_AUDIO_EFFECT_EQ_BAND_NUM_MAX,
 364                                                         "audio effect:audio effect custom eq band freq", DEFAULT_AUDIO_EFFECT_CUSTOM_EQ_BAND_FREQ);
 365                                 }
 366                         }
 367                 }
 368
 369                 /* audio effect custom : Extension effects */
 370                 ini->audio_effect_custom_ext_num = iniparser_getint(dict_audioeffect, "audio effect:audio effect custom ext num",
 371                                 DEFAULT_AUDIO_EFFECT_CUSTOM_EXT_NUM);
 372
 373                 /* Min/Max value list of EQ / Extension effects */
 374                 if (ini->audio_effect_custom_eq_band_num || ini->audio_effect_custom_ext_num) {
 375                         MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_min_level_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
 376                                         "audio effect:audio effect custom min list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST);
 377                         MMPLAYER_INI_GET_INT_FROM_LIST(dict_audioeffect, ini->audio_effect_custom_max_level_list, MM_AUDIO_EFFECT_CUSTOM_NUM,
 378                                         "audio effect:audio effect custom max list", DEFAULT_AUDIO_EFFECT_CUSTOM_LIST);
 379                 }
 380         }
 381
 382         /* audio effect element name */
 383         MMPLAYER_INI_GET_STRING(dict_audioeffect, ini->audioeffect_element_custom, "audio effect:audio effect element custom", DEFAULT_AUDIO_EFFECT_ELEMENT);
 384         if (!ini->audioeffect_element_custom[0])
 385                 LOGW("no secondary audio effect");
 386         else
 387                 LOGD("audioeffect element custom : %s", ini->audioeffect_element_custom);
 388
 389         /* dump structure */
 390         LOGD("audioeffect element : %s", ini->audioeffect_element);
 391         LOGD("audio effect preset mode : %d", ini->use_audio_effect_preset);
 392         LOGD("audio effect custom mode : %d", ini->use_audio_effect_custom);
 393 #ifdef __DEBUG__
 394         int i;
 395         for (i = 0; i < MM_AUDIO_EFFECT_PRESET_NUM; i++)
 396                 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]);
 397
 398         for (i = 0; i < MM_AUDIO_EFFECT_CUSTOM_NUM; i++)
 399                 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]);
 400         LOGD("audio_effect_custom : eq_band_num(%d), ext_num(%d)", ini->audio_effect_custom_eq_band_num, ini->audio_effect_custom_ext_num);
 401         LOGD("audio_effect_custom_EQ : width(Hz) / central frequency(Hz)");
 402         for (i = 0; i < ini->audio_effect_custom_eq_band_num; i++)
 403                 LOGD("     EQ band index(%d) :  %8d / %8d", i, ini->audio_effect_custom_eq_band_width[i], ini->audio_effect_custom_eq_band_freq[i]);
 404         for (i = 0; i < MM_AUDIO_EFFECT_CUSTOM_NUM; i++)
 405                 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]);
 406 #endif
 407         iniparser_freedict(dict_audioeffect);
 408
 409         return MM_ERROR_NONE;
 410
 411 }
 412
 413 static void
 414 __mm_player_ini_check_ini_status(void)
 415 {
 416         struct stat ini_buff;
 417
 418         if (g_stat(MM_PLAYER_INI_DEFAULT_PATH, &ini_buff) < 0) {
 419                 LOGW("failed to get player ini status");
 420         } else {
 421                 if (ini_buff.st_size < 5) {
 422                         LOGW("player.ini file size=%d, Corrupted!So, Removed", (int)ini_buff.st_size);
 423
 424                         if (g_remove(MM_PLAYER_INI_DEFAULT_PATH) == -1)
 425                                 LOGE("failed to delete corrupted ini");
 426                 }
 427         }
 428 }
 429
 430 static void
 431 __get_element_list(mmplayer_ini_t *ini, const gchar *str, int keyword_type)
 432 {
 433         gchar **list = NULL;
 434         gchar **walk = NULL;
 435         gint i = 0;
 436         gint size = PLAYER_INI_MAX_ELEMENT;
 437         gchar *strtmp = NULL;
 438         gchar (*ini_keyword)[PLAYER_INI_MAX_STRLEN] = {NULL, };
 439
 440         if (!str)
 441                 return;
 442
 443         if (strlen(str) < 1)
 444                 return;
 445
 446         strtmp = g_strdup(str);
 447
 448         /* trimming. it works inplace */
 449         g_strstrip(strtmp);
 450
 451         /* split */
 452         list = g_strsplit(strtmp, ",", 10);
 453
 454         if (!list) {
 455                 MMPLAYER_FREEIF(strtmp);
 456                 return;
 457         }
 458
 459         /* copy list */
 460         switch (keyword_type) {
 461         case KEYWORD_EXCLUDE:
 462                 ini_keyword = ini->exclude_element_keyword;
 463                 break;
 464         case KEYWORD_DUMP:
 465                 ini_keyword = ini->dump_element_keyword;
 466                 break;
 467         case KEYWORD_UNSUPPORTED_CODEC:
 468                 ini_keyword = ini->unsupported_codec_keyword;
 469                 break;
 470         case KEYWORD_V_SW_CODEC:
 471                 ini_keyword = ini->videocodec_element_sw;
 472                 break;
 473         case KEYWORD_A_SW_CODEC:
 474                 ini_keyword = ini->audiocodec_element_sw;
 475                 break;
 476         case KEYWORD_A_OFFLOAD_DEVICE_TYPE:
 477                 ini_keyword = ini->audio_offload_device_type;
 478                 size = PLAYER_INI_MAX_DEVICE_TYPE;
 479                 break;
 480         case KEYWORD_A_OFFLOAD_MEDIA_FORMAT:
 481                 ini_keyword = ini->audio_offload_media_format;
 482                 size = PLAYER_INI_MAX_SUPPORTED_MEDIA_FORMAT;
 483                 break;
 484         case KEYWORD_MEDIA_STREAM_IN_FORMAT:
 485                 ini_keyword = ini->media_stream_input_format;
 486                 size = PLAYER_INI_MAX_SUPPORTED_MEDIA_FORMAT;
 487                 break;
 488         default:
 489                 goto EXIT;
 490                 break;
 491         }
 492
 493         for (walk = list; *walk && i < size; walk++) {
 494                 strncpy(ini_keyword[i], *walk, (PLAYER_INI_MAX_STRLEN - 1));
 495                 g_strstrip(ini_keyword[i]);
 496                 ini_keyword[i][PLAYER_INI_MAX_STRLEN -1] = '\0';
 497                 i++;
 498         }
 499
 500         /* mark last item to NULL */
 501         if (i < size) {
 502                 ini_keyword[i][0] = '\0';
 503         } else {
 504                 LOGE("too many keyword exist in list (%d)", i);
 505                 if (i > 0)
 506                         ini_keyword[i-1][0] = '\0';
 507         }
 508
 509 EXIT:
 510         g_strfreev(list);
 511         MMPLAYER_FREEIF(strtmp);
 512 }
 513
 514 #endif