src/player.c

   1 /*
   2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <mm.h>
  21 #include <mm_player.h>
  22 #include <mm_player_audioeffect.h>
  23 #include <mm_player_internal.h>
  24 #include <mm_types.h>
  25 #include <player.h>
  26 #include <player_private.h>
  27 #include <dlog.h>
  28 #include <mm_ta.h>
  29
  30 #ifdef LOG_TAG
  31 #undef LOG_TAG
  32 #endif
  33 #define LOG_TAG "TIZEN_N_PLAYER"
  34
  35 /*
  36 * Internal Macros
  37 */
  38
  39 #define PLAYER_CHECK_CONDITION(condition,error,msg)     \
  40                 if(condition) {} else \
  41                 { LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg,error); return error;}; \
  42
  43
  44 #define PLAYER_INSTANCE_CHECK(player)   \
  45         PLAYER_CHECK_CONDITION(player != NULL, PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER")
  46
  47 #define PLAYER_STATE_CHECK(player,expected_state)       \
  48         PLAYER_CHECK_CONDITION(player->state == expected_state,PLAYER_ERROR_INVALID_STATE,"PLAYER_ERROR_INVALID_STATE")
  49
  50 #define PLAYER_NULL_ARG_CHECK(arg)      \
  51         PLAYER_CHECK_CONDITION(arg != NULL,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER")
  52
  53 /*
  54 * Internal Implementation
  55 */
  56 static int __convert_error_code(int code, char* func_name)
  57 {
  58         int ret = PLAYER_ERROR_INVALID_OPERATION;
  59         char* msg="PLAYER_ERROR_INVALID_OPERATION";
  60         switch(code)
  61         {
  62                 case MM_ERROR_NONE:
  63                         ret = PLAYER_ERROR_NONE;
  64                         msg = "PLAYER_ERROR_NONE";
  65                         break;
  66                 case MM_ERROR_PLAYER_CODEC_NOT_FOUND:
  67                 case MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND:
  68                 case MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND:
  69                 case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_AUDIO:
  70                 case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_VIDEO:
  71                 case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_MEDIA_TYPE:
  72                 case MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT:
  73                         ret = PLAYER_ERROR_NOT_SUPPORTED_FILE;
  74                         msg = "PLAYER_ERROR_NOT_SUPPORTED_FILE";
  75                         break;
  76                 case MM_ERROR_PLAYER_INVALID_STATE:
  77                 case MM_ERROR_PLAYER_NOT_INITIALIZED:
  78                         ret = PLAYER_ERROR_INVALID_STATE;
  79                         msg = "PLAYER_ERROR_INVALID_STATE";
  80                         break;
  81                 case MM_ERROR_PLAYER_INTERNAL:
  82                 case MM_ERROR_PLAYER_INVALID_STREAM:
  83                 case MM_ERROR_PLAYER_STREAMING_FAIL:
  84                 case MM_ERROR_PLAYER_NO_OP:
  85                 case MM_ERROR_NOT_SUPPORT_API:
  86                         ret = PLAYER_ERROR_INVALID_OPERATION;
  87                         msg = "PLAYER_ERROR_INVALID_OPERATION";
  88                         break;
  89                 case MM_ERROR_PLAYER_SOUND_EFFECT_INVALID_STATUS:
  90                 case MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER:
  91                         ret = PLAYER_ERROR_INVALID_OPERATION;
  92                         msg = "PLAYER_ERROR_INVALID_OPERATION (NOT SUPPORTED AUDIO EFFECT)";
  93                         break;
  94                 case  MM_ERROR_PLAYER_NO_FREE_SPACE:
  95                         ret = PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE;
  96                         msg = "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE";
  97                         break;
  98                 case MM_ERROR_PLAYER_FILE_NOT_FOUND:
  99                         ret = PLAYER_ERROR_NO_SUCH_FILE;
 100                         msg = "PLAYER_ERROR_NO_SUCH_FILE";
 101                         break;
 102                 case MM_ERROR_PLAYER_SEEK:
 103                         ret = PLAYER_ERROR_SEEK_FAILED;
 104                         msg = "PLAYER_ERROR_SEEK_FAILED";
 105                         break;
 106                 case MM_ERROR_PLAYER_INVALID_URI:
 107                 case MM_ERROR_PLAYER_STREAMING_INVALID_URL:
 108                         ret = PLAYER_ERROR_INVALID_URI;
 109                         msg = "PLAYER_ERROR_INVALID_URI";
 110                         break;
 111                 case MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL:
 112                 case MM_ERROR_PLAYER_STREAMING_DNS_FAIL :
 113                 case MM_ERROR_PLAYER_STREAMING_SERVER_DISCONNECTED:
 114                 case MM_ERROR_PLAYER_STREAMING_INVALID_PROTOCOL:
 115                 case MM_ERROR_PLAYER_STREAMING_UNEXPECTED_MSG:
 116                 case MM_ERROR_PLAYER_STREAMING_OUT_OF_MEMORIES:
 117                 case MM_ERROR_PLAYER_STREAMING_RTSP_TIMEOUT:
 118                 case MM_ERROR_PLAYER_STREAMING_BAD_REQUEST:
 119                 case MM_ERROR_PLAYER_STREAMING_NOT_AUTHORIZED:
 120                 case MM_ERROR_PLAYER_STREAMING_PAYMENT_REQUIRED:
 121                 case MM_ERROR_PLAYER_STREAMING_FORBIDDEN:
 122                 case MM_ERROR_PLAYER_STREAMING_CONTENT_NOT_FOUND:
 123                 case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_ALLOWED:
 124                 case MM_ERROR_PLAYER_STREAMING_NOT_ACCEPTABLE:
 125                 case MM_ERROR_PLAYER_STREAMING_PROXY_AUTHENTICATION_REQUIRED:
 126                 case MM_ERROR_PLAYER_STREAMING_SERVER_TIMEOUT:
 127                 case MM_ERROR_PLAYER_STREAMING_GONE:
 128                 case MM_ERROR_PLAYER_STREAMING_LENGTH_REQUIRED:
 129                 case MM_ERROR_PLAYER_STREAMING_PRECONDITION_FAILED:
 130                 case MM_ERROR_PLAYER_STREAMING_REQUEST_ENTITY_TOO_LARGE:
 131                 case MM_ERROR_PLAYER_STREAMING_REQUEST_URI_TOO_LARGE:
 132                 case MM_ERROR_PLAYER_STREAMING_PARAMETER_NOT_UNDERSTOOD:
 133                 case MM_ERROR_PLAYER_STREAMING_CONFERENCE_NOT_FOUND:
 134                 case MM_ERROR_PLAYER_STREAMING_NOT_ENOUGH_BANDWIDTH:
 135                 case MM_ERROR_PLAYER_STREAMING_NO_SESSION_ID:
 136                 case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_VALID_IN_THIS_STATE:
 137                 case MM_ERROR_PLAYER_STREAMING_HEADER_FIELD_NOT_VALID_FOR_SOURCE:
 138                 case MM_ERROR_PLAYER_STREAMING_INVALID_RANGE:
 139                 case MM_ERROR_PLAYER_STREAMING_PARAMETER_IS_READONLY:
 140                 case MM_ERROR_PLAYER_STREAMING_AGGREGATE_OP_NOT_ALLOWED:
 141                 case MM_ERROR_PLAYER_STREAMING_ONLY_AGGREGATE_OP_ALLOWED:
 142                 case MM_ERROR_PLAYER_STREAMING_BAD_TRANSPORT:
 143                 case MM_ERROR_PLAYER_STREAMING_DESTINATION_UNREACHABLE:
 144                 case MM_ERROR_PLAYER_STREAMING_INTERNAL_SERVER_ERROR:
 145                 case MM_ERROR_PLAYER_STREAMING_NOT_IMPLEMENTED:
 146                 case MM_ERROR_PLAYER_STREAMING_BAD_GATEWAY:
 147                 case MM_ERROR_PLAYER_STREAMING_SERVICE_UNAVAILABLE:
 148                 case MM_ERROR_PLAYER_STREAMING_GATEWAY_TIME_OUT:
 149                 case MM_ERROR_PLAYER_STREAMING_OPTION_NOT_SUPPORTED:
 150                         ret = PLAYER_ERROR_CONNECTION_FAILED;
 151                         msg = "PLAYER_ERROR_CONNECTION_FAILED";
 152                         break;
 153                 case MM_ERROR_POLICY_BLOCKED:
 154                 case MM_ERROR_POLICY_INTERRUPTED:
 155                 case MM_ERROR_POLICY_INTERNAL:
 156                 case MM_ERROR_POLICY_DUPLICATED:
 157                         ret = PLAYER_ERROR_SOUND_POLICY;
 158                         msg = "PLAYER_ERROR_SOUND_POLICY";
 159                         break;
 160                 case MM_ERROR_PLAYER_DRM_EXPIRED:
 161                         ret = PLAYER_ERROR_DRM_EXPIRED;
 162                         msg = "PLAYER_ERROR_DRM_EXPIRED";
 163                         break;
 164                 case MM_ERROR_PLAYER_DRM_NOT_AUTHORIZED:
 165                 case MM_ERROR_PLAYER_DRM_NO_LICENSE:
 166                         ret = PLAYER_ERROR_DRM_NO_LICENSE;
 167                         msg = "PLAYER_ERROR_DRM_NO_LICENSE";
 168                         break;
 169                 case MM_ERROR_PLAYER_DRM_FUTURE_USE:
 170                         ret = PLAYER_ERROR_DRM_FUTURE_USE;
 171                         msg = "PLAYER_ERROR_DRM_FUTURE_USE";
 172                         break;
 173         }
 174         LOGE("[%s] %s(0x%08x) : core fw error(0x%x)",func_name,msg, ret, code);
 175         return ret;
 176 }
 177
 178 static player_interrupted_code_e __convert_interrupted_code(int code)
 179 {
 180         player_interrupted_code_e ret = PLAYER_INTERRUPTED_BY_RESOURCE_CONFLICT;
 181         switch(code)
 182         {
 183                 case MM_MSG_CODE_INTERRUPTED_BY_ALARM_END:
 184                 case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_END:
 185                         ret = PLAYER_INTERRUPTED_COMPLETED;
 186                         break;
 187                 case MM_MSG_CODE_INTERRUPTED_BY_MEDIA:
 188                 case MM_MSG_CODE_INTERRUPTED_BY_OTHER_PLAYER_APP:
 189                         ret = PLAYER_INTERRUPTED_BY_MEDIA;
 190                         break;
 191                 case MM_MSG_CODE_INTERRUPTED_BY_CALL_START:
 192                         ret = PLAYER_INTERRUPTED_BY_CALL;
 193                         break;
 194                 case MM_MSG_CODE_INTERRUPTED_BY_EARJACK_UNPLUG:
 195                         ret = PLAYER_INTERRUPTED_BY_EARJACK_UNPLUG;
 196                         break;
 197                 case MM_MSG_CODE_INTERRUPTED_BY_ALARM_START:
 198                         ret = PLAYER_INTERRUPTED_BY_ALARM;
 199                         break;
 200                 case MM_MSG_CODE_INTERRUPTED_BY_EMERGENCY_START:
 201                         ret = PLAYER_INTERRUPTED_BY_EMERGENCY;
 202                         break;
 203                 case MM_MSG_CODE_INTERRUPTED_BY_RESUMABLE_MEDIA:
 204                         ret = PLAYER_INTERRUPTED_BY_RESUMABLE_MEDIA;
 205                         break;
 206                 case MM_MSG_CODE_INTERRUPTED_BY_RESOURCE_CONFLICT:
 207                 default :
 208                         ret = PLAYER_INTERRUPTED_BY_RESOURCE_CONFLICT;
 209                         break;
 210         }
 211         LOGE("[%s] incoming(0x%08x) => ret(%d)",__FUNCTION__,code, ret);
 212         return ret;
 213 }
 214
 215 static player_state_e __convert_player_state(MMPlayerStateType state)
 216 {
 217         if(state == MM_PLAYER_STATE_NONE)
 218                 return PLAYER_STATE_NONE;
 219         else
 220                 return state +1;
 221 }
 222
 223 static bool __player_state_validate(player_s * handle, player_state_e threshold)
 224 {
 225         if (handle->state < threshold)
 226                 return FALSE;
 227         return TRUE;
 228 }
 229
 230 static int __set_callback(_player_event_e type, player_h player, void* callback, void *user_data)
 231 {
 232         PLAYER_INSTANCE_CHECK(player);
 233         PLAYER_NULL_ARG_CHECK(callback);
 234         player_s * handle = (player_s *) player;
 235         handle->user_cb[type] = callback;
 236         handle->user_data[type] = user_data;
 237         LOGI("[%s] Event type : %d ",__FUNCTION__, type);
 238         return PLAYER_ERROR_NONE;
 239 }
 240
 241 static int __unset_callback(_player_event_e type, player_h player)
 242 {
 243         PLAYER_INSTANCE_CHECK(player);
 244         player_s * handle = (player_s *) player;
 245         handle->user_cb[type] = NULL;
 246         handle->user_data[type] = NULL;
 247         LOGI("[%s] Event type : %d ",__FUNCTION__, type);
 248         return PLAYER_ERROR_NONE;
 249 }
 250
 251 static int __msg_callback(int message, void *param, void *user_data)
 252 {
 253         player_s * handle = (player_s*)user_data;
 254         MMMessageParamType *msg = (MMMessageParamType*)param;
 255         LOGE("[%s] Start : Got message type : 0x%x" ,__FUNCTION__, message);
 256         player_error_e err_code = PLAYER_ERROR_NONE;
 257         switch(message)
 258         {
 259                 case MM_MESSAGE_ERROR: //0x01
 260                         err_code = __convert_error_code(msg->code,(char*)__FUNCTION__);
 261                         break;
 262                 case  MM_MESSAGE_STATE_CHANGED: //0x03
 263                         LOGE("STATE CHANGED INTERNALLY - from : %d,  to : %d (CAPI State : %d)", msg->state.previous, msg->state.current, handle->state);
 264                         if ((handle->is_progressive_download && msg->state.previous == MM_PLAYER_STATE_NULL && msg->state.current == MM_PLAYER_STATE_READY) ||
 265                                 (msg->state.previous == MM_PLAYER_STATE_READY && msg->state.current == MM_PLAYER_STATE_PAUSED))
 266                         {
 267                                 if(handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE]) // asyc && prepared cb has been set
 268                                 {
 269                                         LOGE("[%s] Prepared! [current state : %d]", __FUNCTION__, handle->state);
 270                                         handle->state = PLAYER_STATE_READY;
 271                                         ((player_prepared_cb)handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE])(handle->user_data[_PLAYER_EVENT_TYPE_PREPARE]);
 272                                         handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 273                                         handle->user_data[_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 274                                 }
 275                         }
 276                         break;
 277                 case MM_MESSAGE_READY_TO_RESUME: //0x05
 278                         if( handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT] )
 279                         {
 280                                 ((player_interrupted_cb)handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT])(PLAYER_INTERRUPTED_COMPLETED,handle->user_data[_PLAYER_EVENT_TYPE_INTERRUPT]);
 281                         }
 282                         break;
 283                 case MM_MESSAGE_BEGIN_OF_STREAM: //0x104
 284                                 MMTA_ACUM_ITEM_END("[CAPI] player_start ~ BOS", 0);
 285                                 LOGE("[%s] Ready to streaming information (BOS) [current state : %d]", __FUNCTION__, handle->state);
 286                         break;
 287                 case MM_MESSAGE_END_OF_STREAM://0x105
 288                         if( handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE] )
 289                         {
 290                                 ((player_completed_cb)handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE])(handle->user_data[_PLAYER_EVENT_TYPE_COMPLETE]);
 291                         }
 292                         break;
 293                 case MM_MESSAGE_BUFFERING: //0x103
 294                         if( handle->user_cb[_PLAYER_EVENT_TYPE_BUFFERING] )
 295                         {
 296                                 ((player_buffering_cb)handle->user_cb[_PLAYER_EVENT_TYPE_BUFFERING])(msg->connection.buffering,handle->user_data[_PLAYER_EVENT_TYPE_BUFFERING]);
 297                         }
 298                         break;
 299                 case MM_MESSAGE_STATE_INTERRUPTED: //0x04
 300                         if( handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT] )
 301                         {
 302                                 handle->state = __convert_player_state(msg->state.current);
 303                                 ((player_interrupted_cb)handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT])(__convert_interrupted_code(msg->code),handle->user_data[_PLAYER_EVENT_TYPE_INTERRUPT]);
 304                         }
 305                         break;
 306                 case MM_MESSAGE_CONNECTION_TIMEOUT: //0x102
 307                         LOGE("[%s] PLAYER_ERROR_CONNECTION_FAILED (0x%08x) : CONNECTION_TIMEOUT" ,__FUNCTION__, PLAYER_ERROR_CONNECTION_FAILED);
 308                         err_code = PLAYER_ERROR_CONNECTION_FAILED;
 309                         break;
 310                 case MM_MESSAGE_UPDATE_SUBTITLE: //0x109
 311                         if( handle->user_cb[_PLAYER_EVENT_TYPE_SUBTITLE] )
 312                         {
 313                                 ((player_subtitle_updated_cb)handle->user_cb[_PLAYER_EVENT_TYPE_SUBTITLE])(msg->subtitle.duration, (char*)msg->data,handle->user_data[_PLAYER_EVENT_TYPE_SUBTITLE]);
 314                         }
 315                         break;
 316                 case MM_MESSAGE_VIDEO_NOT_CAPTURED: //0x113
 317                         LOGE("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x)",__FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED);
 318                         if( handle->user_cb[_PLAYER_EVENT_TYPE_ERROR] )
 319                         {
 320                                 ((player_error_cb)handle->user_cb[_PLAYER_EVENT_TYPE_ERROR])(PLAYER_ERROR_VIDEO_CAPTURE_FAILED,handle->user_data[_PLAYER_EVENT_TYPE_ERROR]);
 321                         }
 322                         break;
 323                 case MM_MESSAGE_VIDEO_CAPTURED: //0x110
 324                         if( handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] )
 325                         {
 326                                 int w;
 327                                 int h;
 328                                 int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_WIDTH ,&w,  MM_PLAYER_VIDEO_HEIGHT, &h, (char*)NULL);
 329                                 if(ret != MM_ERROR_NONE && handle->user_cb[_PLAYER_EVENT_TYPE_ERROR] )
 330                                 {
 331                                         LOGE("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x) : Failed to get video size on video captured (0x%x)" ,__FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED, ret);
 332                                         err_code=PLAYER_ERROR_VIDEO_CAPTURE_FAILED;
 333                                 }
 334                                 else
 335                                 {
 336                                         MMPlayerVideoCapture* capture = (MMPlayerVideoCapture *)msg->data;
 337                                         ((player_video_captured_cb)handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE])(capture->data, w, h, capture->size, handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE]);
 338
 339                                         if (capture->data)
 340                                         {
 341                                                 g_free(capture->data);
 342                                                 capture->data = NULL;
 343                                         }
 344                                 }
 345                                 handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
 346                                 handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
 347                         }
 348                         break;
 349                 case MM_MESSAGE_FILE_NOT_SUPPORTED: //0x10f
 350                         LOGE("[%s] PLAYER_ERROR_NOT_SUPPORTED_FILE (0x%08x) : FILE_NOT_SUPPORTED" ,__FUNCTION__, PLAYER_ERROR_NOT_SUPPORTED_FILE);
 351                         err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE;
 352                         break;
 353                 case MM_MESSAGE_FILE_NOT_FOUND: //0x110
 354                         LOGE("[%s] PLAYER_ERROR_NOT_SUPPORTED_FILE (0x%08x) : FILE_NOT_FOUND" ,__FUNCTION__, PLAYER_ERROR_NOT_SUPPORTED_FILE);
 355                         err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE;
 356                         break;
 357                 case MM_MESSAGE_SEEK_COMPLETED: //0x114
 358                         if (handle->display_type != ((int)MM_DISPLAY_SURFACE_NULL) && handle->state == PLAYER_STATE_READY)
 359                         {
 360                                 if(handle->is_display_visible)
 361                                 {
 362                                         int ret = MM_ERROR_NONE;
 363                                         ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_visible" , 1, (char*)NULL);
 364                                         if(ret != MM_ERROR_NONE)
 365                                         {
 366                                                 LOGW("[%s] Failed to set display visible (0x%x)" ,__FUNCTION__, ret);
 367                                         }
 368
 369                                 }
 370                         }
 371                         if( handle->user_cb[_PLAYER_EVENT_TYPE_SEEK])
 372                         {
 373                                 ((player_seek_completed_cb)handle->user_cb[_PLAYER_EVENT_TYPE_SEEK])(handle->user_data[_PLAYER_EVENT_TYPE_SEEK]);
 374                                 handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = NULL;
 375                                 handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = NULL;
 376                         }
 377                         break;
 378                 case MM_MESSAGE_UNKNOWN: //0x00
 379                 case MM_MESSAGE_WARNING: //0x02
 380                 case MM_MESSAGE_CONNECTING: //0x100
 381                 case MM_MESSAGE_CONNECTED: //0x101
 382                 case MM_MESSAGE_BLUETOOTH_ON: //0x106
 383                 case MM_MESSAGE_BLUETOOTH_OFF: //0x107
 384                 case MM_MESSAGE_RTP_SENDER_REPORT: //0x10a
 385                 case MM_MESSAGE_RTP_RECEIVER_REPORT: //0x10b
 386                 case MM_MESSAGE_RTP_SESSION_STATUS: //0x10c
 387                 case MM_MESSAGE_SENDER_STATE: //0x10d
 388                 case MM_MESSAGE_RECEIVER_STATE: //0x10e
 389                 default:
 390                         break;
 391         }
 392
 393         if(err_code != PLAYER_ERROR_NONE && handle->user_cb[_PLAYER_EVENT_TYPE_ERROR])
 394         {
 395                 ((player_error_cb)handle->user_cb[_PLAYER_EVENT_TYPE_ERROR])(err_code,handle->user_data[_PLAYER_EVENT_TYPE_ERROR]);
 396         }
 397         LOGE("[%s] End", __FUNCTION__);
 398         return 1;
 399 }
 400
 401 static bool  __video_stream_callback(void *stream, int stream_size, void *user_data, int width, int height)
 402 {
 403         player_s * handle = (player_s*)user_data;
 404         if( handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_FRAME])
 405         {
 406                 if(handle->state==PLAYER_STATE_PLAYING)
 407                         ((player_video_frame_decoded_cb)handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_FRAME])((unsigned char *)stream, width, height, stream_size, handle->user_data[_PLAYER_EVENT_TYPE_VIDEO_FRAME]);
 408                 else
 409                         LOGE("[%s] Skip stream - current state : %d", __FUNCTION__,handle->state);
 410         }
 411         return TRUE;
 412 }
 413
 414 static bool  __audio_stream_callback(void *stream, int stream_size, void *user_data)
 415 {
 416         player_s * handle = (player_s*)user_data;
 417         if( handle->user_cb[_PLAYER_EVENT_TYPE_AUDIO_FRAME] )
 418         {
 419                 if(handle->state==PLAYER_STATE_PLAYING)
 420                         ((player_audio_frame_decoded_cb)handle->user_cb[_PLAYER_EVENT_TYPE_AUDIO_FRAME])((unsigned char *)stream, stream_size, handle->user_data[_PLAYER_EVENT_TYPE_AUDIO_FRAME]);
 421                 else
 422                         LOGE("[%s] Skip stream - current state : %d", __FUNCTION__,handle->state);
 423         }
 424         return TRUE;
 425 }
 426
 427 static bool  __video_frame_render_error_callback(void *param, void *user_data)
 428 {
 429         player_s * handle = (player_s*)user_data;
 430         if( handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR])
 431         {
 432                 ((player_x11_pixmap_error_cb)handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR])((unsigned int *)param, handle->user_data[_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR]);
 433         }
 434         return TRUE;
 435 }
 436
 437 static int __pd_message_callback(int message, void *param, void *user_data)
 438 {
 439         player_s * handle = (player_s*)user_data;
 440         player_pd_message_type_e type;
 441         switch(message)
 442         {
 443                 case MM_MESSAGE_PD_DOWNLOADER_START:
 444                         type = PLAYER_PD_STARTED;
 445                         break;
 446                 case MM_MESSAGE_PD_DOWNLOADER_END:
 447                         type = PLAYER_PD_COMPLETED;
 448                         break;
 449                 default:
 450                         return 0;
 451         }
 452
 453         if( handle->user_cb[_PLAYER_EVENT_TYPE_PD] )
 454         {
 455                 ((player_pd_message_cb)handle->user_cb[_PLAYER_EVENT_TYPE_PD])(type, handle->user_data[_PLAYER_EVENT_TYPE_PD]);
 456         }
 457         return 0;
 458 }
 459
 460 static bool __supported_audio_effect_type (int  filter, int type, void *user_data)
 461 {
 462         player_s * handle = (player_s*)user_data;
 463         if(filter != MM_AUDIO_EFFECT_TYPE_CUSTOM || type == MM_AUDIO_EFFECT_CUSTOM_EQ)
 464         {
 465                 LOGI("[%s] Skip invalid filter: %d or type : %d",__FUNCTION__, filter, type);
 466                 return TRUE;
 467         }
 468
 469         if( handle->user_cb[_PLAYER_SUPPORTED_AUDIO_EFFECT_TYPE] )
 470         {
 471                 return ((player_audio_effect_supported_effect_cb)handle->user_cb[_PLAYER_SUPPORTED_AUDIO_EFFECT_TYPE])(type, handle->user_data[_PLAYER_SUPPORTED_AUDIO_EFFECT_TYPE]);
 472         }
 473         return FALSE;
 474 }
 475
 476 static bool __supported_audio_effect_preset (int  filter, int type, void *user_data)
 477 {
 478         player_s * handle = (player_s*)user_data;
 479         if(filter != MM_AUDIO_EFFECT_TYPE_PRESET)
 480         {
 481                 LOGI("[%s] Skip invalid filter: %d or type : %d",__FUNCTION__, filter, type);
 482                 return TRUE;
 483         }
 484
 485         if( handle->user_cb[_PLAYER_SUPPORTED_AUDIO_EFFECT_PRESET] )
 486         {
 487                 return ((player_audio_effect_supported_effect_cb)handle->user_cb[_PLAYER_SUPPORTED_AUDIO_EFFECT_PRESET])(type, handle->user_data[_PLAYER_SUPPORTED_AUDIO_EFFECT_PRESET]);
 488         }
 489         return FALSE;
 490 }
 491
 492
 493 /*
 494 * Public Implementation
 495 */
 496
 497 int player_create (player_h *player)
 498 {
 499         LOGE("[%s] Start", __FUNCTION__);
 500         PLAYER_INSTANCE_CHECK(player);
 501         MMTA_INIT();
 502         MMTA_ACUM_ITEM_BEGIN("[CAPI] player_create", 0);
 503         player_s * handle;
 504         handle = (player_s*)malloc( sizeof(player_s));
 505         if (handle != NULL)
 506                 memset(handle, 0 , sizeof(player_s));
 507         else
 508         {
 509                 LOGE("[%s] PLAYER_ERROR_OUT_OF_MEMORY(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_OUT_OF_MEMORY);
 510                 return PLAYER_ERROR_OUT_OF_MEMORY;
 511         }
 512         int ret = mm_player_create(&handle->mm_handle);
 513         MMTA_ACUM_ITEM_END("[CAPI] player_create", 0);
 514         if( ret != MM_ERROR_NONE)
 515         {
 516                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
 517                 handle->state = PLAYER_STATE_NONE;
 518                 free(handle);
 519                 handle=NULL;
 520                 return PLAYER_ERROR_INVALID_OPERATION;
 521         }
 522         else
 523         {
 524                 *player = (player_h)handle;
 525                 handle->state = PLAYER_STATE_IDLE;
 526                 handle->display_type = MM_DISPLAY_SURFACE_NULL; // means DISPLAY_TYPE_NONE(3)
 527                 handle->is_stopped=false;
 528                 handle->is_display_visible=true;
 529                 LOGE("[%s] End", __FUNCTION__);
 530                 return PLAYER_ERROR_NONE;
 531         }
 532 }
 533
 534
 535 int player_destroy (player_h player)
 536 {
 537         LOGE("[%s] Start", __FUNCTION__);
 538         PLAYER_INSTANCE_CHECK(player);
 539         player_s * handle = (player_s *) player;
 540         MMTA_ACUM_ITEM_SHOW_RESULT_TO(MMTA_SHOW_FILE);
 541
 542         if (mm_player_destroy(handle->mm_handle)!= MM_ERROR_NONE)
 543         {
 544                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
 545                 return PLAYER_ERROR_INVALID_OPERATION;
 546         }
 547         else
 548         {
 549                 handle->state = PLAYER_STATE_NONE;
 550                 free(handle);
 551                 handle= NULL;
 552                 LOGE("[%s] End", __FUNCTION__);
 553                 return PLAYER_ERROR_NONE;
 554         }
 555 }
 556
 557 int     player_prepare_async (player_h player, player_prepared_cb callback, void* user_data)
 558 {
 559         LOGE("[%s] Start", __FUNCTION__);
 560         PLAYER_INSTANCE_CHECK(player);
 561         player_s * handle = (player_s *) player;
 562         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 563
 564         if(handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE])
 565         {
 566                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION (0x%08x) : preparing... we can't do any more " ,__FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
 567                 return PLAYER_ERROR_INVALID_OPERATION;
 568         }
 569         else
 570         {
 571                 LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_PREPARE);
 572                 handle->user_cb[_PLAYER_EVENT_TYPE_PREPARE] = callback;
 573                 handle->user_data[_PLAYER_EVENT_TYPE_PREPARE] = user_data;
 574         }
 575
 576         int ret;
 577         ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void*)handle);
 578         if(ret != MM_ERROR_NONE)
 579         {
 580                 LOGW("[%s] Failed to set message callback function (0x%x)" ,__FUNCTION__, ret);
 581         }
 582
 583         if (handle->display_type==((int)MM_DISPLAY_SURFACE_NULL))
 584         {
 585                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char*)NULL);
 586                 if(ret != MM_ERROR_NONE)
 587                 {
 588                         LOGW("[%s] Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)" ,__FUNCTION__, ret);
 589                 }
 590         }
 591         else
 592         {
 593                 ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_visible", 0, (char*)NULL);
 594                 if(ret != MM_ERROR_NONE)
 595                 {
 596                         LOGW("[%s] Failed to set display visible (0x%x)" ,__FUNCTION__, ret);
 597                 }
 598         }
 599
 600         ret = mm_player_set_attribute(handle->mm_handle, NULL, "profile_prepare_async", 1, (char*)NULL);
 601         if(ret != MM_ERROR_NONE)
 602         {
 603                 LOGE("[%s] Failed to set profile_async_start '1' (0x%x)" ,__FUNCTION__, ret);
 604         }
 605         ret = mm_player_realize(handle->mm_handle);
 606         if(ret != MM_ERROR_NONE)
 607         {
 608                 return __convert_error_code(ret,(char*)__FUNCTION__);
 609         }
 610
 611         if (!handle->is_progressive_download)
 612                 ret = mm_player_pause(handle->mm_handle);
 613
 614         if(ret != MM_ERROR_NONE)
 615         {
 616                 return __convert_error_code(ret,(char*)__FUNCTION__);
 617         }
 618         else
 619         {
 620                 LOGE("[%s] End", __FUNCTION__);
 621                 return PLAYER_ERROR_NONE;
 622         }
 623 }
 624
 625 int     player_prepare (player_h player)
 626 {
 627         LOGE("[%s] Start", __FUNCTION__);
 628         PLAYER_INSTANCE_CHECK(player);
 629         MMTA_ACUM_ITEM_BEGIN("[CAPI] player_prepare", 0);
 630         player_s * handle = (player_s *) player;
 631         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 632
 633         int ret;
 634         ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void*)handle);
 635         if(ret != MM_ERROR_NONE)
 636         {
 637                 LOGW("[%s] Failed to set message callback function (0x%x)" ,__FUNCTION__, ret);
 638         }
 639
 640         if (handle->display_type==((int)MM_DISPLAY_SURFACE_NULL))
 641         {
 642                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char*)NULL);
 643                 if(ret != MM_ERROR_NONE)
 644                 {
 645                         LOGW("[%s] Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)" ,__FUNCTION__, ret);
 646                 }
 647         }
 648         else
 649         {
 650                 ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_visible" , 0, (char*)NULL);
 651                 if(ret != MM_ERROR_NONE)
 652                 {
 653                         LOGW("[%s] Failed to set display display visible '0' (0x%x)" ,__FUNCTION__, ret);
 654                 }
 655         }
 656
 657         ret = mm_player_realize(handle->mm_handle);
 658         if(ret != MM_ERROR_NONE)
 659         {
 660                 LOGE("[%s] Failed to realize - 0x%x", __FUNCTION__,ret);
 661                 return __convert_error_code(ret,(char*)__FUNCTION__);
 662         }
 663
 664         if (!handle->is_progressive_download)
 665                 ret = mm_player_pause(handle->mm_handle);
 666
 667         MMTA_ACUM_ITEM_END("[CAPI] player_prepare", 0);
 668         if(ret != MM_ERROR_NONE)
 669         {
 670                 LOGE("[%s] Failed to pause - 0x%x", __FUNCTION__,ret);
 671                 return __convert_error_code(ret,(char*)__FUNCTION__);
 672         }
 673         else
 674         {
 675                 handle->state = PLAYER_STATE_READY;
 676                 LOGE("[%s] End", __FUNCTION__);
 677                 return PLAYER_ERROR_NONE;
 678         }
 679 }
 680
 681 int     player_unprepare (player_h player)
 682 {
 683         LOGE("[%s] Start", __FUNCTION__);
 684         PLAYER_INSTANCE_CHECK(player);
 685         player_s * handle = (player_s *) player;
 686         if (!__player_state_validate(handle, PLAYER_STATE_READY))
 687         {
 688                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
 689                 return PLAYER_ERROR_INVALID_STATE;
 690         }
 691
 692         int ret = mm_player_unrealize(handle->mm_handle);
 693         if(ret != MM_ERROR_NONE)
 694         {
 695                 return __convert_error_code(ret,(char*)__FUNCTION__);
 696         }
 697         else
 698         {
 699                 handle->state = PLAYER_STATE_IDLE;
 700                 handle->display_type = MM_DISPLAY_SURFACE_NULL; // means DISPLAY_TYPE_NONE(3)
 701                 handle->is_set_pixmap_cb = false;
 702                 handle->is_stopped=false;
 703                 handle->is_display_visible=true;
 704                 handle->is_progressive_download=false;
 705                 LOGE("[%s] End", __FUNCTION__);
 706                 return PLAYER_ERROR_NONE;
 707         }
 708 }
 709
 710 int     player_set_uri (player_h player, const char *uri)
 711 {
 712         PLAYER_INSTANCE_CHECK(player);
 713         PLAYER_NULL_ARG_CHECK(uri);
 714         player_s * handle = (player_s *) player;
 715         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 716
 717         int uri_length = strlen(uri);
 718         int ret = mm_player_set_attribute(handle->mm_handle, NULL,MM_PLAYER_CONTENT_URI , uri, uri_length, (char*)NULL);
 719         if(ret != MM_ERROR_NONE)
 720         {
 721                 return __convert_error_code(ret,(char*)__FUNCTION__);
 722         }
 723         else
 724                 return PLAYER_ERROR_NONE;
 725 }
 726
 727 int     player_set_memory_buffer (player_h player, const void *data, int size)
 728 {
 729         PLAYER_INSTANCE_CHECK(player);
 730         PLAYER_NULL_ARG_CHECK(data);
 731         PLAYER_CHECK_CONDITION(size>=0,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
 732         player_s * handle = (player_s *) player;
 733         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 734
 735         char uri[PATH_MAX] ;
 736
 737         snprintf(uri, sizeof(uri),"mem:///ext=%s,size=%d","", size);
 738         int ret = mm_player_set_attribute(handle->mm_handle, NULL,MM_PLAYER_CONTENT_URI, uri, strlen(uri), MM_PLAYER_MEMORY_SRC, data,size,(char*)NULL);
 739         if(ret != MM_ERROR_NONE)
 740         {
 741                 return __convert_error_code(ret,(char*)__FUNCTION__);
 742         }
 743         else
 744                 return PLAYER_ERROR_NONE;
 745 }
 746
 747 int     player_get_state (player_h player, player_state_e *state)
 748 {
 749         PLAYER_INSTANCE_CHECK(player);
 750         PLAYER_NULL_ARG_CHECK(state);
 751         player_s * handle = (player_s *) player;
 752         *state = handle->state;
 753         MMPlayerStateType currentStat = MM_PLAYER_STATE_NULL;
 754         mm_player_get_state(handle->mm_handle, &currentStat);
 755         LOGE("[%s] State : %d (FW state : %d)", __FUNCTION__,handle->state, currentStat);
 756         return PLAYER_ERROR_NONE;
 757 }
 758
 759 int     player_set_volume (player_h player, float left, float right)
 760 {
 761         PLAYER_INSTANCE_CHECK(player);
 762         PLAYER_CHECK_CONDITION(left>=0 && left <= 1.0 ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
 763         PLAYER_CHECK_CONDITION(right>=0 && right <= 1.0 ,PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER" );
 764         player_s * handle = (player_s *) player;
 765         MMPlayerVolumeType vol;
 766         vol.level[MM_VOLUME_CHANNEL_LEFT] = left;
 767         vol.level[MM_VOLUME_CHANNEL_RIGHT] = right;
 768         int ret = mm_player_set_volume(handle->mm_handle,&vol);
 769         if(ret != MM_ERROR_NONE)
 770         {
 771                 return __convert_error_code(ret,(char*)__FUNCTION__);
 772         }
 773         else
 774         {
 775                 return PLAYER_ERROR_NONE;
 776         }
 777 }
 778
 779 int     player_get_volume (player_h player, float *left, float *right)
 780 {
 781         PLAYER_INSTANCE_CHECK(player);
 782         PLAYER_NULL_ARG_CHECK(left);
 783         PLAYER_NULL_ARG_CHECK(right);
 784         player_s * handle = (player_s *) player;
 785         MMPlayerVolumeType vol;
 786         int ret = mm_player_get_volume(handle->mm_handle,&vol);
 787         if(ret != MM_ERROR_NONE)
 788         {
 789                 return __convert_error_code(ret,(char*)__FUNCTION__);
 790         }
 791         else
 792         {
 793                 *left = vol.level[MM_VOLUME_CHANNEL_LEFT];
 794                 *right = vol.level[MM_VOLUME_CHANNEL_RIGHT];
 795                 return PLAYER_ERROR_NONE;
 796         }
 797 }
 798
 799 int player_set_sound_type(player_h player, sound_type_e type)
 800 {
 801         PLAYER_INSTANCE_CHECK(player);
 802         player_s * handle = (player_s *) player;
 803
 804         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"sound_volume_type" , type, (char*)NULL);
 805         if(ret != MM_ERROR_NONE)
 806         {
 807                 return __convert_error_code(ret,(char*)__FUNCTION__);
 808         }
 809         else
 810                 return PLAYER_ERROR_NONE;
 811 }
 812
 813 int player_set_audio_latency_mode(player_h player, audio_latency_mode_e latency_mode)
 814 {
 815         PLAYER_INSTANCE_CHECK(player);
 816         player_s * handle = (player_s *) player;
 817
 818         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"audio_latency_mode" , latency_mode, (char*)NULL);
 819         if(ret != MM_ERROR_NONE)
 820                 return __convert_error_code(ret,(char*)__FUNCTION__);
 821         else
 822                 return PLAYER_ERROR_NONE;
 823 }
 824
 825 int player_get_audio_latency_mode(player_h player, audio_latency_mode_e *latency_mode)
 826 {
 827         PLAYER_INSTANCE_CHECK(player);
 828         PLAYER_NULL_ARG_CHECK(latency_mode);
 829         player_s * handle = (player_s *) player;
 830
 831         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"audio_latency_mode" , latency_mode, (char*)NULL);
 832         if(ret != MM_ERROR_NONE)
 833                 return __convert_error_code(ret,(char*)__FUNCTION__);
 834         else
 835                 return PLAYER_ERROR_NONE;
 836 }
 837
 838 int     player_start (player_h player)
 839 {
 840         LOGE("[%s] Start", __FUNCTION__);
 841         PLAYER_INSTANCE_CHECK(player);
 842         MMTA_ACUM_ITEM_BEGIN("[CAPI] player_start only", 0);
 843         MMTA_ACUM_ITEM_BEGIN("[CAPI] player_start ~ BOS", 0);
 844         player_s * handle = (player_s *) player;
 845         int ret;
 846         if ( handle->state  ==PLAYER_STATE_READY || handle->state ==PLAYER_STATE_PAUSED)
 847         {
 848                 if(handle->display_type == PLAYER_DISPLAY_TYPE_X11 || handle->display_type == PLAYER_DISPLAY_TYPE_EVAS)
 849                 {
 850                         if(handle->is_display_visible)
 851                         {
 852                                 ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_visible" , 1, (char*)NULL);
 853                                 LOGE("[%s] show video display : %d",__FUNCTION__, ret);
 854                         }
 855                 }
 856
 857                 if(handle->is_stopped)
 858                 {
 859                         if (handle->is_progressive_download)
 860                         {
 861                                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
 862                                 return PLAYER_ERROR_INVALID_OPERATION;
 863                         }
 864
 865                         ret = mm_player_start(handle->mm_handle);
 866                         LOGE("[%s] stop -> start() ",__FUNCTION__);
 867                 }
 868                 else
 869                 {
 870                         if (handle->is_progressive_download && handle->state  ==PLAYER_STATE_READY)
 871                                 ret = mm_player_start(handle->mm_handle);
 872                         else
 873                                 ret = mm_player_resume(handle->mm_handle);
 874                 }
 875         }
 876         else
 877         {
 878                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
 879                 return PLAYER_ERROR_INVALID_STATE;
 880         }
 881
 882         if(ret != MM_ERROR_NONE)
 883         {
 884                 return __convert_error_code(ret,(char*)__FUNCTION__);
 885         }
 886         else
 887         {
 888                 handle->is_stopped = FALSE;
 889                 handle->state = PLAYER_STATE_PLAYING;
 890                 LOGE("[%s] End", __FUNCTION__);
 891                 return PLAYER_ERROR_NONE;
 892         }
 893 }
 894
 895 int     player_stop (player_h player)
 896 {
 897         LOGE("[%s] Start", __FUNCTION__);
 898         PLAYER_INSTANCE_CHECK(player);
 899         player_s * handle = (player_s *) player;
 900         if (handle->state == PLAYER_STATE_PLAYING || handle->state == PLAYER_STATE_PAUSED)
 901         {
 902                 int ret = mm_player_stop(handle->mm_handle);
 903                 if(ret != MM_ERROR_NONE)
 904                 {
 905                         return __convert_error_code(ret,(char*)__FUNCTION__);
 906                 }
 907                 else
 908                 {
 909                         handle->state = PLAYER_STATE_READY;
 910                         handle->is_stopped = TRUE;
 911                         LOGE("[%s] End", __FUNCTION__);
 912                         return PLAYER_ERROR_NONE;
 913                 }
 914         }
 915         else
 916         {
 917                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
 918                 return PLAYER_ERROR_INVALID_STATE;
 919         }
 920 }
 921
 922 int     player_pause (player_h player)
 923 {
 924         LOGE("[%s] Start", __FUNCTION__);
 925         PLAYER_INSTANCE_CHECK(player);
 926         player_s * handle = (player_s *) player;
 927         PLAYER_STATE_CHECK(handle,PLAYER_STATE_PLAYING);
 928
 929         int ret = mm_player_pause(handle->mm_handle);
 930         if(ret != MM_ERROR_NONE)
 931         {
 932                 return __convert_error_code(ret,(char*)__FUNCTION__);
 933         }
 934         else
 935         {
 936                 handle->state = PLAYER_STATE_PAUSED;
 937                 LOGE("[%s] End", __FUNCTION__);
 938                 return PLAYER_ERROR_NONE;
 939         }
 940 }
 941
 942 int     player_set_position (player_h player, int millisecond, player_seek_completed_cb callback, void *user_data)
 943 {
 944         PLAYER_INSTANCE_CHECK(player);
 945         PLAYER_CHECK_CONDITION(millisecond>=0  ,PLAYER_ERROR_INVALID_PARAMETER ,"PLAYER_ERROR_INVALID_PARAMETER" );
 946
 947         player_s * handle = (player_s *) player;
 948         if(handle->user_cb[_PLAYER_EVENT_TYPE_SEEK])
 949         {
 950                 LOGE("[%s] PLAYER_ERROR_SEEK_FAILED (0x%08x) : seeking... we can't do any more " ,__FUNCTION__, PLAYER_ERROR_SEEK_FAILED);
 951                 return PLAYER_ERROR_SEEK_FAILED;
 952         }
 953         else
 954         {
 955                 LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_SEEK);
 956                 handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = callback;
 957                 handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = user_data;
 958         }
 959
 960         int ret = mm_player_set_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME, millisecond);
 961         if(ret != MM_ERROR_NONE)
 962         {
 963                 return __convert_error_code(ret,(char*)__FUNCTION__);
 964         }
 965         else
 966         {
 967                 return PLAYER_ERROR_NONE;
 968         }
 969 }
 970
 971 int     player_set_position_ratio (player_h player, int percent, player_seek_completed_cb callback, void *user_data)
 972 {
 973         PLAYER_INSTANCE_CHECK(player);
 974         PLAYER_CHECK_CONDITION(percent>=0 && percent <= 100 ,PLAYER_ERROR_INVALID_PARAMETER ,"PLAYER_ERROR_INVALID_PARAMETER" );
 975
 976         player_s * handle = (player_s *) player;
 977         if(handle->user_cb[_PLAYER_EVENT_TYPE_SEEK])
 978         {
 979                 LOGE("[%s] PLAYER_ERROR_SEEK_FAILED (0x%08x) : seeking... we can't do any more " ,__FUNCTION__, PLAYER_ERROR_SEEK_FAILED);
 980                 return PLAYER_ERROR_SEEK_FAILED;
 981         }
 982         else
 983         {
 984                 LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_SEEK);
 985                 handle->user_cb[_PLAYER_EVENT_TYPE_SEEK] = callback;
 986                 handle->user_data[_PLAYER_EVENT_TYPE_SEEK] = user_data;
 987         }
 988
 989         int ret = mm_player_set_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_PERCENT , percent);
 990         if(ret != MM_ERROR_NONE)
 991         {
 992                 return __convert_error_code(ret,(char*)__FUNCTION__);
 993         }
 994         else
 995         {
 996                 return PLAYER_ERROR_NONE;
 997         }
 998 }
 999
