legacy/src/legacy_player.c

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