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_internal.h>
  23 #include <mm_types.h>
  24 #include <player.h>
  25 #include <player_private.h>
  26 #include <dlog.h>
  27
  28 #ifdef LOG_TAG
  29 #undef LOG_TAG
  30 #endif
  31 #define LOG_TAG "TIZEN_N_PLAYER"
  32
  33 /*
  34 * Internal Macros
  35 */
  36
  37 #define PLAYER_CHECK_CONDITION(condition,error,msg)     \
  38                 if(condition) {} else \
  39                 { LOGE("[%s] %s(0x%08x)",__FUNCTION__, msg,error); return error;}; \
  40
  41
  42 #define PLAYER_INSTANCE_CHECK(player)   \
  43         PLAYER_CHECK_CONDITION(player != NULL, PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER")
  44
  45 #define PLAYER_STATE_CHECK(player,expected_state)       \
  46         PLAYER_CHECK_CONDITION(player->state == expected_state,PLAYER_ERROR_INVALID_STATE,"PLAYER_ERROR_INVALID_STATE")
  47
  48 #define PLAYER_NULL_ARG_CHECK(arg)      \
  49         PLAYER_CHECK_CONDITION(arg != NULL,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER")
  50
  51 /*
  52 * Internal Implementation
  53 */
  54 int _convert_error_code(int code, char* func_name)
  55 {
  56         int ret = PLAYER_ERROR_NONE;
  57         char* msg="PLAYER_ERROR_NONE";
  58         switch(code)
  59         {
  60                 case MM_ERROR_NONE:
  61                         ret = PLAYER_ERROR_NONE;
  62                         msg = "PLAYER_ERROR_NONE";
  63                         break;
  64                 case MM_ERROR_PLAYER_CODEC_NOT_FOUND:
  65                 case MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND:
  66                 case MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND:
  67                 case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_AUDIO:
  68                 case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_VIDEO:
  69                 case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_MEDIA_TYPE:
  70                 case MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT:
  71                         ret = PLAYER_ERROR_NOT_SUPPORTED_FILE;
  72                         msg = "PLAYER_ERROR_NOT_SUPPORTED_FILE";
  73                         break;
  74                 case MM_ERROR_PLAYER_INVALID_STATE:
  75                 case MM_ERROR_PLAYER_NOT_INITIALIZED:
  76                         ret = PLAYER_ERROR_INVALID_STATE;
  77                         msg = "PLAYER_ERROR_INVALID_STATE";
  78                         break;
  79                 case MM_ERROR_PLAYER_INTERNAL:
  80                 case MM_ERROR_PLAYER_INVALID_STREAM:
  81                 case MM_ERROR_PLAYER_STREAMING_FAIL:
  82                 case MM_ERROR_PLAYER_NO_OP:
  83                         ret = PLAYER_ERROR_INVALID_OPERATION;
  84                         msg = "PLAYER_ERROR_INVALID_OPERATION";
  85                         break;
  86                 case  MM_ERROR_PLAYER_NO_FREE_SPACE:
  87                         ret = PLAYER_ERROR_OUT_OF_MEMORY;
  88                         msg = "PLAYER_ERROR_OUT_OF_MEMORY";
  89                         break;
  90                 case MM_ERROR_PLAYER_FILE_NOT_FOUND:
  91                         ret = PLAYER_ERROR_NO_SUCH_FILE;
  92                         msg = "PLAYER_ERROR_NO_SUCH_FILE";
  93                         break;
  94                 case MM_ERROR_PLAYER_SEEK:
  95                         ret = PLAYER_ERROR_SEEK_FAILED;
  96                         msg = "PLAYER_ERROR_SEEK_FAILED";
  97                         break;
  98                 case MM_ERROR_PLAYER_INVALID_URI:
  99                 case MM_ERROR_PLAYER_STREAMING_INVALID_URL:
 100                         ret = PLAYER_ERROR_INVALID_URI;
 101                         msg = "PLAYER_ERROR_INVALID_URI";
 102                         break;
 103                 case MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL:
 104                 case MM_ERROR_PLAYER_STREAMING_DNS_FAIL :
 105                 case MM_ERROR_PLAYER_STREAMING_SERVER_DISCONNECTED:
 106                 case MM_ERROR_PLAYER_STREAMING_INVALID_PROTOCOL:
 107                 case MM_ERROR_PLAYER_STREAMING_UNEXPECTED_MSG:
 108                 case MM_ERROR_PLAYER_STREAMING_OUT_OF_MEMORIES:
 109                 case MM_ERROR_PLAYER_STREAMING_RTSP_TIMEOUT:
 110                 case MM_ERROR_PLAYER_STREAMING_BAD_REQUEST:
 111                 case MM_ERROR_PLAYER_STREAMING_NOT_AUTHORIZED:
 112                 case MM_ERROR_PLAYER_STREAMING_PAYMENT_REQUIRED:
 113                 case MM_ERROR_PLAYER_STREAMING_FORBIDDEN:
 114                 case MM_ERROR_PLAYER_STREAMING_CONTENT_NOT_FOUND:
 115                 case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_ALLOWED:
 116                 case MM_ERROR_PLAYER_STREAMING_NOT_ACCEPTABLE:
 117                 case MM_ERROR_PLAYER_STREAMING_PROXY_AUTHENTICATION_REQUIRED:
 118                 case MM_ERROR_PLAYER_STREAMING_SERVER_TIMEOUT:
 119                 case MM_ERROR_PLAYER_STREAMING_GONE:
 120                 case MM_ERROR_PLAYER_STREAMING_LENGTH_REQUIRED:
 121                 case MM_ERROR_PLAYER_STREAMING_PRECONDITION_FAILED:
 122                 case MM_ERROR_PLAYER_STREAMING_REQUEST_ENTITY_TOO_LARGE:
 123                 case MM_ERROR_PLAYER_STREAMING_REQUEST_URI_TOO_LARGE:
 124                 case MM_ERROR_PLAYER_STREAMING_PARAMETER_NOT_UNDERSTOOD:
 125                 case MM_ERROR_PLAYER_STREAMING_CONFERENCE_NOT_FOUND:
 126                 case MM_ERROR_PLAYER_STREAMING_NOT_ENOUGH_BANDWIDTH:
 127                 case MM_ERROR_PLAYER_STREAMING_NO_SESSION_ID:
 128                 case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_VALID_IN_THIS_STATE:
 129                 case MM_ERROR_PLAYER_STREAMING_HEADER_FIELD_NOT_VALID_FOR_SOURCE:
 130                 case MM_ERROR_PLAYER_STREAMING_INVALID_RANGE:
 131                 case MM_ERROR_PLAYER_STREAMING_PARAMETER_IS_READONLY:
 132                 case MM_ERROR_PLAYER_STREAMING_AGGREGATE_OP_NOT_ALLOWED:
 133                 case MM_ERROR_PLAYER_STREAMING_ONLY_AGGREGATE_OP_ALLOWED:
 134                 case MM_ERROR_PLAYER_STREAMING_BAD_TRANSPORT:
 135                 case MM_ERROR_PLAYER_STREAMING_DESTINATION_UNREACHABLE:
 136                 case MM_ERROR_PLAYER_STREAMING_INTERNAL_SERVER_ERROR:
 137                 case MM_ERROR_PLAYER_STREAMING_NOT_IMPLEMENTED:
 138                 case MM_ERROR_PLAYER_STREAMING_BAD_GATEWAY:
 139                 case MM_ERROR_PLAYER_STREAMING_SERVICE_UNAVAILABLE:
 140                 case MM_ERROR_PLAYER_STREAMING_GATEWAY_TIME_OUT:
 141                 case MM_ERROR_PLAYER_STREAMING_OPTION_NOT_SUPPORTED:
 142                         ret = PLAYER_ERROR_CONNECTION_FAILED;
 143                         msg = "PLAYER_ERROR_CONNECTION_FAILED";
 144                         break;
 145                 case MM_ERROR_POLICY_BLOCKED:
 146                 case MM_ERROR_POLICY_INTERRUPTED:
 147                 case MM_ERROR_POLICY_INTERNAL:
 148                 case MM_ERROR_POLICY_DUPLICATED:
 149                         ret = PLAYER_ERROR_SOUND_POLICY;
 150                         msg = "PLAYER_ERROR_SOUND_POLICY";
 151                         break;
 152         }
 153         LOGE("[%s] %s(0x%08x) : core fw error(0x%x)",func_name,msg, ret, code);
 154         return ret;
 155 }
 156
 157 player_state_e _convert_player_state(MMPlayerStateType state)
 158 {
 159         if(state == MM_PLAYER_STATE_NONE)
 160                 return PLAYER_STATE_NONE;
 161         else
 162                 return state +1;
 163 }
 164
 165 bool _player_state_validate(player_s * handle, player_state_e threshold)
 166 {
 167         if (handle->state < threshold)
 168                 return FALSE;
 169         return TRUE;
 170 }
 171
 172 int _set_callback(_player_event_e type, player_h player, void* callback, void *user_data)
 173 {
 174         PLAYER_INSTANCE_CHECK(player);
 175         PLAYER_NULL_ARG_CHECK(callback);
 176         player_s * handle = (player_s *) player;
 177         handle->user_cb[type] = callback;
 178         handle->user_data[type] = user_data;
 179         LOGI("[%s] Event type : %d ",__FUNCTION__, type);
 180         return PLAYER_ERROR_NONE;
 181 }
 182
 183 int _unset_callback(_player_event_e type, player_h player)
 184 {
 185         PLAYER_INSTANCE_CHECK(player);
 186         player_s * handle = (player_s *) player;
 187         handle->user_cb[type] = NULL;
 188         handle->user_data[type] = NULL;
 189         LOGI("[%s] Event type : %d ",__FUNCTION__, type);
 190         return PLAYER_ERROR_NONE;
 191 }
 192
 193 player_state_e _get_current_state(player_s * handle)
 194 {
 195         return handle->state;
 196 }
 197
 198 int _msg_callback(int message, void *param, void *user_data)
 199 {
 200         player_s * handle = (player_s*)user_data;
 201         MMMessageParamType *msg = (MMMessageParamType*)param;
 202         LOGI("[%s] Got message type : 0x%x" ,__FUNCTION__, message);
 203         switch(message)
 204         {
 205                 case  MM_MESSAGE_ERROR: //0x01
 206                         if( handle->user_cb[_PLAYER_EVENT_TYPE_ERROR] )
 207                         {
 208                                 ((player_error_cb)handle->user_cb[_PLAYER_EVENT_TYPE_ERROR])(_convert_error_code(msg->code,(char*)__FUNCTION__),handle->user_data[_PLAYER_EVENT_TYPE_ERROR]);
 209                         }
 210                         break;
 211                 case  MM_MESSAGE_STATE_CHANGED: //0x03
 212                         handle->state = _convert_player_state(msg->state.current);
 213                         if(handle->state == PLAYER_STATE_PAUSED &&  handle->user_cb[_PLAYER_EVENT_TYPE_PAUSE] )
 214                         {
 215                                 ((player_paused_cb)handle->user_cb[_PLAYER_EVENT_TYPE_PAUSE])(handle->user_data[_PLAYER_EVENT_TYPE_PAUSE]);
 216                         }
 217                         break;
 218                 case MM_MESSAGE_BEGIN_OF_STREAM: //0x104
 219                         if( handle->user_cb[_PLAYER_EVENT_TYPE_BEGIN] )
 220                         {
 221                                 ((player_started_cb)handle->user_cb[_PLAYER_EVENT_TYPE_BEGIN])(handle->user_data[_PLAYER_EVENT_TYPE_BEGIN]);
 222                         }
 223                         break;
 224                 case MM_MESSAGE_END_OF_STREAM://0x105
 225                         if( handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE] )
 226                         {
 227                                 ((player_completed_cb)handle->user_cb[_PLAYER_EVENT_TYPE_COMPLETE])(handle->user_data[_PLAYER_EVENT_TYPE_COMPLETE]);
 228                         }
 229                         break;
 230                 case MM_MESSAGE_BUFFERING: //0x103
 231                         if( handle->user_cb[_PLAYER_EVENT_TYPE_BUFFERING] )
 232                         {
 233                                 ((player_buffering_cb)handle->user_cb[_PLAYER_EVENT_TYPE_BUFFERING])(msg->connection.buffering,handle->user_data[_PLAYER_EVENT_TYPE_BUFFERING]);
 234                         }
 235                         break;
 236                 case MM_MESSAGE_STATE_INTERRUPTED: //0x04
 237                         if( handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT] )
 238                         {
 239                                 ((player_interrupted_cb)handle->user_cb[_PLAYER_EVENT_TYPE_INTERRUPT])(msg->code,handle->user_data[_PLAYER_EVENT_TYPE_INTERRUPT]);
 240                         }
 241                         break;
 242                 case MM_MESSAGE_UPDATE_SUBTITLE: //0x109
 243                         if( handle->user_cb[_PLAYER_EVENT_TYPE_SUBTITLE] )
 244                         {
 245                                 ((player_subtitle_updated_cb)handle->user_cb[_PLAYER_EVENT_TYPE_SUBTITLE])(msg->subtitle.duration, (char*)msg->data,handle->user_data[_PLAYER_EVENT_TYPE_SUBTITLE]);
 246                         }
 247                         break;
 248                 case MM_MESSAGE_VIDEO_CAPTURED: //0x110
 249                         if( handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE] )
 250                         {
 251                                 int w;
 252                                 int h;
 253                                 int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_WIDTH ,&w,  MM_PLAYER_VIDEO_HEIGHT, &h, (char*)NULL);
 254                                 if(ret != MM_ERROR_NONE)
 255                                 {
 256                                         w=0;
 257                                         h=0;
 258                                         LOGI("[%s] Failed to get video size on video captured : 0x%x" ,__FUNCTION__, ret);
 259                                 }
 260                                 MMPlayerVideoCapture* capture = (MMPlayerVideoCapture *)msg->data;
 261                                 ((player_video_captured_cb)handle->user_cb[_PLAYER_EVENT_TYPE_CAPTURE])(capture->data, w, h, capture->size, handle->user_data[_PLAYER_EVENT_TYPE_CAPTURE]);
 262                         }
 263                         break;
 264                 case MM_MESSAGE_UNKNOWN: //0x00
 265                 case MM_MESSAGE_WARNING: //0x02
 266                 case MM_MESSAGE_READY_TO_RESUME: //0x05
 267                 case MM_MESSAGE_CONNECTING: //0x100
 268                 case MM_MESSAGE_CONNECTED: //0x101
 269                 case MM_MESSAGE_CONNECTION_TIMEOUT: //0x102
 270                 case MM_MESSAGE_BLUETOOTH_ON: //0x106
 271                 case MM_MESSAGE_BLUETOOTH_OFF: //0x107
 272                 case MM_MESSAGE_RESUMED_BY_REW: //0x108
 273                 case MM_MESSAGE_RTP_SENDER_REPORT: //0x10a
 274                 case MM_MESSAGE_RTP_RECEIVER_REPORT: //0x10b
 275                 case MM_MESSAGE_RTP_SESSION_STATUS: //0x10c
 276                 case MM_MESSAGE_SENDER_STATE: //0x10d
 277                 case MM_MESSAGE_RECEIVER_STATE: //0x10e
 278                 case MM_MESSAGE_FILE_NOT_SUPPORTED: //0x10f
 279                 case MM_MESSAGE_FILE_NOT_FOUND: //0x110
 280                 case MM_MESSAGE_DRM_NOT_AUTHORIZED: //0x111
 281                 case MM_MESSAGE_VIDEO_NOT_CAPTURED: //0x113
 282                 case MM_MESSAGE_SEEK_COMPLETED: //0x114
 283                 default:
 284                         break;
 285         }
 286
 287         return 1;
 288 }
 289
 290 /*
 291 * Public Implementation
 292 */
 293
 294 int player_create (player_h *player)
 295 {
 296         PLAYER_INSTANCE_CHECK(player);
 297         player_s * handle;
 298         handle = (player_s*)malloc( sizeof(player_s));
 299         if (handle != NULL)
 300                 memset(handle, 0 , sizeof(player_s));
 301         else
 302         {
 303                 LOGE("[%s] PLAYER_ERROR_OUT_OF_MEMORY" ,__FUNCTION__,PLAYER_ERROR_OUT_OF_MEMORY);
 304                 return PLAYER_ERROR_OUT_OF_MEMORY;
 305         }
 306         int ret = mm_player_create(&handle->mm_handle);
 307         if( ret != MM_ERROR_NONE)
 308         {
 309                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
 310                 handle->state = PLAYER_STATE_NONE;
 311                 free(handle);
 312                 handle=NULL;
 313                 return PLAYER_ERROR_INVALID_OPERATION;
 314         }
 315         else
 316         {
 317                 *player = (player_h)handle;
 318                 handle->state = PLAYER_STATE_IDLE;
 319                 handle->display_type = PLAYER_DISPLAY_TYPE_NONE;
 320                 return PLAYER_ERROR_NONE;
 321         }
 322 }
 323
 324
 325 int player_destroy (player_h player)
 326 {
 327         PLAYER_INSTANCE_CHECK(player);
 328         player_s * handle = (player_s *) player;
 329         if (mm_player_destroy(handle->mm_handle)!= MM_ERROR_NONE)
 330         {
 331                 LOGE("[%s] PLAYER_ERROR_INVALID_OPERATION(0x%08x)" ,__FUNCTION__,PLAYER_ERROR_INVALID_OPERATION);
 332                 return PLAYER_ERROR_INVALID_OPERATION;
 333         }
 334         else
 335         {
 336                 handle->state = PLAYER_STATE_NONE;
 337                 free(handle);
 338                 handle= NULL;
 339                 return PLAYER_ERROR_NONE;
 340         }
 341 }
 342
 343 int     player_prepare (player_h player)
 344 {
 345         PLAYER_INSTANCE_CHECK(player);
 346         player_s * handle = (player_s *) player;
 347         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 348
 349         int ret;
 350         ret = mm_player_set_message_callback(handle->mm_handle, _msg_callback, (void*)handle);
 351         if(ret != MM_ERROR_NONE)
 352         {
 353                 LOGW("[%s] Failed to set message callback function (0x%x)" ,__FUNCTION__, ret);
 354         }
 355         ret = mm_player_realize(handle->mm_handle);
 356         if(ret != MM_ERROR_NONE)
 357         {
 358                 return _convert_error_code(ret,(char*)__FUNCTION__);
 359         }
 360         else
 361         {
 362                 handle->state = PLAYER_STATE_READY;
 363                 return PLAYER_ERROR_NONE;
 364         }
 365 }
 366
 367 int     player_unprepare (player_h player)
 368 {
 369         PLAYER_INSTANCE_CHECK(player);
 370         player_s * handle = (player_s *) player;
 371         if (!_player_state_validate(handle, PLAYER_STATE_READY))
 372         {
 373                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
 374                 return PLAYER_ERROR_INVALID_STATE;
 375         }
 376
 377         int ret = mm_player_unrealize(handle->mm_handle);
 378         if(ret != MM_ERROR_NONE)
 379         {
 380                 return _convert_error_code(ret,(char*)__FUNCTION__);
 381         }
 382         else
 383         {
 384                 handle->state = PLAYER_STATE_IDLE;
 385                 return PLAYER_ERROR_NONE;
 386         }
 387 }
 388
 389 int     player_set_uri (player_h player, const char *uri)
 390 {
 391         PLAYER_INSTANCE_CHECK(player);
 392         PLAYER_NULL_ARG_CHECK(uri);
 393         player_s * handle = (player_s *) player;
 394         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 395
 396         int ret = mm_player_set_attribute(handle->mm_handle, NULL,MM_PLAYER_CONTENT_URI , uri, strlen(uri), (char*)NULL);
 397         if(ret != MM_ERROR_NONE)
 398         {
 399                 return _convert_error_code(ret,(char*)__FUNCTION__);
 400         }
 401         else
 402                 return PLAYER_ERROR_NONE;
 403 }
 404
 405 int     player_set_memory_buffer (player_h player, const void *data, int size)
 406 {
 407         PLAYER_INSTANCE_CHECK(player);
 408         PLAYER_NULL_ARG_CHECK(data);
 409         PLAYER_CHECK_CONDITION(size>=0,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
 410         player_s * handle = (player_s *) player;
 411         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 412
 413         char uri[PATH_MAX] ;
 414
 415         snprintf(uri, sizeof(uri),"mem:///ext=%s,size=%d","", size);
 416         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);
 417         if(ret != MM_ERROR_NONE)
 418         {
 419                 return _convert_error_code(ret,(char*)__FUNCTION__);
 420         }
 421         else
 422                 return PLAYER_ERROR_NONE;
 423 }
 424
 425 int     player_get_state (player_h player, player_state_e *state)
 426 {
 427         PLAYER_INSTANCE_CHECK(player);
 428         PLAYER_NULL_ARG_CHECK(state);
 429         player_s * handle = (player_s *) player;
 430         MMPlayerStateType currentStat = MM_PLAYER_STATE_NULL;
 431         int ret = mm_player_get_state(handle->mm_handle, &currentStat);
 432         if(ret != MM_ERROR_NONE)
 433         {
 434                 *state = handle->state;
 435                 return _convert_error_code(ret,(char*)__FUNCTION__);
 436         }
 437         else
 438         {
 439                 handle->state  = _convert_player_state(currentStat);
 440                 *state = handle->state;
 441                 return PLAYER_ERROR_NONE;
 442         }
 443 }
 444
 445 int     player_set_volume (player_h player, float left, float right)
 446 {
 447         PLAYER_INSTANCE_CHECK(player);
 448         PLAYER_CHECK_CONDITION(left>=0 && left <= 1.0 ,PLAYER_ERROR_INVALID_PARAMETER,"PLAYER_ERROR_INVALID_PARAMETER" );
 449         PLAYER_CHECK_CONDITION(right>=0 && right <= 1.0 ,PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER" );
 450         player_s * handle = (player_s *) player;
 451         MMPlayerVolumeType vol;
 452         vol.level[MM_VOLUME_CHANNEL_LEFT] = left;
 453         vol.level[MM_VOLUME_CHANNEL_RIGHT] = right;
 454         int ret = mm_player_set_volume(handle->mm_handle,&vol);
 455         if(ret != MM_ERROR_NONE)
 456         {
 457                 return _convert_error_code(ret,(char*)__FUNCTION__);
 458         }
 459         else
 460         {
 461                 return PLAYER_ERROR_NONE;
 462         }
 463 }
 464
 465 int     player_get_volume (player_h player, float *left, float *right)
 466 {
 467         PLAYER_INSTANCE_CHECK(player);
 468         PLAYER_NULL_ARG_CHECK(left);
 469         PLAYER_NULL_ARG_CHECK(right);
 470         player_s * handle = (player_s *) player;
 471         MMPlayerVolumeType vol;
 472         int ret = mm_player_get_volume(handle->mm_handle,&vol);
 473         if(ret != MM_ERROR_NONE)
 474         {
 475                 return _convert_error_code(ret,(char*)__FUNCTION__);
 476         }
 477         else
 478         {
 479                 *left = vol.level[MM_VOLUME_CHANNEL_LEFT];
 480                 *right = vol.level[MM_VOLUME_CHANNEL_RIGHT];
 481                 return PLAYER_ERROR_NONE;
 482         }
 483 }
 484
 485 int player_set_sound_type(player_h player, sound_type_e type)
 486 {
 487         PLAYER_INSTANCE_CHECK(player);
 488         player_s * handle = (player_s *) player;
 489
 490         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"sound_volume_type" , type, (char*)NULL);
 491         if(ret != MM_ERROR_NONE)
 492         {
 493                 return _convert_error_code(ret,(char*)__FUNCTION__);
 494         }
 495         else
 496                 return PLAYER_ERROR_NONE;
 497 }
 498
 499 int     player_start (player_h player)
 500 {
 501         PLAYER_INSTANCE_CHECK(player);
 502         player_s * handle = (player_s *) player;
 503         int ret;
 504         if (handle->state == PLAYER_STATE_READY )
 505         {
 506                 ret = mm_player_start(handle->mm_handle);
 507         }
 508         else if ( handle->state  == PLAYER_STATE_PAUSED)
 509         {
 510                 ret = mm_player_resume(handle->mm_handle);
 511         }
 512         else
 513         {
 514                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE(0x%08x) : current state - %d" ,__FUNCTION__,PLAYER_ERROR_INVALID_STATE, handle->state);
 515                 return PLAYER_ERROR_INVALID_STATE;
 516         }
 517
 518         if(ret != MM_ERROR_NONE)
 519         {
 520                 return _convert_error_code(ret,(char*)__FUNCTION__);
 521         }
 522         else
 523         {
 524                 handle->state = PLAYER_STATE_PLAYING;
 525                 return PLAYER_ERROR_NONE;
 526         }
 527 }
 528
 529 int     player_stop (player_h player)
 530 {
 531         PLAYER_INSTANCE_CHECK(player);
 532         player_s * handle = (player_s *) player;
 533         if (handle->state == PLAYER_STATE_PLAYING || handle->state == PLAYER_STATE_PAUSED)
 534         {
 535                 int ret = mm_player_stop(handle->mm_handle);
 536                 if(ret != MM_ERROR_NONE)
 537                 {
 538                         return _convert_error_code(ret,(char*)__FUNCTION__);
 539                 }
 540                 else
 541                 {
 542                         handle->state = PLAYER_STATE_READY;
 543                         return PLAYER_ERROR_NONE;
 544                 }
 545         }
 546         else
 547         {
 548                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 549                 return PLAYER_ERROR_INVALID_STATE;
 550         }
 551 }
 552
 553 int     player_pause (player_h player)
 554 {
 555         PLAYER_INSTANCE_CHECK(player);
 556         player_s * handle = (player_s *) player;
 557         PLAYER_STATE_CHECK(handle,PLAYER_STATE_PLAYING);
 558
 559         int ret = mm_player_pause(handle->mm_handle);
 560         if(ret != MM_ERROR_NONE)
 561         {
 562                 return _convert_error_code(ret,(char*)__FUNCTION__);
 563         }
 564         else
 565         {
 566                 handle->state = PLAYER_STATE_PAUSED;
 567                 return PLAYER_ERROR_NONE;
 568         }
 569 }
 570
 571 int     player_set_position (player_h player, int millisecond)
 572 {
 573         PLAYER_INSTANCE_CHECK(player);
 574         PLAYER_CHECK_CONDITION(millisecond>=0  ,PLAYER_ERROR_INVALID_PARAMETER ,"PLAYER_ERROR_INVALID_PARAMETER" );
 575         player_s * handle = (player_s *) player;
 576
 577         int ret = mm_player_set_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME, millisecond);
 578         if(ret != MM_ERROR_NONE)
 579         {
 580                 return _convert_error_code(ret,(char*)__FUNCTION__);
 581         }
 582         else
 583         {
 584                 return PLAYER_ERROR_NONE;
 585         }
 586 }
 587
 588
 589 int     player_set_position_ratio (player_h player, int percent)
 590 {
 591         PLAYER_INSTANCE_CHECK(player);
 592         PLAYER_CHECK_CONDITION(percent>=0 && percent <= 100 ,PLAYER_ERROR_INVALID_PARAMETER ,"PLAYER_ERROR_INVALID_PARAMETER" );
 593         player_s * handle = (player_s *) player;
 594
 595         int ret = mm_player_set_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_PERCENT , percent);
 596         if(ret != MM_ERROR_NONE)
 597         {
 598                 return _convert_error_code(ret,(char*)__FUNCTION__);
 599         }
 600         else
 601         {
 602                 return PLAYER_ERROR_NONE;
 603         }
 604 }
 605
 606
 607 int     player_get_position (player_h player, int *millisecond)
 608 {
 609         PLAYER_INSTANCE_CHECK(player);
 610         PLAYER_NULL_ARG_CHECK(millisecond);
 611         player_s * handle = (player_s *) player;
 612         if (!_player_state_validate(handle, PLAYER_STATE_READY))
 613         {
 614                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 615                 return PLAYER_ERROR_INVALID_STATE;
 616         }
 617         int pos;
 618         int ret = mm_player_get_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_TIME , &pos);
 619         if(ret != MM_ERROR_NONE)
 620         {
 621                 return _convert_error_code(ret,(char*)__FUNCTION__);
 622         }
 623         else
 624         {
 625                 *millisecond = pos;
 626                 return PLAYER_ERROR_NONE;
 627         }
 628 }
 629
 630 int     player_get_position_ratio (player_h player,int *percent)
 631 {
 632         PLAYER_INSTANCE_CHECK(player);
 633         PLAYER_NULL_ARG_CHECK(percent);
 634         player_s * handle = (player_s *) player;
 635         if (!_player_state_validate(handle, PLAYER_STATE_READY))
 636         {
 637                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 638                 return PLAYER_ERROR_INVALID_STATE;
 639         }
 640         int pos;
 641         int ret = mm_player_get_position(handle->mm_handle, MM_PLAYER_POS_FORMAT_PERCENT, &pos);
 642         if(ret != MM_ERROR_NONE)
 643         {
 644                 return _convert_error_code(ret,(char*)__FUNCTION__);
 645         }
 646         else
 647         {
 648                 *percent=pos;
 649                 return PLAYER_ERROR_NONE;
 650         }
 651 }
 652
 653 int     player_set_mute (player_h player, bool muted)
 654 {
 655         PLAYER_INSTANCE_CHECK(player);
 656         player_s * handle = (player_s *) player;
 657
 658         int ret = mm_player_set_mute(handle->mm_handle, muted);
 659         if(ret != MM_ERROR_NONE)
 660         {
 661                 return _convert_error_code(ret,(char*)__FUNCTION__);
 662         }
 663         else
 664         {
 665                 return PLAYER_ERROR_NONE;
 666         }
 667 }
 668
 669 int     player_is_muted (player_h player, bool *muted)
 670 {
 671         PLAYER_INSTANCE_CHECK(player);
 672         PLAYER_NULL_ARG_CHECK(muted);
 673         player_s * handle = (player_s *) player;
 674
 675         int _mute;
 676         int ret = mm_player_get_mute(handle->mm_handle, &_mute);
 677         if(ret != MM_ERROR_NONE)
 678         {
 679                 return _convert_error_code(ret,(char*)__FUNCTION__);
 680         }
 681         else
 682         {
 683                 if(_mute)
 684                 {
 685                         *muted = TRUE;
 686                 }
 687                 else
 688                 {
 689                         *muted = FALSE;
 690                 }
 691                 return PLAYER_ERROR_NONE;
 692         }
 693 }
 694
 695 int     player_set_looping (player_h player, bool looping)
 696 {
 697         PLAYER_INSTANCE_CHECK(player);
 698         player_s * handle = (player_s *) player;
 699         if (!_player_state_validate(handle, PLAYER_STATE_IDLE))
 700         {
 701                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 702                 return PLAYER_ERROR_INVALID_STATE;
 703         }
 704
 705         int value = 0;
 706         if(looping==TRUE)
 707         {
 708                 value = -1;
 709         }
 710         int ret = mm_player_set_attribute(handle->mm_handle, NULL,MM_PLAYER_PLAYBACK_COUNT , value, (char*)NULL);
 711
 712         if(ret != MM_ERROR_NONE)
 713         {
 714                 return _convert_error_code(ret,(char*)__FUNCTION__);
 715         }
 716         else
 717         {
 718                 return PLAYER_ERROR_NONE;
 719         }
 720 }
 721
 722 int     player_is_looping (player_h player, bool *looping)
 723 {
 724         PLAYER_INSTANCE_CHECK(player);
 725         PLAYER_NULL_ARG_CHECK(looping);
 726         player_s * handle = (player_s *) player;
 727         if (!_player_state_validate(handle, PLAYER_STATE_IDLE))
 728         {
 729                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 730                 return PLAYER_ERROR_INVALID_STATE;
 731         }
 732         int count;
 733         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_PLAYBACK_COUNT , &count, (char*)NULL);
 734         if(ret != MM_ERROR_NONE)
 735         {
 736                 return _convert_error_code(ret,(char*)__FUNCTION__);
 737         }
 738         else
 739         {
 740                 if(count==-1)
 741                 {
 742                         *looping = TRUE;
 743                 }
 744                 else
 745                 {
 746                         *looping = FALSE;
 747                 }
 748                 return PLAYER_ERROR_NONE;
 749         }
 750 }
 751
 752 int     player_get_duration (player_h player, int *duration)
 753 {
 754         PLAYER_INSTANCE_CHECK(player);
 755         PLAYER_NULL_ARG_CHECK(duration);
 756         player_s * handle = (player_s *) player;
 757         if (!_player_state_validate(handle, PLAYER_STATE_PLAYING))
 758         {
 759                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 760                 return PLAYER_ERROR_INVALID_STATE;
 761         }
 762         int _duration;
 763         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_CONTENT_DURATION, &_duration, (char*)NULL);
 764         if(ret != MM_ERROR_NONE)
 765         {
 766                 return _convert_error_code(ret,(char*)__FUNCTION__);
 767         }
 768         else
 769         {
 770                 *duration = _duration;
 771                 return PLAYER_ERROR_NONE;
 772         }
 773 }
 774
 775 int player_set_display(player_h player, player_display_type_e type, player_display_h display)
 776 {
 777         PLAYER_INSTANCE_CHECK(player);
 778         player_s * handle = (player_s *) player;
 779         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 780
 781         handle->display_handle = display;
 782         handle->display_type = type;
 783         int 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);
 784         if(ret != MM_ERROR_NONE)
 785         {
 786                 return _convert_error_code(ret,(char*)__FUNCTION__);
 787         }
 788         else
 789                 return PLAYER_ERROR_NONE;
 790 }
 791
 792 int player_set_x11_display_rotation(player_h player, player_display_rotation_e rotation)
 793 {
 794         PLAYER_INSTANCE_CHECK(player);
 795         player_s * handle = (player_s *) player;
 796
 797         int ret = mm_player_set_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_ROTATION , rotation, (char*)NULL);
 798         if(ret != MM_ERROR_NONE)
 799         {
 800                 return _convert_error_code(ret,(char*)__FUNCTION__);
 801         }
 802         else
 803                 return PLAYER_ERROR_NONE;
 804 }
 805
 806 int player_get_x11_display_rotation( player_h player, player_display_rotation_e *rotation)
 807 {
 808         PLAYER_INSTANCE_CHECK(player);
 809         PLAYER_NULL_ARG_CHECK(rotation);
 810         player_s * handle = (player_s *) player;
 811         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_ROTATION ,rotation, (char*)NULL);
 812         if(ret != MM_ERROR_NONE)
 813         {
 814                 return _convert_error_code(ret,(char*)__FUNCTION__);
 815         }
 816         else
 817         {
 818                 return PLAYER_ERROR_NONE;
 819         }
 820 }
 821
 822 int player_set_x11_display_visible(player_h player, bool visible)
 823 {
 824         PLAYER_INSTANCE_CHECK(player);
 825         player_s * handle = (player_s *) player;
 826
 827         int value = 0;
 828         if(visible==TRUE)
 829         {
 830                 value = 1;
 831         }
 832
 833         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_visible" , value, (char*)NULL);
 834         if(ret != MM_ERROR_NONE)
 835         {
 836                 return _convert_error_code(ret,(char*)__FUNCTION__);
 837         }
 838         else
 839                 return PLAYER_ERROR_NONE;
 840 }
 841
 842 int player_is_x11_display_visible(player_h player, bool* visible)
 843 {
 844         PLAYER_INSTANCE_CHECK(player);
 845         PLAYER_NULL_ARG_CHECK(visible);
 846         player_s * handle = (player_s *) player;
 847         int count;
 848         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"display_visible" ,&count, (char*)NULL);
 849         if(ret != MM_ERROR_NONE)
 850         {
 851                 return _convert_error_code(ret,(char*)__FUNCTION__);
 852         }
 853         else
 854         {
 855                 if(count==0)
 856                 {
 857                         *visible = FALSE;
 858                 }
 859                 else
 860                 {
 861                         *visible = TRUE;
 862                 }
 863
 864                 return PLAYER_ERROR_NONE;
 865         }
 866 }
 867
 868
 869 int player_set_x11_display_mode(player_h player, player_display_mode_e mode)
 870 {
 871         PLAYER_INSTANCE_CHECK(player);
 872         player_s * handle = (player_s *) player;
 873
 874         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"display_method" , mode, (char*)NULL);
 875         if(ret != MM_ERROR_NONE)
 876         {
 877                 return _convert_error_code(ret,(char*)__FUNCTION__);
 878         }
 879         else
 880                 return PLAYER_ERROR_NONE;
 881 }
 882
 883 int player_get_x11_display_mode(player_h player, player_display_mode_e *mode)
 884 {
 885         PLAYER_INSTANCE_CHECK(player);
 886         PLAYER_NULL_ARG_CHECK(mode);
 887         player_s * handle = (player_s *) player;
 888         int ret = mm_player_get_attribute(handle->mm_handle, NULL,"display_method"  ,mode, (char*)NULL);
 889         if(ret != MM_ERROR_NONE)
 890         {
 891                 return _convert_error_code(ret,(char*)__FUNCTION__);
 892         }
 893         else
 894         {
 895                 return PLAYER_ERROR_NONE;
 896         }
 897 }
 898
 899 int     player_get_video_size (player_h player, int *width, int *height)
 900 {
 901         PLAYER_INSTANCE_CHECK(player);
 902         PLAYER_NULL_ARG_CHECK(width);
 903         PLAYER_NULL_ARG_CHECK(height);
 904         player_s * handle = (player_s *) player;
 905         if (!_player_state_validate(handle, PLAYER_STATE_READY))
 906         {
 907                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 908                 return PLAYER_ERROR_INVALID_STATE;
 909         }
 910         int w;
 911         int h;
 912         int ret = mm_player_get_attribute(handle->mm_handle, NULL,MM_PLAYER_VIDEO_WIDTH ,&w,  MM_PLAYER_VIDEO_HEIGHT, &h, (char*)NULL);
 913         if(ret != MM_ERROR_NONE)
 914         {
 915                 return _convert_error_code(ret,(char*)__FUNCTION__);
 916         }
 917         else
 918         {
 919                 *width = w;
 920                 *height = h;
 921                 return PLAYER_ERROR_NONE;
 922         }
 923 }
 924
 925 int player_set_subtitle_path(player_h player, char* path)
 926 {
 927         PLAYER_INSTANCE_CHECK(player);
 928         PLAYER_NULL_ARG_CHECK(path);
 929         player_s * handle = (player_s *) player;
 930         PLAYER_STATE_CHECK(handle,PLAYER_STATE_IDLE);
 931
 932         int ret = mm_player_set_attribute(handle->mm_handle, NULL,"subtitle_uri" , path, strlen(path),"subtitle_silent", 0, (char*)NULL);
 933         if(ret != MM_ERROR_NONE)
 934         {
 935                 return _convert_error_code(ret,(char*)__FUNCTION__);
 936         }
 937         else
 938                 return PLAYER_ERROR_NONE;
 939 }
 940
 941 int player_capture_video(player_h player, player_video_captured_cb callback, void *user_data)
 942 {
 943         int ret =_set_callback(_PLAYER_EVENT_TYPE_CAPTURE,player,callback,user_data);
 944         if(ret != PLAYER_ERROR_NONE)
 945                 return ret;
 946
 947         player_s * handle = (player_s *) player;
 948         if(handle->state == PLAYER_STATE_PAUSED || handle->state == PLAYER_STATE_PLAYING )
 949         {
 950                 ret = mm_player_do_video_capture(handle->mm_handle);
 951                 if(ret != MM_ERROR_NONE)
 952                 {
 953                         return _convert_error_code(ret,(char*)__FUNCTION__);
 954                 }
 955                 else
 956                         return PLAYER_ERROR_NONE;
 957         }
 958         else
 959         {
 960                 LOGE("[%s] PLAYER_ERROR_INVALID_STATE (current state : %d)" ,__FUNCTION__, handle->state);
 961                 return PLAYER_ERROR_INVALID_STATE;
 962         }
 963 }
 964
 965 int     player_set_started_cb (player_h player, player_started_cb callback, void *user_data)
 966 {
 967         return _set_callback(_PLAYER_EVENT_TYPE_BEGIN,player,callback,user_data);
 968 }
 969
 970 int     player_unset_started_cb (player_h player)
 971 {
 972         return _unset_callback(_PLAYER_EVENT_TYPE_BEGIN,player);
 973 }
 974
 975 int     player_set_completed_cb (player_h player, player_completed_cb callback, void *user_data)
 976 {
 977         return _set_callback(_PLAYER_EVENT_TYPE_COMPLETE,player,callback,user_data);
 978 }
 979
 980 int     player_unset_completed_cb (player_h player)
 981 {
 982         return _unset_callback(_PLAYER_EVENT_TYPE_COMPLETE,player);
 983 }
 984
 985 int     player_set_paused_cb (player_h player, player_paused_cb callback, void *user_data)
 986 {
 987         return _set_callback(_PLAYER_EVENT_TYPE_PAUSE,player,callback,user_data);
 988 }
 989
 990 int     player_unset_paused_cb (player_h player)
 991 {
 992         return _unset_callback(_PLAYER_EVENT_TYPE_PAUSE,player);
 993 }
 994
 995 int     player_set_interrupted_cb (player_h player, player_interrupted_cb callback, void *user_data)
 996 {
 997         return _set_callback(_PLAYER_EVENT_TYPE_INTERRUPT,player,callback,user_data);
 998 }
 999
