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