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