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