1000
1001 int     player_get_position (player_h player, int *millisecond)
1002 {
1003         PLAYER_INSTANCE_CHECK(player);
1004         PLAYER_NULL_ARG_CHECK(millisecond);
1005         player_s * handle = (player_s *) player;
1006         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1007         {
1008                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1009                 return PLAYER_ERROR_INVALID_STATE;
1010         }
1011         int pos;
1012         int ret = mm_player_get_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME , &pos);
1013         if(ret != MM_ERROR_NONE)
1014         {
1015                 return __convert_error_code(ret,(char*)__FUNCTION__);
1016         }
1017         else
1018         {
1019                 *millisecond = pos;
1020                 return PLAYER_ERROR_NONE;
1021         }
1022 }
1023
1024 int     player_get_position_ratio (player_h player,int *percent)
1025 {
1026         PLAYER_INSTANCE_CHECK(player);
1027         PLAYER_NULL_ARG_CHECK(percent);
1028         player_s * handle = (player_s *) player;
1029         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1030         {
1031                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1032                 return PLAYER_ERROR_INVALID_STATE;
1033         }
1034         int pos;
1035         int ret = mm_player_get_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_PERCENT, &pos);
1036         if(ret != MM_ERROR_NONE)
1037         {
1038                 return __convert_error_code(ret,(char*)__FUNCTION__);
1039         }
1040         else
1041         {
1042                 *percent=pos;
1043                 return PLAYER_ERROR_NONE;
1044         }
1045 }
1046
1047 int     player_set_mute (player_h player, bool muted)
1048 {
1049         PLAYER_INSTANCE_CHECK(player);
1050         player_s * handle = (player_s *) player;
1051
1052         int ret = mm_player_set_mute(handle->mm_handle, muted);
1053         if(ret != MM_ERROR_NONE)
1054         {
1055                 return __convert_error_code(ret,(char*)__FUNCTION__);
1056         }
1057         else
1058         {
1059                 return PLAYER_ERROR_NONE;
1060         }
1061 }
1062
1063 int     player_is_muted (player_h player, bool *muted)
1064 {
1065         PLAYER_INSTANCE_CHECK(player);
1066         PLAYER_NULL_ARG_CHECK(muted);
1067         player_s * handle = (player_s *) player;
1068
1069         int _mute;
1070         int ret = mm_player_get_mute(handle->mm_handle, &_mute);
1071         if(ret != MM_ERROR_NONE)
1072         {
1073                 return __convert_error_code(ret,(char*)__FUNCTION__);
1074         }
1075         else
1076         {
1077                 if(_mute)
1078                 {
1079                         *muted = TRUE;
1080                 }
1081                 else
1082                 {
1083                         *muted = FALSE;
1084                 }
1085                 return PLAYER_ERROR_NONE;
1086         }
1087 }
1088
1089 int     player_set_looping (player_h player, bool looping)
1090 {
1091         PLAYER_INSTANCE_CHECK(player);
1092         player_s * handle = (player_s *) player;
1093         if (!__player_state_validate(handle, PLAYER_STATE_IDLE))
1094         {
1095                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1096                 return PLAYER_ERROR_INVALID_STATE;
1097         }
1098
1099         int value = 0;
1100         if(looping==TRUE)
1101         {
1102                 value = -1;
1103         }
1104         int ret = mm_player_set_attribute(handle->mm_handle, NULL,MM_PLAYER_PLAYBACK_COUNT , value, (char*)NULL);
1105
1106         if(ret != MM_ERROR_NONE)
1107         {
1108                 return __convert_error_code(ret,(char*)__FUNCTION__);
1109         }
1110         else
1111         {
1112                 return PLAYER_ERROR_NONE;
1113         }
1114 }
1115
1116 int     player_is_looping (player_h player, bool *looping)
1117 {
1118         PLAYER_INSTANCE_CHECK(player);
1119         PLAYER_NULL_ARG_CHECK(looping);
1120         player_s * handle = (player_s *) player;
1121         if (!__player_state_validate(handle, PLAYER_STATE_IDLE))
1122         {
1123                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1124                 return PLAYER_ERROR_INVALID_STATE;
1125         }
1126         int count;
1127         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_PLAYBACK_COUNT , &count, (char*)NULL);
1128         if(ret != MM_ERROR_NONE)
1129         {
1130                 return __convert_error_code(ret,(char*)__FUNCTION__);
1131         }
1132         else
1133         {
1134                 if(count==-1)
1135                 {
1136                         *looping = TRUE;
1137                 }
1138                 else
1139                 {
1140                         *looping = FALSE;
1141                 }
1142                 return PLAYER_ERROR_NONE;
1143         }
1144 }
1145
1146 int     player_get_duration (player_h player, int *duration)
1147 {
1148         PLAYER_INSTANCE_CHECK(player);
1149         PLAYER_NULL_ARG_CHECK(duration);
1150         player_s * handle = (player_s *) player;
1151         if (!__player_state_validate(handle, PLAYER_STATE_IDLE))
1152         {
1153                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1154                 return PLAYER_ERROR_INVALID_STATE;
1155         }
1156         int _duration;
1157         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_CONTENT_DURATION, &_duration, (char*)NULL);
1158         if(ret != MM_ERROR_NONE)
1159         {
1160                 return __convert_error_code(ret,(char*)__FUNCTION__);
1161         }
1162         else
1163         {
1164                 *duration = _duration;
1165                 LOGE("[%s] duration : %d",__FUNCTION__,_duration);
1166                 return PLAYER_ERROR_NONE;
1167         }
1168 }
1169
1170 int player_set_display(player_h player, player_display_type_e type, player_display_h display)
1171 {
1172         PLAYER_INSTANCE_CHECK(player);
1173         player_s * handle = (player_s *) player;
1174
1175         int ret;
1176         if (!__player_state_validate(handle, PLAYER_STATE_IDLE))
1177         {
1178                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1179                 return PLAYER_ERROR_INVALID_STATE;
1180         }
1181
1182         if (handle->is_set_pixmap_cb)
1183         {
1184                 if (handle->state < PLAYER_STATE_READY)
1185                 {
1186                         /* just set below and go to "changing surface case" */
1187                         handle->is_set_pixmap_cb = false;
1188                 }
1189                 else
1190                 {
1191                         LOGE("[%s] pixmap callback was set, try it again after calling player_unprepare()" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
1192                         LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
1193                         return PLAYER_ERROR_INVALID_OPERATION;
1194                 }
1195         }
1196
1197         void* temp;
1198         if (handle->display_type == (int)MM_DISPLAY_SURFACE_NULL || type == handle->display_type) // first time or same type
1199         {
1200                 temp = handle->display_handle;
1201                 handle->display_handle = display;
1202                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", type, "display_overlay" , type == PLAYER_DISPLAY_TYPE_X11 ? &handle->display_handle : display, sizeof(display), (char*)NULL);
1203                 if (ret != MM_ERROR_NONE)
1204                 {
1205                         handle->display_handle = temp;
1206                         LOGE("[%s] Failed to display surface change :%d",__FUNCTION__,ret);
1207                 }
1208                 else
1209                 {
1210                         handle->display_type = type;
1211                         LOGE("[%s] video display has been changed- type :%d, addr : 0x%x",__FUNCTION__,handle->display_type, handle->display_handle);
1212                 }
1213                 LOGE("[%s] video display has been updated - type :%d",__FUNCTION__,type);
1214         }
1215         else //changing surface case
1216         {
1217                 temp = handle->display_handle;
1218                 handle->display_handle = display;
1219
1220                 ret = mm_player_change_videosink(handle->mm_handle, type, type == PLAYER_DISPLAY_TYPE_X11 ? &handle->display_handle : display);
1221                 if (ret != MM_ERROR_NONE)
1222                 {
1223                         handle->display_handle = temp;
1224                         if(ret == MM_ERROR_NOT_SUPPORT_API)
1225                         {
1226                                 LOGE("[%s] change video sink is not available.",__FUNCTION__);
1227                                 ret = PLAYER_ERROR_NONE;
1228                         }
1229                         else
1230                         {
1231                                 LOGE("[%s] Failed to display surface change :%d",__FUNCTION__,ret);
1232                         }
1233                 }
1234                 else
1235                 {
1236                         handle->display_type = type;
1237                         LOGE("[%s] video display has been changed- type :%d, addr : 0x%x",__FUNCTION__,handle->display_type, handle->display_handle);
1238                 }
1239         }
1240
1241         if(ret != MM_ERROR_NONE)
1242         {
1243                 handle->display_type = MM_DISPLAY_SURFACE_NULL;
1244                 return __convert_error_code(ret,(char*)__FUNCTION__);
1245         }
1246         else
1247         {
1248                 LOGE("[%s] End",__FUNCTION__);
1249                 return PLAYER_ERROR_NONE;
1250         }
1251 }
1252
1253 int player_is_display_mode_changeable(player_h player, bool* changeable)
1254 {
1255         PLAYER_INSTANCE_CHECK(player);
1256         PLAYER_NULL_ARG_CHECK(changeable);
1257         player_s * handle = (player_s *) player;
1258         switch(handle->display_type)
1259         {
1260                 case PLAYER_DISPLAY_TYPE_X11:
1261                         *changeable = TRUE;
1262                         break;
1263                 case PLAYER_DISPLAY_TYPE_EVAS:
1264                 {
1265                         char *sink_name = NULL;
1266                         int length;
1267                         int scaling;
1268                         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"display_evas_surface_sink" ,&sink_name, &length, "display_evas_do_scaling", &scaling, (char*)NULL);
1269                         if(ret != MM_ERROR_NONE)
1270                                 *changeable = FALSE;
1271                         if (!strncmp(sink_name,"evaspixmapsink",length) && scaling==1)
1272                         {
1273                                 *changeable = TRUE;
1274                         }
1275                         break;
1276                 }
1277                 default:
1278                         *changeable = FALSE;
1279                         break;
1280         }
1281         return PLAYER_ERROR_NONE;
1282 }
1283
1284 int player_set_display_mode(player_h player, player_display_mode_e mode)
1285 {
1286         PLAYER_INSTANCE_CHECK(player);
1287         player_s * handle = (player_s *) player;
1288
1289         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_method" , mode, (char*)NULL);
1290         if(ret != MM_ERROR_NONE)
1291         {
1292                 return __convert_error_code(ret,(char*)__FUNCTION__);
1293         }
1294         else
1295                 return PLAYER_ERROR_NONE;
1296 }
1297
1298 int player_get_display_mode(player_h player, player_display_mode_e *mode)
1299 {
1300         PLAYER_INSTANCE_CHECK(player);
1301         PLAYER_NULL_ARG_CHECK(mode);
1302         player_s * handle = (player_s *) player;
1303         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"display_method"  ,mode, (char*)NULL);
1304         if(ret != MM_ERROR_NONE)
1305         {
1306                 return __convert_error_code(ret,(char*)__FUNCTION__);
1307         }
1308         else
1309         {
1310                 return PLAYER_ERROR_NONE;
1311         }
1312 }
1313
1314 int player_set_playback_rate(player_h player, float rate)
1315 {
1316         PLAYER_INSTANCE_CHECK(player);
1317         PLAYER_CHECK_CONDITION(rate>=-5.0 && rate <= 5.0 ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
1318         player_s * handle = (player_s *) player;
1319         PLAYER_STATE_CHECK(handle,PLAYER_STATE_PLAYING);
1320
1321         int ret = mm_player_set_play_speed(handle->mm_handle, rate);
1322
1323         switch (ret)
1324         {
1325         case MM_ERROR_NONE:
1326         case MM_ERROR_PLAYER_NO_OP:
1327                 ret = PLAYER_ERROR_NONE;
1328                 break;
1329         case MM_ERROR_NOT_SUPPORT_API:
1330         case MM_ERROR_PLAYER_SEEK:
1331                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x) : seek error",__FUNCTION__, PLAYER_ERROR_INVALID_OPERATION);
1332                 ret = PLAYER_ERROR_INVALID_OPERATION;
1333                 break;
1334         default:
1335                 return __convert_error_code(ret,(char*)__FUNCTION__);
1336         }
1337         return ret;
1338 }
1339
1340
1341 int player_set_x11_display_rotation(player_h player, player_display_rotation_e rotation)
1342 {
1343         PLAYER_INSTANCE_CHECK(player);
1344         player_s * handle = (player_s *) player;
1345
1346         int ret = mm_player_set_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_ROTATION , rotation, (char*)NULL);
1347         if(ret != MM_ERROR_NONE)
1348         {
1349                 return __convert_error_code(ret,(char*)__FUNCTION__);
1350         }
1351         else
1352                 return PLAYER_ERROR_NONE;
1353 }
1354
1355 int player_get_x11_display_rotation( player_h player, player_display_rotation_e *rotation)
1356 {
1357         PLAYER_INSTANCE_CHECK(player);
1358         PLAYER_NULL_ARG_CHECK(rotation);
1359         player_s * handle = (player_s *) player;
1360         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_ROTATION ,rotation, (char*)NULL);
1361         if(ret != MM_ERROR_NONE)
1362         {
1363                 return __convert_error_code(ret,(char*)__FUNCTION__);
1364         }
1365         else
1366         {
1367                 return PLAYER_ERROR_NONE;
1368         }
1369 }
1370
1371 int player_set_x11_display_visible(player_h player, bool visible)
1372 {
1373         PLAYER_INSTANCE_CHECK(player);
1374         player_s * handle = (player_s *) player;
1375
1376         int value = 0;
1377         if(visible==TRUE)
1378         {
1379                 value = 1;
1380         }
1381
1382         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_visible" , value, (char*)NULL);
1383         if(ret != MM_ERROR_NONE)
1384         {
1385                 return __convert_error_code(ret,(char*)__FUNCTION__);
1386         }
1387         else
1388         {
1389                 handle->is_display_visible = visible;
1390                 return PLAYER_ERROR_NONE;
1391         }
1392 }
1393
1394 int player_is_x11_display_visible(player_h player, bool* visible)
1395 {
1396         PLAYER_INSTANCE_CHECK(player);
1397         PLAYER_NULL_ARG_CHECK(visible);
1398         player_s * handle = (player_s *) player;
1399         int count;
1400         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"display_visible" ,&count, (char*)NULL);
1401         if(ret != MM_ERROR_NONE)
1402         {
1403                 return __convert_error_code(ret,(char*)__FUNCTION__);
1404         }
1405         else
1406         {
1407                 if(count==0)
1408                 {
1409                         *visible = FALSE;
1410                 }
1411                 else
1412                 {
1413                         *visible = TRUE;
1414                 }
1415
1416                 return PLAYER_ERROR_NONE;
1417         }
1418 }
1419
1420 int player_set_x11_display_zoom(player_h player, int level)
1421 {
1422         PLAYER_INSTANCE_CHECK(player);
1423         PLAYER_CHECK_CONDITION(level>0 && level < 10 ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
1424
1425         player_s * handle = (player_s *) player;
1426         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_zoom" , level, (char*)NULL);
1427         if(ret != MM_ERROR_NONE)
1428         {
1429                 return __convert_error_code(ret,(char*)__FUNCTION__);
1430         }
1431         else
1432                 return PLAYER_ERROR_NONE;
1433 }
1434
1435 int player_get_x11_display_zoom( player_h player, int *level)
1436 {
1437         PLAYER_INSTANCE_CHECK(player);
1438         PLAYER_NULL_ARG_CHECK(level);
1439         player_s * handle = (player_s *) player;
1440         int _level;
1441         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"display_zoom" , &_level, (char*)NULL);
1442         if(ret != MM_ERROR_NONE)
1443         {
1444                 *level=-1;
1445                 return __convert_error_code(ret,(char*)__FUNCTION__);
1446         }
1447         else
1448         {
1449                 *level = _level;
1450                 return PLAYER_ERROR_NONE;
1451         }
1452 }
1453
1454 int player_set_x11_display_pixmap (player_h player, player_x11_pixmap_updated_cb callback, void *user_data)
1455 {
1456         PLAYER_INSTANCE_CHECK(player);
1457         PLAYER_NULL_ARG_CHECK(callback);
1458         player_s * handle = (player_s *) player;
1459
1460         if (!__player_state_validate(handle, PLAYER_STATE_IDLE))
1461         {
1462                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1463                 return PLAYER_ERROR_INVALID_STATE;
1464         }
1465
1466         if (!handle->is_set_pixmap_cb && handle->display_type != ((int)MM_DISPLAY_SURFACE_NULL))
1467         {
1468                 LOGE("[%s] player_set_display() was set, try it again after calling player_unprepare()" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
1469                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
1470                 return PLAYER_ERROR_INVALID_OPERATION;
1471         }
1472
1473         int ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_X_EXT, "display_overlay" , callback , sizeof(callback), "display_overlay_user_data", user_data, sizeof(user_data), (char*)NULL);
1474         if(ret != MM_ERROR_NONE)
1475         {
1476                 return __convert_error_code(ret,(char*)__FUNCTION__);
1477         }
1478         else
1479         {
1480                 handle->is_set_pixmap_cb = true;
1481                 handle->display_type = MM_DISPLAY_SURFACE_X;
1482                 handle->display_handle = callback;
1483                 LOGE("[%s] video display has been changed- type :%d, pixmap_callback addr : 0x%x",__FUNCTION__,handle->display_type, handle->display_handle);
1484                 return PLAYER_ERROR_NONE;
1485         }
1486
1487 }
1488
1489 int player_set_x11_display_pixmap_error_cb (player_h player, player_x11_pixmap_error_cb callback, void *user_data)
1490 {
1491         PLAYER_INSTANCE_CHECK(player);
1492         PLAYER_NULL_ARG_CHECK(callback);
1493         player_s * handle = (player_s *) player;
1494
1495         if (!__player_state_validate(handle, PLAYER_STATE_IDLE))
1496         {
1497                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
1498                 return PLAYER_ERROR_INVALID_STATE;
1499         }
1500
1501         int ret = mm_player_set_video_frame_render_error_callback(handle->mm_handle, __video_frame_render_error_callback, (void*)handle);
1502         if(ret != MM_ERROR_NONE)
1503         {
1504                 return __convert_error_code(ret,(char*)__FUNCTION__);
1505         }
1506         else
1507         {
1508                 LOGE("[%s] set pixmap_error_cb(0x%08x) and user_data(0x%8x)" ,__FUNCTION__, callback, user_data);
1509                 handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR] = callback;
1510                 handle->user_data[_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR] = user_data;
1511                 LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR);
1512                 return PLAYER_ERROR_NONE;
1513         }
1514 }
1515
1516 int player_enable_evas_display_scaling(player_h player, bool enable)
1517 {
1518         PLAYER_INSTANCE_CHECK(player);
1519         player_s * handle = (player_s *) player;
1520
1521         int scaling = enable?1:0;
1522         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_evas_do_scaling" , scaling, (char*)NULL);
1523         if(ret != MM_ERROR_NONE)
1524         {
1525                 return __convert_error_code(ret,(char*)__FUNCTION__);
1526         }
1527         else
1528                 return PLAYER_ERROR_NONE;
1529 }
1530
1531 int player_get_content_info(player_h player, player_content_info_e key, char ** value)
1532 {
1533         PLAYER_INSTANCE_CHECK(player);
1534         PLAYER_NULL_ARG_CHECK(value);
1535         player_s * handle = (player_s *) player;
1536         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1537         {
1538                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
1539                 return PLAYER_ERROR_INVALID_STATE;
1540         }
1541
1542         char* attr=NULL;
1543         char* val=NULL;
1544         int val_len=0;
1545
1546         switch(key)
1547         {
1548                 case PLAYER_CONTENT_INFO_ALBUM:
1549                         attr = MM_PLAYER_TAG_ALBUM;
1550                         break;
1551                 case PLAYER_CONTENT_INFO_ARTIST:
1552                         attr = MM_PLAYER_TAG_ARTIST;
1553                         break;
1554                 case PLAYER_CONTENT_INFO_AUTHOR:
1555                         attr = MM_PLAYER_TAG_AUTHOUR;
1556                         break;
1557                 case PLAYER_CONTENT_INFO_GENRE:
1558                         attr = MM_PLAYER_TAG_GENRE;
1559                         break;
1560                 case PLAYER_CONTENT_INFO_TITLE:
1561                         attr = MM_PLAYER_TAG_TITLE;
1562                         break;
1563                 case PLAYER_CONTENT_INFO_YEAR:
1564                         attr = MM_PLAYER_TAG_DATE;
1565                         break;
1566                 default:
1567                                 attr=NULL;
1568         }
1569
1570         int ret = mm_player_get_attribute(handle->mm_handle, NULL,attr ,&val, &val_len, (char*)NULL);
1571         if(ret != MM_ERROR_NONE)
1572         {
1573                 return __convert_error_code(ret,(char*)__FUNCTION__);
1574         }
1575         else
1576         {
1577                 *value = NULL;
1578                 if(val!=NULL)
1579                         *value = strndup(val,val_len);
1580                 else
1581                         *value = strndup("",0);
1582
1583                 if (*value == NULL)
1584                 {
1585                         LOGE("[%s] PLAYER_ERROR_OUT_OF_MEMORY(0x%08x) : fail to strdup ", __FUNCTION__,PLAYER_ERROR_OUT_OF_MEMORY);
1586                         return PLAYER_ERROR_OUT_OF_MEMORY;
1587                 }
1588                 return PLAYER_ERROR_NONE;
1589         }
1590 }
1591
1592 int player_get_codec_info(player_h player, char **audio_codec, char **video_codec)
1593 {
1594         PLAYER_INSTANCE_CHECK(player);
1595         PLAYER_NULL_ARG_CHECK(audio_codec);
1596         PLAYER_NULL_ARG_CHECK(video_codec);
1597         player_s * handle = (player_s *) player;
1598         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1599         {
1600                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
1601                 return PLAYER_ERROR_INVALID_STATE;
1602         }
1603
1604         char* audio=NULL;
1605         int audio_len=0;
1606         char* video=NULL;
1607         int video_len=0;
1608
1609         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_AUDIO_CODEC,&audio,&audio_len,MM_PLAYER_VIDEO_CODEC,&video,&video_len,(char*)NULL);
1610         if(ret != MM_ERROR_NONE)
1611         {
1612                 return __convert_error_code(ret,(char*)__FUNCTION__);
1613         }
1614         else
1615         {
1616                 *audio_codec = NULL;
1617                 if(audio!=NULL)
1618                         *audio_codec = strndup(audio,audio_len);
1619                 else
1620                         *audio_codec = strndup("",0);
1621
1622                 *video_codec = NULL;
1623                 if(video!=NULL)
1624                         *video_codec = strndup(video,video_len);
1625                 else
1626                         *video_codec = strndup("",0);
1627
1628                 return PLAYER_ERROR_NONE;
1629         }
1630 }
1631
1632 int player_get_audio_stream_info(player_h player, int *sample_rate, int *channel, int *bit_rate)
1633 {
1634         PLAYER_INSTANCE_CHECK(player);
1635         PLAYER_NULL_ARG_CHECK(sample_rate);
1636         PLAYER_NULL_ARG_CHECK(channel);
1637         PLAYER_NULL_ARG_CHECK(bit_rate);
1638         player_s * handle = (player_s *) player;
1639         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1640         {
1641                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
1642                 return PLAYER_ERROR_INVALID_STATE;
1643         }
1644         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_AUDIO_SAMPLERATE,sample_rate,MM_PLAYER_AUDIO_CHANNEL,channel,MM_PLAYER_AUDIO_BITRATE,bit_rate,(char*)NULL);
1645         if(ret != MM_ERROR_NONE)
1646         {
1647                 return __convert_error_code(ret,(char*)__FUNCTION__);
1648         }
1649         return PLAYER_ERROR_NONE;
1650 }
1651
1652 int player_get_video_stream_info(player_h player, int *fps, int *bit_rate)
1653 {
1654         PLAYER_INSTANCE_CHECK(player);
1655         PLAYER_NULL_ARG_CHECK(fps);
1656         PLAYER_NULL_ARG_CHECK(bit_rate);
1657         player_s * handle = (player_s *) player;
1658         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1659         {
1660                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
1661                 return PLAYER_ERROR_INVALID_STATE;
1662         }
1663         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"content_video_fps",fps,"content_video_bitrate",bit_rate,(char*)NULL);
1664         if(ret != MM_ERROR_NONE)
1665         {
1666                 return __convert_error_code(ret,(char*)__FUNCTION__);
1667         }
1668         return PLAYER_ERROR_NONE;
1669 }
1670
1671 int player_get_video_size (player_h player, int *width, int *height)
1672 {
1673         PLAYER_INSTANCE_CHECK(player);
1674         PLAYER_NULL_ARG_CHECK(width);
1675         PLAYER_NULL_ARG_CHECK(height);
1676         player_s * handle = (player_s *) player;
1677         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1678         {
1679                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
1680                 return PLAYER_ERROR_INVALID_STATE;
1681         }
1682         int w;
1683         int h;
1684         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_WIDTH ,&w,  MM_PLAYER_VIDEO_HEIGHT, &h, (char*)NULL);
1685         if(ret != MM_ERROR_NONE)
1686         {
1687                 return __convert_error_code(ret,(char*)__FUNCTION__);
1688         }
1689         else
1690         {
1691                 *width = w;
1692                 *height = h;
1693                 LOGE("[%s] width : %d, height : %d",__FUNCTION__,w, h);
1694                 return PLAYER_ERROR_NONE;
1695         }
1696 }
1697
1698 int player_get_album_art(player_h player, void **album_art, int *size)
1699 {
1700         PLAYER_INSTANCE_CHECK(player);
1701         PLAYER_NULL_ARG_CHECK(size);
1702         player_s * handle = (player_s *) player;
1703         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1704         {
1705                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
1706                 return PLAYER_ERROR_INVALID_STATE;
1707         }
1708
1709         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"tag_album_cover",album_art,size,(char*)NULL);
1710         if(ret != MM_ERROR_NONE)
1711         {
1712                 return __convert_error_code(ret,(char*)__FUNCTION__);
1713         }
1714         return PLAYER_ERROR_NONE;
1715 }
1716
1717 int player_get_track_count(player_h player, player_track_type_e type, int *count)
1718 {
1719         PLAYER_INSTANCE_CHECK(player);
1720         PLAYER_NULL_ARG_CHECK(count);
1721         player_s * handle = (player_s *) player;
1722         if (!__player_state_validate(handle, PLAYER_STATE_READY))
1723         {
1724                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) :  current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
1725                 return PLAYER_ERROR_INVALID_STATE;
1726         }
1727         int ret = mm_player_get_track_count(handle->mm_handle, type, count);
1728         if(ret != MM_ERROR_NONE)
1729         {
1730                 return __convert_error_code(ret,(char*)__FUNCTION__);
1731         }
1732         return PLAYER_ERROR_NONE;
1733 }
1734
1735 int player_audio_effect_set_value(player_h player, audio_effect_e effect, int value)
1736 {
1737         PLAYER_INSTANCE_CHECK(player);
1738         player_s * handle = (player_s *) player;
1739         int ret = mm_player_audio_effect_custom_set_level(handle->mm_handle,effect,0,value);
1740         if(ret != MM_ERROR_NONE)
1741         {
1742                 return __convert_error_code(ret,(char*)__FUNCTION__);
1743         }
1744         else
1745         {
1746                 ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
1747                 return (ret==MM_ERROR_NONE)?PLAYER_ERROR_NONE:__convert_error_code(ret,(char*)__FUNCTION__);
1748         }
1749 }
1750
1751 int player_audio_effect_get_value(player_h player, audio_effect_e effect, int *value)
1752 {
1753         PLAYER_INSTANCE_CHECK(player);
1754         PLAYER_NULL_ARG_CHECK(value);
1755         player_s * handle = (player_s *) player;
1756         int ret = mm_player_audio_effect_custom_get_level(handle->mm_handle,effect,0,value);
1757         if(ret != MM_ERROR_NONE)
1758                 return __convert_error_code(ret,(char*)__FUNCTION__);
1759         else
1760                 return PLAYER_ERROR_NONE;
1761 }
1762
1763 int player_audio_effect_clear(player_h player, audio_effect_e effect)
1764 {
1765         PLAYER_INSTANCE_CHECK(player);
1766         player_s * handle = (player_s *) player;
1767         int ret = mm_player_audio_effect_custom_clear_ext_all(handle->mm_handle);
1768         if(ret != MM_ERROR_NONE)
1769         {
1770                 return __convert_error_code(ret,(char*)__FUNCTION__);
1771         }
1772         else
1773         {
1774                 ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
1775                 return (ret==MM_ERROR_NONE)?PLAYER_ERROR_NONE:__convert_error_code(ret,(char*)__FUNCTION__);
1776         }
1777 }
1778
1779 int player_audio_effect_get_value_range(player_h player, audio_effect_e effect, int* min, int* max)
1780 {
1781         PLAYER_INSTANCE_CHECK(player);
1782         PLAYER_NULL_ARG_CHECK(min);
1783         PLAYER_NULL_ARG_CHECK(max);
1784         player_s * handle = (player_s *) player;
1785         int ret = mm_player_audio_effect_custom_get_level_range(handle->mm_handle, effect, min, max);
1786         if(ret != MM_ERROR_NONE)
1787                 return __convert_error_code(ret,(char*)__FUNCTION__);
1788         else
1789                 return PLAYER_ERROR_NONE;
1790 }
1791
1792 int player_audio_effect_is_available(player_h player, audio_effect_e effect, bool *available)
1793 {
1794         PLAYER_INSTANCE_CHECK(player);
1795         PLAYER_NULL_ARG_CHECK(available);
1796         player_s * handle = (player_s *) player;
1797         int ret = mm_player_is_supported_custom_effect_type(handle->mm_handle, effect);
1798         if(ret != MM_ERROR_NONE)
1799                 *available = FALSE;
1800         else
1801                 *available = TRUE;
1802         return PLAYER_ERROR_NONE;
1803 }
1804
1805 int player_audio_effect_foreach_supported_effect(player_h player, player_audio_effect_supported_effect_cb callback, void *user_data)
1806 {
1807         PLAYER_INSTANCE_CHECK(player);
1808         PLAYER_NULL_ARG_CHECK(callback);
1809         player_s * handle = (player_s *) player;
1810
1811         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_SUPPORTED_AUDIO_EFFECT_TYPE);
1812         handle->user_cb[_PLAYER_SUPPORTED_AUDIO_EFFECT_TYPE] = callback;
1813         handle->user_data[_PLAYER_SUPPORTED_AUDIO_EFFECT_TYPE] = user_data;
1814         int ret = mm_player_get_foreach_present_supported_effect_type(handle->mm_handle, MM_AUDIO_EFFECT_TYPE_CUSTOM, __supported_audio_effect_type, (void*)handle);
1815         if(ret != MM_ERROR_NONE)
1816                 return __convert_error_code(ret,(char*)__FUNCTION__);
1817         else
1818                 return PLAYER_ERROR_NONE;
1819 }
1820
1821 int player_audio_effect_set_preset(player_h player, audio_effect_preset_e preset)
1822 {
1823         PLAYER_INSTANCE_CHECK(player);
1824         player_s * handle = (player_s *) player;
1825         int ret = mm_player_audio_effect_preset_apply(handle->mm_handle, preset);
1826         if(ret != MM_ERROR_NONE)
1827                 return __convert_error_code(ret,(char*)__FUNCTION__);
1828         else
1829                 return PLAYER_ERROR_NONE;
1830 }
1831
1832 int player_audio_effect_preset_is_available(player_h player, audio_effect_preset_e preset, bool *available)
1833 {
1834         PLAYER_INSTANCE_CHECK(player);
1835         PLAYER_NULL_ARG_CHECK(available);
1836         player_s * handle = (player_s *) player;
1837         int ret = mm_player_is_supported_preset_effect_type(handle->mm_handle, preset);
1838         if(ret != MM_ERROR_NONE)
1839                 *available = FALSE;
1840         else
1841                 *available = TRUE;
1842         return PLAYER_ERROR_NONE;
1843 }
1844
1845 int player_audio_effect_foreach_supported_preset(player_h player, player_audio_effect_supported_preset_cb callback, void *user_data)
1846 {
1847         PLAYER_INSTANCE_CHECK(player);
1848         PLAYER_NULL_ARG_CHECK(callback);
1849         player_s * handle = (player_s *) player;
1850
1851         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_SUPPORTED_AUDIO_EFFECT_PRESET);
1852         handle->user_cb[_PLAYER_SUPPORTED_AUDIO_EFFECT_PRESET] = callback;
1853         handle->user_data[_PLAYER_SUPPORTED_AUDIO_EFFECT_PRESET] = user_data;
1854         int ret = mm_player_get_foreach_present_supported_effect_type(handle->mm_handle, MM_AUDIO_EFFECT_TYPE_PRESET, __supported_audio_effect_preset, (void*)handle);
1855         if(ret != MM_ERROR_NONE)
1856                 return __convert_error_code(ret,(char*)__FUNCTION__);
1857         else
1858                 return PLAYER_ERROR_NONE;
1859 }
1860
1861 int player_audio_effect_get_equalizer_bands_count (player_h player, int *count)
1862 {
1863         PLAYER_INSTANCE_CHECK(player);
1864         PLAYER_NULL_ARG_CHECK(count);
1865         player_s * handle = (player_s *) player;
1866         int ret = mm_player_audio_effect_custom_get_eq_bands_number(handle->mm_handle, count);
1867         if(ret != MM_ERROR_NONE)
1868                 return __convert_error_code(ret,(char*)__FUNCTION__);
1869         else
1870                 return PLAYER_ERROR_NONE;
1871 }
1872
1873 int player_audio_effect_set_equalizer_all_bands(player_h player, int *band_levels, int length)
1874 {
1875         PLAYER_INSTANCE_CHECK(player);
1876         PLAYER_NULL_ARG_CHECK(band_levels);
1877         player_s * handle = (player_s *) player;
1878         int ret = mm_player_audio_effect_custom_set_level_eq_from_list(handle->mm_handle, band_levels, length);
1879         if(ret != MM_ERROR_NONE)
1880         {
1881                 return __convert_error_code(ret,(char*)__FUNCTION__);
1882         }
1883         else
1884         {
1885                 ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
1886                 return (ret==MM_ERROR_NONE)?PLAYER_ERROR_NONE:__convert_error_code(ret,(char*)__FUNCTION__);
1887         }
1888 }
1889
1890 int player_audio_effect_set_equalizer_band_level(player_h player, int index, int level)
1891 {
1892         PLAYER_INSTANCE_CHECK(player);
1893         player_s * handle = (player_s *) player;
1894         int ret = mm_player_audio_effect_custom_set_level(handle->mm_handle,MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
1895         if(ret != MM_ERROR_NONE)
1896         {
1897                 return __convert_error_code(ret,(char*)__FUNCTION__);
1898         }
1899         else
1900         {
1901                 ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
1902                 return (ret==MM_ERROR_NONE)?PLAYER_ERROR_NONE:__convert_error_code(ret,(char*)__FUNCTION__);
1903         }
1904 }
1905
1906 int player_audio_effect_get_equalizer_band_level(player_h player, int index, int *level)
1907 {
1908         PLAYER_INSTANCE_CHECK(player);
1909         PLAYER_NULL_ARG_CHECK(level);
1910         player_s * handle = (player_s *) player;
1911         int ret = mm_player_audio_effect_custom_get_level(handle->mm_handle,MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
1912         if(ret != MM_ERROR_NONE)
1913                 return __convert_error_code(ret,(char*)__FUNCTION__);
1914         else
1915                 return PLAYER_ERROR_NONE;
1916 }
1917
1918 int player_audio_effect_get_equalizer_level_range(player_h player, int* min, int* max)
1919 {
1920         PLAYER_INSTANCE_CHECK(player);
1921         PLAYER_NULL_ARG_CHECK(min);
1922         PLAYER_NULL_ARG_CHECK(max);
1923         player_s * handle = (player_s *) player;
1924         int ret = mm_player_audio_effect_custom_get_level_range(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, min, max);
1925         if(ret != MM_ERROR_NONE)
1926                 return __convert_error_code(ret,(char*)__FUNCTION__);
1927         else
1928                 return PLAYER_ERROR_NONE;
1929 }
1930
1931 int player_audio_effect_get_equalizer_band_frequency(player_h player, int index, int *frequency)
1932 {
1933         PLAYER_INSTANCE_CHECK(player);
1934         PLAYER_NULL_ARG_CHECK(frequency);
1935         player_s * handle = (player_s *) player;
1936         int ret = mm_player_audio_effect_custom_get_eq_bands_freq(handle->mm_handle, index, frequency);
1937         if(ret != MM_ERROR_NONE)
1938                 return __convert_error_code(ret,(char*)__FUNCTION__);
1939         else
1940                 return PLAYER_ERROR_NONE;
1941 }
1942
1943 int player_audio_effect_get_equalizer_band_frequency_range(player_h player, int index, int *range)
1944 {
1945         PLAYER_INSTANCE_CHECK(player);
1946         PLAYER_NULL_ARG_CHECK(range);
1947         player_s * handle = (player_s *) player;
1948         int ret = mm_player_audio_effect_custom_get_eq_bands_width(handle->mm_handle, index, range);
1949         if(ret != MM_ERROR_NONE)
1950                 return __convert_error_code(ret,(char*)__FUNCTION__);
1951         else
1952                 return PLAYER_ERROR_NONE;
1953 }
1954
1955 int player_audio_effect_equalizer_clear(player_h player)
1956 {
1957         PLAYER_INSTANCE_CHECK(player);
1958         player_s * handle = (player_s *) player;
1959         int ret = mm_player_audio_effect_custom_clear_eq_all(handle->mm_handle);
1960         if(ret != MM_ERROR_NONE)
1961                 return __convert_error_code(ret,(char*)__FUNCTION__);
1962         else
1963                 return PLAYER_ERROR_NONE;
1964 }
1965
1966 int player_audio_effect_equalizer_is_available(player_h player, bool *available)
1967 {
1968         PLAYER_INSTANCE_CHECK(player);
1969         PLAYER_NULL_ARG_CHECK(available);
1970         player_s * handle = (player_s *) player;
1971         int ret = mm_player_is_supported_custom_effect_type(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ);
1972         if(ret != MM_ERROR_NONE)
1973                 *available = FALSE;
1974         else
1975                 *available = TRUE;
1976         return PLAYER_ERROR_NONE;
1977 }
1978
1979 int player_set_subtitle_path(player_h player,const char* path)
1980 {
1981         PLAYER_INSTANCE_CHECK(player);
1982         PLAYER_NULL_ARG_CHECK(path);
1983         player_s * handle = (player_s *) player;
1984         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
1985
1986         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"subtitle_uri" , path, strlen(path), (char*)NULL);
1987         if(ret != MM_ERROR_NONE)
1988         {
1989                 return __convert_error_code(ret,(char*)__FUNCTION__);
1990         }
1991         else
1992                 return PLAYER_ERROR_NONE;
1993 }
1994
1995 int player_set_subtitle_position(player_h player, int millisecond)
1996 {
1997         PLAYER_INSTANCE_CHECK(player);
1998         PLAYER_CHECK_CONDITION(millisecond>=0  ,PLAYER_ERROR_INVALID_PARAMETER ,"PLAYER_ERROR_INVALID_PARAMETER" );
1999         player_s * handle = (player_s *) player;
2000         if (!__player_state_validate(handle, PLAYER_STATE_PLAYING))
2001         {
2002                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
2003                 return PLAYER_ERROR_INVALID_STATE;
2004         }
2005
2006         int ret = mm_player_adjust_subtitle_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME, millisecond);
2007         if(ret != MM_ERROR_NONE)
2008         {
2009                 return __convert_error_code(ret,(char*)__FUNCTION__);
2010         }
2011         else
2012                 return PLAYER_ERROR_NONE;
2013 }
2014
2015 int player_set_progressive_download_path(player_h player, const char *path)
2016 {
2017         PLAYER_INSTANCE_CHECK(player);
2018         PLAYER_NULL_ARG_CHECK(path);
2019         player_s * handle = (player_s *) player;
2020         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
2021
2022         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"pd_mode", MM_PLAYER_PD_MODE_URI, "pd_location", path, strlen(path), (char*)NULL);
2023         if(ret != MM_ERROR_NONE)
2024         {
2025                 return __convert_error_code(ret,(char*)__FUNCTION__);
2026         }
2027         else
2028         {
2029                 handle->is_progressive_download = 1;
2030                 return PLAYER_ERROR_NONE;
2031         }
2032 }
2033
2034 int player_get_progressive_download_status(player_h player, unsigned long *current, unsigned long *total_size)
2035 {
2036
2037         PLAYER_INSTANCE_CHECK(player);
2038         PLAYER_NULL_ARG_CHECK(current);
2039         PLAYER_NULL_ARG_CHECK(total_size);
2040         player_s * handle = (player_s *) player;
2041         if (handle->state != PLAYER_STATE_PLAYING && handle->state != PLAYER_STATE_PAUSED)
2042         {
2043                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
2044                 return PLAYER_ERROR_INVALID_STATE;
2045         }
2046         guint64 _current;
2047         guint64 _total;
2048         int ret = mm_player_get_pd_status(handle->mm_handle, &_current, &_total);
2049         if(ret != MM_ERROR_NONE)
2050         {
2051                 return __convert_error_code(ret,(char*)__FUNCTION__);
2052         }
2053         else
2054         {
2055                 *current = _current;
2056                 *total_size = _total;
2057                 return PLAYER_ERROR_NONE;
2058         }
2059 }
2060
2061 int player_capture_video(player_h player, player_video_captured_cb callback, void *user_data)
2062 {
2063         PLAYER_INSTANCE_CHECK(player);
2064         PLAYER_NULL_ARG_CHECK(callback);
2065
2066         player_s * handle = (player_s *) player;
2067         if(handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE])
2068         {
2069                 LOGE("[%s] PLAYER_ERROR_VIDEO_CAPTURE_FAILED (0x%08x) : capturing... we can't do any more " ,__FUNCTION__, PLAYER_ERROR_VIDEO_CAPTURE_FAILED);
2070                 return PLAYER_ERROR_VIDEO_CAPTURE_FAILED;
2071         }
2072         else
2073         {
2074                 LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_CAPTURE);
2075                 handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = callback;
2076                 handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = user_data;
2077         }
2078
2079         if(handle->state == PLAYER_STATE_PAUSED || handle->state == PLAYER_STATE_PLAYING )
2080         {
2081                 int ret = mm_player_do_video_capture(handle->mm_handle);
2082                 if(ret==MM_ERROR_PLAYER_NO_OP)
2083                 {
2084                         handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
2085                         handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
2086                         LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION (0x%08x) : video display must be set : %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_OPERATION, handle->display_type);
2087                         return PLAYER_ERROR_INVALID_OPERATION;
2088                 }
2089                 if(ret != MM_ERROR_NONE)
2090                 {
2091                         handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
2092                         handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
2093                         return __convert_error_code(ret,(char*)__FUNCTION__);
2094                 }
2095                 else
2096                         return PLAYER_ERROR_NONE;
2097         }
2098         else
2099         {
2100                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (0x%08x) : current state - %d" ,__FUNCTION__, PLAYER_ERROR_INVALID_STATE, handle->state);
2101                 handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
2102                 handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
2103                 return PLAYER_ERROR_INVALID_STATE;
2104         }
2105 }
2106
2107 int player_set_streaming_cookie(player_h player, const char *cookie, int size)
2108 {
2109         PLAYER_INSTANCE_CHECK(player);
2110         PLAYER_NULL_ARG_CHECK(cookie);
2111         PLAYER_CHECK_CONDITION(size>=0,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
2112         player_s * handle = (player_s *) player;
2113         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
2114
2115         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"streaming_cookie", cookie, size, (char*)NULL);
2116         if(ret != MM_ERROR_NONE)
2117         {
2118                 return __convert_error_code(ret,(char*)__FUNCTION__);
2119         }
2120         else
2121                 return PLAYER_ERROR_NONE;
2122 }
2123
2124 int player_set_streaming_user_agent(player_h player, const char *user_agent, int size)
2125 {
2126         PLAYER_INSTANCE_CHECK(player);
2127         PLAYER_NULL_ARG_CHECK(user_agent);
2128         PLAYER_CHECK_CONDITION(size>=0,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
2129         player_s * handle = (player_s *) player;
2130         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
2131
2132         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"streaming_user_agent", user_agent, size, (char*)NULL);
2133         if(ret != MM_ERROR_NONE)
2134         {
2135                 return __convert_error_code(ret,(char*)__FUNCTION__);
2136         }
2137         else
2138                 return PLAYER_ERROR_NONE;
2139 }
2140
2141 int player_get_streaming_download_progress(player_h player, int *start, int *current)
2142 {
2143         PLAYER_INSTANCE_CHECK(player);
2144         PLAYER_NULL_ARG_CHECK(start);
2145         PLAYER_NULL_ARG_CHECK(current);
2146         player_s * handle = (player_s *) player;
2147         if (handle->state != PLAYER_STATE_PLAYING && handle->state != PLAYER_STATE_PAUSED)
2148         {
2149                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
2150                 return PLAYER_ERROR_INVALID_STATE;
2151         }
2152         int _current;
2153         int _start;
2154         int ret = mm_player_get_buffer_position(handle->mm_handle,MM_PLAYER_POS_FORMAT_PERCENT,&_start,&_current);
2155         if(ret != MM_ERROR_NONE)
2156         {
2157                 return __convert_error_code(ret,(char*)__FUNCTION__);
2158         }
2159         else
2160         {
2161                 *start = _start;
2162                 *current = _current;
2163                 return PLAYER_ERROR_NONE;
2164         }
2165 }
2166
2167 int     player_set_completed_cb (player_h player, player_completed_cb callback, void *user_data)
2168 {
2169         return __set_callback(_PLAYER_EVENT_TYPE_COMPLETE,player,callback,user_data);
2170 }
2171
2172 int     player_unset_completed_cb (player_h player)
2173 {
2174         return __unset_callback(_PLAYER_EVENT_TYPE_COMPLETE,player);
2175 }
2176
2177 int     player_set_interrupted_cb (player_h player, player_interrupted_cb callback, void *user_data)
2178 {
2179         return __set_callback(_PLAYER_EVENT_TYPE_INTERRUPT,player,callback,user_data);
2180 }
2181
2182 int     player_unset_interrupted_cb (player_h player)
2183 {
2184         return __unset_callback(_PLAYER_EVENT_TYPE_INTERRUPT,player);
2185 }
2186
2187 int     player_set_error_cb (player_h player, player_error_cb callback, void *user_data)
2188 {
2189         return __set_callback(_PLAYER_EVENT_TYPE_ERROR,player,callback,user_data);
2190 }
2191
2192 int     player_unset_error_cb (player_h player)
2193 {
2194         return __unset_callback(_PLAYER_EVENT_TYPE_ERROR,player);
2195 }
2196
2197 int     player_set_buffering_cb (player_h player, player_buffering_cb callback, void *user_data)
2198 {
2199         return __set_callback(_PLAYER_EVENT_TYPE_BUFFERING,player,callback,user_data);
2200 }
2201
2202 int     player_unset_buffering_cb (player_h player)
2203 {
2204         return __unset_callback(_PLAYER_EVENT_TYPE_BUFFERING,player);
2205 }
2206
2207 int     player_set_subtitle_updated_cb(player_h player, player_subtitle_updated_cb callback, void* user_data )
2208 {
2209         return __set_callback(_PLAYER_EVENT_TYPE_SUBTITLE,player,callback,user_data);
2210 }
2211
2212 int     player_unset_subtitle_updated_cb (player_h player)
2213 {
2214         return __unset_callback(_PLAYER_EVENT_TYPE_SUBTITLE,player);
2215 }
2216
2217 int player_set_video_frame_decoded_cb(player_h player, player_video_frame_decoded_cb callback, void *user_data)
2218 {
2219         PLAYER_INSTANCE_CHECK(player);
2220         PLAYER_NULL_ARG_CHECK(callback);
2221         player_s * handle = (player_s *) player;
2222         if (handle->state != PLAYER_STATE_IDLE )
2223         {
2224                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
2225                 return PLAYER_ERROR_INVALID_STATE;
2226         }
2227
2228         int ret = mm_player_set_video_stream_callback(handle->mm_handle, __video_stream_callback, (void*)handle);
2229         if(ret != MM_ERROR_NONE)
2230                 return __convert_error_code(ret,(char*)__FUNCTION__);
2231
2232         handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_FRAME] = callback;
2233         handle->user_data[_PLAYER_EVENT_TYPE_VIDEO_FRAME] = user_data;
2234         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_VIDEO_FRAME);
2235         return PLAYER_ERROR_NONE;
2236 }
2237
2238 int player_unset_video_frame_decoded_cb(player_h player)
2239 {
2240         PLAYER_INSTANCE_CHECK(player);
2241         player_s * handle = (player_s *) player;
2242         handle->user_cb[_PLAYER_EVENT_TYPE_VIDEO_FRAME] = NULL;
2243         handle->user_data[_PLAYER_EVENT_TYPE_VIDEO_FRAME] = NULL;
2244         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_VIDEO_FRAME);
2245         int ret = mm_player_set_video_stream_callback(handle->mm_handle, NULL, NULL);
2246         if(ret != MM_ERROR_NONE)
2247                 return __convert_error_code(ret,(char*)__FUNCTION__);
2248         else
2249                 return PLAYER_ERROR_NONE;
2250 }
2251
2252 int player_set_audio_frame_decoded_cb(player_h player, int start, int end, player_audio_frame_decoded_cb callback, void *user_data)
2253 {
2254         PLAYER_INSTANCE_CHECK(player);
2255         PLAYER_NULL_ARG_CHECK(callback);
2256         PLAYER_CHECK_CONDITION(start>=0 ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
2257         PLAYER_CHECK_CONDITION(end>=start ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
2258         player_s * handle = (player_s *) player;
2259         if (handle->state != PLAYER_STATE_IDLE)
2260         {
2261                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
2262                 return PLAYER_ERROR_INVALID_STATE;
2263         }
2264
2265         int ret = mm_player_set_attribute(handle->mm_handle, NULL, "pcm_extraction",TRUE, "pcm_extraction_start_msec", start, "pcm_extraction_end_msec", end, NULL);
2266         if(ret != MM_ERROR_NONE)
2267                 return __convert_error_code(ret,(char*)__FUNCTION__);
2268
2269         ret = mm_player_set_audio_stream_callback(handle->mm_handle, __audio_stream_callback, (void*)handle);
2270         if(ret != MM_ERROR_NONE)
2271                 return __convert_error_code(ret,(char*)__FUNCTION__);
2272
2273         handle->user_cb[_PLAYER_EVENT_TYPE_AUDIO_FRAME] = callback;
2274         handle->user_data[_PLAYER_EVENT_TYPE_AUDIO_FRAME] = user_data;
2275         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_AUDIO_FRAME);
2276         return PLAYER_ERROR_NONE;
2277 }
2278
2279 int player_unset_audio_frame_decoded_cb(player_h player)
2280 {
2281         PLAYER_INSTANCE_CHECK(player);
2282         player_s * handle = (player_s *) player;
2283
2284         handle->user_cb[_PLAYER_EVENT_TYPE_AUDIO_FRAME] = NULL;
2285         handle->user_data[_PLAYER_EVENT_TYPE_AUDIO_FRAME] = NULL;
2286         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_AUDIO_FRAME);
2287
2288         int ret = mm_player_set_attribute(handle->mm_handle, NULL, "pcm_extraction",FALSE, NULL);
2289         if(ret != MM_ERROR_NONE)
2290                 return __convert_error_code(ret,(char*)__FUNCTION__);
2291
2292         ret = mm_player_set_audio_buffer_callback(handle->mm_handle, NULL, NULL);
2293         if(ret != MM_ERROR_NONE)
2294                 return __convert_error_code(ret,(char*)__FUNCTION__);
2295         else
2296                 return PLAYER_ERROR_NONE;
2297 }
2298
2299 int player_set_progressive_download_message_cb(player_h player, player_pd_message_cb callback, void *user_data)
2300 {
2301         PLAYER_INSTANCE_CHECK(player);
2302         PLAYER_NULL_ARG_CHECK(callback);
2303         player_s * handle = (player_s *) player;
2304         if (handle->state != PLAYER_STATE_IDLE  &&  handle->state != PLAYER_STATE_READY)
2305         {
2306                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
2307                 return PLAYER_ERROR_INVALID_STATE;
2308         }
2309
2310         int ret = mm_player_set_pd_message_callback(handle->mm_handle, __pd_message_callback, (void*)handle);
2311         if(ret != MM_ERROR_NONE)
2312                 return __convert_error_code(ret,(char*)__FUNCTION__);
2313
2314         handle->user_cb[_PLAYER_EVENT_TYPE_PD] = callback;
2315         handle->user_data[_PLAYER_EVENT_TYPE_PD] = user_data;
2316         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_PD);
2317         return PLAYER_ERROR_NONE;
2318 }
2319
2320 int player_unset_progressive_download_message_cb(player_h player)
2321 {
2322         PLAYER_INSTANCE_CHECK(player);
2323         player_s * handle = (player_s *) player;
2324
2325         handle->user_cb[_PLAYER_EVENT_TYPE_PD] = NULL;
2326         handle->user_data[_PLAYER_EVENT_TYPE_PD] = NULL;
2327         LOGI("[%s] Event type : %d ",__FUNCTION__, _PLAYER_EVENT_TYPE_PD);
2328
2329         int ret = mm_player_set_pd_message_callback(handle->mm_handle, NULL, NULL);
2330         if(ret != MM_ERROR_NONE)
2331                 return __convert_error_code(ret,(char*)__FUNCTION__);
2332         else
2333                 return PLAYER_ERROR_NONE;
2334 }