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