1000 int     player_unset_interrupted_cb (player_h player)
1001 {
1002         return _unset_callback(_PLAYER_EVENT_TYPE_INTERRUPT,player);
1003 }
1004
1005 int     player_set_error_cb (player_h player, player_error_cb callback, void *user_data)
1006 {
1007         return _set_callback(_PLAYER_EVENT_TYPE_ERROR,player,callback,user_data);
1008 }
1009
1010 int     player_unset_error_cb (player_h player)
1011 {
1012         return _unset_callback(_PLAYER_EVENT_TYPE_ERROR,player);
1013 }
1014
1015 int     player_set_buffering_cb (player_h player, player_buffering_cb callback, void *user_data)
1016 {
1017         return _set_callback(_PLAYER_EVENT_TYPE_BUFFERING,player,callback,user_data);
1018 }
1019
1020 int     player_unset_buffering_cb (player_h player)
1021 {
1022         return _unset_callback(_PLAYER_EVENT_TYPE_BUFFERING,player);
1023 }
1024
1025
1026 int     player_set_subtilte_updated_cb(player_h player, player_subtitle_updated_cb callback, void* user_data )
1027 {
1028         return _set_callback(_PLAYER_EVENT_TYPE_SUBTITLE,player,callback,user_data);
1029 }
1030
1031 int     player_unset_subtilte_updated_cb (player_h player)
1032 {
1033         return _unset_callback(_PLAYER_EVENT_TYPE_SUBTITLE,player);
1034 }
1035