legacy/src/legacy_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 <inttypes.h>
  21 #include <mm.h>
  22 #include <mm_player.h>
  23 #include <mm_player_audioeffect.h>
  24 #include <mm_player_internal.h>
  25 #include <mm_types.h>
  26 #include <sound_manager.h>
  27 #include <sound_manager_internal.h>
  28 #include <dlog.h>
  29 #include "muse_player.h"
  30 #include "legacy_player.h"
  31 #include "legacy_player_private.h"
  32
  33 #define MIN_BUFFERING_TIME_MS 0   /* use platform default value */
  34
  35 #define __RELEASEIF_PREPARE_THREAD(thread_id) \
  36         do { \
  37                 if (thread_id) { \
  38                         pthread_join(thread_id, NULL); \
  39                         thread_id = 0; \
  40                         LOGI("prepare thread released\n"); \
  41                 } \
  42         } while (0)
  43
  44 #define __RELEASEIF_MESSAGE_THREAD(thread_id) \
  45         do { \
  46                 if (thread_id) { \
  47                         pthread_join(thread_id, NULL); \
  48                         thread_id = 0; \
  49                         LOGI("message thread released\n"); \
  50                 } \
  51         } while (0)
  52
  53 #define __GET_MESSAGE(handle) \
  54         do { \
  55                 if (handle && handle->message_queue) { \
  56                         g_mutex_lock(&handle->message_queue_lock); \
  57                         if (g_queue_is_empty(handle->message_queue)) { \
  58                                 g_cond_wait(&handle->message_queue_cond, &handle->message_queue_lock); \
  59                         } \
  60                         handle->current_message = (int)(intptr_t)g_queue_pop_head(handle->message_queue); \
  61                         g_mutex_unlock(&handle->message_queue_lock); \
  62                         LOGI("Retrieved  message [%d] from queue", handle->current_message); \
  63                 } else { \
  64                         LOGI("Failed to retrieve message from queue"); \
  65                         handle->current_message = PLAYER_MESSAGE_NONE; \
  66                 } \
  67         } while (0)
  68
  69 #define __ADD_MESSAGE(handle, message) \
  70         do { \
  71                 if (handle && handle->message_queue) { \
  72                         g_mutex_lock(&handle->message_queue_lock); \
  73                         if (message == PLAYER_MESSAGE_LOOP_EXIT) \
  74                                 g_queue_clear(handle->message_queue); \
  75                         g_queue_push_tail(handle->message_queue, (gpointer)message); \
  76                         g_cond_signal(&handle->message_queue_cond); \
  77                         g_mutex_unlock(&handle->message_queue_lock); \
  78                         LOGI("Adding message [%d] to queue", message); \
  79                 } else { \
  80                         LOGI("Failed to add message [%d] to queue", message); \
  81                 } \
  82         } while (0)
  83
  84 /*
  85  * Internal Implementation
  86  */
  87 int __player_convert_error_code(int code, char *func_name)
  88 {
  89         int ret = PLAYER_ERROR_INVALID_OPERATION;
  90         char *msg = "PLAYER_ERROR_INVALID_OPERATION";
  91         switch (code) {
  92         case MM_ERROR_NONE:
  93                 ret = PLAYER_ERROR_NONE;
  94                 msg = "PLAYER_ERROR_NONE";
  95                 break;
  96         case MM_ERROR_PLAYER_AUDIO_CODEC_NOT_FOUND:
  97                 ret = PLAYER_ERROR_NOT_SUPPORTED_AUDIO_CODEC;
  98                 msg = "PLAYER_ERROR_NOT_SUPPORTED_AUDIO_CODEC";
  99                 break;
 100         case MM_ERROR_PLAYER_VIDEO_CODEC_NOT_FOUND:
 101                 ret = PLAYER_ERROR_NOT_SUPPORTED_VIDEO_CODEC;
 102                 msg = "PLAYER_ERROR_NOT_SUPPORTED_VIDEO_CODEC";
 103                 break;
 104         case MM_ERROR_PLAYER_NOT_SUPPORTED_SUBTITLE:
 105                 ret = PLAYER_ERROR_NOT_SUPPORTED_SUBTITLE;
 106                 msg = "PLAYER_ERROR_NOT_SUPPORTED_SUBTITLE";
 107                 break;
 108         case MM_ERROR_INVALID_ARGUMENT:
 109         case MM_ERROR_COMMON_INVALID_ARGUMENT:
 110                 ret = PLAYER_ERROR_INVALID_PARAMETER;
 111                 msg = "PLAYER_ERROR_INVALID_PARAMETER";
 112                 break;
 113         case MM_ERROR_PLAYER_CODEC_NOT_FOUND:
 114         case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_AUDIO:
 115         case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_VIDEO:
 116         case MM_ERROR_PLAYER_STREAMING_UNSUPPORTED_MEDIA_TYPE:
 117         case MM_ERROR_PLAYER_NOT_SUPPORTED_FORMAT:
 118                 ret = PLAYER_ERROR_NOT_SUPPORTED_FILE;
 119                 msg = "PLAYER_ERROR_NOT_SUPPORTED_FILE";
 120                 break;
 121         case MM_ERROR_PLAYER_INVALID_STATE:
 122         case MM_ERROR_PLAYER_NOT_INITIALIZED:
 123                 ret = PLAYER_ERROR_INVALID_STATE;
 124                 msg = "PLAYER_ERROR_INVALID_STATE";
 125                 break;
 126         case MM_ERROR_PLAYER_INTERNAL:
 127         case MM_ERROR_PLAYER_INVALID_STREAM:
 128         case MM_ERROR_PLAYER_STREAMING_FAIL:
 129         case MM_ERROR_PLAYER_NO_OP:
 130                 ret = PLAYER_ERROR_INVALID_OPERATION;
 131                 msg = "PLAYER_ERROR_INVALID_OPERATION";
 132                 break;
 133         case MM_ERROR_PLAYER_SOUND_EFFECT_INVALID_STATUS:
 134         case MM_ERROR_NOT_SUPPORT_API:
 135         case MM_ERROR_PLAYER_SOUND_EFFECT_NOT_SUPPORTED_FILTER:
 136                 ret = PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE;
 137                 msg = "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE";
 138                 break;
 139         case MM_ERROR_PLAYER_NO_FREE_SPACE:
 140                 ret = PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE;
 141                 msg = "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE";
 142                 break;
 143         case MM_ERROR_PLAYER_FILE_NOT_FOUND:
 144                 ret = PLAYER_ERROR_NO_SUCH_FILE;
 145                 msg = "PLAYER_ERROR_NO_SUCH_FILE";
 146                 break;
 147         case MM_ERROR_PLAYER_SEEK:
 148                 ret = PLAYER_ERROR_SEEK_FAILED;
 149                 msg = "PLAYER_ERROR_SEEK_FAILED";
 150                 break;
 151         case MM_ERROR_PLAYER_INVALID_URI:
 152         case MM_ERROR_PLAYER_STREAMING_INVALID_URL:
 153                 ret = PLAYER_ERROR_INVALID_URI;
 154                 msg = "PLAYER_ERROR_INVALID_URI";
 155                 break;
 156         case MM_ERROR_PLAYER_STREAMING_CONNECTION_FAIL:
 157         case MM_ERROR_PLAYER_STREAMING_DNS_FAIL:
 158         case MM_ERROR_PLAYER_STREAMING_SERVER_DISCONNECTED:
 159         case MM_ERROR_PLAYER_STREAMING_INVALID_PROTOCOL:
 160         case MM_ERROR_PLAYER_STREAMING_UNEXPECTED_MSG:
 161         case MM_ERROR_PLAYER_STREAMING_OUT_OF_MEMORIES:
 162         case MM_ERROR_PLAYER_STREAMING_RTSP_TIMEOUT:
 163         case MM_ERROR_PLAYER_STREAMING_BAD_REQUEST:
 164         case MM_ERROR_PLAYER_STREAMING_NOT_AUTHORIZED:
 165         case MM_ERROR_PLAYER_STREAMING_PAYMENT_REQUIRED:
 166         case MM_ERROR_PLAYER_STREAMING_FORBIDDEN:
 167         case MM_ERROR_PLAYER_STREAMING_CONTENT_NOT_FOUND:
 168         case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_ALLOWED:
 169         case MM_ERROR_PLAYER_STREAMING_NOT_ACCEPTABLE:
 170         case MM_ERROR_PLAYER_STREAMING_PROXY_AUTHENTICATION_REQUIRED:
 171         case MM_ERROR_PLAYER_STREAMING_SERVER_TIMEOUT:
 172         case MM_ERROR_PLAYER_STREAMING_GONE:
 173         case MM_ERROR_PLAYER_STREAMING_LENGTH_REQUIRED:
 174         case MM_ERROR_PLAYER_STREAMING_PRECONDITION_FAILED:
 175         case MM_ERROR_PLAYER_STREAMING_REQUEST_ENTITY_TOO_LARGE:
 176         case MM_ERROR_PLAYER_STREAMING_REQUEST_URI_TOO_LARGE:
 177         case MM_ERROR_PLAYER_STREAMING_PARAMETER_NOT_UNDERSTOOD:
 178         case MM_ERROR_PLAYER_STREAMING_CONFERENCE_NOT_FOUND:
 179         case MM_ERROR_PLAYER_STREAMING_NOT_ENOUGH_BANDWIDTH:
 180         case MM_ERROR_PLAYER_STREAMING_NO_SESSION_ID:
 181         case MM_ERROR_PLAYER_STREAMING_METHOD_NOT_VALID_IN_THIS_STATE:
 182         case MM_ERROR_PLAYER_STREAMING_HEADER_FIELD_NOT_VALID_FOR_SOURCE:
 183         case MM_ERROR_PLAYER_STREAMING_INVALID_RANGE:
 184         case MM_ERROR_PLAYER_STREAMING_PARAMETER_IS_READONLY:
 185         case MM_ERROR_PLAYER_STREAMING_AGGREGATE_OP_NOT_ALLOWED:
 186         case MM_ERROR_PLAYER_STREAMING_ONLY_AGGREGATE_OP_ALLOWED:
 187         case MM_ERROR_PLAYER_STREAMING_BAD_TRANSPORT:
 188         case MM_ERROR_PLAYER_STREAMING_DESTINATION_UNREACHABLE:
 189         case MM_ERROR_PLAYER_STREAMING_INTERNAL_SERVER_ERROR:
 190         case MM_ERROR_PLAYER_STREAMING_NOT_IMPLEMENTED:
 191         case MM_ERROR_PLAYER_STREAMING_BAD_GATEWAY:
 192         case MM_ERROR_PLAYER_STREAMING_SERVICE_UNAVAILABLE:
 193         case MM_ERROR_PLAYER_STREAMING_GATEWAY_TIME_OUT:
 194         case MM_ERROR_PLAYER_STREAMING_OPTION_NOT_SUPPORTED:
 195                 ret = PLAYER_ERROR_CONNECTION_FAILED;
 196                 msg = "PLAYER_ERROR_CONNECTION_FAILED";
 197                 break;
 198         case MM_ERROR_POLICY_BLOCKED:
 199         case MM_ERROR_POLICY_INTERRUPTED:
 200         case MM_ERROR_POLICY_INTERNAL:
 201         case MM_ERROR_POLICY_DUPLICATED:
 202                 ret = PLAYER_ERROR_SOUND_POLICY;
 203                 msg = "PLAYER_ERROR_SOUND_POLICY";
 204                 break;
 205         case MM_ERROR_PLAYER_DRM_EXPIRED:
 206                 ret = PLAYER_ERROR_DRM_EXPIRED;
 207                 msg = "PLAYER_ERROR_DRM_EXPIRED";
 208                 break;
 209         case MM_ERROR_PLAYER_DRM_NOT_AUTHORIZED:
 210         case MM_ERROR_PLAYER_DRM_NO_LICENSE:
 211                 ret = PLAYER_ERROR_DRM_NO_LICENSE;
 212                 msg = "PLAYER_ERROR_DRM_NO_LICENSE";
 213                 break;
 214         case MM_ERROR_PLAYER_DRM_FUTURE_USE:
 215                 ret = PLAYER_ERROR_DRM_FUTURE_USE;
 216                 msg = "PLAYER_ERROR_DRM_FUTURE_USE";
 217                 break;
 218         case MM_ERROR_PLAYER_DRM_OUTPUT_PROTECTION:
 219                 ret = PLAYER_ERROR_DRM_NOT_PERMITTED;
 220                 msg = "PLAYER_ERROR_DRM_NOT_PERMITTED";
 221                 break;
 222         case MM_ERROR_PLAYER_RESOURCE_LIMIT:
 223                 ret = PLAYER_ERROR_RESOURCE_LIMIT;
 224                 msg = "PLAYER_ERROR_RESOURCE_LIMIT";
 225                 break;
 226         case MM_ERROR_PLAYER_PERMISSION_DENIED:
 227                 ret = PLAYER_ERROR_PERMISSION_DENIED;
 228                 msg = "PLAYER_ERROR_PERMISSION_DENIED";
 229                 break;
 230         case MM_ERROR_PLAYER_BUFFER_SPACE:
 231                 ret = PLAYER_ERROR_BUFFER_SPACE;
 232                 msg = "PLAYER_ERROR_BUFFER_SPACE";
 233                 break;
 234         default:
 235                 break;
 236         }
 237         LOGE("[%s] %s(0x%08x) : core fw error(0x%x)", func_name, msg, ret, code);
 238         return ret;
 239 }
 240
 241 static void __player_update_state(legacy_player_t *handle, player_internal_state_e state)
 242 {
 243         switch (state) {
 244         case PLAYER_INTERNAL_STATE_NONE:
 245                 handle->state = PLAYER_STATE_NONE;
 246                 handle->internal_state = PLAYER_INTERNAL_STATE_IDLE;
 247         break;
 248         case PLAYER_INTERNAL_STATE_IDLE:
 249                 handle->state = PLAYER_STATE_IDLE;
 250                 handle->internal_state = PLAYER_INTERNAL_STATE_IDLE;
 251         break;
 252         case PLAYER_INTERNAL_STATE_PRE_READY:
 253                 handle->internal_state = PLAYER_INTERNAL_STATE_PRE_READY;
 254         break;
 255         case PLAYER_INTERNAL_STATE_READY:
 256                 handle->state = PLAYER_STATE_READY;
 257                 handle->internal_state = PLAYER_INTERNAL_STATE_READY;
 258         break;
 259         case PLAYER_INTERNAL_STATE_PLAYING:
 260                 handle->internal_state = PLAYER_INTERNAL_STATE_PLAYING;
 261                 handle->state = PLAYER_STATE_PLAYING;
 262         break;
 263         case PLAYER_INTERNAL_STATE_PAUSED:
 264                 handle->internal_state = PLAYER_INTERNAL_STATE_PAUSED;
 265                 handle->state = PLAYER_STATE_PAUSED;
 266         break;
 267         case PLAYER_INTERNAL_STATE_STOPPED:
 268                 handle->state = PLAYER_STATE_READY;
 269                 handle->internal_state = PLAYER_INTERNAL_STATE_STOPPED;
 270         break;
 271         default:
 272         break;
 273         }
 274
 275         LOGD("player state is updated to 0x%X, 0x%X", handle->state, handle->internal_state);
 276         return;
 277 }
 278
 279 bool __player_state_validate(legacy_player_t *handle, player_state_e threshold)
 280 {
 281         if (handle->state < threshold)
 282                 return false;
 283
 284         return true;
 285 }
 286
 287 static int __set_callback(muse_player_event_e type, legacy_player_h player, void *callback, void *user_data)
 288 {
 289         legacy_player_t *handle = (legacy_player_t *)player;
 290         PLAYER_INSTANCE_CHECK(player);
 291         PLAYER_NULL_ARG_CHECK(callback);
 292
 293         handle->user_cb[type] = callback;
 294         handle->user_data[type] = user_data;
 295         LOGI("Event type : %d ", type);
 296         return PLAYER_ERROR_NONE;
 297 }
 298
 299 static int __unset_callback(muse_player_event_e type, legacy_player_h player)
 300 {
 301         legacy_player_t *handle = (legacy_player_t *)player;
 302         PLAYER_INSTANCE_CHECK(player);
 303         handle->user_cb[type] = NULL;
 304         handle->user_data[type] = NULL;
 305         LOGI("Event type : %d ", type);
 306         return PLAYER_ERROR_NONE;
 307 }
 308
 309 static void __message_cb_loop(void *data)
 310 {
 311         bool running = true;
 312         legacy_player_t *handle = (legacy_player_t *)data;
 313         if (!handle) {
 314                 LOGE("null handle in __message_cb_loop");
 315                 return;
 316         }
 317         do {
 318                 __GET_MESSAGE(handle);
 319                 switch (handle->current_message) {
 320                 case PLAYER_MESSAGE_NONE:
 321                         {
 322                                 LOGW("PLAYER_MESSAGE_NONE");
 323                                 running = false;
 324                         }
 325                         break;
 326                 case PLAYER_MESSAGE_PREPARED:
 327                         {
 328                                 LOGW("PLAYER_MESSAGE_PREPARED");
 329
 330                                 LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 331                                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 332                                         __player_update_state(handle, PLAYER_INTERNAL_STATE_READY);
 333                                         ((player_prepared_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE])(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
 334                                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 335                                         handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 336                                 } else {
 337                                         LOGE("null handle in PLAYER_MESSAGE_PREPARED");
 338                                 }
 339                                 LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 340                         }
 341                         break;
 342                 case PLAYER_MESSAGE_ERROR:
 343                         {
 344                                 LOGW("PLAYER_MESSAGE_ERROR");
 345                                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])
 346                                         ((player_error_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])(handle->error_code, handle->user_data[MUSE_PLAYER_EVENT_TYPE_ERROR]);
 347                                 else
 348                                         LOGE("null handle in PLAYER_MESSAGE_ERROR");
 349                         }
 350                         break;
 351                 case PLAYER_MESSAGE_SEEK_DONE:
 352                         {
 353                                 LOGW("PLAYER_MESSAGE_SEEK_DONE");
 354                                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK]) {
 355                                         ((player_seek_completed_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK])(handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK]);
 356                                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
 357                                         handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
 358                                 } else {
 359                                         LOGE("null handle in PLAYER_MESSAGE_SEEK_DONE");
 360                                 }
 361                         }
 362                         break;
 363                 case PLAYER_MESSAGE_EOS:
 364                         {
 365                                 LOGW("PLAYER_MESSAGE_EOS");
 366                                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_COMPLETE])
 367                                         ((player_completed_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_COMPLETE])(handle->user_data[MUSE_PLAYER_EVENT_TYPE_COMPLETE]);
 368                                 else
 369                                         LOGE("null handle in PLAYER_MESSAGE_EOS");
 370                         }
 371                         break;
 372 #ifdef TIZEN_FEATURE_EVAS_RENDERER
 373                 case PLAYER_MESSAGE_GAPLESS_CONSTRUCTION:
 374                         {
 375                                 LOGW("PLAYER_MESSAGE_GAPLESS_CONSTRUCTION");
 376                                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER])
 377                                         ((player_retrieve_buffer_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER])(handle->user_data[MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER]);
 378                                 else
 379                                         LOGE("null handle in PLAYER_MESSAGE_GAPLESS_CONSTRUCTION");
 380                         }
 381                         break;
 382 #endif
 383                 case PLAYER_MESSAGE_LOOP_EXIT:
 384                         {
 385                                 LOGW("PLAYER_MESSAGE_LOOP_EXIT");
 386                                 running = false;
 387                         }
 388                         break;
 389                 case PLAYER_MESSAGE_MAX:
 390                         {
 391                                 LOGW("PLAYER_MESSAGE_MAX");
 392                                 running = false;
 393                         }
 394                         break;
 395                 default:
 396                         break;
 397                 }
 398         } while (running);
 399         return;
 400 }
 401
 402 static player_state_e __convert_player_state(mmplayer_state_e state)
 403 {
 404         if (state == MM_PLAYER_STATE_NONE)
 405                 return PLAYER_STATE_NONE;
 406
 407         return state + 1;
 408 }
 409
 410 static int __msg_callback(int message, void *param, void *user_data)
 411 {
 412         legacy_player_t *handle = (legacy_player_t *)user_data;
 413         MMMessageParamType *msg = (MMMessageParamType *)param;
 414         player_error_e err_code = PLAYER_ERROR_NONE;
 415
 416         LOGW("Got message type : 0x%x", message);
 417         switch (message) {
 418         case MM_MESSAGE_ERROR:  /* 0x01 */
 419                 err_code = __player_convert_error_code(msg->code, (char *)__FUNCTION__);
 420
 421                 LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 422                 if (PLAYER_ERROR_NOT_SUPPORTED_FILE == err_code && handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 423                         LOGW("Failed to pause, so prepare cb will be released soon");
 424                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 425                         if (handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 426                                 g_free(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
 427                                 handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 428                         }
 429                 }
 430                 LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 431                 break;
 432         case MM_MESSAGE_STATE_CHANGED:  /* 0x03 */
 433                 LOGI("STATE CHANGED INTERNALLY - from : %d,  to : %d (CAPI State : %d)", msg->state.previous, msg->state.current, handle->state);
 434                 if (msg->state.previous == MM_PLAYER_STATE_READY && msg->state.current == MM_PLAYER_STATE_PAUSED) {
 435                         LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 436                         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 437                                 /* asyc && prepared cb has been set */
 438                                 LOGI("Prepared! [current state : %d]", handle->state);
 439                                 PLAYER_TRACE_ASYNC_END("MM:PLAYER:PREPARE_ASYNC", *(int *)handle);
 440                                 __ADD_MESSAGE(handle, PLAYER_MESSAGE_PREPARED);
 441                         }
 442                         LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 443                 }
 444                 break;
 445         case MM_MESSAGE_BEGIN_OF_STREAM:        /* 0x104 */
 446                 LOGI("Ready to streaming information (BOS) [current state : %d]", handle->state);
 447                 break;
 448         case MM_MESSAGE_END_OF_STREAM:  /* 0x105 */
 449                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_COMPLETE])
 450                         __ADD_MESSAGE(handle, PLAYER_MESSAGE_EOS);
 451                 break;
 452 #ifdef TIZEN_FEATURE_EVAS_RENDERER
 453         case MM_MESSAGE_GAPLESS_CONSTRUCTION:   /* 0x105 */
 454                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER])
 455                         __ADD_MESSAGE(handle, PLAYER_MESSAGE_GAPLESS_CONSTRUCTION);
 456                 break;
 457 #endif
 458         case MM_MESSAGE_BUFFERING:      /* 0x103 */
 459                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_BUFFERING])
 460                         ((player_buffering_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_BUFFERING])(msg->connection.buffering, handle->user_data[MUSE_PLAYER_EVENT_TYPE_BUFFERING]);
 461                 break;
 462         case MM_MESSAGE_STATE_INTERRUPTED:      /* 0x04 */
 463                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_INTERRUPT]) {
 464                         if (msg->union_type == MM_MSG_UNION_STATE) {
 465                                 LOGW("received mm state msg prev:%d, curr:%d", msg->state.previous, msg->state.current);
 466                                 handle->state = __convert_player_state(msg->state.current);
 467                                 LOGW("player state is changed to %d by resource conflict", handle->state);
 468                         }
 469                         ((player_interrupted_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_INTERRUPT])(handle->user_data[MUSE_PLAYER_EVENT_TYPE_INTERRUPT]);
 470                 }
 471                 break;
 472         case MM_MESSAGE_CONNECTION_TIMEOUT:     /* 0x102 */
 473                 LOGE("PLAYER_ERROR_CONNECTION_FAILED : CONNECTION_TIMEOUT");
 474                 err_code = PLAYER_ERROR_CONNECTION_FAILED;
 475                 break;
 476         case MM_MESSAGE_UPDATE_SUBTITLE:        /* 0x109 */
 477                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SUBTITLE])
 478                         ((player_subtitle_updated_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SUBTITLE])(msg->subtitle.duration, (char *)msg->data, handle->user_data[MUSE_PLAYER_EVENT_TYPE_SUBTITLE]);
 479                 break;
 480         case MM_MESSAGE_VIDEO_NOT_CAPTURED:     /* 0x113 */
 481                 LOGE("PLAYER_ERROR_VIDEO_CAPTURE_FAILED");
 482                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])
 483                         ((player_error_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR])(PLAYER_ERROR_VIDEO_CAPTURE_FAILED, handle->user_data[MUSE_PLAYER_EVENT_TYPE_ERROR]);
 484                 break;
 485         case MM_MESSAGE_VIDEO_CAPTURED: /* 0x110 */
 486         {
 487                 mmplayer_video_capture_t *capture = (mmplayer_video_capture_t *)msg->data;
 488
 489                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE]) {
 490                         if (!capture || !capture->data) {
 491                                 LOGE("PLAYER_ERROR_VIDEO_CAPTURE_FAILED : Failed to get capture data");
 492                                 err_code = PLAYER_ERROR_VIDEO_CAPTURE_FAILED;
 493                         } else {
 494                                 LOGI("captured image ori: %d, width: %d, height: %d, size: %d",
 495                                                         capture->orientation, capture->width, capture->height, capture->size);
 496
 497                                 /* call application callback */
 498                                 ((player_video_captured_cb)handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE])
 499                                                 (capture->data, capture->width, capture->height, capture->size, handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE]);
 500                         }
 501
 502                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
 503                         handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
 504                 }
 505
 506                 /* capure->data have to be released to avoid mem leak in all cases. */
 507                 if (capture) {
 508                         g_free(capture->data);
 509                         capture->data = NULL;
 510                 }
 511                 break;
 512         }
 513         case MM_MESSAGE_FILE_NOT_SUPPORTED:     /* 0x10f */
 514                 LOGE("PLAYER_ERROR_NOT_SUPPORTED_FILE : FILE_NOT_SUPPORTED");
 515                 err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE;
 516                 break;
 517         case MM_MESSAGE_FILE_NOT_FOUND: /* 0x110 */
 518                 LOGE("PLAYER_ERROR_NOT_SUPPORTED_FILE : FILE_NOT_FOUND");
 519                 err_code = PLAYER_ERROR_NOT_SUPPORTED_FILE;
 520                 break;
 521         case MM_MESSAGE_SEEK_COMPLETED: /* 0x114 */
 522                 if (handle->display_type != PLAYER_DISPLAY_TYPE_NONE && handle->state == PLAYER_STATE_READY) {
 523                         if (handle->is_display_visible) {
 524                                 int ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 1, (char *)NULL);
 525                                 if (ret != MM_ERROR_NONE)
 526                                         LOGW("Failed to set display_visible '1' (0x%x)", ret);
 527                         }
 528                 }
 529                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK]) {
 530                         __ADD_MESSAGE(handle, PLAYER_MESSAGE_SEEK_DONE);
 531                 }
 532                 break;
 533         case MM_MESSAGE_PLAY_POSITION:
 534                 LOGI("MM_MESSAGE_PLAY_POSITION (%"PRId64" ns)", msg->time.elapsed);
 535                 handle->last_play_position = msg->time.elapsed;
 536                 break;
 537         case MM_MESSAGE_UNKNOWN:        /* 0x00 */
 538         case MM_MESSAGE_WARNING:        /* 0x02 */
 539         case MM_MESSAGE_CONNECTING:     /* 0x100 */
 540         case MM_MESSAGE_CONNECTED:      /* 0x101 */
 541         case MM_MESSAGE_BLUETOOTH_ON:   /* 0x106 */
 542         case MM_MESSAGE_BLUETOOTH_OFF:  /* 0x107 */
 543         case MM_MESSAGE_RTP_SENDER_REPORT:      /* 0x10a */
 544         case MM_MESSAGE_RTP_RECEIVER_REPORT:    /* 0x10b */
 545         case MM_MESSAGE_RTP_SESSION_STATUS:     /* 0x10c */
 546         case MM_MESSAGE_SENDER_STATE:   /* 0x10d */
 547         case MM_MESSAGE_RECEIVER_STATE: /* 0x10e */
 548         default:
 549                 break;
 550         }
 551
 552         if (err_code != PLAYER_ERROR_NONE && handle->user_cb[MUSE_PLAYER_EVENT_TYPE_ERROR]) {
 553                 handle->error_code = err_code;
 554                 __ADD_MESSAGE(handle, PLAYER_MESSAGE_ERROR);
 555         }
 556
 557         LPLAYER_FLEAVE();
 558         return 1;
 559 }
 560
 561 static MMDisplaySurfaceType __player_convert_display_type(player_display_type_e type)
 562 {
 563         switch (type) {
 564         case PLAYER_DISPLAY_TYPE_OVERLAY:
 565                 return MM_DISPLAY_SURFACE_OVERLAY;
 566         case PLAYER_DISPLAY_TYPE_EVAS: /* fall through ifndef TIZEN_FEATURE_EVAS_RENDERER */
 567 #ifdef TIZEN_FEATURE_EVAS_RENDERER
 568                 return MM_DISPLAY_SURFACE_REMOTE;
 569 #endif
 570         case PLAYER_DISPLAY_TYPE_NONE:  /* fall through */
 571         default:
 572                 return MM_DISPLAY_SURFACE_NULL;
 573         }
 574 }
 575
 576 bool _check_enabled_user_cb_lock(int type)
 577 {
 578         switch (type) {
 579         case MUSE_PLAYER_EVENT_TYPE_PREPARE:          /* fall through */
 580         case MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO:    /* fall through */
 581         case MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO:    /* fall through */
 582                 return true;
 583         default:
 584                 return false;
 585         }
 586 }
 587
 588 /*
 589  * Public Implementation
 590  */
 591
 592 int legacy_player_create(legacy_player_h *player)
 593 {
 594         legacy_player_t *handle;
 595         int ret = MM_ERROR_NONE;
 596
 597         PLAYER_INSTANCE_CHECK(player);
 598         PLAYER_TRACE_BEGIN("MM:PLAYER:CREATE");
 599
 600         handle = g_try_new0(legacy_player_t, 1);
 601         if (!handle) {
 602                 LOGE("PLAYER_ERROR_OUT_OF_MEMORY");
 603                 return PLAYER_ERROR_OUT_OF_MEMORY;
 604         }
 605         ret = mm_player_create(&handle->mm_handle);
 606         if (ret != MM_ERROR_NONE) {
 607                 LOGE("Failed to create player 0x%X", ret);
 608                 __player_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
 609                 g_free(handle);
 610                 handle = NULL;
 611                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 612         }
 613
 614         muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PREPARE;
 615
 616         *player = (legacy_player_h)handle;
 617         __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 618         handle->display_type = PLAYER_DISPLAY_TYPE_NONE;
 619         handle->is_display_visible = true;
 620         handle->is_media_stream = false;
 621
 622         for (type = MUSE_PLAYER_EVENT_TYPE_PREPARE; type < MUSE_PLAYER_EVENT_TYPE_NUM; type++) {
 623                 if (_check_enabled_user_cb_lock(type))
 624                         g_mutex_init(&handle->user_cb_lock[type]);
 625         }
 626
 627         handle->message_queue = g_queue_new();
 628         g_mutex_init(&handle->message_queue_lock);
 629         g_cond_init(&handle->message_queue_cond);
 630         ret = pthread_create(&handle->message_thread, NULL, (void *)__message_cb_loop, (void *)handle);
 631         if (ret != 0) {
 632                 LOGE("Failed to create message thread 0x%X", ret);
 633                 return PLAYER_ERROR_OUT_OF_MEMORY;
 634         }
 635
 636         LOGI("new handle : %p", *player);
 637         PLAYER_TRACE_END();
 638         return PLAYER_ERROR_NONE;
 639 }
 640
 641 int legacy_player_destroy(legacy_player_h player)
 642 {
 643         legacy_player_t *handle = (legacy_player_t *)player;
 644         int ret = MM_ERROR_NONE;
 645
 646         LOGI("<Enter: %p>", player);
 647         PLAYER_TRACE_BEGIN("MM:PLAYER:DESTROY");
 648         PLAYER_INSTANCE_CHECK(player);
 649
 650         handle->is_shutdown = true;
 651
 652         __ADD_MESSAGE(handle, PLAYER_MESSAGE_LOOP_EXIT);
 653
 654         LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 655         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 656                 handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 657                 g_free(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
 658                 handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 659         }
 660         LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 661
 662         /* stop the pause state trasition to release prepare thread */
 663         if (handle->internal_state == PLAYER_INTERNAL_STATE_PRE_READY)
 664                 mm_player_abort_pause(handle->mm_handle);
 665
 666         __RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread);
 667         __RELEASEIF_MESSAGE_THREAD(handle->message_thread);
 668
 669         ret = mm_player_destroy(handle->mm_handle);
 670         if (ret != MM_ERROR_NONE) {
 671                 LOGE("Failed to player destroy 0x%X", ret);
 672                 return PLAYER_ERROR_INVALID_OPERATION;
 673         }
 674         LOGI("Done mm_player_destroy");
 675
 676         muse_player_event_e type = MUSE_PLAYER_EVENT_TYPE_PREPARE;
 677
 678         __player_update_state(handle, PLAYER_INTERNAL_STATE_NONE);
 679
 680         for (type = MUSE_PLAYER_EVENT_TYPE_PREPARE; type < MUSE_PLAYER_EVENT_TYPE_NUM; type++) {
 681                 if (_check_enabled_user_cb_lock(type))
 682                         g_mutex_clear(&handle->user_cb_lock[type]);
 683         }
 684
 685         if (handle->message_queue) {
 686                 g_queue_free(handle->message_queue);
 687                 handle->message_queue = NULL;
 688         }
 689
 690         g_cond_broadcast(&handle->message_queue_cond);
 691         g_mutex_clear(&handle->message_queue_lock);
 692         g_cond_clear(&handle->message_queue_cond);
 693
 694         g_free(handle);
 695         handle = NULL;
 696
 697         LPLAYER_FLEAVE();
 698         PLAYER_TRACE_END();
 699         return PLAYER_ERROR_NONE;
 700 }
 701
 702 static void *__prepare_async_thread_func(void *data)
 703 {
 704         legacy_player_t *handle = data;
 705         int ret = MM_ERROR_NONE;
 706         LPLAYER_FENTER();
 707
 708         ret = mm_player_pause(handle->mm_handle);
 709         if (ret != MM_ERROR_NONE) {
 710                 LOGE("Failed to pause - core fw error(0x%x)", ret);
 711                 __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 712
 713                 if (handle->error_code == PLAYER_ERROR_NONE) {
 714                         /* if there is no received error msg, it has to be posted here. */
 715                         MMMessageParamType msg_param;
 716                         msg_param.code = ret;
 717                         __msg_callback(MM_MESSAGE_ERROR, (void *)&msg_param, (void *)handle);
 718                 }
 719
 720                 if (!handle->is_shutdown) {
 721                         ret = mm_player_unrealize(handle->mm_handle);
 722                         if (ret != MM_ERROR_NONE)
 723                                 LOGE("Failed to unrealize - 0x%x", ret);
 724                 }
 725         }
 726
 727         LPLAYER_FLEAVE();
 728         return NULL;
 729 }
 730
 731 int legacy_player_prepare_async(legacy_player_h player, player_prepared_cb callback, void *user_data)
 732 {
 733         legacy_player_t *handle = (legacy_player_t *)player;
 734         int ret = MM_ERROR_NONE;
 735         int visible = 0;
 736         int value = 0;
 737
 738         LPLAYER_FENTER();
 739         PLAYER_INSTANCE_CHECK(player);
 740         PLAYER_TRACE_ASYNC_BEGIN("MM:PLAYER:PREPARE_ASYNC", *(int *)handle);
 741         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 742
 743         __player_update_state(handle, PLAYER_INTERNAL_STATE_PRE_READY);
 744         LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 745
 746         handle->last_play_position = 0;
 747         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 748                 LOGE("player is already prepareing");
 749                 LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 750                 __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 751                 return PLAYER_ERROR_INVALID_OPERATION;
 752         }
 753
 754         /* LOGI("Event type : %d ", MUSE_PLAYER_EVENT_TYPE_PREPARE); */
 755         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = callback;
 756         handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = user_data;
 757
 758         LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 759
 760         ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle);
 761         if (ret != MM_ERROR_NONE)
 762                 LOGW("Failed to set message callback function (0x%x)", ret);
 763
 764         if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) {
 765                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char *)NULL);
 766                 if (ret != MM_ERROR_NONE)
 767                         LOGW("Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", ret);
 768         } else {
 769
 770                 /* FIXME : new funct path is needed to update video instead of set attr again */
 771                 ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &visible, (char *)NULL);
 772                 if (ret != MM_ERROR_NONE) goto ERROR;
 773
 774                 if (!visible)
 775                         value = FALSE;
 776                 else
 777                         value = TRUE;
 778
 779                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", value, (char *)NULL);
 780                 if (ret != MM_ERROR_NONE) goto ERROR;
 781         }
 782
 783         ret = mm_player_realize(handle->mm_handle);
 784         if (ret != MM_ERROR_NONE) {
 785                 LOGE("Failed to realize - 0x%x", ret);
 786                 goto ERROR;
 787         }
 788
 789         ret = pthread_create(&handle->prepare_async_thread, NULL, (void *)__prepare_async_thread_func, (void *)handle);
 790
 791         if (ret != 0) {
 792                 LOGE("Failed to create thread ret = %d", ret);
 793                 LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 794                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 795                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 796                         /* user_data will be free at player_disp_prepare_async() */
 797                         handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 798                 }
 799                 LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 800                 __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 801                 return PLAYER_ERROR_OUT_OF_MEMORY;
 802         }
 803
 804         LPLAYER_FLEAVE();
 805         return PLAYER_ERROR_NONE;
 806
 807 ERROR:
 808         LOGW("prepare cb is released");
 809         LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 810         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 811                 handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 812                 /* user_data will be free at player_disp_prepare_async() */
 813                 handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 814         }
 815         LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 816         __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 817
 818         LOGE("LEAVE 0x%X", ret);
 819         return __player_convert_error_code(ret, (char *)__FUNCTION__);
 820 }
 821
 822 int legacy_player_prepare(legacy_player_h player)
 823 {
 824         int ret = MM_ERROR_NONE;
 825         int visible = 0;
 826         legacy_player_t *handle = (legacy_player_t *)player;
 827
 828         LPLAYER_FENTER();
 829         PLAYER_TRACE_BEGIN("MM:PLAYER:PREPARE");
 830         PLAYER_INSTANCE_CHECK(player);
 831         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 832         __player_update_state(handle, PLAYER_INTERNAL_STATE_PRE_READY);
 833
 834         handle->last_play_position = 0;
 835         ret = mm_player_set_message_callback(handle->mm_handle, __msg_callback, (void *)handle);
 836         if (ret != MM_ERROR_NONE)
 837                 LOGW("Failed to set message callback function (0x%x)", ret);
 838
 839         if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE) {
 840                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", MM_DISPLAY_SURFACE_NULL, (char *)NULL);
 841                 if (ret != MM_ERROR_NONE)
 842                         LOGW("Failed to set display surface type 'MM_DISPLAY_SURFACE_NULL' (0x%x)", ret);
 843         } else {
 844                 ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &visible, (char *)NULL);
 845                 if (ret != MM_ERROR_NONE) {
 846                         __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 847                         return __player_convert_error_code(ret, (char *)__FUNCTION__);
 848                 }
 849
 850                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", visible, (char *)NULL);
 851                 if (ret != MM_ERROR_NONE)
 852                         LOGW("Failed to set display display_visible '%d' (0x%x)", visible, ret);
 853         }
 854
 855         ret = mm_player_realize(handle->mm_handle);
 856         if (ret != MM_ERROR_NONE) {
 857                 LOGE("Failed to realize - 0x%x", ret);
 858                 __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 859                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 860         }
 861
 862         ret = mm_player_pause(handle->mm_handle);
 863         if (ret != MM_ERROR_NONE) {
 864                 int uret;
 865                 uret = mm_player_unrealize(handle->mm_handle);
 866                 if (uret != MM_ERROR_NONE)
 867                         LOGE("Failed to unrealize - 0x%x", uret);
 868
 869                 LOGE("Failed to pause - 0x%x", ret);
 870                 __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 871                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 872         }
 873
 874         __player_update_state(handle, PLAYER_INTERNAL_STATE_READY);
 875
 876         LPLAYER_FLEAVE();
 877         PLAYER_TRACE_END();
 878         return PLAYER_ERROR_NONE;
 879 }
 880
 881 int legacy_player_unprepare(legacy_player_h player)
 882 {
 883         legacy_player_t *handle = (legacy_player_t *)player;
 884         int ret = MM_ERROR_NONE;
 885
 886         LPLAYER_FENTER();
 887         PLAYER_TRACE_BEGIN("MM:PLAYER:UNPREPARE");
 888         PLAYER_INSTANCE_CHECK(player);
 889
 890         handle->is_shutdown = true;
 891
 892         /* Initialize the setting regardless of error return */
 893         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK]) {
 894                 handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
 895                 handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
 896         }
 897
 898         if (!__player_state_validate(handle, PLAYER_STATE_READY) && !handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 899                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
 900                 return PLAYER_ERROR_INVALID_STATE;
 901         }
 902
 903         LEGACY_PLAYER_USER_CB_LOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 904         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE]) {
 905                 LOGW("Need to check. prepare cb have to be reset before");
 906                 handle->user_cb[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 907                 g_free(handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE]);
 908                 handle->user_data[MUSE_PLAYER_EVENT_TYPE_PREPARE] = NULL;
 909         }
 910         LEGACY_PLAYER_USER_CB_UNLOCK(handle, MUSE_PLAYER_EVENT_TYPE_PREPARE);
 911
 912         /* stop the pause state trasition to release prepare thread */
 913         if (handle->internal_state == PLAYER_INTERNAL_STATE_PRE_READY)
 914                 mm_player_abort_pause(handle->mm_handle);
 915
 916         __RELEASEIF_PREPARE_THREAD(handle->prepare_async_thread);
 917
 918         ret = mm_player_unrealize(handle->mm_handle);
 919         if (ret != MM_ERROR_NONE)
 920                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 921
 922         __player_update_state(handle, PLAYER_INTERNAL_STATE_IDLE);
 923         handle->is_display_visible = true;
 924
 925         LPLAYER_FLEAVE();
 926         PLAYER_TRACE_END();
 927         return PLAYER_ERROR_NONE;
 928 }
 929
 930 int legacy_player_set_uri(legacy_player_h player, const char *uri)
 931 {
 932         legacy_player_t *handle = (legacy_player_t *)player;
 933         int ret = MM_ERROR_NONE;
 934         PLAYER_INSTANCE_CHECK(player);
 935         PLAYER_NULL_ARG_CHECK(uri);
 936         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 937
 938         handle->is_media_stream = false;
 939         ret = mm_player_set_uri(handle->mm_handle, uri);
 940         if (ret != MM_ERROR_NONE)
 941                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 942
 943         return PLAYER_ERROR_NONE;
 944 }
 945
 946 int legacy_player_set_memory_buffer(legacy_player_h player, const void *data, int size)
 947 {
 948         legacy_player_t *handle = (legacy_player_t *)player;
 949         char uri[PATH_MAX];
 950         int ret = MM_ERROR_NONE;
 951         PLAYER_INSTANCE_CHECK(player);
 952         PLAYER_NULL_ARG_CHECK(data);
 953         PLAYER_CHECK_CONDITION(size >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
 954         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
 955
 956         handle->is_media_stream = FALSE;
 957
 958         snprintf(uri, sizeof(uri), "mem:///ext=%s,size=%d", "", size);
 959         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_CONTENT_URI, uri, strlen(uri), MM_PLAYER_MEMORY_SRC, data, size, (char *)NULL);
 960         if (ret != MM_ERROR_NONE)
 961                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 962
 963         return PLAYER_ERROR_NONE;
 964 }
 965
 966 int legacy_player_get_state(legacy_player_h player, player_state_e *state)
 967 {
 968         legacy_player_t *handle = (legacy_player_t *)player;
 969         PLAYER_INSTANCE_CHECK(player);
 970         PLAYER_NULL_ARG_CHECK(state);
 971         *state = handle->state;
 972         return PLAYER_ERROR_NONE;
 973 }
 974
 975 int legacy_player_set_volume(legacy_player_h player, float volume)
 976 {
 977         legacy_player_t *handle = (legacy_player_t *)player;
 978         int ret = MM_ERROR_NONE;
 979         PLAYER_INSTANCE_CHECK(player);
 980         PLAYER_CHECK_CONDITION(volume >= 0 && volume <= 1.0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
 981
 982         ret = mm_player_set_volume(handle->mm_handle, volume);
 983         if (ret != MM_ERROR_NONE)
 984                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 985
 986         return PLAYER_ERROR_NONE;
 987 }
 988
 989 int legacy_player_get_volume(legacy_player_h player, float *volume)
 990 {
 991         legacy_player_t *handle = (legacy_player_t *)player;
 992         int ret = MM_ERROR_NONE;
 993         PLAYER_INSTANCE_CHECK(player);
 994         PLAYER_NULL_ARG_CHECK(volume);
 995
 996         ret = mm_player_get_volume(handle->mm_handle, volume);
 997         if (ret != MM_ERROR_NONE) {
 998                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
 999         }
1000
1001         return PLAYER_ERROR_NONE;
1002 }
1003
1004 int legacy_player_set_sound_stream_info(legacy_player_h player, sound_stream_info_h stream_info)
1005 {
1006         legacy_player_t *handle = (legacy_player_t *)player;
1007         int ret = MM_ERROR_NONE;
1008         bool is_available = false;
1009         PLAYER_INSTANCE_CHECK(player);
1010         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
1011
1012         /* check if stream_info is valid */
1013         ret = sound_manager_is_available_stream_information(stream_info, NATIVE_API_PLAYER, &is_available);
1014         if (ret != MM_ERROR_NONE)
1015                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1016
1017         if (is_available) {
1018                 char *stream_type = NULL;
1019                 int stream_index = 0;
1020                 ret = sound_manager_get_type_from_stream_information(stream_info, &stream_type);
1021                 ret = sound_manager_get_index_from_stream_information(stream_info, &stream_index);
1022                 if (ret == SOUND_MANAGER_ERROR_NONE)
1023                         ret = mm_player_set_sound_stream_info(handle->mm_handle, stream_type, stream_index);
1024                 else
1025                         ret = MM_ERROR_PLAYER_INTERNAL;
1026         } else {
1027                 ret = MM_ERROR_NOT_SUPPORT_API;
1028         }
1029
1030         if (ret != MM_ERROR_NONE)
1031                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1032
1033         return PLAYER_ERROR_NONE;
1034 }
1035
1036 int legacy_player_set_audio_latency_mode(legacy_player_h player, audio_latency_mode_e latency_mode)
1037 {
1038         legacy_player_t *handle = (legacy_player_t *)player;
1039         int ret = MM_ERROR_NONE;
1040         PLAYER_INSTANCE_CHECK(player);
1041
1042         ret = mm_player_set_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL);
1043         if (ret != MM_ERROR_NONE)
1044                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1045
1046         return PLAYER_ERROR_NONE;
1047 }
1048
1049 int legacy_player_get_audio_latency_mode(legacy_player_h player, audio_latency_mode_e *latency_mode)
1050 {
1051         legacy_player_t *handle = (legacy_player_t *)player;
1052         int ret = MM_ERROR_NONE;
1053         PLAYER_INSTANCE_CHECK(player);
1054         PLAYER_NULL_ARG_CHECK(latency_mode);
1055
1056         ret = mm_player_get_attribute(handle->mm_handle, NULL, "sound_latency_mode", latency_mode, (char *)NULL);
1057         if (ret != MM_ERROR_NONE)
1058                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1059
1060         return PLAYER_ERROR_NONE;
1061 }
1062
1063 int legacy_player_start(legacy_player_h player)
1064 {
1065         legacy_player_t *handle = (legacy_player_t *)player;
1066         int ret = MM_ERROR_NONE;
1067
1068         LPLAYER_FENTER();
1069         PLAYER_INSTANCE_CHECK(player);
1070
1071         if (handle->state > PLAYER_STATE_IDLE) {
1072                 if (handle->display_type == PLAYER_DISPLAY_TYPE_OVERLAY && handle->is_display_visible) {
1073                         ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 1, (char *)NULL);
1074                         if (ret != MM_ERROR_NONE)
1075                                 LOGW("Failed to set display_visible '1' (0x%x)", ret);
1076                 }
1077                 if (handle->internal_state == PLAYER_INTERNAL_STATE_STOPPED) {
1078                         ret = mm_player_start(handle->mm_handle);
1079                         LOGI("stop -> start() ");
1080                 } else {
1081                         if (handle->state == PLAYER_STATE_READY)
1082                                 ret = mm_player_start(handle->mm_handle);
1083                         else
1084                                 ret = mm_player_resume(handle->mm_handle);
1085                 }
1086         } else {
1087                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1088                 return PLAYER_ERROR_INVALID_STATE;
1089         }
1090
1091         if (ret != MM_ERROR_NONE)
1092                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1093
1094         __player_update_state(handle, PLAYER_INTERNAL_STATE_PLAYING);
1095
1096         LPLAYER_FLEAVE();
1097         return PLAYER_ERROR_NONE;
1098 }
1099
1100 int legacy_player_stop(legacy_player_h player)
1101 {
1102         legacy_player_t *handle = (legacy_player_t *)player;
1103         int ret = MM_ERROR_NONE;
1104
1105         LPLAYER_FENTER();
1106         PLAYER_INSTANCE_CHECK(player);
1107
1108         if (handle->state == PLAYER_STATE_PLAYING || handle->state == PLAYER_STATE_PAUSED) {
1109                 if (handle->display_type == PLAYER_DISPLAY_TYPE_OVERLAY) {
1110                         ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", 0, (char *)NULL);
1111                         if (ret != MM_ERROR_NONE)
1112                                 LOGW("Failed to set display_visible '0' (0x%x)", ret);
1113                 }
1114
1115                 ret = mm_player_stop(handle->mm_handle);
1116                 if (ret != MM_ERROR_NONE) {
1117                         return __player_convert_error_code(ret, (char *)__FUNCTION__);
1118                 }
1119
1120                 if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK]) {
1121                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
1122                         handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
1123                 }
1124
1125                 __player_update_state(handle, PLAYER_INTERNAL_STATE_STOPPED);
1126
1127                 LPLAYER_FLEAVE();
1128                 return PLAYER_ERROR_NONE;
1129         }
1130
1131         LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1132         return PLAYER_ERROR_INVALID_STATE;
1133 }
1134
1135 int legacy_player_pause(legacy_player_h player)
1136 {
1137         legacy_player_t *handle = (legacy_player_t *)player;
1138         int ret = MM_ERROR_NONE;
1139
1140         LPLAYER_FENTER();
1141         PLAYER_INSTANCE_CHECK(player);
1142         PLAYER_STATE_CHECK(handle, PLAYER_STATE_PLAYING);
1143
1144         ret = mm_player_pause(handle->mm_handle);
1145         if (ret != MM_ERROR_NONE)
1146                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1147
1148         __player_update_state(handle, PLAYER_INTERNAL_STATE_PAUSED);
1149
1150         LPLAYER_FLEAVE();
1151         return PLAYER_ERROR_NONE;
1152 }
1153
1154 int legacy_player_set_play_position(legacy_player_h player, int64_t nanoseconds, bool accurate, player_seek_completed_cb callback, void *user_data)
1155 {
1156         legacy_player_t *handle = (legacy_player_t *)player;
1157         int ret = MM_ERROR_NONE;
1158         int accurated = accurate ? 1 : 0;
1159
1160         LPLAYER_FENTER();
1161         PLAYER_INSTANCE_CHECK(player);
1162         PLAYER_CHECK_CONDITION(nanoseconds >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
1163
1164         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1165                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1166                 return PLAYER_ERROR_INVALID_STATE;
1167         }
1168
1169         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] && !handle->is_media_stream) {
1170                 LOGE("previous seeking request is in processing.");
1171                 return PLAYER_ERROR_SEEK_FAILED;
1172         }
1173
1174         LOGI("Event type : %d, pos : %"PRId64, MUSE_PLAYER_EVENT_TYPE_SEEK, nanoseconds);
1175         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = callback;
1176         handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = user_data;
1177
1178         ret = mm_player_set_attribute(handle->mm_handle, NULL, "accurate_seek", accurated, (char *)NULL);
1179         if (ret != MM_ERROR_NONE)
1180                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1181
1182         ret = mm_player_set_position(handle->mm_handle, nanoseconds);
1183         if (ret != MM_ERROR_NONE) {
1184                 handle->user_cb[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
1185                 handle->user_data[MUSE_PLAYER_EVENT_TYPE_SEEK] = NULL;
1186                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1187         }
1188
1189         LPLAYER_FLEAVE();
1190         return PLAYER_ERROR_NONE;
1191 }
1192
1193 int legacy_player_get_play_position(legacy_player_h player, int64_t *nanoseconds)
1194 {
1195         legacy_player_t *handle = (legacy_player_t *)player;
1196         int ret = MM_ERROR_NONE;
1197         int64_t pos = 0;
1198         PLAYER_INSTANCE_CHECK(player);
1199         PLAYER_NULL_ARG_CHECK(nanoseconds);
1200
1201         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
1202                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1203                 return PLAYER_ERROR_INVALID_STATE;
1204         }
1205
1206         ret = mm_player_get_position(handle->mm_handle, &pos);
1207         if (ret != MM_ERROR_NONE) {
1208                 if (ret == MM_ERROR_PLAYER_NOT_INITIALIZED) {
1209                         /* During playbak if a interrupt is occurred, the player can be destroyed internally.
1210                            libmm-player will post position msg with last playback position before destory pipeline */
1211                         if (handle->state == PLAYER_STATE_IDLE) {
1212                                 if (handle->last_play_position > 0)
1213                                         *nanoseconds = handle->last_play_position;
1214                                 else
1215                                         *nanoseconds = 0;
1216                                 LOGD("position %"PRId64, *nanoseconds);
1217                                 return PLAYER_ERROR_NONE;
1218                         }
1219                 }
1220                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1221         }
1222
1223         *nanoseconds = pos;
1224         return PLAYER_ERROR_NONE;
1225 }
1226
1227 int legacy_player_set_mute(legacy_player_h player, bool muted)
1228 {
1229         legacy_player_t *handle = (legacy_player_t *)player;
1230         int ret = MM_ERROR_NONE;
1231         PLAYER_INSTANCE_CHECK(player);
1232
1233         ret = mm_player_set_mute(handle->mm_handle, muted);
1234         if (ret != MM_ERROR_NONE)
1235                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1236
1237         return PLAYER_ERROR_NONE;
1238 }
1239
1240 int legacy_player_is_muted(legacy_player_h player, bool *muted)
1241 {
1242         legacy_player_t *handle = (legacy_player_t *)player;
1243         int ret = MM_ERROR_NONE;
1244         PLAYER_INSTANCE_CHECK(player);
1245         PLAYER_NULL_ARG_CHECK(muted);
1246
1247         ret = mm_player_get_mute(handle->mm_handle, muted);
1248         if (ret != MM_ERROR_NONE)
1249                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1250
1251         return PLAYER_ERROR_NONE;
1252 }
1253
1254 int legacy_player_set_looping(legacy_player_h player, bool looping)
1255 {
1256         legacy_player_t *handle = (legacy_player_t *)player;
1257         int ret = MM_ERROR_NONE;
1258         int value = 0;
1259         PLAYER_INSTANCE_CHECK(player);
1260
1261         if (looping)
1262                 value = -1;
1263
1264         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PLAYBACK_COUNT, value, (char *)NULL);
1265         if (ret != MM_ERROR_NONE)
1266                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1267
1268         return PLAYER_ERROR_NONE;
1269 }
1270
1271 int legacy_player_is_looping(legacy_player_h player, bool *looping)
1272 {
1273         legacy_player_t *handle = (legacy_player_t *)player;
1274         int ret = MM_ERROR_NONE;
1275         int count;
1276         PLAYER_INSTANCE_CHECK(player);
1277         PLAYER_NULL_ARG_CHECK(looping);
1278
1279         ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PLAYBACK_COUNT, &count, (char *)NULL);
1280         if (ret != MM_ERROR_NONE)
1281                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1282
1283         *looping = (count == -1) ? true : false;
1284
1285         return PLAYER_ERROR_NONE;
1286 }
1287
1288 int legacy_player_get_duration(legacy_player_h player, int64_t *duration)
1289 {
1290         legacy_player_t *handle = (legacy_player_t *)player;
1291         int ret = MM_ERROR_NONE;
1292         PLAYER_INSTANCE_CHECK(player);
1293         PLAYER_NULL_ARG_CHECK(duration);
1294
1295         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1296                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1297                 return PLAYER_ERROR_INVALID_STATE;
1298         }
1299
1300         ret = mm_player_get_duration(handle->mm_handle, duration);
1301         if (ret != MM_ERROR_NONE)
1302                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1303
1304         LOGD("content dur: %"PRId64, *duration);
1305         return PLAYER_ERROR_NONE;
1306 }
1307
1308 int legacy_player_set_display_mode(legacy_player_h player, player_display_mode_e mode)
1309 {
1310         legacy_player_t *handle = (legacy_player_t *)player;
1311         int ret = MM_ERROR_NONE;
1312
1313         LOGI("<ENTER: mode:%d>", mode);
1314         PLAYER_INSTANCE_CHECK(player);
1315
1316         ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_method", mode, (char *)NULL);
1317         if (ret != MM_ERROR_NONE)
1318                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1319
1320         return PLAYER_ERROR_NONE;
1321 }
1322
1323 int legacy_player_get_display_mode(legacy_player_h player, player_display_mode_e *mode)
1324 {
1325         legacy_player_t *handle = (legacy_player_t *)player;
1326         int ret = MM_ERROR_NONE;
1327         PLAYER_INSTANCE_CHECK(player);
1328         PLAYER_NULL_ARG_CHECK(mode);
1329
1330         ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_method", mode, (char *)NULL);
1331         if (ret != MM_ERROR_NONE)
1332                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1333
1334         return PLAYER_ERROR_NONE;
1335 }
1336
1337 int legacy_player_set_playback_rate(legacy_player_h player, float rate)
1338 {
1339         legacy_player_t *handle = (legacy_player_t *)player;
1340         int ret = MM_ERROR_NONE;
1341         LOGI("<ENTER: rate %0.1f>", rate);
1342         PLAYER_INSTANCE_CHECK(player);
1343         PLAYER_CHECK_CONDITION(rate >= -5.0 && rate <= 5.0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
1344
1345         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1346                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1347                 return PLAYER_ERROR_INVALID_STATE;
1348         }
1349
1350         ret = mm_player_set_play_speed(handle->mm_handle, rate, false);
1351         switch (ret) {
1352         case MM_ERROR_NONE:
1353         case MM_ERROR_PLAYER_NO_OP:
1354                 ret = PLAYER_ERROR_NONE;
1355                 break;
1356         case MM_ERROR_NOT_SUPPORT_API:
1357         case MM_ERROR_PLAYER_SEEK:
1358                 LOGE("PLAYER_ERROR_INVALID_OPERATION : seek error");
1359                 ret = PLAYER_ERROR_INVALID_OPERATION;
1360                 break;
1361         default:
1362                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1363         }
1364
1365         return ret;
1366 }
1367
1368 int legacy_player_set_display_rotation(legacy_player_h player, player_display_rotation_e rotation)
1369 {
1370         legacy_player_t *handle = (legacy_player_t *)player;
1371         int ret = MM_ERROR_NONE;
1372         PLAYER_INSTANCE_CHECK(player);
1373
1374         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_ROTATION, rotation, (char *)NULL);
1375         if (ret != MM_ERROR_NONE)
1376                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1377
1378         return PLAYER_ERROR_NONE;
1379 }
1380
1381 int legacy_player_get_display_rotation(legacy_player_h player, player_display_rotation_e *rotation)
1382 {
1383         legacy_player_t *handle = (legacy_player_t *)player;
1384         int ret = MM_ERROR_NONE;
1385         PLAYER_INSTANCE_CHECK(player);
1386         PLAYER_NULL_ARG_CHECK(rotation);
1387
1388         ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_ROTATION, rotation, (char *)NULL);
1389         if (ret != MM_ERROR_NONE)
1390                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1391
1392         return PLAYER_ERROR_NONE;
1393 }
1394
1395 int legacy_player_set_display_visible(legacy_player_h player, bool visible)
1396 {
1397         legacy_player_t *handle = (legacy_player_t *)player;
1398         int ret = MM_ERROR_NONE;
1399         int value = 0;
1400         PLAYER_INSTANCE_CHECK(player);
1401
1402         if (visible)
1403                 value = 1;
1404
1405         ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_visible", value, (char *)NULL);
1406         if (ret != MM_ERROR_NONE)
1407                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1408
1409         handle->is_display_visible = visible;
1410         return PLAYER_ERROR_NONE;
1411 }
1412
1413 int legacy_player_is_display_visible(legacy_player_h player, bool *visible)
1414 {
1415         legacy_player_t *handle = (legacy_player_t *)player;
1416         int ret = MM_ERROR_NONE;
1417         int value;
1418         PLAYER_INSTANCE_CHECK(player);
1419         PLAYER_NULL_ARG_CHECK(visible);
1420
1421         ret = mm_player_get_attribute(handle->mm_handle, NULL, "display_visible", &value, (char *)NULL);
1422         if (ret != MM_ERROR_NONE)
1423                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1424
1425         *visible = (value == 0) ? false : true;
1426
1427         return PLAYER_ERROR_NONE;
1428 }
1429
1430 int legacy_player_get_content_info(legacy_player_h player, player_content_info_e key, char **value)
1431 {
1432         legacy_player_t *handle = (legacy_player_t *)player;
1433         int ret = MM_ERROR_NONE;
1434         char *attr = NULL;
1435         char *val = NULL;
1436         int val_len = 0;
1437         PLAYER_INSTANCE_CHECK(player);
1438         PLAYER_NULL_ARG_CHECK(value);
1439
1440         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1441                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1442                 return PLAYER_ERROR_INVALID_STATE;
1443         }
1444
1445         switch (key) {
1446         case PLAYER_CONTENT_INFO_ALBUM:
1447                 attr = MM_PLAYER_TAG_ALBUM;
1448                 break;
1449         case PLAYER_CONTENT_INFO_ARTIST:
1450                 attr = MM_PLAYER_TAG_ARTIST;
1451                 break;
1452         case PLAYER_CONTENT_INFO_AUTHOR:
1453                 attr = MM_PLAYER_TAG_AUTHOUR;
1454                 break;
1455         case PLAYER_CONTENT_INFO_GENRE:
1456                 attr = MM_PLAYER_TAG_GENRE;
1457                 break;
1458         case PLAYER_CONTENT_INFO_TITLE:
1459                 attr = MM_PLAYER_TAG_TITLE;
1460                 break;
1461         case PLAYER_CONTENT_INFO_YEAR:
1462                 attr = MM_PLAYER_TAG_DATE;
1463                 break;
1464         default:
1465                 attr = NULL;
1466         }
1467
1468         ret = mm_player_get_attribute(handle->mm_handle, NULL, attr, &val, &val_len, (char *)NULL);
1469         if (ret != MM_ERROR_NONE)
1470                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1471
1472         *value = NULL;
1473         if (val != NULL)
1474                 *value = strndup(val, val_len);
1475         else
1476                 *value = strndup("", 0);
1477
1478         if (*value == NULL) {
1479                 LOGE("PLAYER_ERROR_OUT_OF_MEMORY : fail to strdup");
1480                 return PLAYER_ERROR_OUT_OF_MEMORY;
1481         }
1482
1483         return PLAYER_ERROR_NONE;
1484 }
1485
1486 int legacy_player_get_codec_info(legacy_player_h player, char **audio_codec, char **video_codec)
1487 {
1488         legacy_player_t *handle = (legacy_player_t *)player;
1489         int ret = MM_ERROR_NONE;
1490         char *audio = NULL;
1491         int audio_len = 0;
1492         char *video = NULL;
1493         int video_len = 0;
1494         PLAYER_INSTANCE_CHECK(player);
1495         PLAYER_NULL_ARG_CHECK(audio_codec);
1496         PLAYER_NULL_ARG_CHECK(video_codec);
1497
1498         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1499                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1500                 return PLAYER_ERROR_INVALID_STATE;
1501         }
1502
1503         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);
1504         if (ret != MM_ERROR_NONE)
1505                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1506
1507         *audio_codec = NULL;
1508         if (audio != NULL)
1509                 *audio_codec = strndup(audio, audio_len);
1510         else
1511                 *audio_codec = strndup("", 0);
1512
1513         *video_codec = NULL;
1514         if (video != NULL)
1515                 *video_codec = strndup(video, video_len);
1516         else
1517                 *video_codec = strndup("", 0);
1518
1519         LOGD("codec info: %s, %s", *audio_codec, *video_codec);
1520         return PLAYER_ERROR_NONE;
1521 }
1522
1523 int legacy_player_get_audio_stream_info(legacy_player_h player, int *sample_rate, int *channel, int *bit_rate)
1524 {
1525         legacy_player_t *handle = (legacy_player_t *)player;
1526         int ret = MM_ERROR_NONE;
1527         PLAYER_INSTANCE_CHECK(player);
1528         PLAYER_NULL_ARG_CHECK(sample_rate);
1529         PLAYER_NULL_ARG_CHECK(channel);
1530         PLAYER_NULL_ARG_CHECK(bit_rate);
1531
1532         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1533                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1534                 return PLAYER_ERROR_INVALID_STATE;
1535         }
1536         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);
1537         if (ret != MM_ERROR_NONE)
1538                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1539
1540         return PLAYER_ERROR_NONE;
1541 }
1542
1543 int legacy_player_get_video_stream_info(legacy_player_h player, int *fps, int *bit_rate)
1544 {
1545         legacy_player_t *handle = (legacy_player_t *)player;
1546         int ret = MM_ERROR_NONE;
1547         PLAYER_INSTANCE_CHECK(player);
1548         PLAYER_NULL_ARG_CHECK(fps);
1549         PLAYER_NULL_ARG_CHECK(bit_rate);
1550
1551         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1552                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1553                 return PLAYER_ERROR_INVALID_STATE;
1554         }
1555         ret = mm_player_get_attribute(handle->mm_handle, NULL, "content_video_fps", fps, "content_video_bitrate", bit_rate, (char *)NULL);
1556         if (ret != MM_ERROR_NONE)
1557                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1558
1559         return PLAYER_ERROR_NONE;
1560 }
1561
1562 int legacy_player_get_video_size(legacy_player_h player, int *width, int *height)
1563 {
1564         legacy_player_t *handle = (legacy_player_t *)player;
1565         int ret = MM_ERROR_NONE;
1566         int w;
1567         int h;
1568         PLAYER_INSTANCE_CHECK(player);
1569         PLAYER_NULL_ARG_CHECK(width);
1570         PLAYER_NULL_ARG_CHECK(height);
1571         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1572                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1573                 return PLAYER_ERROR_INVALID_STATE;
1574         }
1575         ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_VIDEO_WIDTH, &w, MM_PLAYER_VIDEO_HEIGHT, &h, (char *)NULL);
1576         if (ret != MM_ERROR_NONE)
1577                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1578
1579         *width = w;
1580         *height = h;
1581         LOGI("width : %d, height : %d", w, h);
1582         return PLAYER_ERROR_NONE;
1583 }
1584
1585 int legacy_player_get_album_art(legacy_player_h player, void **album_art, int *size)
1586 {
1587         legacy_player_t *handle = (legacy_player_t *)player;
1588         int ret = MM_ERROR_NONE;
1589         PLAYER_INSTANCE_CHECK(player);
1590         PLAYER_NULL_ARG_CHECK(size);
1591         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1592                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1593                 return PLAYER_ERROR_INVALID_STATE;
1594         }
1595
1596         ret = mm_player_get_attribute(handle->mm_handle, NULL, "tag_album_cover", album_art, size, (char *)NULL);
1597         if (ret != MM_ERROR_NONE)
1598                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1599
1600         return PLAYER_ERROR_NONE;
1601 }
1602
1603 int legacy_player_audio_effect_get_equalizer_bands_count(legacy_player_h player, int *count)
1604 {
1605         legacy_player_t *handle = (legacy_player_t *)player;
1606         int ret = MM_ERROR_NONE;
1607         PLAYER_INSTANCE_CHECK(player);
1608         PLAYER_NULL_ARG_CHECK(count);
1609
1610         ret = mm_player_audio_effect_custom_get_eq_bands_number(handle->mm_handle, count);
1611         if (ret != MM_ERROR_NONE)
1612                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1613
1614         return PLAYER_ERROR_NONE;
1615 }
1616
1617 int legacy_player_audio_effect_set_equalizer_all_bands(legacy_player_h player, int *band_levels, int length)
1618 {
1619         legacy_player_t *handle = (legacy_player_t *)player;
1620         int ret = MM_ERROR_NONE;
1621         PLAYER_INSTANCE_CHECK(player);
1622         PLAYER_NULL_ARG_CHECK(band_levels);
1623
1624         ret = mm_player_audio_effect_custom_set_level_eq_from_list(handle->mm_handle, band_levels, length);
1625         if (ret != MM_ERROR_NONE)
1626                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1627
1628         ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
1629         return (ret == MM_ERROR_NONE) ? PLAYER_ERROR_NONE : __player_convert_error_code(ret, (char *)__FUNCTION__);
1630 }
1631
1632 int legacy_player_audio_effect_set_equalizer_band_level(legacy_player_h player, int index, int level)
1633 {
1634         legacy_player_t *handle = (legacy_player_t *)player;
1635         int ret = MM_ERROR_NONE;
1636         PLAYER_INSTANCE_CHECK(player);
1637
1638         ret = mm_player_audio_effect_custom_set_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
1639         if (ret != MM_ERROR_NONE)
1640                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1641
1642         ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
1643         if (ret != MM_ERROR_NONE)
1644                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1645
1646         return PLAYER_ERROR_NONE;
1647 }
1648
1649 int legacy_player_audio_effect_get_equalizer_band_level(legacy_player_h player, int index, int *level)
1650 {
1651         legacy_player_t *handle = (legacy_player_t *)player;
1652         int ret = MM_ERROR_NONE;
1653         PLAYER_INSTANCE_CHECK(player);
1654         PLAYER_NULL_ARG_CHECK(level);
1655
1656         ret = mm_player_audio_effect_custom_get_level(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, index, level);
1657         if (ret != MM_ERROR_NONE)
1658                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1659
1660         return PLAYER_ERROR_NONE;
1661 }
1662
1663 int legacy_player_audio_effect_get_equalizer_level_range(legacy_player_h player, int *min, int *max)
1664 {
1665         legacy_player_t *handle = (legacy_player_t *)player;
1666         int ret = MM_ERROR_NONE;
1667         PLAYER_INSTANCE_CHECK(player);
1668         PLAYER_NULL_ARG_CHECK(min);
1669         PLAYER_NULL_ARG_CHECK(max);
1670
1671         ret = mm_player_audio_effect_custom_get_level_range(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ, min, max);
1672         if (ret != MM_ERROR_NONE)
1673                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1674
1675         return PLAYER_ERROR_NONE;
1676 }
1677
1678 int legacy_player_audio_effect_get_equalizer_band_frequency(legacy_player_h player, int index, int *frequency)
1679 {
1680         legacy_player_t *handle = (legacy_player_t *)player;
1681         int ret = MM_ERROR_NONE;
1682         PLAYER_INSTANCE_CHECK(player);
1683         PLAYER_NULL_ARG_CHECK(frequency);
1684
1685         ret = mm_player_audio_effect_custom_get_eq_bands_freq(handle->mm_handle, index, frequency);
1686         if (ret != MM_ERROR_NONE)
1687                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1688
1689         return PLAYER_ERROR_NONE;
1690 }
1691
1692 int legacy_player_audio_effect_get_equalizer_band_frequency_range(legacy_player_h player, int index, int *range)
1693 {
1694         legacy_player_t *handle = (legacy_player_t *)player;
1695         int ret = MM_ERROR_NONE;
1696         PLAYER_INSTANCE_CHECK(player);
1697         PLAYER_NULL_ARG_CHECK(range);
1698
1699         ret = mm_player_audio_effect_custom_get_eq_bands_width(handle->mm_handle, index, range);
1700         if (ret != MM_ERROR_NONE)
1701                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1702
1703         return PLAYER_ERROR_NONE;
1704 }
1705
1706 int legacy_player_audio_effect_equalizer_clear(legacy_player_h player)
1707 {
1708         legacy_player_t *handle = (legacy_player_t *)player;
1709         int ret = MM_ERROR_NONE;
1710         PLAYER_INSTANCE_CHECK(player);
1711
1712         ret = mm_player_audio_effect_custom_clear_eq_all(handle->mm_handle);
1713         if (ret != MM_ERROR_NONE)
1714                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1715
1716         ret = mm_player_audio_effect_custom_apply(handle->mm_handle);
1717         if (ret != MM_ERROR_NONE)
1718                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1719
1720         return PLAYER_ERROR_NONE;
1721 }
1722
1723 int legacy_player_audio_effect_equalizer_is_available(legacy_player_h player, bool *available)
1724 {
1725         legacy_player_t *handle = (legacy_player_t *)player;
1726         int ret = MM_ERROR_NONE;
1727         PLAYER_INSTANCE_CHECK(player);
1728         PLAYER_NULL_ARG_CHECK(available);
1729         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
1730                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1731                 return PLAYER_ERROR_INVALID_STATE;
1732         }
1733
1734         ret = mm_player_is_supported_custom_effect_type(handle->mm_handle, MM_AUDIO_EFFECT_CUSTOM_EQ);
1735         if (ret != MM_ERROR_NONE)
1736                 *available = false;
1737         else
1738                 *available = true;
1739
1740         return PLAYER_ERROR_NONE;
1741 }
1742
1743 int legacy_player_set_subtitle_path(legacy_player_h player, const char *path)
1744 {
1745         legacy_player_t *handle = (legacy_player_t *)player;
1746         int ret = MM_ERROR_NONE;
1747
1748         LPLAYER_FENTER();
1749         PLAYER_INSTANCE_CHECK(player);
1750
1751         if ((path == NULL) && (handle->state != PLAYER_STATE_IDLE))
1752                 return PLAYER_ERROR_INVALID_PARAMETER;
1753
1754         ret = mm_player_set_external_subtitle_path(handle->mm_handle, path);
1755         if (ret != MM_ERROR_NONE)
1756                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1757
1758         LPLAYER_FLEAVE();
1759         return PLAYER_ERROR_NONE;
1760 }
1761
1762 int legacy_player_set_subtitle_position_offset(legacy_player_h player, int millisecond)
1763 {
1764         /* PLAYER_CHECK_CONDITION(millisecond>=0  ,PLAYER_ERROR_INVALID_PARAMETER ,"PLAYER_ERROR_INVALID_PARAMETER" ); */
1765         legacy_player_t *handle = (legacy_player_t *)player;
1766         int ret = MM_ERROR_NONE;
1767         PLAYER_INSTANCE_CHECK(player);
1768         if (!__player_state_validate(handle, PLAYER_STATE_PLAYING)) {
1769                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1770                 return PLAYER_ERROR_INVALID_STATE;
1771         }
1772
1773         ret = mm_player_adjust_subtitle_position(handle->mm_handle, millisecond);
1774         if (ret != MM_ERROR_NONE)
1775                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1776
1777         return PLAYER_ERROR_NONE;
1778 }
1779
1780 int legacy_player_capture_video(legacy_player_h player, player_video_captured_cb callback, void *user_data)
1781 {
1782         legacy_player_t *handle = (legacy_player_t *)player;
1783         int ret = MM_ERROR_NONE;
1784
1785         LPLAYER_FENTER();
1786         PLAYER_INSTANCE_CHECK(player);
1787         PLAYER_NULL_ARG_CHECK(callback);
1788         if (handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE]) {
1789                 LOGE("previous capturing request is in processing.");
1790                 return PLAYER_ERROR_VIDEO_CAPTURE_FAILED;
1791         }
1792
1793         LOGI("Event type : %d ", MUSE_PLAYER_EVENT_TYPE_CAPTURE);
1794         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = callback;
1795         handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = user_data;
1796
1797         if (handle->state >= PLAYER_STATE_READY) {
1798                 ret = mm_player_do_video_capture(handle->mm_handle);
1799                 if (ret == MM_ERROR_PLAYER_NO_OP) {
1800                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
1801                         handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
1802                         LOGE("PLAYER_ERROR_INVALID_OPERATION : video display must be set : %d", handle->display_type);
1803                         return PLAYER_ERROR_INVALID_OPERATION;
1804                 }
1805                 if (ret != MM_ERROR_NONE) {
1806                         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
1807                         handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
1808                         return __player_convert_error_code(ret, (char *)__FUNCTION__);
1809                 }
1810                 return PLAYER_ERROR_NONE;
1811         }
1812
1813         LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
1814         handle->user_cb[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
1815         handle->user_data[MUSE_PLAYER_EVENT_TYPE_CAPTURE] = NULL;
1816
1817         LPLAYER_FLEAVE();
1818         return PLAYER_ERROR_INVALID_STATE;
1819 }
1820
1821 int legacy_player_set_streaming_cookie(legacy_player_h player, const char *cookie, int size)
1822 {
1823         legacy_player_t *handle = (legacy_player_t *)player;
1824         int ret = MM_ERROR_NONE;
1825         PLAYER_INSTANCE_CHECK(player);
1826         PLAYER_NULL_ARG_CHECK(cookie);
1827         PLAYER_CHECK_CONDITION(size >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
1828         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
1829
1830         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_STREAMING_COOKIE, cookie, size, (char *)NULL);
1831         if (ret != MM_ERROR_NONE)
1832                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1833
1834         return PLAYER_ERROR_NONE;
1835 }
1836
1837 int legacy_player_set_streaming_user_agent(legacy_player_h player, const char *user_agent, int size)
1838 {
1839         legacy_player_t *handle = (legacy_player_t *)player;
1840         int ret = MM_ERROR_NONE;
1841         PLAYER_INSTANCE_CHECK(player);
1842         PLAYER_NULL_ARG_CHECK(user_agent);
1843         PLAYER_CHECK_CONDITION(size >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
1844         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
1845
1846         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_STREAMING_USER_AGENT, user_agent, size, (char *)NULL);
1847         if (ret != MM_ERROR_NONE)
1848                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1849
1850         return PLAYER_ERROR_NONE;
1851 }
1852
1853 int legacy_player_get_streaming_download_progress(legacy_player_h player, int *start_pos, int *end_pos)
1854 {
1855         legacy_player_t *handle = (legacy_player_t *)player;
1856         int ret = MM_ERROR_NONE;
1857         PLAYER_INSTANCE_CHECK(player);
1858         PLAYER_NULL_ARG_CHECK(start_pos && end_pos);
1859         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
1860                 LOGE("invalid state error, current state - %d", handle->state);
1861                 return PLAYER_ERROR_INVALID_STATE;
1862         }
1863
1864         ret = mm_player_get_buffer_position(handle->mm_handle, start_pos, end_pos);
1865         if (ret != MM_ERROR_NONE)
1866                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1867
1868         return PLAYER_ERROR_NONE;
1869 }
1870
1871 int legacy_player_set_completed_cb(legacy_player_h player, player_completed_cb callback, void *user_data)
1872 {
1873         return __set_callback(MUSE_PLAYER_EVENT_TYPE_COMPLETE, player, callback, user_data);
1874 }
1875
1876 int legacy_player_unset_completed_cb(legacy_player_h player)
1877 {
1878         return __unset_callback(MUSE_PLAYER_EVENT_TYPE_COMPLETE, player);
1879 }
1880
1881 #ifdef TIZEN_FEATURE_EVAS_RENDERER
1882 int legacy_player_set_retrieve_buffer_cb(legacy_player_h player, player_retrieve_buffer_cb callback, void *user_data)
1883 {
1884         return __set_callback(MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER, player, callback, user_data);
1885 }
1886
1887 int legacy_player_unset_retrieve_buffer_cb(legacy_player_h player)
1888 {
1889         return __unset_callback(MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER, player);
1890 }
1891 #endif
1892
1893 int legacy_player_set_interrupted_cb(legacy_player_h player, player_interrupted_cb callback, void *user_data)
1894 {
1895         return __set_callback(MUSE_PLAYER_EVENT_TYPE_INTERRUPT, player, callback, user_data);
1896 }
1897
1898 int legacy_player_unset_interrupted_cb(legacy_player_h player)
1899 {
1900         return __unset_callback(MUSE_PLAYER_EVENT_TYPE_INTERRUPT, player);
1901 }
1902
1903 int legacy_player_set_error_cb(legacy_player_h player, player_error_cb callback, void *user_data)
1904 {
1905         return __set_callback(MUSE_PLAYER_EVENT_TYPE_ERROR, player, callback, user_data);
1906 }
1907
1908 int legacy_player_unset_error_cb(legacy_player_h player)
1909 {
1910         return __unset_callback(MUSE_PLAYER_EVENT_TYPE_ERROR, player);
1911 }
1912
1913 int legacy_player_set_buffering_cb(legacy_player_h player, player_buffering_cb callback, void *user_data)
1914 {
1915         return __set_callback(MUSE_PLAYER_EVENT_TYPE_BUFFERING, player, callback, user_data);
1916 }
1917
1918 int legacy_player_unset_buffering_cb(legacy_player_h player)
1919 {
1920         return __unset_callback(MUSE_PLAYER_EVENT_TYPE_BUFFERING, player);
1921 }
1922
1923 int legacy_player_set_subtitle_updated_cb(legacy_player_h player, player_subtitle_updated_cb callback, void *user_data)
1924 {
1925         return __set_callback(MUSE_PLAYER_EVENT_TYPE_SUBTITLE, player, callback, user_data);
1926 }
1927
1928 int legacy_player_unset_subtitle_updated_cb(legacy_player_h player)
1929 {
1930         return __unset_callback(MUSE_PLAYER_EVENT_TYPE_SUBTITLE, player);
1931 }
1932
1933 int legacy_player_release_video_stream_bo(legacy_player_h player, void *bo)
1934 {
1935         legacy_player_t *handle = (legacy_player_t *)player;
1936         PLAYER_INSTANCE_CHECK(player);
1937
1938         LOGD("ENTER %p %p", player, bo);
1939
1940         mm_player_release_video_stream_bo(handle->mm_handle, bo);
1941
1942         LOGD("LEAVE");
1943
1944         return PLAYER_ERROR_NONE;
1945 }
1946
1947 int legacy_player_set_media_packet_video_frame_decoded_cb(legacy_player_h player, legacy_player_media_packet_video_decoded_cb callback, void *user_data)
1948 {
1949         legacy_player_t *handle = (legacy_player_t *)player;
1950         int ret = MM_ERROR_NONE;
1951         PLAYER_INSTANCE_CHECK(player);
1952         PLAYER_NULL_ARG_CHECK(callback);
1953         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
1954
1955         ret = mm_player_set_video_decoded_callback(handle->mm_handle, (mm_player_video_decoded_callback)callback, user_data);
1956         if (ret != MM_ERROR_NONE)
1957                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
1958
1959         return PLAYER_ERROR_NONE;
1960 }
1961
1962 static bool __video_stream_changed_callback(void *user_data)
1963 {
1964         legacy_player_t *handle = (legacy_player_t *)user_data;
1965         int ret = MM_ERROR_NONE;
1966         muse_player_event_e event_type = MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED;
1967
1968         LOGE("event type %d", event_type);
1969
1970         if (handle->user_cb[event_type]) {
1971                 int width = 0, height = 0, fps = 0, bit_rate = 0;
1972                 ret = mm_player_get_attribute(handle->mm_handle, NULL,
1973                                                                                   MM_PLAYER_VIDEO_WIDTH, &width,
1974                                                                                   MM_PLAYER_VIDEO_HEIGHT, &height,
1975                                                                                   "content_video_fps", &fps,
1976                                                                                   "content_video_bitrate", &bit_rate, (char *)NULL);
1977
1978                 if (ret != MM_ERROR_NONE) {
1979                         LOGE("get attr is failed");
1980                         return false;
1981                 }
1982                 ((player_video_stream_changed_cb)handle->user_cb[event_type])(width, height, fps, bit_rate, handle->user_data[event_type]);
1983                 return true;
1984         }
1985
1986         LOGE("video stream changed cb was not set.");
1987         return false;
1988 }
1989
1990 int legacy_player_set_video_stream_changed_cb(legacy_player_h player, player_video_stream_changed_cb callback, void *user_data)
1991 {
1992         legacy_player_t *handle = (legacy_player_t *)player;
1993         int ret = MM_ERROR_NONE;
1994         PLAYER_INSTANCE_CHECK(player);
1995         PLAYER_NULL_ARG_CHECK(callback);
1996         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
1997
1998         ret = mm_player_set_video_stream_changed_callback(handle->mm_handle, (mm_player_stream_changed_callback)__video_stream_changed_callback, (void *)handle);
1999         if (ret != MM_ERROR_NONE)
2000                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2001
2002         return __set_callback(MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED, player, callback, user_data);
2003 }
2004
2005 int legacy_player_unset_video_stream_changed_cb(legacy_player_h player)
2006 {
2007         PLAYER_INSTANCE_CHECK(player);
2008
2009         __unset_callback(MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED, player);
2010
2011         return PLAYER_ERROR_NONE;
2012 }
2013
2014 static bool __media_stream_buffer_status_callback(player_stream_type_e type, player_media_stream_buffer_status_e status, unsigned long long bytes, void *user_data)
2015 {
2016         legacy_player_t *handle = (legacy_player_t *)user_data;
2017         muse_player_event_e event_type;
2018
2019         if (type == PLAYER_STREAM_TYPE_AUDIO)
2020                 event_type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS;
2021         else if (type == PLAYER_STREAM_TYPE_VIDEO)
2022                 event_type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS;
2023         else
2024                 return false;
2025
2026         LOGE("event type %d", event_type);
2027
2028         if (handle->user_cb[event_type]) {
2029                 ((player_media_stream_buffer_status_cb)handle->user_cb[event_type])(status, handle->user_data[event_type]);
2030         } else {
2031                 LOGE("[type:%d] buffer status cb was not set.", type);
2032                 return false;
2033         }
2034
2035         return true;
2036 }
2037
2038 static bool __media_stream_seek_data_callback(player_stream_type_e type, unsigned long long offset, void *user_data)
2039 {
2040         legacy_player_t *handle = (legacy_player_t *)user_data;
2041         muse_player_event_e event_type;
2042
2043         if (type == PLAYER_STREAM_TYPE_AUDIO)
2044                 event_type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK;
2045         else if (type == PLAYER_STREAM_TYPE_VIDEO)
2046                 event_type = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK;
2047         else
2048                 return false;
2049
2050         LOGE("event type %d", event_type);
2051
2052         if (handle->user_cb[event_type]) {
2053                 ((player_media_stream_seek_cb)handle->user_cb[event_type])(offset, handle->user_data[event_type]);
2054         } else {
2055                 LOGE("[type:%d] seek cb was not set.", type);
2056                 return false;
2057         }
2058
2059         return true;
2060 }
2061
2062 int legacy_player_set_media_stream_buffer_status_cb(legacy_player_h player, player_stream_type_e type, player_media_stream_buffer_status_cb callback, void *user_data)
2063 {
2064         legacy_player_t *handle = (legacy_player_t *)player;
2065         int ret = MM_ERROR_NONE;
2066         PLAYER_INSTANCE_CHECK(player);
2067         PLAYER_NULL_ARG_CHECK(callback);
2068         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
2069
2070         /* the type can be expaned with default and text. */
2071         if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) {
2072                 LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", type);
2073                 return PLAYER_ERROR_INVALID_PARAMETER;
2074         }
2075
2076         ret = mm_player_set_media_stream_buffer_status_callback(handle->mm_handle, type, (mm_player_media_stream_buffer_status_callback)__media_stream_buffer_status_callback, (void *)handle);
2077
2078         if (ret != MM_ERROR_NONE)
2079                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2080
2081         if (type == PLAYER_STREAM_TYPE_VIDEO)
2082                 return __set_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS, player, callback, user_data);
2083         else
2084                 return __set_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS, player, callback, user_data);
2085 }
2086
2087 int legacy_player_unset_media_stream_buffer_status_cb(legacy_player_h player, player_stream_type_e type)
2088 {
2089         PLAYER_INSTANCE_CHECK(player);
2090
2091         if (type == PLAYER_STREAM_TYPE_VIDEO)
2092                 __unset_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS, player);
2093         else if (type == PLAYER_STREAM_TYPE_AUDIO)
2094                 __unset_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS, player);
2095         else
2096                 return PLAYER_ERROR_INVALID_PARAMETER;
2097
2098         return PLAYER_ERROR_NONE;
2099 }
2100
2101 int legacy_player_set_media_stream_seek_cb(legacy_player_h player, player_stream_type_e type, player_media_stream_seek_cb callback, void *user_data)
2102 {
2103         legacy_player_t *handle = (legacy_player_t *)player;
2104         int ret = MM_ERROR_NONE;
2105         PLAYER_INSTANCE_CHECK(player);
2106         PLAYER_NULL_ARG_CHECK(callback);
2107         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
2108
2109         /* the type can be expaned with default and text. */
2110         if ((type != PLAYER_STREAM_TYPE_VIDEO) && (type != PLAYER_STREAM_TYPE_AUDIO)) {
2111                 LOGE("PLAYER_ERROR_INVALID_PARAMETER(type : %d)", type);
2112                 return PLAYER_ERROR_INVALID_PARAMETER;
2113         }
2114
2115         ret = mm_player_set_media_stream_seek_data_callback(handle->mm_handle, type, (mm_player_media_stream_seek_data_callback)__media_stream_seek_data_callback, (void *)handle);
2116         if (ret != MM_ERROR_NONE)
2117                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2118
2119         if (type == PLAYER_STREAM_TYPE_VIDEO)
2120                 return __set_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK, player, callback, user_data);
2121
2122         return __set_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK, player, callback, user_data);
2123 }
2124
2125 int legacy_player_unset_media_stream_seek_cb(legacy_player_h player, player_stream_type_e type)
2126 {
2127         PLAYER_INSTANCE_CHECK(player);
2128
2129         if (type == PLAYER_STREAM_TYPE_VIDEO)
2130                 __unset_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK, player);
2131         else if (type == PLAYER_STREAM_TYPE_AUDIO)
2132                 __unset_callback(MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK, player);
2133         else
2134                 return PLAYER_ERROR_INVALID_PARAMETER;
2135
2136         return PLAYER_ERROR_NONE;
2137 }
2138
2139 int legacy_player_push_media_stream(legacy_player_h player, media_packet_h packet)
2140 {
2141         legacy_player_t *handle = (legacy_player_t *)player;
2142         int ret = MM_ERROR_NONE;
2143         PLAYER_INSTANCE_CHECK(player);
2144
2145         PLAYER_CHECK_CONDITION(handle->error_code == PLAYER_ERROR_NONE, PLAYER_ERROR_NOT_SUPPORTED_FILE, "can't support this format");
2146
2147         ret = mm_player_submit_packet(handle->mm_handle, packet);
2148         if (ret != MM_ERROR_NONE)
2149                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2150
2151         return PLAYER_ERROR_NONE;
2152 }
2153
2154 int legacy_player_set_media_stream_info(legacy_player_h player, player_stream_type_e type, media_format_h format)
2155 {
2156         legacy_player_t *handle = (legacy_player_t *)player;
2157         int ret = MM_ERROR_NONE;
2158         PLAYER_INSTANCE_CHECK(player);
2159         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
2160
2161         handle->is_media_stream = true;
2162
2163         if (type == PLAYER_STREAM_TYPE_VIDEO)
2164                 ret = mm_player_set_video_info(handle->mm_handle, format);
2165         else if (type == PLAYER_STREAM_TYPE_AUDIO)
2166                 ret = mm_player_set_audio_info(handle->mm_handle, format);
2167         else
2168                 return PLAYER_ERROR_INVALID_PARAMETER;
2169
2170         if (ret != MM_ERROR_NONE)
2171                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2172
2173         return PLAYER_ERROR_NONE;
2174 }
2175
2176 int legacy_player_set_media_stream_buffer_max_size(legacy_player_h player, player_stream_type_e type, unsigned long long max_size)
2177 {
2178         legacy_player_t *handle = (legacy_player_t *)player;
2179         int ret = MM_ERROR_NONE;
2180         PLAYER_INSTANCE_CHECK(player);
2181         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2182                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2183                 return PLAYER_ERROR_INVALID_STATE;
2184         }
2185
2186         ret = mm_player_set_media_stream_buffer_max_size(handle->mm_handle, type, max_size);
2187         if (ret != MM_ERROR_NONE)
2188                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2189
2190         return PLAYER_ERROR_NONE;
2191 }
2192
2193 int legacy_player_get_media_stream_buffer_max_size(legacy_player_h player, player_stream_type_e type, unsigned long long *max_size)
2194 {
2195         legacy_player_t *handle = (legacy_player_t *)player;
2196         int ret = MM_ERROR_NONE;
2197         unsigned long long _max_size;
2198         PLAYER_INSTANCE_CHECK(player);
2199         PLAYER_NULL_ARG_CHECK(max_size);
2200
2201         ret = mm_player_get_media_stream_buffer_max_size(handle->mm_handle, type, &_max_size);
2202         if (ret != MM_ERROR_NONE)
2203                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2204
2205         *max_size = _max_size;
2206         return PLAYER_ERROR_NONE;
2207 }
2208
2209 int legacy_player_set_media_stream_buffer_min_threshold(legacy_player_h player, player_stream_type_e type, unsigned int percent)
2210 {
2211         legacy_player_t *handle = (legacy_player_t *)player;
2212         int ret = MM_ERROR_NONE;
2213         PLAYER_INSTANCE_CHECK(player);
2214         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2215                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2216                 return PLAYER_ERROR_INVALID_STATE;
2217         }
2218
2219         ret = mm_player_set_media_stream_buffer_min_percent(handle->mm_handle, type, percent);
2220         if (ret != MM_ERROR_NONE)
2221                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2222
2223         return PLAYER_ERROR_NONE;
2224 }
2225
2226 int legacy_player_get_media_stream_buffer_min_threshold(legacy_player_h player, player_stream_type_e type, unsigned int *percent)
2227 {
2228         legacy_player_t *handle = (legacy_player_t *)player;
2229         int ret = MM_ERROR_NONE;
2230         unsigned int _value;
2231         PLAYER_INSTANCE_CHECK(player);
2232         PLAYER_NULL_ARG_CHECK(percent);
2233
2234         ret = mm_player_get_media_stream_buffer_min_percent(handle->mm_handle, type, &_value);
2235         if (ret != MM_ERROR_NONE)
2236                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2237
2238         *percent = _value;
2239         return PLAYER_ERROR_NONE;
2240 }
2241
2242 int legacy_player_get_track_count(legacy_player_h player, player_stream_type_e type, int *count)
2243 {
2244         legacy_player_t *handle = (legacy_player_t *)player;
2245         int ret = MM_ERROR_NONE;
2246         mmplayer_track_type_e track_type = 0;
2247         PLAYER_INSTANCE_CHECK(player);
2248         PLAYER_NULL_ARG_CHECK(count);
2249
2250         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
2251                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2252                 return PLAYER_ERROR_INVALID_STATE;
2253         }
2254
2255         switch (type) {
2256         case PLAYER_STREAM_TYPE_AUDIO:
2257                 track_type = MM_PLAYER_TRACK_TYPE_AUDIO;
2258                 break;
2259         case PLAYER_STREAM_TYPE_TEXT:
2260                 track_type = MM_PLAYER_TRACK_TYPE_TEXT;
2261                 break;
2262         default:
2263                 LOGE("invalid stream type %d", type);
2264                 return PLAYER_ERROR_INVALID_PARAMETER;
2265         }
2266
2267         ret = mm_player_get_track_count(handle->mm_handle, track_type, count);
2268         if (ret != MM_ERROR_NONE)
2269                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2270
2271         return PLAYER_ERROR_NONE;
2272 }
2273
2274 int legacy_player_get_current_track(legacy_player_h player, player_stream_type_e type, int *index)
2275 {
2276         legacy_player_t *handle = (legacy_player_t *)player;
2277         int ret = MM_ERROR_NONE;
2278         mmplayer_track_type_e track_type = 0;
2279         PLAYER_INSTANCE_CHECK(player);
2280         PLAYER_NULL_ARG_CHECK(index);
2281         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
2282                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2283                 return PLAYER_ERROR_INVALID_STATE;
2284         }
2285
2286         switch (type) {
2287         case PLAYER_STREAM_TYPE_AUDIO:
2288                 track_type = MM_PLAYER_TRACK_TYPE_AUDIO;
2289                 break;
2290         case PLAYER_STREAM_TYPE_TEXT:
2291                 track_type = MM_PLAYER_TRACK_TYPE_TEXT;
2292                 break;
2293         default:
2294                 LOGE("invalid stream type %d", type);
2295                 return PLAYER_ERROR_INVALID_PARAMETER;
2296         }
2297
2298         ret = mm_player_get_current_track(handle->mm_handle, track_type, index);
2299         if (ret != MM_ERROR_NONE)
2300                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2301
2302         return PLAYER_ERROR_NONE;
2303 }
2304
2305 int legacy_player_select_track(legacy_player_h player, player_stream_type_e type, int index)
2306 {
2307         legacy_player_t *handle = (legacy_player_t *)player;
2308         int ret = MM_ERROR_NONE;
2309         mmplayer_track_type_e track_type = 0;
2310
2311         LPLAYER_FENTER();
2312         PLAYER_INSTANCE_CHECK(player);
2313         PLAYER_CHECK_CONDITION(index >= 0, PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER");
2314         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
2315                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2316                 return PLAYER_ERROR_INVALID_STATE;
2317         }
2318
2319         switch (type) {
2320         case PLAYER_STREAM_TYPE_AUDIO:
2321                 track_type = MM_PLAYER_TRACK_TYPE_AUDIO;
2322                 break;
2323         case PLAYER_STREAM_TYPE_TEXT:
2324                 track_type = MM_PLAYER_TRACK_TYPE_TEXT;
2325                 break;
2326         default:
2327                 LOGE("invalid stream type %d", type);
2328                 return PLAYER_ERROR_INVALID_PARAMETER;
2329         }
2330
2331         ret = mm_player_select_track(handle->mm_handle, track_type, index);
2332         if (ret != MM_ERROR_NONE)
2333                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2334
2335         LPLAYER_FLEAVE();
2336         return PLAYER_ERROR_NONE;
2337 }
2338
2339 int legacy_player_get_track_language_code(legacy_player_h player, player_stream_type_e type, int index, char **code, int *len)
2340 {
2341         legacy_player_t *handle = (legacy_player_t *)player;
2342         int ret = MM_ERROR_NONE;
2343         mmplayer_track_type_e track_type = 0;
2344         PLAYER_INSTANCE_CHECK(player);
2345         PLAYER_NULL_ARG_CHECK(code);
2346         PLAYER_NULL_ARG_CHECK(len);
2347         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
2348                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2349                 return PLAYER_ERROR_INVALID_STATE;
2350         }
2351
2352         switch (type) {
2353         case PLAYER_STREAM_TYPE_AUDIO:
2354                 track_type = MM_PLAYER_TRACK_TYPE_AUDIO;
2355                 break;
2356         case PLAYER_STREAM_TYPE_VIDEO:
2357                 track_type = MM_PLAYER_TRACK_TYPE_VIDEO;
2358                 break;
2359         case PLAYER_STREAM_TYPE_TEXT:
2360                 track_type = MM_PLAYER_TRACK_TYPE_TEXT;
2361                 break;
2362         default:
2363                 LOGE("invalid stream type %d", type);
2364                 return PLAYER_ERROR_INVALID_PARAMETER;
2365         }
2366
2367         *code = NULL;
2368         ret = mm_player_get_track_language_code(handle->mm_handle, track_type, index, code);
2369         if (ret != MM_ERROR_NONE)
2370                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2371
2372         LOGD("idx %d, lang code %s", index, *code);
2373         *len = strlen(*code);
2374         return PLAYER_ERROR_NONE;
2375 }
2376
2377 int legacy_player_set_video_roi_area(legacy_player_h player, double scale_x,
2378                 double scale_y, double scale_width, double scale_heights)
2379 {
2380         legacy_player_t *handle = (legacy_player_t *)player;
2381         int ret = MM_ERROR_NONE;
2382         PLAYER_INSTANCE_CHECK(player);
2383
2384         LOGD("<Enter>");
2385
2386         if (handle->display_type != PLAYER_DISPLAY_TYPE_OVERLAY) {
2387                 LOGE("not supportable display type %d", handle->display_type);
2388                 return PLAYER_ERROR_INVALID_OPERATION;
2389         }
2390
2391         ret = mm_player_set_video_roi_area(handle->mm_handle, scale_x, scale_y, scale_width, scale_heights);
2392         if (ret != PLAYER_ERROR_NONE)
2393                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2394
2395         return PLAYER_ERROR_NONE;
2396 }
2397
2398 int legacy_player_get_video_roi_area(legacy_player_h player, double *scale_x,
2399                 double *scale_y, double *scale_width, double *scale_height)
2400 {
2401         legacy_player_t *handle = (legacy_player_t *)player;
2402         int ret = MM_ERROR_NONE;
2403         PLAYER_INSTANCE_CHECK(player);
2404         PLAYER_NULL_ARG_CHECK(scale_x);
2405         PLAYER_NULL_ARG_CHECK(scale_y);
2406         PLAYER_NULL_ARG_CHECK(scale_width);
2407         PLAYER_NULL_ARG_CHECK(scale_height);
2408
2409         LOGD("<Enter>");
2410
2411         ret = mm_player_get_video_roi_area(handle->mm_handle, scale_x, scale_y, scale_width, scale_height);
2412         if (ret != PLAYER_ERROR_NONE)
2413                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2414
2415         return PLAYER_ERROR_NONE;
2416 }
2417
2418 int legacy_player_set_roi_area(legacy_player_h player, int x, int y, int w, int h)
2419 {
2420         legacy_player_t *handle = (legacy_player_t *)player;
2421         int ret = MM_ERROR_NONE;
2422         PLAYER_INSTANCE_CHECK(player);
2423
2424         LOGD("<Enter>");
2425
2426         /* set roi area */
2427         ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_win_roi_x", x, "display_win_roi_y", y, "display_win_roi_width", w, "display_win_roi_height", h, (char *)NULL);
2428         if (ret != MM_ERROR_NONE)
2429                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2430
2431         return PLAYER_ERROR_NONE;
2432 }
2433
2434 int legacy_player_set_display(legacy_player_h player, player_display_type_e type, unsigned int wl_surface_id)
2435 {
2436         legacy_player_t *handle = (legacy_player_t *)player;
2437         int ret = MM_ERROR_NONE;
2438         void *set_handle = NULL;
2439         void *temp = NULL;
2440         MMDisplaySurfaceType mmType = __player_convert_display_type(type);
2441         PLAYER_INSTANCE_CHECK(player);
2442         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2443                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2444                 return PLAYER_ERROR_INVALID_STATE;
2445         }
2446
2447         if (type == PLAYER_DISPLAY_TYPE_NONE) {
2448                 /* NULL surface */
2449                 handle->display_handle = 0;
2450                 handle->display_type = type;
2451                 set_handle = NULL;
2452         } else {
2453                 /* get handle from overlay or evas surface */
2454                 temp = handle->display_handle;
2455                 if (type == PLAYER_DISPLAY_TYPE_OVERLAY) {
2456                         LOGI("Wayland overlay surface type");
2457                         LOGI("wl_surface_id %d", wl_surface_id);
2458                         handle->display_handle = (void *)(uintptr_t)wl_surface_id;
2459                         set_handle = &(handle->display_handle);
2460 #ifdef TIZEN_FEATURE_EVAS_RENDERER
2461                 } else if (type == PLAYER_DISPLAY_TYPE_EVAS) {
2462                         LOGI("Evas surface type");
2463                         set_handle = &(handle->display_handle);
2464 #endif
2465                 } else {
2466                         LOGE("invalid surface type");
2467                         return PLAYER_ERROR_INVALID_PARAMETER;
2468                 }
2469         }
2470
2471         /* set display handle */
2472         if (handle->display_type == PLAYER_DISPLAY_TYPE_NONE || type == handle->display_type) {
2473                 /* first time or same type */
2474                 LOGW("first time or same type");
2475                 ret = mm_player_set_attribute(handle->mm_handle, NULL, "display_surface_type", mmType, "display_overlay", set_handle, sizeof(wl_surface_id), NULL);
2476
2477                 if (ret != MM_ERROR_NONE) {
2478                         handle->display_handle = temp;
2479                         LOGE("Failed to display surface change: %d", ret);
2480                 } else {
2481                         if (type != PLAYER_DISPLAY_TYPE_NONE) {
2482                                 handle->display_type = type;
2483                                 LOGI("video display has been changed- type: %d, addr: %p", handle->display_type, handle->display_handle);
2484                         } else {
2485                                 LOGI("NULL surface");
2486                         }
2487                 }
2488         } else {
2489                 /* changing surface case */
2490                 ret = mm_player_change_videosink(handle->mm_handle, mmType, set_handle);
2491                 if (ret != MM_ERROR_NONE) {
2492                         handle->display_handle = temp;
2493                         if (ret == MM_ERROR_NOT_SUPPORT_API) {
2494                                 LOGE("change video sink is not available.");
2495                                 ret = PLAYER_ERROR_NONE;
2496                         } else {
2497                                 LOGE("Failed to display surface change: %d", ret);
2498                         }
2499                 } else {
2500                         handle->display_type = type;
2501                         LOGI("video display has been changed- type: %d, addr: %p", handle->display_type, handle->display_handle);
2502                 }
2503         }
2504
2505         if (ret != MM_ERROR_NONE) {
2506                 handle->display_type = PLAYER_DISPLAY_TYPE_NONE;
2507                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2508         }
2509
2510         return PLAYER_ERROR_NONE;
2511 }
2512
2513 int legacy_player_set_sound_stream_info_for_mused(legacy_player_h player, char *stream_type, int stream_index)
2514 {
2515         legacy_player_t *handle = (legacy_player_t *)player;
2516         int ret = MM_ERROR_NONE;
2517         PLAYER_INSTANCE_CHECK(player);
2518         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
2519
2520         if (stream_type == NULL || stream_index < 0) {
2521                 LOGE("invalid parameter %p %d", stream_type, stream_index);
2522                 return PLAYER_ERROR_INVALID_PARAMETER;
2523         }
2524
2525         ret = mm_player_set_sound_stream_info(handle->mm_handle, stream_type, stream_index);
2526         if (ret != MM_ERROR_NONE)
2527                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2528
2529         return PLAYER_ERROR_NONE;
2530 }
2531
2532 int legacy_player_get_timeout_for_muse(legacy_player_h player, int *timeout)
2533 {
2534         legacy_player_t *handle = (legacy_player_t *)player;
2535         int ret = MM_ERROR_NONE;
2536         PLAYER_INSTANCE_CHECK(player);
2537
2538         ret = mm_player_get_timeout(handle->mm_handle, timeout);
2539         if (ret != MM_ERROR_NONE)
2540                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2541
2542         return PLAYER_ERROR_NONE;
2543 }
2544
2545 int legacy_player_get_num_of_video_out_buffers(legacy_player_h player, int *num, int *extra_num)
2546 {
2547         legacy_player_t *handle = (legacy_player_t *)player;
2548         int ret = MM_ERROR_NONE;
2549         PLAYER_INSTANCE_CHECK(player);
2550         PLAYER_NULL_ARG_CHECK(num);
2551         PLAYER_NULL_ARG_CHECK(extra_num);
2552
2553         ret = mm_player_get_num_of_video_out_buffers(handle->mm_handle, num, extra_num);
2554         if (ret != MM_ERROR_NONE)
2555                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2556
2557         return PLAYER_ERROR_NONE;
2558 }
2559
2560 int legacy_player_manage_external_storage_state(legacy_player_h player, int id, int state)
2561 {
2562         legacy_player_t *handle = (legacy_player_t *)player;
2563         int ret = MM_ERROR_NONE;
2564         PLAYER_INSTANCE_CHECK(player);
2565
2566         ret = mm_player_manage_external_storage_state(handle->mm_handle, id, state);
2567         if (ret != MM_ERROR_NONE)
2568                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2569
2570         return PLAYER_ERROR_NONE;
2571 }
2572
2573 int legacy_player_get_adaptive_variant_info(legacy_player_h player, int *num, char **var_info)
2574 {
2575         int ret = MM_ERROR_NONE;
2576         legacy_player_t *handle = (legacy_player_t *)player;
2577         PLAYER_INSTANCE_CHECK(player);
2578         PLAYER_NULL_ARG_CHECK(num);
2579         PLAYER_NULL_ARG_CHECK(var_info);
2580
2581         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
2582                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2583                 return PLAYER_ERROR_INVALID_STATE;
2584         }
2585
2586         ret = mm_player_get_adaptive_variant_info(handle->mm_handle, num, var_info);
2587         if (ret != MM_ERROR_NONE)
2588                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2589
2590         return PLAYER_ERROR_NONE;
2591 }
2592
2593 int legacy_player_set_max_adaptive_variant_limit(legacy_player_h player, int bandwidth, int width, int height)
2594 {
2595         int ret = MM_ERROR_NONE;
2596         legacy_player_t *handle = (legacy_player_t *)player;
2597         PLAYER_INSTANCE_CHECK(player);
2598
2599         ret = mm_player_set_max_adaptive_variant_limit(handle->mm_handle, bandwidth, width, height);
2600         if (ret != MM_ERROR_NONE)
2601                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2602
2603         return PLAYER_ERROR_NONE;
2604 }
2605
2606 int legacy_player_get_max_adaptive_variant_limit(legacy_player_h player, int *bandwidth, int *width, int *height)
2607 {
2608         legacy_player_t *handle = (legacy_player_t *)player;
2609         int ret = MM_ERROR_NONE;
2610         PLAYER_INSTANCE_CHECK(player);
2611         PLAYER_NULL_ARG_CHECK(bandwidth);
2612         PLAYER_NULL_ARG_CHECK(width);
2613         PLAYER_NULL_ARG_CHECK(height);
2614
2615         ret = mm_player_get_max_adaptive_variant_limit(handle->mm_handle, bandwidth, width, height);
2616         if (ret != MM_ERROR_NONE)
2617                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2618
2619         return PLAYER_ERROR_NONE;
2620 }
2621
2622 int legacy_player_set_audio_only(legacy_player_h player, bool audio_only)
2623 {
2624         legacy_player_t *handle = (legacy_player_t *)player;
2625         int ret = MM_ERROR_NONE;
2626         PLAYER_INSTANCE_CHECK(player);
2627
2628         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
2629                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2630                 return PLAYER_ERROR_INVALID_STATE;
2631         }
2632
2633         ret = mm_player_set_audio_only(handle->mm_handle, audio_only);
2634         if (ret != MM_ERROR_NONE)
2635                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2636
2637         return PLAYER_ERROR_NONE;
2638 }
2639
2640 int legacy_player_is_audio_only(legacy_player_h player, bool *paudio_only)
2641 {
2642         legacy_player_t *handle = (legacy_player_t *)player;
2643         int ret = MM_ERROR_NONE;
2644         bool audio_only = false;
2645         PLAYER_INSTANCE_CHECK(player);
2646         PLAYER_NULL_ARG_CHECK(paudio_only);
2647
2648         ret = mm_player_get_audio_only(handle->mm_handle, &audio_only);
2649         if (ret != MM_ERROR_NONE)
2650                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2651
2652         *paudio_only = audio_only;
2653         return PLAYER_ERROR_NONE;
2654 }
2655
2656 int legacy_player_set_streaming_buffering_time(legacy_player_h player, int prebuffer_ms, int rebuffer_ms)
2657 {
2658         legacy_player_t *handle = (legacy_player_t *)player;
2659         int ret = MM_ERROR_NONE;
2660         PLAYER_INSTANCE_CHECK(player);
2661         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
2662
2663         LOGD("set buffering time : %d ms, %d ms", prebuffer_ms, rebuffer_ms);
2664
2665         /* set streaming buffering time */
2666         if (prebuffer_ms >= MIN_BUFFERING_TIME_MS)
2667                 ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PREBUFFER_MS, prebuffer_ms, (char *)NULL);
2668
2669         if ((ret == MM_ERROR_NONE) && (rebuffer_ms >= MIN_BUFFERING_TIME_MS))
2670                 ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_REBUFFER_MS, rebuffer_ms, (char *)NULL);
2671
2672         if (ret != MM_ERROR_NONE)
2673                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2674
2675         return PLAYER_ERROR_NONE;
2676 }
2677
2678 int legacy_player_get_streaming_buffering_time(legacy_player_h player, int *prebuffer_ms, int *rebuffer_ms)
2679 {
2680         legacy_player_t *handle = (legacy_player_t *)player;
2681         int ret = MM_ERROR_NONE;
2682         PLAYER_INSTANCE_CHECK(player);
2683         PLAYER_NULL_ARG_CHECK(prebuffer_ms && rebuffer_ms);
2684
2685         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2686                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2687                 return PLAYER_ERROR_INVALID_STATE;
2688         }
2689
2690         if (handle->state < PLAYER_STATE_READY) {
2691                 ret = mm_player_get_attribute(handle->mm_handle, NULL,
2692                         MM_PLAYER_PREBUFFER_MS, prebuffer_ms, MM_PLAYER_REBUFFER_MS, rebuffer_ms, (char *)NULL);
2693                 if (ret != MM_ERROR_NONE)
2694                         return __player_convert_error_code(ret, (char *)__FUNCTION__);
2695
2696                 LOGD("pre: %d ms, re: %d ms", *prebuffer_ms, *rebuffer_ms);
2697                 return PLAYER_ERROR_NONE;
2698         }
2699
2700         ret = mm_player_get_streaming_buffering_time(handle->mm_handle, prebuffer_ms, rebuffer_ms);
2701         if (ret != MM_ERROR_NONE)
2702                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2703
2704         LOGD("pre: %d ms, re: %d ms", *prebuffer_ms, *rebuffer_ms);
2705
2706         if (*prebuffer_ms < MIN_BUFFERING_TIME_MS) *prebuffer_ms = MIN_BUFFERING_TIME_MS;
2707         if (*rebuffer_ms < MIN_BUFFERING_TIME_MS) *rebuffer_ms = MIN_BUFFERING_TIME_MS;
2708
2709         return PLAYER_ERROR_NONE;
2710 }
2711
2712 int legacy_player_360_is_content_spherical(legacy_player_h player, bool *is_spherical)
2713 {
2714         legacy_player_t *handle = (legacy_player_t *)player;
2715         int ret = MM_ERROR_NONE;
2716         PLAYER_INSTANCE_CHECK(player);
2717         PLAYER_NULL_ARG_CHECK(is_spherical);
2718
2719         if (!__player_state_validate(handle, PLAYER_STATE_READY)) {
2720                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2721                 return PLAYER_ERROR_INVALID_STATE;
2722         }
2723
2724         ret = mm_player_360_is_content_spherical(handle->mm_handle, is_spherical);
2725         if (ret != MM_ERROR_NONE)
2726                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2727
2728         return PLAYER_ERROR_NONE;
2729 }
2730
2731 int legacy_player_360_set_enabled(legacy_player_h player, bool enabled)
2732 {
2733         legacy_player_t *handle = (legacy_player_t *)player;
2734         int ret = MM_ERROR_NONE;
2735         PLAYER_INSTANCE_CHECK(player);
2736
2737         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2738                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2739                 return PLAYER_ERROR_INVALID_STATE;
2740         }
2741
2742         ret = mm_player_360_set_enabled(handle->mm_handle, enabled);
2743         if (ret != MM_ERROR_NONE)
2744                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2745
2746         return PLAYER_ERROR_NONE;
2747 }
2748
2749 int legacy_player_360_is_enabled(legacy_player_h player, bool *enabled)
2750 {
2751         legacy_player_t *handle = (legacy_player_t *)player;
2752         int ret = MM_ERROR_NONE;
2753         PLAYER_INSTANCE_CHECK(player);
2754         PLAYER_NULL_ARG_CHECK(enabled);
2755         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2756                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2757                 return PLAYER_ERROR_INVALID_STATE;
2758         }
2759
2760         ret = mm_player_360_is_enabled(handle->mm_handle, enabled);
2761         if (ret != MM_ERROR_NONE)
2762                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2763
2764         return PLAYER_ERROR_NONE;
2765 }
2766
2767 int legacy_player_360_set_direction_of_view(legacy_player_h player, float yaw, float pitch)
2768 {
2769         legacy_player_t *handle = (legacy_player_t *)player;
2770         int ret = MM_ERROR_NONE;
2771         PLAYER_INSTANCE_CHECK(player);
2772
2773         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2774                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2775                 return PLAYER_ERROR_INVALID_STATE;
2776         }
2777
2778         ret = mm_player_360_set_direction_of_view(handle->mm_handle, yaw, pitch);
2779         if (ret != MM_ERROR_NONE)
2780                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2781
2782         return PLAYER_ERROR_NONE;
2783 }
2784
2785 int legacy_player_360_get_direction_of_view(legacy_player_h player, float *yaw, float *pitch)
2786 {
2787         legacy_player_t *handle = (legacy_player_t *)player;
2788         int ret = MM_ERROR_NONE;
2789         PLAYER_INSTANCE_CHECK(player);
2790         PLAYER_NULL_ARG_CHECK(yaw);
2791         PLAYER_NULL_ARG_CHECK(pitch);
2792
2793         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2794                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2795                 return PLAYER_ERROR_INVALID_STATE;
2796         }
2797
2798         ret = mm_player_360_get_direction_of_view(handle->mm_handle, yaw, pitch);
2799         if (ret != MM_ERROR_NONE)
2800                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2801
2802         return PLAYER_ERROR_NONE;
2803 }
2804
2805 int legacy_player_360_set_zoom(legacy_player_h player, float level)
2806 {
2807         legacy_player_t *handle = (legacy_player_t *)player;
2808         int ret = MM_ERROR_NONE;
2809         PLAYER_INSTANCE_CHECK(player);
2810
2811         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2812                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2813                 return PLAYER_ERROR_INVALID_STATE;
2814         }
2815
2816         ret = mm_player_360_set_zoom(handle->mm_handle, level);
2817         if (ret != MM_ERROR_NONE)
2818                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2819
2820         return PLAYER_ERROR_NONE;
2821 }
2822
2823 int legacy_player_360_get_zoom(legacy_player_h player, float *level)
2824 {
2825         legacy_player_t *handle = (legacy_player_t *)player;
2826         int ret = MM_ERROR_NONE;
2827         PLAYER_INSTANCE_CHECK(player);
2828
2829         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2830                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2831                 return PLAYER_ERROR_INVALID_STATE;
2832         }
2833
2834         ret = mm_player_360_get_zoom(handle->mm_handle, level);
2835         if (ret != MM_ERROR_NONE)
2836                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2837
2838         return PLAYER_ERROR_NONE;
2839 }
2840
2841 int legacy_player_360_set_field_of_view(legacy_player_h player, int horizontal_degrees, int vertical_degrees)
2842 {
2843         legacy_player_t *handle = (legacy_player_t *)player;
2844         int ret = MM_ERROR_NONE;
2845         PLAYER_INSTANCE_CHECK(player);
2846
2847         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2848                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2849                 return PLAYER_ERROR_INVALID_STATE;
2850         }
2851
2852         ret = mm_player_360_set_field_of_view(handle->mm_handle, horizontal_degrees, vertical_degrees);
2853         if (ret != MM_ERROR_NONE)
2854                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2855
2856         return PLAYER_ERROR_NONE;
2857 }
2858
2859 int legacy_player_360_get_field_of_view(legacy_player_h player, int *horizontal_degrees, int *vertical_degrees)
2860 {
2861         legacy_player_t *handle = (legacy_player_t *)player;
2862         int ret = MM_ERROR_NONE;
2863         PLAYER_INSTANCE_CHECK(player);
2864         PLAYER_NULL_ARG_CHECK(horizontal_degrees);
2865         PLAYER_NULL_ARG_CHECK(vertical_degrees);
2866
2867         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2868                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2869                 return PLAYER_ERROR_INVALID_STATE;
2870         }
2871
2872         ret = mm_player_360_get_field_of_view(handle->mm_handle, horizontal_degrees, vertical_degrees);
2873         if (ret != MM_ERROR_NONE)
2874                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2875
2876         return PLAYER_ERROR_NONE;
2877 }
2878
2879 int legacy_player_set_replaygain_enabled(legacy_player_h player, bool enabled)
2880 {
2881         legacy_player_t *handle = (legacy_player_t *)player;
2882         int ret = MM_ERROR_NONE;
2883         PLAYER_INSTANCE_CHECK(player);
2884
2885         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2886                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2887                 return PLAYER_ERROR_INVALID_STATE;
2888         }
2889
2890         ret = mm_player_set_replaygain_enabled(handle->mm_handle, enabled);
2891         if (ret != MM_ERROR_NONE)
2892                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2893
2894         return PLAYER_ERROR_NONE;
2895 }
2896
2897 int legacy_player_is_replaygain_enabled(legacy_player_h player, bool *enabled)
2898 {
2899         legacy_player_t *handle = (legacy_player_t *)player;
2900         int ret = MM_ERROR_NONE;
2901         bool _enable;
2902         PLAYER_INSTANCE_CHECK(player);
2903         PLAYER_NULL_ARG_CHECK(enabled);
2904
2905         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2906                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2907                 return PLAYER_ERROR_INVALID_STATE;
2908         }
2909
2910         ret = mm_player_is_replaygain_enabled(handle->mm_handle, &_enable);
2911         if (ret != MM_ERROR_NONE)
2912                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2913
2914         *enabled = _enable;
2915         return PLAYER_ERROR_NONE;
2916 }
2917
2918 int legacy_player_set_audio_offload_enabled(legacy_player_h player, bool enabled)
2919 {
2920         legacy_player_t *handle = (legacy_player_t *)player;
2921         int ret = MM_ERROR_NONE;
2922         PLAYER_INSTANCE_CHECK(player);
2923         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
2924
2925         LOGD("set audio offload %d", enabled);
2926
2927         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_OFFLOAD, (int)enabled, (char *)NULL);
2928         if (ret != MM_ERROR_NONE)
2929                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2930
2931         return PLAYER_ERROR_NONE;
2932 }
2933
2934 int legacy_player_is_audio_offload_enabled(legacy_player_h player, bool *enabled)
2935 {
2936         legacy_player_t *handle = (legacy_player_t *)player;
2937         int ret = MM_ERROR_NONE;
2938         int val = 0;
2939         PLAYER_INSTANCE_CHECK(player);
2940         PLAYER_NULL_ARG_CHECK(enabled);
2941
2942         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2943                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2944                 return PLAYER_ERROR_INVALID_STATE;
2945         }
2946
2947         ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_AUDIO_OFFLOAD, &val, (char *)NULL);
2948         if (ret != MM_ERROR_NONE)
2949                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2950
2951         *enabled = (bool)val;
2952         LOGD("get audio offload %d", *enabled);
2953         return PLAYER_ERROR_NONE;
2954 }
2955
2956 int legacy_player_pitch_set_enabled(legacy_player_h player, bool enabled)
2957 {
2958         legacy_player_t *handle = (legacy_player_t *)player;
2959         int ret = MM_ERROR_NONE;
2960         PLAYER_INSTANCE_CHECK(player);
2961         PLAYER_STATE_CHECK(handle, PLAYER_STATE_IDLE);
2962
2963         LOGD("set pitch control %d", enabled);
2964         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, (int)enabled, (char *)NULL);
2965
2966         if (ret != MM_ERROR_NONE)
2967                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2968
2969         return PLAYER_ERROR_NONE;
2970 }
2971
2972 int legacy_player_pitch_is_enabled(legacy_player_h player, bool *enabled)
2973 {
2974         legacy_player_t *handle = (legacy_player_t *)player;
2975         int ret = MM_ERROR_NONE;
2976         int val = 0;
2977         PLAYER_INSTANCE_CHECK(player);
2978         PLAYER_NULL_ARG_CHECK(enabled);
2979
2980         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
2981                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
2982                 return PLAYER_ERROR_INVALID_STATE;
2983         }
2984
2985         ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, &val, (char *)NULL);
2986         if (ret != MM_ERROR_NONE)
2987                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
2988
2989         *enabled = (bool)val;
2990         LOGD("get pitch control %d", *enabled);
2991         return PLAYER_ERROR_NONE;
2992 }
2993
2994 int legacy_player_pitch_set_value(legacy_player_h player, float pitch)
2995 {
2996         legacy_player_t *handle = (legacy_player_t *)player;
2997         int ret = MM_ERROR_NONE;
2998         int is_enabled = 0;
2999
3000         PLAYER_INSTANCE_CHECK(player);
3001
3002         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
3003                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
3004                 return PLAYER_ERROR_INVALID_STATE;
3005         }
3006
3007         ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_CONTROL, &is_enabled, (char *)NULL);
3008         if (ret != MM_ERROR_NONE)
3009                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
3010
3011         if (!is_enabled) {
3012                 LOGE("pitch is not enabled");
3013                 return PLAYER_ERROR_INVALID_OPERATION;
3014         }
3015
3016         LOGD("set pitch value %1.3f", pitch);
3017         ret = mm_player_set_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_VALUE, (double)pitch, (char *)NULL);
3018         if (ret != MM_ERROR_NONE)
3019                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
3020
3021         return PLAYER_ERROR_NONE;
3022 }
3023
3024 int legacy_player_pitch_get_value(legacy_player_h player, float *pitch)
3025 {
3026         legacy_player_t *handle = (legacy_player_t *)player;
3027         int ret = MM_ERROR_NONE;
3028         double value = 0.0;
3029         PLAYER_INSTANCE_CHECK(player);
3030         PLAYER_NULL_ARG_CHECK(pitch);
3031
3032         if (!__player_state_validate(handle, PLAYER_STATE_IDLE)) {
3033                 LOGE("PLAYER_ERROR_INVALID_STATE : current state - %d", handle->state);
3034                 return PLAYER_ERROR_INVALID_STATE;
3035         }
3036
3037         ret = mm_player_get_attribute(handle->mm_handle, NULL, MM_PLAYER_PITCH_VALUE, &value, (char *)NULL);
3038         if (ret != MM_ERROR_NONE)
3039                 return __player_convert_error_code(ret, (char *)__FUNCTION__);
3040
3041         *pitch = (float)value;
3042         LOGD("get pitch value %1.3f", *pitch);
3043
3044         return PLAYER_ERROR_NONE;
3045 }