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