legacy/src/legacy_player.c

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