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