legacy/src/legacy_player.c

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