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