muse/src/muse_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 #ifndef _GNU_SOURCE
  18 #define _GNU_SOURCE
  19 #endif
  20
  21 #include <dlog.h>
  22 #include <stdlib.h>
  23 #include <mm_error.h>
  24 #include <sys/socket.h>
  25 #include <tbm_bufmgr.h>
  26 #include <tbm_surface.h>
  27 #include <tbm_surface_internal.h>
  28 #include <media_packet.h>
  29 #include <media_packet_internal.h>
  30 #include <muse_server.h>
  31 #include <tzplatform_config.h>
  32 #include <system_info.h>
  33 #include "muse_player.h"
  34 #include "muse_player_msg.h"
  35 #include "muse_player_private.h"
  36 #include "muse_player_api.h" /* generated during build, ref ../make_api.py */
  37 #include "legacy_player_private.h"
  38 #include "legacy_player_internal.h"
  39
  40 #define DEFAULT_VDEC_TOTAL_SIZE_OF_BUFFER 0
  41 #define DEFAULT_VDEC_EXTRA_SIZE_OF_BUFFER 3
  42
  43 #define INVALID_DEFAULT_VALUE -1
  44 #define ADAPTIVE_VARIANT_DEFAULT_VALUE -1 /* auto */
  45
  46 #define MEDIA_PATH_EXTERNAL  tzplatform_getenv(TZ_SYS_STORAGE)  /* external storage, or TZ_SYS_MEDIA */
  47 #define MEDIA_PATH_USER      tzplatform_getenv(TZ_USER_CONTENT) /* user media storage */
  48
  49 #define MEDIA_STORAGE_PRIVILEGE_NAME    "http://tizen.org/privilege/mediastorage"
  50 #define EXTERNAL_STORAGE_PRIVILEGE_NAME "http://tizen.org/privilege/externalstorage"
  51 #define INTERNET_PRIVILEGE_NAME         "http://tizen.org/privilege/internet"
  52 #define NUM_OF_URI_PREFIX 7
  53 #define INVALID_MUSE_TYPE_VALUE 0
  54
  55 static const char *uri_prefix[NUM_OF_URI_PREFIX] = {
  56         "http://",
  57         "https://",
  58         "mms://",
  59         "rtsp://",
  60         "rtsps://",
  61         "rtspu://",
  62         "rtspr://"
  63 };
  64
  65 /**
  66  * msg dispatcher functions
  67  * To add new disp function with new player API,
  68  * by running python cmd, the function template will be added at the bottom of this file.
  69  * see ../README_FOR_NEW_API
  70  * see ../api.list
  71  * see ../make_api.py
  72  */
  73 static bool _create_export_data(muse_player_handle_t *muse_player, void *data, int size, void *ext_data, int ext_size, tbm_fd *out_tfd, int *out_key)
  74 {
  75         muse_player_export_data_t *export_data = NULL;
  76         tbm_bo bo = NULL;
  77         tbm_fd tfd = INVALID_DEFAULT_VALUE;
  78         tbm_bo_handle thandle;
  79         int bo_size = size + ext_size;
  80
  81         /* LOGD("ENTER"); */
  82
  83         *out_tfd = *out_key = INVALID_DEFAULT_VALUE;
  84
  85         if (muse_player == NULL) {
  86                 LOGE("handle is NULL");
  87                 return false;
  88         }
  89
  90         if (data == NULL || size <= 0) {
  91                 LOGE("data is empty");
  92                 return false;
  93         }
  94
  95         export_data = g_try_new0(muse_player_export_data_t, 1);
  96         if (export_data == NULL) {
  97                 LOGE("failed to alloc export_data");
  98                 return false;
  99         }
 100
 101         /* alloc and map the bo */
 102         bo = tbm_bo_alloc(muse_player->bufmgr, bo_size, TBM_BO_DEFAULT);
 103         if (!bo) {
 104                 LOGE("TBM get error : tbm_bo_alloc return NULL");
 105                 goto ERROR;
 106         }
 107
 108         thandle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_WRITE);
 109         if (thandle.ptr == NULL) {
 110                 LOGE("TBM get error : handle pointer is NULL");
 111                 goto ERROR;
 112         }
 113
 114         /* copy data to bo and export tbm fd */
 115         if (ext_size > 0 && ext_data != NULL)
 116                 memcpy(thandle.ptr, ext_data, ext_size);
 117
 118         memcpy(thandle.ptr + ext_size, data, size);
 119
 120         tbm_bo_unmap(bo);
 121
 122         tfd = tbm_bo_export_fd(bo);
 123         if (tfd < 0) {
 124                 LOGE("tbm_bo_export_fd err 0x%x", tfd);
 125                 goto ERROR;
 126         }
 127
 128         /* LOGD("bo %p, vaddr %p, size %d(%d, %d), tbm_fd %d", bo, thandle.ptr, bo_size, ext_size, size, tfd); */
 129
 130         /* set bo info */
 131         export_data->tfd = tfd;
 132         export_data->bo = bo;
 133         export_data->key = tfd; /* keep the tfd integer value as a unique key */
 134
 135         /* add bo info to list */
 136         g_mutex_lock(&muse_player->list_lock);
 137         muse_player->data_list = g_list_append(muse_player->data_list, (gpointer)export_data);
 138         g_mutex_unlock(&muse_player->list_lock);
 139
 140         *out_tfd = export_data->tfd;
 141         *out_key = export_data->key;
 142
 143         return true;
 144
 145 ERROR:
 146         if (bo) {
 147                 tbm_bo_unref(bo);
 148                 bo = NULL;
 149         }
 150
 151         g_free(export_data);
 152
 153         return false;
 154 }
 155
 156 static bool _remove_export_data(muse_module_h module, int key, bool remove_all)
 157 {
 158         bool ret = true;
 159         muse_player_handle_t *muse_player = NULL;
 160
 161         /* LOGD("ENTER"); */
 162         if (module == NULL || (key < 0 && !remove_all)) {
 163                 LOGE("invalid parameter %p, %d", module, key);
 164                 return false;
 165         }
 166
 167         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
 168
 169         if (muse_player && muse_player->data_list) {
 170
 171                 GList *iter = NULL;
 172                 muse_player_export_data_t *export_data = NULL;
 173                 g_mutex_lock(&muse_player->list_lock);
 174
 175                 /* LOGE("number of remained buffer %d", g_list_length(muse_player->data_list)); */
 176
 177                 iter = g_list_first(muse_player->data_list);
 178                 while (iter) {
 179                         export_data = (muse_player_export_data_t *)iter->data;
 180                         if ((export_data) &&
 181                                 (export_data->key == key || remove_all)) {
 182                                 LOGD("buffer key : %d matched, remove it (remove_all %d)", key, remove_all);
 183                                 if (export_data->tfd > INVALID_DEFAULT_VALUE) {
 184                                         close(export_data->tfd);
 185                                         export_data->tfd = INVALID_DEFAULT_VALUE;
 186                                 }
 187                                 if (export_data->bo) {
 188                                         tbm_bo_unref(export_data->bo);
 189                                         export_data->bo = NULL;
 190                                 } else {
 191                                         LOGW("bo for key:%d is NULL", key);
 192                                 }
 193
 194                                 iter = g_list_next(iter);
 195
 196                                 muse_player->data_list = g_list_remove(muse_player->data_list, export_data);
 197                                 g_free(export_data);
 198                                 export_data = NULL;
 199
 200                                 if (!remove_all) {
 201                                         /* LOGD("buffer key:%d, remove done", key); */
 202                                         g_mutex_unlock(&muse_player->list_lock);
 203                                         return ret;
 204                                 }
 205                         } else {
 206                                 iter = g_list_next(iter);
 207                         }
 208                 }
 209
 210                 g_mutex_unlock(&muse_player->list_lock);
 211
 212                 if (!remove_all) {
 213                         LOGE("There is no key:%d in data_list", key);
 214                         ret = false;
 215                 }
 216         }
 217
 218         return ret;
 219 }
 220
 221 static void _remove_video_stream_data(muse_module_h module, mmplayer_video_decoded_data_info_t *video_data)
 222 {
 223         int i = 0, bo_num = 0;
 224         muse_player_handle_t *muse_player = NULL;
 225
 226         if (video_data == NULL) {
 227                 LOGE("video_data is null, module %p", module);
 228                 return;
 229         }
 230
 231         /* check bo */
 232         for (i = 0, bo_num = 0; i < BUFFER_MAX_PLANE_NUM; i++) {
 233                 if (video_data->bo[i])
 234                         bo_num++;
 235         }
 236
 237         /* In case of Tizen native format used on videosink video_data->internal_buffer
 238          * contains reference to the original Gst buffer. Otherwise it is null.
 239          * */
 240         if (!video_data->internal_buffer) { /* sw codec */
 241 #define NUM_OF_SW_CODEC_BO 1
 242                 tbm_bo bo = NULL;
 243
 244                 if (bo_num == NUM_OF_SW_CODEC_BO) {
 245                         bo = video_data->bo[0];
 246                         if (bo) { /* sw codec bo list */
 247                                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
 248                                 if (muse_player == NULL) {
 249                                         LOGE("muse_player is NULL");
 250                                         goto EXIT;
 251                                 }
 252
 253                                 legacy_player_release_video_stream_bo(muse_player->player_handle, bo);
 254                                 g_free(video_data);
 255                                 return;
 256                         } else {
 257                                 LOGE("bo is NULL");
 258                         }
 259                 }
 260         }
 261
 262 EXIT:
 263         for (i = 0; i < bo_num; i++) {
 264                 tbm_bo_unref(video_data->bo[i]);
 265                 video_data->bo[i] = NULL;
 266         }
 267
 268         if (video_data->internal_buffer) {
 269                 mm_player_video_stream_internal_buffer_unref(video_data->internal_buffer);
 270                 video_data->internal_buffer = NULL;
 271         }
 272
 273         // LOGD("release exported video_data %p", video_data);
 274         g_free(video_data);
 275         return;
 276 }
 277
 278
 279 static void _remove_export_media_packet(muse_module_h module)
 280 {
 281         muse_player_handle_t *muse_player = NULL;
 282
 283         LOGD("ENTER");
 284         if (module == NULL) {
 285                 LOGE("invalid parameter");
 286                 return;
 287         }
 288
 289         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
 290         if (muse_player == NULL) {
 291                 LOGE("invalid handle");
 292                 return;
 293         }
 294
 295         muse_player->export_video_data = false;
 296
 297         if (muse_player->video_data_list) {
 298                 GList *video_list = NULL;
 299                 g_mutex_lock(&muse_player->list_lock);
 300
 301                 LOGW("number of remained video_list %d", g_list_length(muse_player->video_data_list));
 302                 for (video_list = g_list_first(muse_player->video_data_list); video_list; video_list = g_list_next(video_list)) {
 303                         LOGW("%p will be removed", video_list->data);
 304                         _remove_video_stream_data(module, (mmplayer_video_decoded_data_info_t *)video_list->data);
 305                 }
 306                 g_list_free(muse_player->video_data_list);
 307                 muse_player->video_data_list = NULL;
 308
 309                 g_mutex_unlock(&muse_player->list_lock);
 310         }
 311 }
 312
 313 /* check the given path is indicating sdp file */
 314 static bool _is_sdp_file(const char *path)
 315 {
 316         bool ret = false;
 317         gchar *uri = NULL;
 318
 319         if (!path) {
 320                 LOGE("invalid path param");
 321                 return ret;
 322         }
 323
 324         uri = g_ascii_strdown(path, -1);
 325
 326         if (uri == NULL)
 327                 return false;
 328
 329         /* trimming */
 330         g_strstrip(uri);
 331
 332         /* strlen(".sdp") == 4 */
 333         if (strlen(uri) <= 4) {
 334                 LOGW("path is too short.\n");
 335                 return ret;
 336         }
 337
 338         /* first, check extension name */
 339         ret = g_str_has_suffix(uri, "sdp");
 340
 341         /* second, if no suffix is there, check it's contents */
 342         if (!ret)
 343                 /* FIXIT : do it soon */
 344                 LOGD("no suffix");
 345
 346         g_free(uri);
 347         uri = NULL;
 348
 349         return ret;
 350 }
 351
 352 static bool _check_network_availability(void)
 353 {
 354 #define _FEATURE_NAME_WIFI              "http://tizen.org/feature/network.wifi"
 355 #define _FEATURE_NAME_TELEPHONY "http://tizen.org/feature/network.telephony"
 356 #define _FEATURE_NAME_ETHERNET  "http://tizen.org/feature/network.ethernet"
 357         bool enabled = false;
 358         bool supported = false;
 359
 360         if (SYSTEM_INFO_ERROR_NONE == system_info_get_platform_bool(_FEATURE_NAME_WIFI, &enabled)) {
 361                 LOGI("wifi status = %d", enabled);
 362                 if (enabled)
 363                         supported = true;
 364         } else {
 365                 LOGE("SYSTEM_INFO_ERROR");
 366         }
 367
 368         if (SYSTEM_INFO_ERROR_NONE == system_info_get_platform_bool(_FEATURE_NAME_TELEPHONY, &enabled)) {
 369                 LOGI("telephony status = %d", enabled);
 370                 if (enabled)
 371                         supported = true;
 372         } else {
 373                 LOGE("SYSTEM_INFO_ERROR");
 374         }
 375
 376         if (SYSTEM_INFO_ERROR_NONE == system_info_get_platform_bool(_FEATURE_NAME_ETHERNET, &enabled)) {
 377                 LOGI("ethernet status = %d", enabled);
 378                 if (enabled)
 379                         supported = true;
 380         } else {
 381                 LOGE("SYSTEM_INFO_ERROR");
 382         }
 383
 384         if (!supported)
 385                 return false;
 386
 387         return true;
 388 }
 389
 390 static int _check_supportable(muse_module_h module, char *path)
 391 {
 392         int ret = PLAYER_ERROR_NONE;
 393         int client_fd = -1;
 394         int idx = 0;
 395         char *privilege = NULL;
 396         char *internal_path = NULL;
 397         struct ucred cred;
 398
 399         if (!path) {
 400                 LOGE("invalid path param");
 401                 return PLAYER_ERROR_INVALID_PARAMETER;
 402         }
 403
 404         client_fd = muse_server_module_get_msg_fd(module);
 405
 406         if ((client_fd < 0) || !muse_core_fd_is_valid(client_fd)) {
 407                 LOGE("get msg fd failed : %d", client_fd);
 408                 return PLAYER_ERROR_INVALID_OPERATION;
 409         }
 410
 411         for (idx = 0; idx < NUM_OF_URI_PREFIX; idx++) {
 412                 if (strncmp(path, uri_prefix[idx], strlen(uri_prefix[idx])) == 0) {
 413                         LOGD("internet privilege will be checked for %s path", uri_prefix[idx]);
 414                         break;
 415                 }
 416         }
 417
 418         if (idx != NUM_OF_URI_PREFIX) {
 419                 privilege = INTERNET_PRIVILEGE_NAME;
 420         } else {
 421                 char *file_path = path;
 422
 423                 if (strncmp(path, "file://", strlen("file://")) == 0)
 424                         file_path = path + 7; /* remove file prefix */
 425
 426                 if (_is_sdp_file(file_path)) /* check internet privilege */
 427                         privilege = INTERNET_PRIVILEGE_NAME;
 428
 429                 if (!privilege) {
 430                         if (strncmp(file_path, MEDIA_PATH_EXTERNAL, strlen(MEDIA_PATH_EXTERNAL)) == 0) { /* external media storage */
 431                                 privilege = EXTERNAL_STORAGE_PRIVILEGE_NAME;
 432                         } else {
 433                                 socklen_t len = sizeof(struct ucred);
 434                                 if (getsockopt(client_fd, SOL_SOCKET, SO_PEERCRED, &cred, &len) < 0) {
 435                                         LOGE("failed to get peer client uid of socketfd %d", client_fd);
 436                                         return PLAYER_ERROR_INVALID_OPERATION;
 437                                 }
 438
 439                                 /* get home/media path of client and can be different in case of multi-user */
 440                                 tzplatform_set_user(cred.uid);
 441                                 internal_path = g_strdup(MEDIA_PATH_USER);
 442                                 tzplatform_reset_user();
 443
 444                                 // LOGD("internal storage path %s", internal_path);
 445
 446                                 if (strncmp(file_path, internal_path, strlen(internal_path)) == 0) { /* internal media storage */
 447                                         privilege = MEDIA_STORAGE_PRIVILEGE_NAME;
 448                                         g_free(internal_path);
 449                                 } else {        /* can access without permission */
 450                                         g_free(internal_path);
 451                                         return PLAYER_ERROR_NONE;
 452                                 }
 453                         }
 454                 }
 455         }
 456
 457         LOGD("privilege check : %s", privilege);
 458         if (!muse_server_security_check_cynara(client_fd, privilege)) {
 459                 ret = PLAYER_ERROR_PERMISSION_DENIED;
 460                 LOGE("security check failed %s", privilege);
 461         } else {
 462                 if (strncmp(privilege, INTERNET_PRIVILEGE_NAME, strlen(INTERNET_PRIVILEGE_NAME)) == 0) {
 463                         /*check internet feature*/
 464                         if (!_check_network_availability()) {
 465                                 ret = PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE;
 466                                 LOGE("feature is not supportable.");
 467                         }
 468                 }
 469         }
 470
 471         return ret;
 472 }
 473
 474 static void _prepare_async_cb(void *user_data)
 475 {
 476         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_PREPARE;
 477         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 478         prepare_data_t *prepare_data = (prepare_data_t *)user_data;
 479         muse_module_h module;
 480         muse_player_handle_t *muse_player = NULL;
 481         int ret = PLAYER_ERROR_NONE;
 482         int num = 0, extra_num = 0;
 483
 484         if (!prepare_data) {
 485                 LOGE("user data of callback is NULL");
 486                 return;
 487         }
 488         module = prepare_data->module;
 489         g_free(prepare_data);
 490
 491         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
 492         if (muse_player == NULL) {
 493                 LOGE("muse handle is NULL");
 494                 return;
 495         }
 496
 497         ret = legacy_player_get_num_of_video_out_buffers(muse_player->player_handle, &num, &extra_num);
 498         if (ret == PLAYER_ERROR_NONE) {
 499                 muse_player->total_size_of_buffers = num;
 500                 muse_player->extra_size_of_buffers = extra_num;
 501                 LOGD("num of vdec out buffer, total:%d, extra:%d", num, extra_num);
 502         }
 503
 504         PLAYER_SEND_EVENT_MSG(api, ev, module);
 505 }
 506
 507 static void __player_callback(muse_player_event_e ev, muse_module_h module)
 508 {
 509         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 510
 511         LOGD("ENTER");
 512
 513         PLAYER_SEND_EVENT_MSG(api, ev, module);
 514 }
 515
 516 static void _seek_complate_cb(void *user_data)
 517 {
 518         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_SEEK;
 519         __player_callback(ev, (muse_module_h)user_data);
 520 }
 521
 522 static void _completed_cb(void *user_data)
 523 {
 524         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_COMPLETE;
 525         __player_callback(ev, (muse_module_h)user_data);
 526 }
 527
 528 #ifdef TIZEN_FEATURE_EVAS_RENDERER
 529 static void _retrieve_buffer_cb(void *user_data)
 530 {
 531         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER;
 532         __player_callback(ev, (muse_module_h)user_data);
 533 }
 534 #endif
 535
 536 static void _set_completed_cb(legacy_player_h player, void *module, bool set)
 537 {
 538         if (set)
 539                 legacy_player_set_completed_cb(player, _completed_cb, module);
 540         else
 541                 legacy_player_unset_completed_cb(player);
 542 }
 543
 544 #ifdef TIZEN_FEATURE_EVAS_RENDERER
 545 static void _set_retrieve_buffer_cb(legacy_player_h player, void *module, bool set)
 546 {
 547         if (set)
 548                 legacy_player_set_retrieve_buffer_cb(player, _retrieve_buffer_cb, module);
 549         else
 550                 legacy_player_unset_retrieve_buffer_cb(player);
 551 }
 552 #endif
 553
 554 static void _capture_video_cb(unsigned char *data, int width, int height, unsigned int size, void *user_data)
 555 {
 556         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 557         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_CAPTURE;
 558         muse_module_h module = (muse_module_h)user_data;
 559         muse_player_handle_t *muse_player = NULL;
 560         bool ret = true;
 561         tbm_fd tfd = INVALID_DEFAULT_VALUE;
 562         int key = INVALID_DEFAULT_VALUE;
 563         LOGD("ENTER");
 564
 565         if (data == NULL || size == 0) {
 566                 LOGE("cature data is empty");
 567                 return;
 568         }
 569
 570         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
 571         if (muse_player == NULL) {
 572                 LOGE("handle is NULL");
 573                 return;
 574         }
 575
 576         ret = _create_export_data(muse_player, (void *)data, size, NULL, 0, &tfd, &key);
 577         if (!ret) {
 578                 LOGE("failed to create export data");
 579                 return;
 580         }
 581
 582         PLAYER_SEND_EVENT_MSG_WITH_TFD(api, ev, module, tfd,
 583                         MUSE_TYPE_INT, "width", width, MUSE_TYPE_INT, "height", height,
 584                         MUSE_TYPE_INT, "size", (int)size, MUSE_TYPE_INT, "key", key);
 585         return;
 586 }
 587
 588 static int _get_tbm_surface_format(int in_format, uint32_t *out_format)
 589 {
 590         if (in_format <= MM_PIXEL_FORMAT_INVALID || in_format >= MM_PIXEL_FORMAT_NUM || out_format == NULL) {
 591                 LOGE("INVALID_PARAMETER : in_format %d, out_format ptr %p", in_format, out_format);
 592                 return PLAYER_ERROR_INVALID_PARAMETER;
 593         }
 594
 595         switch (in_format) {
 596         case MM_PIXEL_FORMAT_NV12:
 597                 *out_format = TBM_FORMAT_NV12;
 598                 break;
 599         case MM_PIXEL_FORMAT_NV12T:
 600                 *out_format = TBM_FORMAT_NV12MT;
 601                 break;
 602         case MM_PIXEL_FORMAT_NV16:
 603                 *out_format = TBM_FORMAT_NV16;
 604                 break;
 605         case MM_PIXEL_FORMAT_NV21:
 606                 *out_format = TBM_FORMAT_NV21;
 607                 break;
 608         case MM_PIXEL_FORMAT_YUYV:
 609                 *out_format = TBM_FORMAT_YUYV;
 610                 break;
 611         case MM_PIXEL_FORMAT_UYVY:
 612         case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
 613                 *out_format = TBM_FORMAT_UYVY;
 614                 break;
 615         case MM_PIXEL_FORMAT_422P:
 616                 *out_format = TBM_FORMAT_YUV422;
 617                 break;
 618         case MM_PIXEL_FORMAT_I420:
 619                 *out_format = TBM_FORMAT_YUV420;
 620                 break;
 621         case MM_PIXEL_FORMAT_YV12:
 622                 *out_format = TBM_FORMAT_YVU420;
 623                 break;
 624         case MM_PIXEL_FORMAT_RGB565:
 625                 *out_format = TBM_FORMAT_RGB565;
 626                 break;
 627         case MM_PIXEL_FORMAT_RGB888:
 628                 *out_format = TBM_FORMAT_RGB888;
 629                 break;
 630         case MM_PIXEL_FORMAT_RGBA:
 631                 *out_format = TBM_FORMAT_ARGB8888;
 632                 break;
 633         case MM_PIXEL_FORMAT_ARGB:
 634                 *out_format = TBM_FORMAT_ARGB8888;
 635                 break;
 636         default:
 637                 LOGE("invalid in_format %d", in_format);
 638                 return PLAYER_ERROR_INVALID_PARAMETER;
 639         }
 640
 641         return PLAYER_ERROR_NONE;
 642 }
 643
 644 static int _get_media_packet_mimetype(int in_format, media_format_mimetype_e *mimetype)
 645 {
 646         if (in_format <= MM_PIXEL_FORMAT_INVALID || in_format >= MM_PIXEL_FORMAT_NUM || mimetype == NULL) {
 647                 LOGE("INVALID_PARAMETER : in_format %d, mimetype ptr %p", in_format, mimetype);
 648                 return PLAYER_ERROR_INVALID_PARAMETER;
 649         }
 650
 651         switch (in_format) {
 652         case MM_PIXEL_FORMAT_NV12:
 653                 *mimetype = MEDIA_FORMAT_NV12;
 654                 break;
 655         case MM_PIXEL_FORMAT_NV12T:
 656                 *mimetype = MEDIA_FORMAT_NV12T;
 657                 break;
 658         case MM_PIXEL_FORMAT_NV16:
 659                 *mimetype = MEDIA_FORMAT_NV16;
 660                 break;
 661         case MM_PIXEL_FORMAT_NV21:
 662                 *mimetype = MEDIA_FORMAT_NV21;
 663                 break;
 664         case MM_PIXEL_FORMAT_YUYV:
 665                 *mimetype = MEDIA_FORMAT_YUYV;
 666                 break;
 667         case MM_PIXEL_FORMAT_UYVY:
 668         case MM_PIXEL_FORMAT_ITLV_JPEG_UYVY:
 669                 *mimetype = MEDIA_FORMAT_UYVY;
 670                 break;
 671         case MM_PIXEL_FORMAT_422P:
 672                 *mimetype = MEDIA_FORMAT_422P;
 673                 break;
 674         case MM_PIXEL_FORMAT_I420:
 675                 *mimetype = MEDIA_FORMAT_I420;
 676                 break;
 677         case MM_PIXEL_FORMAT_YV12:
 678                 *mimetype = MEDIA_FORMAT_YV12;
 679                 break;
 680         case MM_PIXEL_FORMAT_RGB565:
 681                 *mimetype = MEDIA_FORMAT_RGB565;
 682                 break;
 683         case MM_PIXEL_FORMAT_RGB888:
 684                 *mimetype = MEDIA_FORMAT_RGB888;
 685                 break;
 686         case MM_PIXEL_FORMAT_RGBA:
 687                 *mimetype = MEDIA_FORMAT_RGBA;
 688                 break;
 689         case MM_PIXEL_FORMAT_ARGB:
 690                 *mimetype = MEDIA_FORMAT_ARGB;
 691                 break;
 692         default:
 693                 LOGE("invalid in_format %d", in_format);
 694                 return PLAYER_ERROR_INVALID_PARAMETER;
 695         }
 696
 697         return PLAYER_ERROR_NONE;
 698 }
 699 static bool __video_decoded_callback(void *video_data, void *user_data)
 700 {
 701         int ret = 0;
 702         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 703         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME;
 704         muse_module_h module = (muse_module_h)user_data;
 705         mmplayer_video_decoded_data_info_t *video_stream = (mmplayer_video_decoded_data_info_t *)video_data;
 706         muse_player_handle_t *muse_player = NULL;
 707         uint32_t bo_format = 0;
 708         int bo_num = 0;
 709         tbm_fd tfd[4];
 710         int key[4];
 711         tbm_surface_info_s sinfo;
 712         int i = 0;
 713         char *surface_info = (char *)&sinfo;
 714         int surface_info_size = sizeof(tbm_surface_info_s);
 715         intptr_t v_data = (intptr_t)video_data;
 716         media_format_mimetype_e mimetype = MEDIA_FORMAT_NV12;
 717         bool ret_val = false;
 718         uint64_t pts = 0;
 719         int orientation = 0;
 720         int msg_len = 0;
 721
 722         memset(&sinfo, 0, sizeof(tbm_surface_info_s));
 723         memset(tfd, INVALID_DEFAULT_VALUE, sizeof(tfd));
 724         memset(key, INVALID_DEFAULT_VALUE, sizeof(key));
 725
 726         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
 727         if (muse_player == NULL) {
 728                 LOGE("handle is NULL");
 729                 /* resource will be released after return */
 730                 goto ERROR;
 731         }
 732
 733         if (muse_player->export_video_data == false) {
 734                 LOGE("do not export video data");
 735                 goto ERROR;
 736         }
 737
 738         /* check bo */
 739         for (i = 0, bo_num = 0; i < BUFFER_MAX_PLANE_NUM; i++) {
 740                 if (video_stream->bo[i]) {
 741                         key[i] = tbm_bo_export(video_stream->bo[i]); /* FIXME: will be exchanged to the unique index */
 742                         tfd[i] = tbm_bo_export_fd(video_stream->bo[i]);
 743
 744                         if (i == 0 && tfd[0] <= INVALID_DEFAULT_VALUE) {
 745                                 LOGE("failed to get tbm fd from %p", video_stream->bo[0]);
 746                                 /* resource will be released after return */
 747                                 goto ERROR;
 748                         }
 749                         bo_num++;
 750                 }
 751         }
 752
 753         if (bo_num <= 0) {
 754                 LOGE("There is no valid tbm bo");
 755                 goto ERROR;
 756         }
 757
 758         /* get format info */
 759         ret = _get_tbm_surface_format(video_stream->format, &bo_format);
 760         ret |= _get_media_packet_mimetype(video_stream->format, &mimetype);
 761
 762         if (ret != PLAYER_ERROR_NONE) {
 763                 LOGE("Fail to get format info");
 764                 goto ERROR;
 765         }
 766
 767         sinfo.width = video_stream->width;
 768         sinfo.height = video_stream->height;
 769         sinfo.format = bo_format;
 770         sinfo.bpp = tbm_surface_internal_get_bpp(bo_format);
 771         sinfo.num_planes = tbm_surface_internal_get_num_planes(bo_format);
 772         sinfo.size = 0;
 773
 774         for (i = 0; i < sinfo.num_planes; i++) {
 775                 sinfo.planes[i].stride = video_stream->stride[i];
 776                 sinfo.planes[i].size = video_stream->stride[i] * video_stream->elevation[i];
 777                 if (i < bo_num)
 778                         sinfo.planes[i].offset = 0;
 779                 else
 780                         sinfo.planes[i].offset = sinfo.planes[i - 1].offset + sinfo.planes[i - 1].size;
 781                 sinfo.size += sinfo.planes[i].size;
 782                 if (video_stream->format == MM_PIXEL_FORMAT_RGBA)
 783                         sinfo.size = video_stream->stride[0] * video_stream->height;
 784         }
 785
 786         pts = (uint64_t)video_stream->timestamp * 1000000;
 787         orientation = video_stream->orientation;
 788
 789         g_mutex_lock(&muse_player->list_lock);
 790         if (g_list_length(muse_player->video_data_list) > muse_player->extra_size_of_buffers) {
 791                 LOGE("Too many buffers are not released. video(%p) will be drop.", video_data);
 792                 g_mutex_unlock(&muse_player->list_lock);
 793                 goto ERROR;
 794         }
 795
 796         muse_player->video_data_list = g_list_append(muse_player->video_data_list, (gpointer)video_data);
 797         g_mutex_unlock(&muse_player->list_lock);
 798
 799         msg_len = (surface_info_size / sizeof(int) + (surface_info_size % sizeof(int) ? 1 : 0));
 800         PLAYER_SEND_EVENT_MSG_WITH_TFDS(api, ev, module, tfd,
 801                 MUSE_TYPE_INT, "key[0]", key[0], MUSE_TYPE_INT, "key[1]", key[1],
 802                 MUSE_TYPE_INT, "key[2]", key[2], MUSE_TYPE_INT, "key[3]", key[3],
 803                 MUSE_TYPE_POINTER, "v_data", v_data, MUSE_TYPE_INT, "mimetype", (int)mimetype,
 804                 MUSE_TYPE_INT64, "pts", (INT64)pts, MUSE_TYPE_INT, "orientation", orientation,
 805                 MUSE_TYPE_ARRAY, "surface_info", msg_len, surface_info);
 806
 807         ret_val = true;
 808 ERROR:
 809
 810         for (i = 0; i < bo_num; i++) {
 811                 if (tfd[i] > INVALID_DEFAULT_VALUE)
 812                         close(tfd[i]);
 813         }
 814
 815         return ret_val;
 816 }
 817
 818 static void _video_stream_changed_cb(int width, int height, int fps, int bit_rate, void *user_data)
 819 {
 820         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 821         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED;
 822         muse_module_h module = (muse_module_h)user_data;
 823
 824         PLAYER_SEND_EVENT_MSG(api, ev, module,
 825                         MUSE_TYPE_INT, "width", width, MUSE_TYPE_INT, "height", height,
 826                         MUSE_TYPE_INT, "fps", fps, MUSE_TYPE_INT, "bit_rate", bit_rate);
 827 }
 828
 829 static void _media_stream_audio_buffer_status_cb(player_media_stream_buffer_status_e status, void *user_data)
 830 {
 831         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 832         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS;
 833         muse_module_h module = (muse_module_h)user_data;
 834
 835         PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT, "status", (int)status);
 836 }
 837
 838 static void _media_stream_video_buffer_status_cb(player_media_stream_buffer_status_e status, void *user_data)
 839 {
 840         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 841         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS;
 842         muse_module_h module = (muse_module_h)user_data;
 843
 844         PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT, "status", (int)status);
 845 }
 846
 847 static void _media_stream_audio_buffer_status_cb_ex(player_media_stream_buffer_status_e status, unsigned long long bytes, void *user_data)
 848 {
 849         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 850         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO;
 851         muse_module_h module = (muse_module_h)user_data;
 852
 853         PLAYER_SEND_EVENT_MSG(api, ev, module,
 854                         MUSE_TYPE_INT, "status", (int)status, MUSE_TYPE_INT64, "bytes", (INT64)bytes);
 855 }
 856
 857 static void _media_stream_video_buffer_status_cb_ex(player_media_stream_buffer_status_e status, unsigned long long bytes, void *user_data)
 858 {
 859         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 860         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO;
 861         muse_module_h module = (muse_module_h)user_data;
 862
 863         PLAYER_SEND_EVENT_MSG(api, ev, module,
 864                         MUSE_TYPE_INT, "status", (int)status, MUSE_TYPE_INT64, "bytes", (INT64)bytes);
 865 }
 866
 867 static void _media_stream_audio_seek_cb(unsigned long long offset, void *user_data)
 868 {
 869         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 870         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK;
 871         muse_module_h module = (muse_module_h)user_data;
 872
 873         PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT64, "offset", (INT64)offset);
 874 }
 875
 876 static void _media_stream_video_seek_cb(unsigned long long offset, void *user_data)
 877 {
 878         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 879         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK;
 880         muse_module_h module = (muse_module_h)user_data;
 881
 882         PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT64, "offset", (INT64)offset);
 883 }
 884
 885 static void _interrupted_cb(void *user_data)
 886 {
 887         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_INTERRUPT;
 888         __player_callback(ev, (muse_module_h)user_data);
 889 }
 890
 891 static void _set_interrupted_cb(legacy_player_h player, void *module, bool set)
 892 {
 893         if (set)
 894                 legacy_player_set_interrupted_cb(player, _interrupted_cb, module);
 895         else
 896                 legacy_player_unset_interrupted_cb(player);
 897 }
 898
 899 static void _error_cb(int code, void *user_data)
 900 {
 901         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 902         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_ERROR;
 903         muse_module_h module = (muse_module_h)user_data;
 904
 905         LOGD("ENTER code 0x%X", code);
 906
 907         PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT, "code", code);
 908 }
 909
 910 static void _set_error_cb(legacy_player_h player, void *module, bool set)
 911 {
 912         if (set)
 913                 legacy_player_set_error_cb(player, _error_cb, module);
 914         else
 915                 legacy_player_unset_error_cb(player);
 916 }
 917
 918 static void _subtitle_updated_cb(unsigned long duration, char *text, void *user_data)
 919 {
 920         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 921         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_SUBTITLE;
 922         muse_module_h module = (muse_module_h)user_data;
 923
 924         LOGD("ENTER");
 925
 926         PLAYER_SEND_EVENT_MSG(api, ev, module,
 927                         MUSE_TYPE_INT, "duration", (int)duration, MUSE_TYPE_STRING, "text", (const char *)text);
 928 }
 929
 930 static void _set_subtitle_cb(legacy_player_h player, void *module, bool set)
 931 {
 932         if (set)
 933                 legacy_player_set_subtitle_updated_cb(player, _subtitle_updated_cb, module);
 934         else
 935                 legacy_player_unset_subtitle_updated_cb(player);
 936 }
 937
 938 static void _buffering_cb(int percent, void *user_data)
 939 {
 940         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
 941         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_BUFFERING;
 942         muse_module_h module = (muse_module_h)user_data;
 943
 944         LOGD("ENTER");
 945
 946         PLAYER_SEND_EVENT_MSG(api, ev, module, MUSE_TYPE_INT, "percent", percent);
 947
 948 }
 949
 950 static void _set_buffering_cb(legacy_player_h player, void *module, bool set)
 951 {
 952         if (set)
 953                 legacy_player_set_buffering_cb(player, _buffering_cb, module);
 954         else
 955                 legacy_player_unset_buffering_cb(player);
 956 }
 957
 958 static void _set_media_packet_video_frame_cb(legacy_player_h player, void *data, bool set)
 959 {
 960         int ret = PLAYER_ERROR_NONE;
 961         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
 962         muse_module_h module = (muse_module_h)data;
 963         muse_player_handle_t *muse_player = NULL;
 964         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
 965
 966         if (set) {
 967                 muse_player->export_video_data = true;
 968                 ret = legacy_player_set_media_packet_video_frame_decoded_cb(player, __video_decoded_callback, module);
 969         } else {
 970                 muse_player->export_video_data = false;
 971                 LOGD("video data will not be exported.");
 972         }
 973
 974         PLAYER_RETURN_MSG(api, ret, module);
 975 }
 976
 977 static void _set_video_stream_changed_cb(legacy_player_h player, void *data, bool set)
 978 {
 979         int ret = PLAYER_ERROR_NONE;
 980         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
 981         muse_module_h module = (muse_module_h)data;
 982
 983         if (set)
 984                 ret = legacy_player_set_video_stream_changed_cb(player, _video_stream_changed_cb, module);
 985         else
 986                 ret = legacy_player_unset_video_stream_changed_cb(player);
 987
 988         PLAYER_RETURN_MSG(api, ret, module);
 989 }
 990
 991 static void _set_media_stream_audio_seek_cb(legacy_player_h player, void *data, bool set)
 992 {
 993         int ret = PLAYER_ERROR_NONE;
 994         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
 995         muse_module_h module = (muse_module_h)data;
 996
 997         if (set)
 998                 ret = legacy_player_set_media_stream_seek_cb(player, PLAYER_STREAM_TYPE_AUDIO, _media_stream_audio_seek_cb, module);
 999         else
1000                 ret = legacy_player_unset_media_stream_seek_cb(player, PLAYER_STREAM_TYPE_AUDIO);
1001
1002         PLAYER_RETURN_MSG(api, ret, module);
1003 }
1004
1005 static void _set_media_stream_video_seek_cb(legacy_player_h player, void *data, bool set)
1006 {
1007         int ret = PLAYER_ERROR_NONE;
1008         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
1009         muse_module_h module = (muse_module_h)data;
1010
1011         if (set)
1012                 ret = legacy_player_set_media_stream_seek_cb(player, PLAYER_STREAM_TYPE_VIDEO, _media_stream_video_seek_cb, module);
1013         else
1014                 ret = legacy_player_unset_media_stream_seek_cb(player, PLAYER_STREAM_TYPE_VIDEO);
1015
1016         PLAYER_RETURN_MSG(api, ret, module);
1017 }
1018
1019 static void _set_media_stream_audio_buffer_cb(legacy_player_h player, void *data, bool set)
1020 {
1021         int ret = PLAYER_ERROR_NONE;
1022         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
1023         muse_module_h module = (muse_module_h)data;
1024
1025         if (set)
1026                 ret = legacy_player_set_media_stream_buffer_status_cb(player, PLAYER_STREAM_TYPE_AUDIO, _media_stream_audio_buffer_status_cb, module);
1027         else
1028                 ret = legacy_player_unset_media_stream_buffer_status_cb(player, PLAYER_STREAM_TYPE_AUDIO);
1029
1030         PLAYER_RETURN_MSG(api, ret, module);
1031 }
1032
1033 static void _set_media_stream_video_buffer_cb(legacy_player_h player, void *data, bool set)
1034 {
1035         int ret = PLAYER_ERROR_NONE;
1036         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
1037         muse_module_h module = (muse_module_h)data;
1038
1039         if (set)
1040                 ret = legacy_player_set_media_stream_buffer_status_cb(player, PLAYER_STREAM_TYPE_VIDEO, _media_stream_video_buffer_status_cb, module);
1041         else
1042                 ret = legacy_player_unset_media_stream_buffer_status_cb(player, PLAYER_STREAM_TYPE_VIDEO);
1043
1044         PLAYER_RETURN_MSG(api, ret, module);
1045 }
1046
1047 static void _set_media_stream_audio_buffer_cb_ex(legacy_player_h player, void *data, bool set)
1048 {
1049         int ret = PLAYER_ERROR_NONE;
1050         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
1051         muse_module_h module = (muse_module_h)data;
1052
1053         if (set)
1054                 ret = legacy_player_set_media_stream_buffer_status_cb_ex(player, PLAYER_STREAM_TYPE_AUDIO, _media_stream_audio_buffer_status_cb_ex, module);
1055         else
1056                 ret = legacy_player_unset_media_stream_buffer_status_cb_ex(player, PLAYER_STREAM_TYPE_AUDIO);
1057
1058         PLAYER_RETURN_MSG(api, ret, module);
1059 }
1060
1061 static void _set_media_stream_video_buffer_cb_ex(legacy_player_h player, void *data, bool set)
1062 {
1063         int ret = PLAYER_ERROR_NONE;
1064         muse_player_api_e api = MUSE_PLAYER_API_SET_CALLBACK;
1065         muse_module_h module = (muse_module_h)data;
1066
1067         if (set)
1068                 ret = legacy_player_set_media_stream_buffer_status_cb_ex(player, PLAYER_STREAM_TYPE_VIDEO, _media_stream_video_buffer_status_cb_ex, module);
1069         else
1070                 ret = legacy_player_unset_media_stream_buffer_status_cb_ex(player, PLAYER_STREAM_TYPE_VIDEO);
1071
1072         PLAYER_RETURN_MSG(api, ret, module);
1073 }
1074
1075 static void (*set_callback_func[MUSE_PLAYER_EVENT_TYPE_NUM])(legacy_player_h player, void *user_data, bool set) = {
1076         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_PREPARE */
1077         _set_completed_cb,              /* MUSE_PLAYER_EVENT_TYPE_COMPLETE */
1078         _set_interrupted_cb,    /* MUSE_PLAYER_EVENT_TYPE_INTERRUPT */
1079         _set_error_cb,                  /* MUSE_PLAYER_EVENT_TYPE_ERROR */
1080         _set_buffering_cb,              /* MUSE_PLAYER_EVENT_TYPE_BUFFERING */
1081         _set_subtitle_cb,               /* MUSE_PLAYER_EVENT_TYPE_SUBTITLE */
1082         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_CAPTURE */
1083         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_SEEK */
1084         _set_media_packet_video_frame_cb,       /* MUSE_PLAYER_EVENT_TYPE_MEDIA_PACKET_VIDEO_FRAME */
1085         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_AUDIO_FRAME */
1086         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_VIDEO_FRAME_RENDER_ERROR */
1087         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT */
1088         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_SUPPORTED_AUDIO_EFFECT_PRESET */
1089         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_MISSED_PLUGIN */
1090 #ifdef _PLAYER_FOR_PRODUCT
1091         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_IMAGE_BUFFER */
1092         NULL,                                   /* MUSE_PLAYER_EVENT_TYPE_SELECTED_SUBTITLE_LANGUAGE */
1093 #endif
1094         _set_media_stream_video_buffer_cb,      /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS */
1095         _set_media_stream_audio_buffer_cb,      /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS */
1096         _set_media_stream_video_buffer_cb_ex,   /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_BUFFER_STATUS_WITH_INFO */
1097         _set_media_stream_audio_buffer_cb_ex,   /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_BUFFER_STATUS_WITH_INFO */
1098         _set_media_stream_video_seek_cb,        /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_VIDEO_SEEK */
1099         _set_media_stream_audio_seek_cb,        /* MUSE_PLAYER_EVENT_TYPE_MEDIA_STREAM_AUDIO_SEEK */
1100         NULL,                                                           /* MUSE_PLAYER_EVENT_TYPE_AUDIO_STREAM_CHANGED */
1101         _set_video_stream_changed_cb,           /* MUSE_PLAYER_EVENT_TYPE_VIDEO_STREAM_CHANGED */
1102 #ifdef TIZEN_FEATURE_EVAS_RENDERER
1103         _set_retrieve_buffer_cb,        /* MUSE_PLAYER_EVENT_TYPE_RETURN_BUFFER */
1104 #endif
1105         NULL,                           /* MUSE_PLAYER_EVENT_TYPE_SERVICE_DISCONNECTED */
1106 };
1107
1108 static int _push_media_stream(muse_player_handle_t *muse_player, player_push_media_msg_type *push_media, char *buf)
1109 {
1110         int ret = MEDIA_FORMAT_ERROR_NONE;
1111         media_format_h format;
1112         media_packet_h packet;
1113         media_format_mimetype_e mimetype;
1114         int width = 0;
1115         int height = 0;
1116
1117         if (push_media->mimetype & MEDIA_FORMAT_VIDEO) {
1118                 if (!muse_player->video_format) {
1119                         media_format_create(&muse_player->video_format);
1120                         if (!muse_player->video_format) {
1121                                 LOGE("fail to create media format");
1122                                 return PLAYER_ERROR_INVALID_PARAMETER;
1123                         }
1124                         ret |= media_format_set_video_mime(muse_player->video_format, push_media->mimetype);
1125                         ret |= media_format_set_video_width(muse_player->video_format, push_media->width);
1126                         ret |= media_format_set_video_height(muse_player->video_format, push_media->height);
1127                 }
1128                 ret |= media_format_get_video_info(muse_player->video_format, &mimetype, &width, &height, NULL, NULL);
1129                 if (mimetype != push_media->mimetype) {
1130                         media_format_unref(muse_player->video_format);
1131                         media_format_create(&muse_player->video_format);
1132                         ret |= media_format_set_video_mime(muse_player->video_format, push_media->mimetype);
1133                         ret |= media_format_set_video_width(muse_player->video_format, push_media->width);
1134                         ret |= media_format_set_video_height(muse_player->video_format, push_media->height);
1135                 }
1136                 format = muse_player->video_format;
1137         } else if (push_media->mimetype & MEDIA_FORMAT_AUDIO) {
1138                 if (!muse_player->audio_format) {
1139                         media_format_create(&muse_player->audio_format);
1140                         if (!muse_player->audio_format) {
1141                                 LOGE("fail to create media format");
1142                                 return PLAYER_ERROR_INVALID_PARAMETER;
1143                         }
1144                         ret |= media_format_set_audio_mime(muse_player->audio_format, push_media->mimetype);
1145                 }
1146                 ret |= media_format_get_audio_info(muse_player->audio_format, &mimetype, NULL, NULL, NULL, NULL);
1147                 if (mimetype != push_media->mimetype) {
1148                         media_format_unref(muse_player->audio_format);
1149                         media_format_create(&muse_player->audio_format);
1150                         ret |= media_format_set_audio_mime(muse_player->audio_format, push_media->mimetype);
1151                 }
1152                 format = muse_player->audio_format;
1153         } else {
1154                 ret = MEDIA_FORMAT_ERROR_INVALID_PARAMETER;
1155         }
1156
1157         if (ret != MEDIA_FORMAT_ERROR_NONE) {
1158                 LOGE("Invalid MIME %d", push_media->mimetype);
1159                 return PLAYER_ERROR_INVALID_PARAMETER;
1160         }
1161
1162         if (buf) {
1163                 ret = media_packet_create_from_external_memory(format, buf, push_media->size, NULL, NULL, &packet);
1164                 if (ret != MEDIA_PACKET_ERROR_NONE) {
1165                         LOGE("fail to create media packet with external mem");
1166                         return PLAYER_ERROR_INVALID_PARAMETER;
1167                 }
1168         } else {
1169                 ret = media_packet_create(format, NULL, NULL, &packet);
1170                 if (ret != MEDIA_PACKET_ERROR_NONE) {
1171                         LOGE("fail to create media packet");
1172                         return PLAYER_ERROR_INVALID_PARAMETER;
1173                 }
1174         }
1175
1176         if (push_media->codec_data_size > 0)
1177                 media_packet_set_codec_data(packet, push_media->codec_data, push_media->codec_data_size);
1178
1179         media_packet_set_pts(packet, push_media->pts);
1180         media_packet_set_flags(packet, push_media->flags);
1181
1182         ret = legacy_player_push_media_stream(muse_player->player_handle, packet);
1183         if (ret != PLAYER_ERROR_NONE)
1184                 LOGE("ret %d", ret);
1185
1186         media_packet_destroy(packet);
1187
1188         return ret;
1189 }
1190
1191 static void _audio_decoded_cb(player_audio_raw_data_s *audio_frame, void *user_data)
1192 {
1193         muse_player_cb_e api = MUSE_PLAYER_CB_EVENT;
1194         muse_player_event_e ev = MUSE_PLAYER_EVENT_TYPE_AUDIO_FRAME;
1195         muse_module_h module = (muse_module_h)user_data;
1196         muse_player_handle_t *muse_player = NULL;
1197         void *data = NULL;
1198         int size = 0;
1199         bool ret = true;
1200         tbm_fd tfd = INVALID_DEFAULT_VALUE;
1201         int key = INVALID_DEFAULT_VALUE;
1202
1203         /* LOGD("ENTER"); */
1204
1205         if (audio_frame) {
1206                 data = audio_frame->data;
1207                 size = audio_frame->size;
1208         }
1209
1210         if (data == NULL || size == 0) {
1211                 LOGE("audio frame is NULL");
1212                 return;
1213         }
1214
1215         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1216         if (muse_player == NULL) {
1217                 LOGE("handle is NULL");
1218                 return;
1219         }
1220
1221         ret = _create_export_data(muse_player, data, size, audio_frame, sizeof(player_audio_raw_data_s), &tfd, &key);
1222         if (!ret) {
1223                 LOGE("failed to create export data");
1224                 return;
1225         }
1226
1227         /* send message */
1228         PLAYER_SEND_EVENT_MSG_WITH_TFD(api, ev, module, tfd, MUSE_TYPE_INT, "key", key);
1229         return;
1230 }
1231
1232 int _player_disp_send_msg(int send_fd, char *msg, int *tfd)
1233 {
1234         int send_len = 0;
1235
1236         if ((send_fd <= 0) || !muse_core_fd_is_valid(send_fd)) {
1237                 LOGE("invalid socket fd %d", send_fd);
1238                 return PLAYER_ERROR_INVALID_OPERATION;
1239         }
1240
1241         if (tfd != NULL)
1242                 send_len = muse_core_msg_send_fd(send_fd, tfd, msg);
1243         else
1244                 send_len = muse_core_msg_send(send_fd, msg);
1245
1246         if (send_len <= 0) {
1247                 LOGE("sending message failed");
1248                 return PLAYER_ERROR_INVALID_OPERATION;
1249         }
1250
1251         return PLAYER_ERROR_NONE;
1252 }
1253
1254 int _player_disp_send_msg_async(int send_fd, char *msg)
1255 {
1256         int send_len = 0;
1257
1258         if ((send_fd <= 0) || !muse_core_fd_is_valid(send_fd)) {
1259                 LOGE("invalid socket fd %d", send_fd);
1260                 return PLAYER_ERROR_INVALID_OPERATION;
1261         }
1262
1263         send_len = muse_core_msg_send(send_fd, msg);
1264         if (send_len <= 0) {
1265                 LOGE("sending message failed");
1266                 return PLAYER_ERROR_INVALID_OPERATION;
1267         }
1268
1269         return PLAYER_ERROR_NONE;
1270 }
1271
1272 static bool _player_disp_get_param_value(char *buf, ...)
1273 {
1274         muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
1275         bool ret = true;
1276         va_list var_args;
1277         int type = MUSE_TYPE_ANY;
1278         char *param_name = NULL;
1279         void *value = NULL;
1280
1281         LOGE("ENTER");
1282
1283         void *jobj = muse_core_msg_object_new(buf, NULL, &err);
1284
1285         if (!jobj) {
1286                 LOGE("failed to get msg object. err:%d", err);
1287                 return false;
1288         }
1289
1290         va_start(var_args, buf);
1291
1292         while ((type = va_arg(var_args, int)) != INVALID_MUSE_TYPE_VALUE) {
1293                 param_name = va_arg(var_args, char *);
1294                 switch (type) {
1295                 case MUSE_TYPE_INT:
1296                 case MUSE_TYPE_INT64:
1297                 case MUSE_TYPE_DOUBLE:
1298                 case MUSE_TYPE_STRING:
1299                         value = va_arg(var_args, void *);
1300
1301                         if (!muse_core_msg_object_get_value(param_name, jobj, type, value)) {
1302                                 ret = false;
1303                                 LOGE("failed to get %s value", param_name);
1304                         }
1305                         break;
1306                 default:
1307                         LOGE("Unexpected type %d", type);
1308                         ret = false;
1309                         break;
1310                 }
1311         }
1312
1313         muse_core_msg_object_free(jobj);
1314
1315         va_end(var_args);
1316         return ret;
1317 }
1318
1319 int player_disp_create(muse_module_h module)
1320 {
1321         int ret = PLAYER_ERROR_NONE;
1322         muse_player_api_e api = MUSE_PLAYER_API_CREATE;
1323         muse_player_handle_t *muse_player = NULL;
1324
1325         int pid;
1326         intptr_t handle = 0;
1327         intptr_t module_addr = (intptr_t)module;
1328
1329         player_msg_get(pid, muse_server_module_get_msg(module));
1330
1331         /* init handle */
1332         muse_player = g_try_new0(muse_player_handle_t, 1);
1333         if (!muse_player) {
1334                 ret = PLAYER_ERROR_OUT_OF_MEMORY;
1335                 LOGE("failed to alloc handle 0x%x", ret);
1336                 PLAYER_RETURN_MSG(api, ret, module);
1337                 return ret;
1338         }
1339
1340         /* get buffer mgr */
1341         if (muse_server_ipc_get_bufmgr(&muse_player->bufmgr) != MM_ERROR_NONE) {
1342                 LOGE("muse_server_ipc_get_bufmgr failed");
1343                 ret = PLAYER_ERROR_INVALID_OPERATION;
1344                 goto ERROR;
1345         }
1346
1347         /* create player handle */
1348         ret = legacy_player_create(&muse_player->player_handle);
1349         if (ret != PLAYER_ERROR_NONE)
1350                 goto ERROR;
1351
1352         muse_player->total_size_of_buffers = DEFAULT_VDEC_TOTAL_SIZE_OF_BUFFER;
1353         muse_player->extra_size_of_buffers = DEFAULT_VDEC_EXTRA_SIZE_OF_BUFFER;
1354         g_mutex_init(&muse_player->list_lock);
1355
1356         LOGD("handle : %p, module : %p", muse_player, module);
1357
1358         handle = (intptr_t)muse_player;
1359         muse_server_ipc_set_handle(module, handle);
1360         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_POINTER, "module_addr", module_addr);
1361         if (ret != PLAYER_ERROR_NONE) {
1362                 LOGE("failed to return msg");
1363                 goto ERROR;
1364         }
1365         return ret;
1366
1367 ERROR:
1368         legacy_player_destroy(muse_player->player_handle);
1369
1370         g_free(muse_player);
1371         muse_player = NULL;
1372         PLAYER_RETURN_MSG(api, ret, module);
1373         return ret;
1374 }
1375
1376 int player_disp_destroy(muse_module_h module)
1377 {
1378         int ret = PLAYER_ERROR_NONE;
1379         muse_player_api_e api = MUSE_PLAYER_API_DESTROY;
1380         muse_player_handle_t *muse_player = NULL;
1381
1382         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1383
1384         /* decoder buffer need to be released first to destroy pipeline */
1385         _remove_export_media_packet(module);
1386
1387         ret = legacy_player_destroy(muse_player->player_handle);
1388
1389         if (muse_player->audio_format) {
1390                 media_format_unref(muse_player->audio_format);
1391                 muse_player->audio_format = NULL;
1392         }
1393         if (muse_player->video_format) {
1394                 media_format_unref(muse_player->video_format);
1395                 muse_player->video_format = NULL;
1396         }
1397
1398         _remove_export_data(module, 0, true);
1399         g_mutex_clear(&muse_player->list_lock);
1400
1401         muse_player->bufmgr = NULL;
1402
1403         g_free(muse_player);
1404         muse_player = NULL;
1405
1406         PLAYER_RETURN_MSG(api, ret, module);
1407
1408         return PLAYER_ERROR_NONE; /* to clean up the resource */
1409 }
1410
1411 int player_disp_prepare(muse_module_h module)
1412 {
1413         int ret = PLAYER_ERROR_NONE;
1414         muse_player_api_e api = MUSE_PLAYER_API_PREPARE;
1415         muse_player_handle_t *muse_player = NULL;
1416         int timeout = 0;
1417         int num = 0, extra_num = 0;
1418
1419         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1420         muse_player->export_video_data = true;
1421
1422         ret = legacy_player_prepare(muse_player->player_handle);
1423         if (ret == PLAYER_ERROR_NONE) {
1424                 ret = legacy_player_get_num_of_video_out_buffers(muse_player->player_handle, &num, &extra_num);
1425                 LOGD("num of vdec out buffer, total:%d, extra:%d", num, extra_num);
1426         }
1427
1428         if (ret == PLAYER_ERROR_NONE) {
1429                 legacy_player_get_timeout_for_muse(muse_player->player_handle, &timeout);
1430                 muse_player->total_size_of_buffers = num;
1431                 muse_player->extra_size_of_buffers = extra_num;
1432                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "timeout", timeout);
1433         } else {
1434                 PLAYER_RETURN_MSG(api, ret, module);
1435         }
1436
1437         return ret;
1438 }
1439
1440 int player_disp_prepare_async(muse_module_h module)
1441 {
1442         int ret = PLAYER_ERROR_NONE;
1443         muse_player_api_e api = MUSE_PLAYER_API_PREPARE_ASYNC;
1444         muse_player_handle_t *muse_player = NULL;
1445         prepare_data_t *prepare_data;
1446         int timeout = 0;
1447
1448         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1449
1450         prepare_data = g_try_new(prepare_data_t, 1);
1451         if (!prepare_data) {
1452                 ret = PLAYER_ERROR_INVALID_OPERATION;
1453                 goto ERROR;
1454         }
1455
1456         prepare_data->player = muse_player->player_handle;
1457         prepare_data->module = module;
1458
1459         ret = legacy_player_prepare_async(muse_player->player_handle, _prepare_async_cb, prepare_data);
1460         if (ret == PLAYER_ERROR_NONE) {
1461                 legacy_player_get_timeout_for_muse(muse_player->player_handle, &timeout);
1462                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "timeout", timeout);
1463                 return ret;
1464         } /* else is error */
1465
1466 ERROR:
1467         g_free(prepare_data);
1468
1469         PLAYER_RETURN_MSG(api, ret, module);
1470         return ret;
1471 }
1472
1473 int player_disp_unprepare(muse_module_h module)
1474 {
1475         int ret = PLAYER_ERROR_NONE;
1476         muse_player_api_e api = MUSE_PLAYER_API_UNPREPARE;
1477         muse_player_handle_t *muse_player = NULL;
1478
1479         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1480
1481         /* decoder buffer need to be released first to destroy pipeline */
1482         _remove_export_media_packet(module);
1483
1484         ret = legacy_player_unprepare(muse_player->player_handle);
1485
1486         _remove_export_data(module, 0, true);
1487
1488         PLAYER_RETURN_MSG(api, ret, module);
1489
1490         return ret;
1491 }
1492
1493 int player_disp_set_uri(muse_module_h module)
1494 {
1495         int ret = PLAYER_ERROR_NONE;
1496         muse_player_api_e api = MUSE_PLAYER_API_SET_URI;
1497         muse_player_handle_t *muse_player = NULL;
1498         char path[MUSE_URI_MAX_LENGTH] = { 0, };
1499
1500         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1501         player_msg_get_string(path, muse_server_module_get_msg(module));
1502
1503         if ((ret = _check_supportable(module, path)) == PLAYER_ERROR_NONE)
1504                 ret = legacy_player_set_uri(muse_player->player_handle, path);
1505
1506         PLAYER_RETURN_MSG(api, ret, module);
1507         return ret;
1508 }
1509
1510 int player_disp_start(muse_module_h module)
1511 {
1512         int ret = PLAYER_ERROR_NONE;
1513         muse_player_api_e api = MUSE_PLAYER_API_START;
1514         muse_player_handle_t *muse_player = NULL;
1515
1516         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1517
1518         ret = legacy_player_start(muse_player->player_handle);
1519
1520         PLAYER_RETURN_MSG(api, ret, module);
1521
1522         return ret;
1523 }
1524
1525 int player_disp_stop(muse_module_h module)
1526 {
1527         int ret = PLAYER_ERROR_NONE;
1528         muse_player_api_e api = MUSE_PLAYER_API_STOP;
1529         muse_player_handle_t *muse_player = NULL;
1530
1531         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1532
1533         ret = legacy_player_stop(muse_player->player_handle);
1534
1535         PLAYER_RETURN_MSG(api, ret, module);
1536
1537         return ret;
1538 }
1539
1540 int player_disp_pause(muse_module_h module)
1541 {
1542         int ret = PLAYER_ERROR_NONE;
1543         muse_player_api_e api = MUSE_PLAYER_API_PAUSE;
1544         muse_player_handle_t *muse_player = NULL;
1545
1546         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1547
1548         ret = legacy_player_pause(muse_player->player_handle);
1549
1550         PLAYER_RETURN_MSG(api, ret, module);
1551
1552         return ret;
1553 }
1554
1555 int player_disp_set_memory_buffer(muse_module_h module)
1556 {
1557         int ret = PLAYER_ERROR_NONE;
1558         muse_player_api_e api = MUSE_PLAYER_API_SET_MEMORY_BUFFER;
1559         muse_player_handle_t *muse_player = NULL;
1560
1561         tbm_bo bo = NULL;
1562         tbm_bo_handle thandle = {NULL, };
1563         tbm_fd tfd = INVALID_DEFAULT_VALUE;
1564         int size = 0;
1565         intptr_t bo_addr = 0;
1566
1567         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1568         player_msg_get_type(size, muse_server_module_get_msg(module), INT);
1569
1570         muse_server_ipc_get_fd(module, &tfd);
1571         if (tfd > INVALID_DEFAULT_VALUE)
1572                 bo = tbm_bo_import_fd(muse_player->bufmgr, tfd);
1573
1574         if (bo == NULL) {
1575                 LOGE("TBM get error : bo is NULL");
1576                 ret = PLAYER_ERROR_INVALID_OPERATION;
1577                 goto ERROR;
1578         }
1579         thandle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
1580         if (thandle.ptr == NULL) {
1581                 LOGE("TBM get error : handle pointer is NULL");
1582                 ret = PLAYER_ERROR_INVALID_OPERATION;
1583                 goto ERROR;
1584         }
1585
1586         bo_addr = (intptr_t)bo;
1587         ret = legacy_player_set_memory_buffer(muse_player->player_handle, thandle.ptr, size);
1588         if (ret != PLAYER_ERROR_NONE) {
1589                 tbm_bo_unmap(bo);
1590                 goto ERROR;
1591         }
1592
1593         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "bo_addr", bo_addr);
1594
1595         /* don't call bo unmap/unref here *
1596          * it will be released at player_disp_deinit_memory_buffer() during _destroy */
1597
1598         close(tfd);
1599         return ret;
1600
1601 ERROR:
1602         if (tfd > INVALID_DEFAULT_VALUE)
1603                 close(tfd);
1604
1605         if (bo)
1606                 tbm_bo_unref(bo);
1607
1608         PLAYER_RETURN_MSG(api, ret, module);
1609         return ret;
1610 }
1611
1612 int player_disp_deinit_memory_buffer(muse_module_h module)      /* MUSE_PLAYER_API_DEINIT_MEMORY_BUFFER */
1613 {
1614         intptr_t bo_addr;
1615         tbm_bo bo;
1616
1617         if (player_msg_get(bo_addr, muse_server_module_get_msg(module))) {
1618
1619                 bo = (tbm_bo)bo_addr;
1620
1621                 tbm_bo_unmap(bo);
1622                 tbm_bo_unref(bo);
1623         }
1624
1625         return PLAYER_ERROR_NONE;
1626 }
1627
1628 int player_disp_get_state(muse_module_h module)
1629 {
1630         int ret = PLAYER_ERROR_NONE;
1631         muse_player_api_e api = MUSE_PLAYER_API_GET_STATE;
1632         muse_player_handle_t *muse_player = NULL;
1633         player_state_e state;
1634
1635         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1636
1637         ret = legacy_player_get_state(muse_player->player_handle, &state);
1638
1639         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "state", (int)state);
1640
1641         return ret;
1642 }
1643
1644 int player_disp_set_volume(muse_module_h module)
1645 {
1646         int ret = PLAYER_ERROR_NONE;
1647         muse_player_api_e api = MUSE_PLAYER_API_SET_VOLUME;
1648         muse_player_handle_t *muse_player = NULL;
1649         double left, right;
1650         bool ret_val = true;
1651
1652         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
1653                                                                 MUSE_TYPE_DOUBLE, "left", (void *)&left,
1654                                                                 MUSE_TYPE_DOUBLE, "right", (void *)&right,
1655                                                                 INVALID_MUSE_TYPE_VALUE);
1656         if (ret_val) {
1657                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1658                 ret = legacy_player_set_volume(muse_player->player_handle, (float)left, (float)right);
1659         } else {
1660                 ret = PLAYER_ERROR_INVALID_OPERATION;
1661         }
1662         PLAYER_RETURN_MSG(api, ret, module);
1663
1664         return ret;
1665 }
1666
1667 int player_disp_get_volume(muse_module_h module)
1668 {
1669         int ret = PLAYER_ERROR_NONE;
1670         muse_player_api_e api = MUSE_PLAYER_API_GET_VOLUME;
1671         muse_player_handle_t *muse_player = NULL;
1672         float left, right;
1673
1674         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1675
1676         ret = legacy_player_get_volume(muse_player->player_handle, &left, &right);
1677
1678         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_DOUBLE, "left", (double)left, MUSE_TYPE_DOUBLE, "right", (double)right);
1679
1680         return ret;
1681 }
1682
1683 int player_disp_set_sound_stream_info(muse_module_h module)
1684 {
1685         int ret = PLAYER_ERROR_NONE;
1686         muse_player_api_e api = MUSE_PLAYER_API_SET_SOUND_STREAM_INFO;
1687         muse_player_handle_t *muse_player = NULL;
1688         int stream_index = 0;
1689         char stream_type[MUSE_URI_MAX_LENGTH] = { 0, };
1690         bool ret_val = true;
1691
1692         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
1693                                                                 MUSE_TYPE_INT, "stream_index", (void *)&stream_index,
1694                                                                 MUSE_TYPE_STRING, "stream_type", (void *)stream_type,
1695                                                                 INVALID_MUSE_TYPE_VALUE);
1696         if (ret_val) {
1697                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1698                 ret = legacy_player_set_sound_stream_info_for_mused(muse_player->player_handle, stream_type, stream_index);
1699         } else {
1700                 ret = PLAYER_ERROR_INVALID_OPERATION;
1701         }
1702
1703         PLAYER_RETURN_MSG(api, ret, module);
1704
1705         return ret;
1706 }
1707
1708 int player_disp_set_audio_latency_mode(muse_module_h module)
1709 {
1710         int ret = PLAYER_ERROR_NONE;
1711         muse_player_api_e api = MUSE_PLAYER_API_SET_AUDIO_LATENCY_MODE;
1712         muse_player_handle_t *muse_player = NULL;
1713         int latency_mode = 0;
1714
1715         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1716         player_msg_get(latency_mode, muse_server_module_get_msg(module));
1717
1718         ret = legacy_player_set_audio_latency_mode(muse_player->player_handle, (audio_latency_mode_e)latency_mode);
1719
1720         PLAYER_RETURN_MSG(api, ret, module);
1721
1722         return ret;
1723 }
1724
1725 int player_disp_get_audio_latency_mode(muse_module_h module)
1726 {
1727         int ret = PLAYER_ERROR_NONE;
1728         muse_player_api_e api = MUSE_PLAYER_API_GET_AUDIO_LATENCY_MODE;
1729         muse_player_handle_t *muse_player = NULL;
1730         audio_latency_mode_e latency_mode;
1731
1732         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1733
1734         ret = legacy_player_get_audio_latency_mode(muse_player->player_handle, &latency_mode);
1735
1736         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "latency_mode", (int)latency_mode);
1737
1738         return ret;
1739 }
1740
1741 int player_disp_set_play_position(muse_module_h module)
1742 {
1743         int ret = PLAYER_ERROR_NONE;
1744         muse_player_api_e api = MUSE_PLAYER_API_SET_PLAY_POSITION;
1745         muse_player_handle_t *muse_player = NULL;
1746         int64_t pos = 0;
1747         int accurate = 0;
1748         bool ret_val = true;
1749
1750         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
1751                                                                 MUSE_TYPE_INT64, "pos", (void *)&pos,
1752                                                                 MUSE_TYPE_INT, "accurate", (void *)&accurate,
1753                                                                 INVALID_MUSE_TYPE_VALUE);
1754         if (ret_val) {
1755                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1756                 ret = legacy_player_set_play_position(muse_player->player_handle, pos, accurate, _seek_complate_cb, module);
1757         } else {
1758                 ret = PLAYER_ERROR_INVALID_OPERATION;
1759         }
1760
1761         PLAYER_RETURN_MSG(api, ret, module);
1762
1763         return ret;
1764 }
1765
1766 int player_disp_get_play_position(muse_module_h module)
1767 {
1768         int ret = PLAYER_ERROR_NONE;
1769         muse_player_api_e api = MUSE_PLAYER_API_GET_PLAY_POSITION;
1770         muse_player_handle_t *muse_player = NULL;
1771         int64_t pos = 0;
1772
1773         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1774
1775         ret = legacy_player_get_play_position(muse_player->player_handle, &pos);
1776
1777         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT64, "pos", pos);
1778
1779         return ret;
1780 }
1781
1782 int player_disp_set_mute(muse_module_h module)
1783 {
1784         int ret = PLAYER_ERROR_NONE;
1785         muse_player_api_e api = MUSE_PLAYER_API_SET_MUTE;
1786         muse_player_handle_t *muse_player = NULL;
1787         int mute;
1788
1789         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1790         player_msg_get(mute, muse_server_module_get_msg(module));
1791
1792         ret = legacy_player_set_mute(muse_player->player_handle, (bool)mute);
1793
1794         PLAYER_RETURN_MSG(api, ret, module);
1795
1796         return ret;
1797 }
1798
1799 int player_disp_is_muted(muse_module_h module)
1800 {
1801         int ret = PLAYER_ERROR_NONE;
1802         muse_player_api_e api = MUSE_PLAYER_API_IS_MUTED;
1803         muse_player_handle_t *muse_player = NULL;
1804         bool mute;
1805
1806         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1807
1808         ret = legacy_player_is_muted(muse_player->player_handle, &mute);
1809
1810         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "mute", (int)mute);
1811
1812         return ret;
1813 }
1814
1815 int player_disp_set_looping(muse_module_h module)
1816 {
1817         int ret = PLAYER_ERROR_NONE;
1818         muse_player_api_e api = MUSE_PLAYER_API_SET_LOOPING;
1819         muse_player_handle_t *muse_player = NULL;
1820         int looping;
1821
1822         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1823         player_msg_get(looping, muse_server_module_get_msg(module));
1824
1825         ret = legacy_player_set_looping(muse_player->player_handle, (bool)looping);
1826
1827         PLAYER_RETURN_MSG(api, ret, module);
1828
1829         return ret;
1830 }
1831
1832 int player_disp_is_looping(muse_module_h module)
1833 {
1834         int ret = PLAYER_ERROR_NONE;
1835         muse_player_api_e api = MUSE_PLAYER_API_IS_LOOPING;
1836         muse_player_handle_t *muse_player = NULL;
1837         bool looping;
1838
1839         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1840
1841         ret = legacy_player_is_looping(muse_player->player_handle, &looping);
1842
1843         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "looping", (int)looping);
1844
1845         return ret;
1846 }
1847
1848 int player_disp_get_duration(muse_module_h module)
1849 {
1850         int ret = PLAYER_ERROR_NONE;
1851         muse_player_api_e api = MUSE_PLAYER_API_GET_DURATION;
1852         muse_player_handle_t *muse_player = NULL;
1853         int64_t duration = 0;
1854
1855         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1856
1857         ret = legacy_player_get_duration(muse_player->player_handle, &duration);
1858
1859         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT64, "duration", duration);
1860
1861         return ret;
1862 }
1863
1864 int player_disp_set_display(muse_module_h module)
1865 {
1866         int ret = PLAYER_ERROR_NONE;
1867         muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY;
1868         muse_player_handle_t *muse_player = NULL;
1869         wl_win_msg_type wl_win;
1870         char *wl_win_msg = (char *)&wl_win;
1871
1872         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1873         player_msg_get_array(wl_win_msg, muse_server_module_get_msg(module));
1874         ret = legacy_player_set_display(muse_player->player_handle, wl_win.type, wl_win.surface_id);
1875         PLAYER_RETURN_MSG(api, ret, module);
1876
1877         return ret;
1878 }
1879
1880
1881 int player_disp_set_display_mode(muse_module_h module)
1882 {
1883         int ret = PLAYER_ERROR_NONE;
1884         muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY_MODE;
1885         muse_player_handle_t *muse_player = NULL;
1886         int mode = 0;
1887
1888         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1889         player_msg_get(mode, muse_server_module_get_msg(module));
1890
1891         ret = legacy_player_set_display_mode(muse_player->player_handle, (player_display_mode_e)mode);
1892
1893         PLAYER_RETURN_MSG(api, ret, module);
1894
1895         return ret;
1896 }
1897
1898
1899 int player_disp_get_display_mode(muse_module_h module)
1900 {
1901         int ret = PLAYER_ERROR_NONE;
1902         muse_player_api_e api = MUSE_PLAYER_API_GET_DISPLAY_MODE;
1903         muse_player_handle_t *muse_player = NULL;
1904         player_display_mode_e mode = 0;
1905
1906         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1907
1908         ret = legacy_player_get_display_mode(muse_player->player_handle, &mode);
1909
1910         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "mode", (int)mode);
1911
1912         return ret;
1913 }
1914
1915 int player_disp_set_video_roi_area(muse_module_h module)
1916 {
1917         int ret = PLAYER_ERROR_NONE;
1918         muse_player_api_e api = MUSE_PLAYER_API_SET_VIDEO_ROI_AREA;
1919         muse_player_handle_t *muse_player = NULL;
1920         double x_scale = 0, y_scale = 0, w_scale = 0, h_scale = 0;
1921         bool ret_val = true;
1922
1923         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
1924                                         MUSE_TYPE_DOUBLE, "x_scale", (void *)&x_scale,
1925                                         MUSE_TYPE_DOUBLE, "y_scale", (void *)&y_scale,
1926                                         MUSE_TYPE_DOUBLE, "w_scale", (void *)&w_scale,
1927                                         MUSE_TYPE_DOUBLE, "h_scale", (void *)&h_scale,
1928                                         INVALID_MUSE_TYPE_VALUE);
1929         if (ret_val) {
1930                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1931                 ret = legacy_player_set_video_roi_area(muse_player->player_handle, x_scale,
1932                                 y_scale, w_scale, h_scale);
1933         }
1934
1935         PLAYER_RETURN_MSG(api, ret, module);
1936
1937         return ret;
1938 }
1939
1940 int player_disp_get_video_roi_area(muse_module_h module)
1941 {
1942         int ret = PLAYER_ERROR_NONE;
1943         muse_player_api_e api = MUSE_PLAYER_API_GET_VIDEO_ROI_AREA;
1944         muse_player_handle_t *muse_player = NULL;
1945         double scale_x = 0, scale_y = 0, scale_w = 0, scale_h = 0;
1946
1947         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1948
1949         ret = legacy_player_get_video_roi_area(muse_player->player_handle, &scale_x,
1950                         &scale_y, &scale_w, &scale_h);
1951
1952         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_DOUBLE, "scale_x", scale_x,
1953                         MUSE_TYPE_DOUBLE, "scale_y", scale_y,
1954                         MUSE_TYPE_DOUBLE, "scale_w", scale_w,
1955                         MUSE_TYPE_DOUBLE, "scale_h", scale_h);
1956
1957         return ret;
1958 }
1959
1960 int player_disp_set_display_roi_area(muse_module_h module)
1961 {
1962         int ret = PLAYER_ERROR_NONE;
1963         muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY_ROI_AREA;
1964         muse_player_handle_t *muse_player = NULL;
1965         wl_win_msg_type wl_win;
1966         char *wl_win_msg = (char *)&wl_win;
1967
1968         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1969
1970         player_msg_get_array(wl_win_msg, muse_server_module_get_msg(module));
1971
1972         ret = legacy_player_set_roi_area(muse_player->player_handle, wl_win.win_roi_x,
1973                         wl_win.win_roi_y, wl_win.win_roi_width, wl_win.win_roi_height);
1974
1975         PLAYER_RETURN_MSG(api, ret, module);
1976
1977         return ret;
1978 }
1979
1980 int player_disp_set_playback_rate(muse_module_h module)
1981 {
1982         int ret = PLAYER_ERROR_NONE;
1983         muse_player_api_e api = MUSE_PLAYER_API_SET_PLAYBACK_RATE;
1984         muse_player_handle_t *muse_player = NULL;
1985         double rate = 0;
1986
1987         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
1988         player_msg_get_type(rate, muse_server_module_get_msg(module), DOUBLE);
1989
1990         ret = legacy_player_set_playback_rate(muse_player->player_handle, (float)rate);
1991
1992         PLAYER_RETURN_MSG(api, ret, module);
1993
1994         return ret;
1995 }
1996
1997 int player_disp_set_display_rotation(muse_module_h module)
1998 {
1999         int ret = PLAYER_ERROR_NONE;
2000         muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY_ROTATION;
2001         muse_player_handle_t *muse_player = NULL;
2002         int rotation = 0;
2003
2004         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2005         player_msg_get(rotation, muse_server_module_get_msg(module));
2006
2007         ret = legacy_player_set_display_rotation(muse_player->player_handle, (player_display_rotation_e)rotation);
2008
2009         PLAYER_RETURN_MSG(api, ret, module);
2010
2011         return ret;
2012 }
2013
2014 int player_disp_get_display_rotation(muse_module_h module)
2015 {
2016         int ret = PLAYER_ERROR_NONE;
2017         muse_player_api_e api = MUSE_PLAYER_API_GET_DISPLAY_ROTATION;
2018         muse_player_handle_t *muse_player = NULL;
2019         player_display_rotation_e rotation;
2020
2021         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2022
2023         ret = legacy_player_get_display_rotation(muse_player->player_handle, &rotation);
2024
2025         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "rotation", (int)rotation);
2026
2027         return ret;
2028 }
2029
2030 int player_disp_set_display_visible(muse_module_h module)
2031 {
2032         int ret = PLAYER_ERROR_NONE;
2033         muse_player_api_e api = MUSE_PLAYER_API_SET_DISPLAY_VISIBLE;
2034         muse_player_handle_t *muse_player = NULL;
2035         int visible = 0;
2036
2037         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2038         player_msg_get(visible, muse_server_module_get_msg(module));
2039
2040         ret = legacy_player_set_display_visible(muse_player->player_handle, visible);
2041
2042         PLAYER_RETURN_MSG(api, ret, module);
2043
2044         return ret;
2045 }
2046
2047 int player_disp_is_display_visible(muse_module_h module)
2048 {
2049         int ret = PLAYER_ERROR_NONE;
2050         muse_player_api_e api = MUSE_PLAYER_API_IS_DISPLAY_VISIBLE;
2051         muse_player_handle_t *muse_player = NULL;
2052         bool value = 0;
2053
2054         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2055
2056         ret = legacy_player_is_display_visible(muse_player->player_handle, &value);
2057
2058         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "value", (int)value);
2059
2060         return ret;
2061 }
2062
2063 int player_disp_get_content_info(muse_module_h module)
2064 {
2065         int ret = PLAYER_ERROR_NONE;
2066         muse_player_handle_t *muse_player = NULL;
2067         muse_player_api_e api = MUSE_PLAYER_API_GET_CONTENT_INFO;
2068         char *value = NULL;
2069         player_content_info_e key;
2070
2071         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2072         player_msg_get(key, muse_server_module_get_msg(module));
2073
2074         ret = legacy_player_get_content_info(muse_player->player_handle, key, &value);
2075
2076         if (ret == PLAYER_ERROR_NONE) {
2077                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_STRING, "value", (const char *)value);
2078                 if (value)
2079                         free(value);
2080         } else {
2081                 PLAYER_RETURN_MSG(api, ret, module);
2082         }
2083
2084         return ret;
2085 }
2086
2087 int player_disp_get_codec_info(muse_module_h module)
2088 {
2089         int ret = PLAYER_ERROR_NONE;
2090         muse_player_handle_t *muse_player = NULL;
2091         muse_player_api_e api = MUSE_PLAYER_API_GET_CODEC_INFO;
2092         char *video_codec = NULL;
2093         char *audio_codec = NULL;
2094
2095         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2096
2097         ret = legacy_player_get_codec_info(muse_player->player_handle, &audio_codec, &video_codec);
2098
2099         if (ret == PLAYER_ERROR_NONE) {
2100                 PLAYER_RETURN_MSG(api, ret, module,
2101                                 MUSE_TYPE_STRING, "audio_codec", (const char *)audio_codec,
2102                                 MUSE_TYPE_STRING, "video_codec", (const char *)video_codec);
2103                 if (audio_codec)
2104                         free(audio_codec);
2105                 if (video_codec)
2106                         free(video_codec);
2107         } else {
2108                 PLAYER_RETURN_MSG(api, ret, module);
2109         }
2110
2111         return ret;
2112 }
2113
2114 int player_disp_get_audio_stream_info(muse_module_h module)
2115 {
2116         int ret = PLAYER_ERROR_NONE;
2117         muse_player_handle_t *muse_player = NULL;
2118         muse_player_api_e api = MUSE_PLAYER_API_GET_AUDIO_STREAM_INFO;
2119         int sample_rate = 0;
2120         int channel = 0;
2121         int bit_rate = 0;
2122
2123         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2124
2125         ret = legacy_player_get_audio_stream_info(muse_player->player_handle, &sample_rate, &channel, &bit_rate);
2126
2127         PLAYER_RETURN_MSG(api, ret, module,
2128                                         MUSE_TYPE_INT, "sample_rate", sample_rate,
2129                                         MUSE_TYPE_INT, "channel", channel,
2130                                         MUSE_TYPE_INT, "bit_rate", bit_rate);
2131
2132         return ret;
2133 }
2134
2135 int player_disp_get_video_stream_info(muse_module_h module)
2136 {
2137         int ret = PLAYER_ERROR_NONE;
2138         muse_player_handle_t *muse_player = NULL;
2139         muse_player_api_e api = MUSE_PLAYER_API_GET_VIDEO_STREAM_INFO;
2140         int fps = 0;
2141         int bit_rate = 0;
2142
2143         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2144
2145         ret = legacy_player_get_video_stream_info(muse_player->player_handle, &fps, &bit_rate);
2146
2147         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "fps", fps, MUSE_TYPE_INT, "bit_rate", bit_rate);
2148
2149         return ret;
2150 }
2151
2152 int player_disp_get_video_size(muse_module_h module)
2153 {
2154         int ret = PLAYER_ERROR_NONE;
2155         muse_player_handle_t *muse_player = NULL;
2156         muse_player_api_e api = MUSE_PLAYER_API_GET_VIDEO_SIZE;
2157         int width = 0;
2158         int height = 0;
2159
2160         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2161
2162         ret = legacy_player_get_video_size(muse_player->player_handle, &width, &height);
2163
2164         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "width", width, MUSE_TYPE_INT, "height", height);
2165
2166         return ret;
2167 }
2168
2169 int player_disp_get_album_art(muse_module_h module)
2170 {
2171         int ret = PLAYER_ERROR_NONE;
2172         muse_player_handle_t *muse_player = NULL;
2173         muse_player_api_e api = MUSE_PLAYER_API_GET_ALBUM_ART;
2174         void *album_art = NULL;
2175         int size = 0;
2176         bool ret_val = true;
2177         tbm_fd tfd = INVALID_DEFAULT_VALUE;
2178         int key = INVALID_DEFAULT_VALUE;
2179
2180         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2181         if (muse_player == NULL) {
2182                 LOGE("handle is NULL");
2183                 ret = PLAYER_ERROR_INVALID_OPERATION;
2184                 goto ERROR;
2185         }
2186
2187         ret = legacy_player_get_album_art(muse_player->player_handle, &album_art, &size);
2188         if (ret != PLAYER_ERROR_NONE)
2189                 goto ERROR;
2190
2191         if ((album_art != NULL) && (size > 0)) {
2192                 ret_val = _create_export_data(muse_player, album_art, size, NULL, 0, &tfd, &key);
2193                 if (!ret_val) {
2194                         LOGE("failed to create export data");
2195                         ret = PLAYER_ERROR_INVALID_OPERATION;
2196                         goto ERROR;
2197                 }
2198                 PLAYER_RETURN_MSG_WITH_TFD(api, ret, module, tfd,
2199                                                 MUSE_TYPE_INT, "size", size, MUSE_TYPE_INT, "key", key);
2200         } else {
2201                 LOGD("album art is empty, didn't make tbm_bo");
2202                 size = 0;
2203                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "size", size);
2204         }
2205
2206         return ret;
2207
2208 ERROR:
2209         PLAYER_RETURN_MSG(api, ret, module);
2210         return ret;
2211 }
2212
2213 int player_disp_audio_effect_get_equalizer_bands_count(muse_module_h module)
2214 {
2215         int ret = PLAYER_ERROR_NONE;
2216         muse_player_handle_t *muse_player = NULL;
2217         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BANDS_COUNT;
2218         int count;
2219
2220         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2221
2222         ret = legacy_player_audio_effect_get_equalizer_bands_count(muse_player->player_handle, &count);
2223
2224         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "count", count);
2225
2226         return ret;
2227 }
2228
2229 int player_disp_audio_effect_set_equalizer_all_bands(muse_module_h module)
2230 {
2231         int ret = PLAYER_ERROR_NONE;
2232         muse_player_handle_t *muse_player = NULL;
2233         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_ALL_BANDS;
2234         muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
2235         int *band_levels = NULL;
2236         int length = 0;
2237
2238         void *jobj = muse_core_msg_object_new(muse_server_module_get_msg(module), NULL, &err);
2239         if (!jobj || !muse_core_msg_object_get_value("length", jobj, MUSE_TYPE_INT, &length)) {
2240                 LOGE("failed to get msg object. jobj:%p, err:%d, length:%d", jobj, err, length);
2241                 ret = PLAYER_ERROR_INVALID_OPERATION;
2242                 goto DONE;
2243         }
2244
2245         band_levels = (int *)g_try_new0(int, length);
2246         if (band_levels) {
2247                 if (muse_core_msg_object_get_value("band_levels", jobj, MUSE_TYPE_ARRAY, band_levels)) {
2248                         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2249                         ret = legacy_player_audio_effect_set_equalizer_all_bands(muse_player->player_handle, band_levels, length);
2250                 } else {
2251                         LOGE("failed to get cookie value from msg");
2252                         ret = PLAYER_ERROR_INVALID_OPERATION;
2253                 }
2254                 g_free(band_levels);
2255         } else {
2256                 ret = PLAYER_ERROR_INVALID_OPERATION;
2257         }
2258
2259 DONE:
2260         if (jobj)
2261                 muse_core_msg_object_free(jobj);
2262
2263         PLAYER_RETURN_MSG(api, ret, module);
2264
2265         return ret;
2266 }
2267
2268 int player_disp_audio_effect_set_equalizer_band_level(muse_module_h module)
2269 {
2270         int ret = PLAYER_ERROR_NONE;
2271         muse_player_handle_t *muse_player = NULL;
2272         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_SET_EQUALIZER_BAND_LEVEL;
2273         int index = 0, level = 0;
2274         bool ret_val = true;
2275
2276         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
2277                                                                 MUSE_TYPE_INT, "index", (void *)&index,
2278                                                                 MUSE_TYPE_INT, "level", (void *)&level,
2279                                                                 INVALID_MUSE_TYPE_VALUE);
2280         if (ret_val) {
2281                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2282                 ret = legacy_player_audio_effect_set_equalizer_band_level(muse_player->player_handle, index, level);
2283         } else {
2284                 ret = PLAYER_ERROR_INVALID_OPERATION;
2285         }
2286
2287         PLAYER_RETURN_MSG(api, ret, module);
2288
2289         return ret;
2290 }
2291
2292 int player_disp_audio_effect_get_equalizer_band_level(muse_module_h module)
2293 {
2294         int ret = PLAYER_ERROR_NONE;
2295         muse_player_handle_t *muse_player = NULL;
2296         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_LEVEL;
2297         int index, level;
2298
2299         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2300         player_msg_get(index, muse_server_module_get_msg(module));
2301
2302         ret = legacy_player_audio_effect_get_equalizer_band_level(muse_player->player_handle, index, &level);
2303
2304         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "level", level);
2305
2306         return ret;
2307 }
2308
2309 int player_disp_audio_effect_get_equalizer_level_range(muse_module_h module)
2310 {
2311         int ret = PLAYER_ERROR_NONE;
2312         muse_player_handle_t *muse_player = NULL;
2313         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_LEVEL_RANGE;
2314         int min, max;
2315
2316         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2317
2318         ret = legacy_player_audio_effect_get_equalizer_level_range(muse_player->player_handle, &min, &max);
2319
2320         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "min", min, MUSE_TYPE_INT, "max", max);
2321
2322         return ret;
2323 }
2324
2325 int player_disp_audio_effect_get_equalizer_band_frequency(muse_module_h module)
2326 {
2327         int ret = PLAYER_ERROR_NONE;
2328         muse_player_handle_t *muse_player = NULL;
2329         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY;
2330         int index, frequency;
2331
2332         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2333         player_msg_get(index, muse_server_module_get_msg(module));
2334
2335         ret = legacy_player_audio_effect_get_equalizer_band_frequency(muse_player->player_handle, index, &frequency);
2336
2337         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "frequency", frequency);
2338
2339         return ret;
2340 }
2341
2342 int player_disp_audio_effect_get_equalizer_band_frequency_range(muse_module_h module)
2343 {
2344         int ret = PLAYER_ERROR_NONE;
2345         muse_player_handle_t *muse_player = NULL;
2346         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_GET_EQUALIZER_BAND_FREQUENCY_RANGE;
2347         int index, range;
2348
2349         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2350         player_msg_get(index, muse_server_module_get_msg(module));
2351
2352         ret = legacy_player_audio_effect_get_equalizer_band_frequency_range(muse_player->player_handle, index, &range);
2353
2354         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "range", range);
2355
2356         return ret;
2357 }
2358
2359 int player_disp_audio_effect_equalizer_clear(muse_module_h module)
2360 {
2361         int ret = PLAYER_ERROR_NONE;
2362         muse_player_handle_t *muse_player = NULL;
2363         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_EQUALIZER_CLEAR;
2364
2365         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2366
2367         ret = legacy_player_audio_effect_equalizer_clear(muse_player->player_handle);
2368
2369         PLAYER_RETURN_MSG(api, ret, module);
2370
2371         return ret;
2372 }
2373
2374 int player_disp_audio_effect_equalizer_is_available(muse_module_h module)
2375 {
2376         int ret = PLAYER_ERROR_NONE;
2377         muse_player_handle_t *muse_player = NULL;
2378         muse_player_api_e api = MUSE_PLAYER_API_AUDIO_EFFECT_EQUALIZER_IS_AVAILABLE;
2379         bool available;
2380
2381         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2382
2383         ret = legacy_player_audio_effect_equalizer_is_available(muse_player->player_handle, &available);
2384
2385         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "available", (int)available);
2386
2387         return ret;
2388 }
2389
2390 int player_disp_capture_video(muse_module_h module)
2391 {
2392         int ret = PLAYER_ERROR_NONE;
2393         muse_player_handle_t *muse_player = NULL;
2394         muse_player_api_e api = MUSE_PLAYER_API_CAPTURE_VIDEO;
2395
2396         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2397
2398         ret = legacy_player_capture_video(muse_player->player_handle, _capture_video_cb, module);
2399
2400         PLAYER_RETURN_MSG(api, ret, module);
2401
2402         return ret;
2403 }
2404
2405 int player_disp_set_streaming_cookie(muse_module_h module)
2406 {
2407         int ret = PLAYER_ERROR_NONE;
2408         muse_player_handle_t *muse_player = NULL;
2409         muse_player_api_e api = MUSE_PLAYER_API_SET_STREAMING_COOKIE;
2410         muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
2411         char *cookie = NULL;
2412         int size = 0;
2413
2414         void *jobj = muse_core_msg_object_new(muse_server_module_get_msg(module), NULL, &err);
2415         if (!jobj || !muse_core_msg_object_get_value("size", jobj, MUSE_TYPE_INT, &size)) {
2416                 LOGE("failed to get msg object. jobj:%p, err:%d, size:%d", jobj, err, size);
2417                 ret = PLAYER_ERROR_INVALID_OPERATION;
2418                 goto DONE;
2419         }
2420
2421         cookie = (char *)g_try_new0(char, size + 1);
2422         if (cookie) {
2423                 if (muse_core_msg_object_get_value("cookie", jobj, MUSE_TYPE_STRING, cookie)) {
2424                         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2425                         ret = legacy_player_set_streaming_cookie(muse_player->player_handle, cookie, size);
2426                 } else {
2427                         LOGE("failed to get cookie value from msg");
2428                         ret = PLAYER_ERROR_INVALID_OPERATION;
2429                 }
2430                 g_free(cookie);
2431         } else {
2432                 ret = PLAYER_ERROR_INVALID_OPERATION;
2433         }
2434
2435 DONE:
2436         if (jobj)
2437                 muse_core_msg_object_free(jobj);
2438
2439         PLAYER_RETURN_MSG(api, ret, module);
2440
2441         return ret;
2442 }
2443
2444 int player_disp_set_streaming_user_agent(muse_module_h module)
2445 {
2446         int ret = PLAYER_ERROR_NONE;
2447         muse_player_handle_t *muse_player = NULL;
2448         muse_player_api_e api = MUSE_PLAYER_API_SET_STREAMING_USER_AGENT;
2449         muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
2450         char *user_agent = NULL;
2451         int size = 0;
2452
2453         void *jobj = muse_core_msg_object_new(muse_server_module_get_msg(module), NULL, &err);
2454         if (!jobj || !muse_core_msg_object_get_value("size", jobj, MUSE_TYPE_INT, &size)) {
2455                 LOGE("failed to get msg object jobj:%p, err:%d", jobj, err);
2456                 ret = PLAYER_ERROR_INVALID_OPERATION;
2457                 goto DONE;
2458         }
2459
2460         user_agent = (char *)g_try_new0(char, size + 1);
2461         if (user_agent) {
2462                 if (muse_core_msg_object_get_value("user_agent", jobj, MUSE_TYPE_STRING, user_agent)) {
2463                         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2464                         ret = legacy_player_set_streaming_user_agent(muse_player->player_handle, user_agent, size);
2465                 } else {
2466                         LOGE("failed to get user_agent value from msg");
2467                         ret = PLAYER_ERROR_INVALID_OPERATION;
2468                 }
2469                 g_free(user_agent);
2470         } else {
2471                 ret = PLAYER_ERROR_INVALID_OPERATION;
2472         }
2473
2474 DONE:
2475         if (jobj)
2476                 muse_core_msg_object_free(jobj);
2477
2478         PLAYER_RETURN_MSG(api, ret, module);
2479
2480         return ret;
2481 }
2482
2483 int player_disp_get_streaming_download_progress(muse_module_h module)
2484 {
2485         int ret = PLAYER_ERROR_NONE;
2486         muse_player_handle_t *muse_player = NULL;
2487         muse_player_api_e api = MUSE_PLAYER_API_GET_STREAMING_DOWNLOAD_PROGRESS;
2488         int start_pos = 0, end_pos = 0;
2489
2490         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2491
2492         ret = legacy_player_get_streaming_download_progress(muse_player->player_handle, &start_pos, &end_pos);
2493
2494         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "start_pos", start_pos, MUSE_TYPE_INT, "end_pos", end_pos);
2495
2496         return ret;
2497 }
2498
2499 int player_disp_set_subtitle_path(muse_module_h module)
2500 {
2501         int ret = PLAYER_ERROR_NONE;
2502         muse_player_handle_t *muse_player = NULL;
2503         muse_player_api_e api = MUSE_PLAYER_API_SET_SUBTITLE_PATH;
2504         char subtitle_path[MUSE_URI_MAX_LENGTH] = { 0, };
2505
2506         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2507         player_msg_get_string(subtitle_path, muse_server_module_get_msg(module));
2508
2509         if (strncmp(subtitle_path, "", 1)) {
2510                 if ((ret = _check_supportable(module, subtitle_path)) == PLAYER_ERROR_NONE)
2511                         ret = legacy_player_set_subtitle_path(muse_player->player_handle, subtitle_path);
2512         } else {
2513                 ret = legacy_player_set_subtitle_path(muse_player->player_handle, NULL);
2514         }
2515
2516         PLAYER_RETURN_MSG(api, ret, module);
2517
2518         return ret;
2519 }
2520
2521 int player_disp_set_subtitle_position_offset(muse_module_h module)
2522 {
2523         int ret = PLAYER_ERROR_NONE;
2524         muse_player_handle_t *muse_player = NULL;
2525         muse_player_api_e api = MUSE_PLAYER_API_SET_SUBTITLE_POSITION_OFFSET;
2526         int milliseconds;
2527
2528         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2529         player_msg_get(milliseconds, muse_server_module_get_msg(module));
2530
2531         ret = legacy_player_set_subtitle_position_offset(muse_player->player_handle, milliseconds);
2532
2533         PLAYER_RETURN_MSG(api, ret, module);
2534
2535         return ret;
2536 }
2537
2538 int player_disp_push_media_stream(muse_module_h module)
2539 {
2540         int ret = MEDIA_FORMAT_ERROR_NONE;
2541         muse_player_handle_t *muse_player = NULL;
2542         muse_player_api_e api = MUSE_PLAYER_API_PUSH_MEDIA_STREAM;
2543         muse_core_msg_parse_err_e err = MUSE_MSG_PARSE_ERROR_NONE;
2544         player_push_media_msg_type push_media;
2545         char *push_media_msg = (char *)&push_media;
2546         tbm_bo bo = NULL;
2547         tbm_bo_handle thandle;
2548         tbm_fd tfd = INVALID_DEFAULT_VALUE;
2549         char *buf = NULL;
2550
2551         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2552         void *jobj = muse_core_msg_object_new(muse_server_module_get_msg(module), NULL, &err);
2553         if (!jobj || !muse_core_msg_object_get_value("push_media_msg", jobj, MUSE_TYPE_ARRAY, push_media_msg)) {
2554                 LOGE("failed to get msg object. jobj:%p, err:%d", jobj, err);
2555                 ret = PLAYER_ERROR_INVALID_OPERATION;
2556                 goto push_media_stream_exit1;
2557         }
2558
2559         if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM) {
2560                 muse_server_ipc_get_fd(module, &tfd);
2561                 if (tfd > INVALID_DEFAULT_VALUE)
2562                         bo = tbm_bo_import_fd(muse_player->bufmgr, tfd);
2563                 if (bo == NULL) {
2564                         LOGE("TBM get error : bo is NULL");
2565                         ret = PLAYER_ERROR_INVALID_OPERATION;
2566                         goto push_media_stream_exit1;
2567                 }
2568                 thandle = tbm_bo_map(bo, TBM_DEVICE_CPU, TBM_OPTION_READ);
2569                 if (thandle.ptr == NULL) {
2570                         LOGE("TBM get error : handle pointer is NULL");
2571                         ret = PLAYER_ERROR_INVALID_OPERATION;
2572                         goto push_media_stream_exit2;
2573                 }
2574                 buf = thandle.ptr;
2575         } else if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_MSG) {
2576                 buf = g_new(char, push_media.size);
2577                 if (!buf) {
2578                         ret = PLAYER_ERROR_OUT_OF_MEMORY;
2579                         goto push_media_stream_exit1;
2580                 }
2581                 if (!muse_core_msg_object_get_value("buf", jobj, MUSE_TYPE_ARRAY, buf)) {
2582                         LOGE("failed to get buf from msg.");
2583                         ret = PLAYER_ERROR_INVALID_OPERATION;
2584                         goto push_media_stream_exit2;
2585                 }
2586         } else if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_RAW) {
2587                 if (push_media.size > 0)
2588                         buf = muse_server_ipc_get_data(module);
2589         }
2590
2591         ret = _push_media_stream(muse_player, &push_media, buf);
2592
2593         if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM)
2594                 tbm_bo_unmap(bo);
2595 push_media_stream_exit2:
2596         if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_TBM)
2597                 tbm_bo_unref(bo);
2598         else if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_MSG)
2599                 g_free(buf);
2600         else if (push_media.buf_type == PUSH_MEDIA_BUF_TYPE_RAW && buf)
2601                 muse_server_ipc_delete_data(buf);
2602 push_media_stream_exit1:
2603         if (tfd > INVALID_DEFAULT_VALUE)
2604                 close(tfd);
2605
2606         if (jobj)
2607                 muse_core_msg_object_free(jobj);
2608         PLAYER_RETURN_MSG(api, ret, module);
2609         return ret;
2610 }
2611
2612 int player_disp_set_media_stream_info(muse_module_h module)
2613 {
2614         int ret = PLAYER_ERROR_NONE;
2615         muse_player_handle_t *muse_player = NULL;
2616         muse_player_api_e api = MUSE_PLAYER_API_SET_MEDIA_STREAM_INFO;
2617         media_format_mimetype_e mimetype;
2618         player_stream_type_e type;
2619         media_format_h format = NULL;
2620         int width = 0;
2621         int height = 0;
2622         int avg_bps = 0;
2623         int max_bps = 0;
2624         int channel = 0;
2625         int samplerate = 0;
2626         int bit = 0;
2627         int frame_rate = 0;
2628
2629         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2630         player_msg_get(mimetype, muse_server_module_get_msg(module));
2631         player_msg_get(type, muse_server_module_get_msg(module));
2632         player_msg_get(avg_bps, muse_server_module_get_msg(module));
2633         if (type == PLAYER_STREAM_TYPE_VIDEO) {
2634                 player_msg_get(width, muse_server_module_get_msg(module));
2635                 player_msg_get(height, muse_server_module_get_msg(module));
2636                 player_msg_get(max_bps, muse_server_module_get_msg(module));
2637                 player_msg_get(frame_rate, muse_server_module_get_msg(module));
2638         } else if (type == PLAYER_STREAM_TYPE_AUDIO) {
2639                 player_msg_get(channel, muse_server_module_get_msg(module));
2640                 player_msg_get(samplerate, muse_server_module_get_msg(module));
2641                 player_msg_get(bit, muse_server_module_get_msg(module));
2642         } else {
2643                 ret = PLAYER_ERROR_INVALID_PARAMETER;
2644                 goto set_media_stream_info_exit;
2645         }
2646
2647         if (media_format_create(&format) == MEDIA_FORMAT_ERROR_NONE) {
2648                 if (type == PLAYER_STREAM_TYPE_VIDEO) {
2649                         ret = media_format_set_video_mime(format, mimetype);
2650                         ret |= media_format_set_video_width(format, width);
2651                         ret |= media_format_set_video_height(format, height);
2652                         ret |= media_format_set_video_avg_bps(format, avg_bps);
2653                         ret |= media_format_set_video_max_bps(format, max_bps);
2654                         ret |= media_format_set_video_frame_rate(format, frame_rate);
2655                 } else if (type == PLAYER_STREAM_TYPE_AUDIO) {
2656                         ret = media_format_set_audio_mime(format, mimetype);
2657                         ret |= media_format_set_audio_channel(format, channel);
2658                         ret |= media_format_set_audio_samplerate(format, samplerate);
2659                         ret |= media_format_set_audio_bit(format, bit);
2660                         ret |= media_format_set_audio_avg_bps(format, avg_bps);
2661                 }
2662                 if (ret != MEDIA_FORMAT_ERROR_NONE) {
2663                         ret = PLAYER_ERROR_INVALID_OPERATION;
2664                         goto set_media_stream_info_exit;
2665                 }
2666         } else {
2667                 ret = PLAYER_ERROR_OUT_OF_MEMORY;
2668                 goto set_media_stream_info_exit;
2669         }
2670
2671         ret = legacy_player_set_media_stream_info(muse_player->player_handle, type, format);
2672
2673 set_media_stream_info_exit:
2674         media_format_unref(format);
2675         PLAYER_RETURN_MSG(api, ret, module);
2676         return ret;
2677 }
2678
2679
2680 int player_disp_set_callback(muse_module_h module)
2681 {
2682         int ret = PLAYER_ERROR_NONE;
2683         muse_player_handle_t *muse_player = NULL;
2684         muse_player_event_e type;
2685         int set = 0;
2686         bool ret_val = true;
2687
2688         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
2689                                                                 MUSE_TYPE_INT, "type", (void *)&type,
2690                                                                 MUSE_TYPE_INT, "set", (void *)&set,
2691                                                                 INVALID_MUSE_TYPE_VALUE);
2692
2693         if (ret_val) {
2694                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2695                 if (type < MUSE_PLAYER_EVENT_TYPE_NUM && set_callback_func[type] != NULL)
2696                         set_callback_func[type] (muse_player->player_handle, module, set);
2697         } else {
2698                 ret = PLAYER_ERROR_INVALID_OPERATION;
2699                 PLAYER_RETURN_MSG(MUSE_PLAYER_API_SET_CALLBACK, ret, module);
2700         }
2701
2702         return ret;
2703 }
2704
2705 int player_disp_return_video_data(muse_module_h module) /* MUSE_PLAYER_API_RETURN_VIDEO_DATA */
2706 {
2707         mmplayer_video_decoded_data_info_t *v_data = NULL;
2708         muse_player_handle_t *muse_player = NULL;
2709         bool find_data = false;
2710
2711         player_msg_get_type(v_data, muse_server_module_get_msg(module), POINTER);
2712
2713         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2714         if (muse_player && muse_player->video_data_list) {
2715                 g_mutex_lock(&muse_player->list_lock);
2716                 if (g_list_find(muse_player->video_data_list, v_data)) {
2717                         muse_player->video_data_list = g_list_remove(muse_player->video_data_list, v_data);
2718                         find_data = true;
2719                 } else {
2720                         LOGW("the v_data(%p) is not in the exported list.", v_data);
2721                 }
2722                 g_mutex_unlock(&muse_player->list_lock);
2723
2724                 if (find_data)
2725                         _remove_video_stream_data(module, v_data);
2726         }
2727
2728         return PLAYER_ERROR_NONE;
2729 }
2730
2731 int player_disp_set_media_stream_buffer_max_size(muse_module_h module)
2732 {
2733         int ret = PLAYER_ERROR_NONE;
2734         muse_player_handle_t *muse_player = NULL;
2735         muse_player_api_e api = MUSE_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MAX_SIZE;
2736         player_stream_type_e type;
2737         unsigned long long max_size;
2738         bool ret_val = true;
2739
2740         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
2741                                                                 MUSE_TYPE_INT, "type", (void *)&type,
2742                                                                 MUSE_TYPE_INT64, "max_size", (void *)&max_size,
2743                                                                 INVALID_MUSE_TYPE_VALUE);
2744         if (ret_val) {
2745                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2746                 ret = legacy_player_set_media_stream_buffer_max_size(muse_player->player_handle, type, max_size);
2747         } else {
2748                 ret = PLAYER_ERROR_INVALID_OPERATION;
2749         }
2750
2751         PLAYER_RETURN_MSG(api, ret, module);
2752
2753         return ret;
2754 }
2755
2756
2757 int player_disp_get_media_stream_buffer_max_size(muse_module_h module)
2758 {
2759         int ret = PLAYER_ERROR_NONE;
2760         muse_player_handle_t *muse_player = NULL;
2761         muse_player_api_e api = MUSE_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MAX_SIZE;
2762         player_stream_type_e type;
2763         unsigned long long max_size;
2764         /* unsigned upper_max_size, lower_max_size; */
2765
2766         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2767         player_msg_get(type, muse_server_module_get_msg(module));
2768
2769         ret = legacy_player_get_media_stream_buffer_max_size(muse_player->player_handle, type, &max_size);
2770         if (ret == PLAYER_ERROR_NONE)
2771                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT64, "max_size", (INT64)max_size);
2772         else
2773                 PLAYER_RETURN_MSG(api, ret, module);
2774
2775         return ret;
2776 }
2777
2778 int player_disp_set_media_stream_buffer_min_threshold(muse_module_h module)
2779 {
2780         int ret = PLAYER_ERROR_NONE;
2781         muse_player_handle_t *muse_player = NULL;
2782         muse_player_api_e api = MUSE_PLAYER_API_SET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD;
2783         player_stream_type_e type;
2784         unsigned percent = 0;
2785         bool ret_val = true;
2786
2787         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
2788                                                                 MUSE_TYPE_INT, "type", (void *)&type,
2789                                                                 MUSE_TYPE_INT, "percent", (void *)&percent,
2790                                                                 INVALID_MUSE_TYPE_VALUE);
2791         if (ret_val) {
2792                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2793                 ret = legacy_player_set_media_stream_buffer_min_threshold(muse_player->player_handle, type, percent);
2794         } else {
2795                 ret = PLAYER_ERROR_INVALID_OPERATION;
2796         }
2797         PLAYER_RETURN_MSG(api, ret, module);
2798
2799         return ret;
2800 }
2801
2802 int player_disp_get_media_stream_buffer_min_threshold(muse_module_h module)
2803 {
2804         int ret = PLAYER_ERROR_NONE;
2805         muse_player_handle_t *muse_player = NULL;
2806         muse_player_api_e api = MUSE_PLAYER_API_GET_MEDIA_STREAM_BUFFER_MIN_THRESHOLD;
2807         player_stream_type_e type;
2808         unsigned percent;
2809
2810         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2811         player_msg_get(type, muse_server_module_get_msg(module));
2812
2813         ret = legacy_player_get_media_stream_buffer_min_threshold(muse_player->player_handle, type, &percent);
2814         if (ret == PLAYER_ERROR_NONE)
2815                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "percent", (int)percent);
2816         else
2817                 PLAYER_RETURN_MSG(api, ret, module);
2818
2819         return ret;
2820 }
2821
2822 int player_disp_set_media_stream_dynamic_resolution(muse_module_h module)
2823 {
2824         int ret = PLAYER_ERROR_NONE;
2825         muse_player_api_e api = MUSE_PLAYER_API_SET_MEDIA_STREAM_DYNAMIC_RESOLUTION;
2826         muse_player_handle_t *muse_player = NULL;
2827         int drc = 0;
2828
2829         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2830         player_msg_get(drc, muse_server_module_get_msg(module));
2831
2832         ret = legacy_player_set_media_stream_dynamic_resolution(muse_player->player_handle, (bool)drc);
2833
2834         PLAYER_RETURN_MSG(api, ret, module);
2835
2836         return ret;
2837 }
2838
2839
2840 int player_disp_get_track_count(muse_module_h module)
2841 {
2842         int ret = PLAYER_ERROR_NONE;
2843         muse_player_handle_t *muse_player = NULL;
2844         muse_player_api_e api = MUSE_PLAYER_API_GET_TRACK_COUNT;
2845         player_stream_type_e type;
2846         int count;
2847
2848         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2849         player_msg_get(type, muse_server_module_get_msg(module));
2850
2851         ret = legacy_player_get_track_count(muse_player->player_handle, type, &count);
2852         if (ret == PLAYER_ERROR_NONE)
2853                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "count", count);
2854         else
2855                 PLAYER_RETURN_MSG(api, ret, module);
2856
2857         return ret;
2858 }
2859
2860 int player_disp_get_current_track(muse_module_h module)
2861 {
2862         int ret = PLAYER_ERROR_NONE;
2863         muse_player_handle_t *muse_player = NULL;
2864         muse_player_api_e api = MUSE_PLAYER_API_GET_CURRENT_TRACK;
2865         player_stream_type_e type;
2866         int index;
2867
2868         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2869         player_msg_get(type, muse_server_module_get_msg(module));
2870
2871         ret = legacy_player_get_current_track(muse_player->player_handle, type, &index);
2872         if (ret == PLAYER_ERROR_NONE)
2873                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "index", index);
2874         else
2875                 PLAYER_RETURN_MSG(api, ret, module);
2876
2877         return ret;
2878 }
2879
2880 int player_disp_select_track(muse_module_h module)
2881 {
2882         int ret = PLAYER_ERROR_NONE;
2883         muse_player_handle_t *muse_player = NULL;
2884         muse_player_api_e api = MUSE_PLAYER_API_SELECT_TRACK;
2885         player_stream_type_e type;
2886         int index = 0;
2887         bool ret_val = true;
2888
2889         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
2890                                                                 MUSE_TYPE_INT, "type", (void *)&type,
2891                                                                 MUSE_TYPE_INT, "index", (void *)&index,
2892                                                                 INVALID_MUSE_TYPE_VALUE);
2893         if (ret_val) {
2894                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2895                 ret = legacy_player_select_track(muse_player->player_handle, type, index);
2896         } else {
2897                 ret = PLAYER_ERROR_INVALID_OPERATION;
2898         }
2899         PLAYER_RETURN_MSG(api, ret, module);
2900
2901         return ret;
2902 }
2903
2904 int player_disp_get_track_language_code(muse_module_h module)
2905 {
2906         int ret = PLAYER_ERROR_NONE;
2907         muse_player_handle_t *muse_player = NULL;
2908         muse_player_api_e api = MUSE_PLAYER_API_GET_TRACK_LANGUAGE_CODE;
2909         player_stream_type_e type = PLAYER_STREAM_TYPE_DEFAULT;
2910         int index = 0;
2911         char *code = NULL;
2912         int code_len = 0;
2913         bool ret_val = true;
2914
2915         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
2916                                                                 MUSE_TYPE_INT, "type", (void *)&type,
2917                                                                 MUSE_TYPE_INT, "index", (void *)&index,
2918                                                                 INVALID_MUSE_TYPE_VALUE);
2919         if (ret_val) {
2920                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2921                 ret = legacy_player_get_track_language_code(muse_player->player_handle, type, index, &code, &code_len);
2922         } else {
2923                 ret = PLAYER_ERROR_INVALID_OPERATION;
2924         }
2925
2926         if (ret == PLAYER_ERROR_NONE)
2927                 PLAYER_RETURN_MSG(api, ret, module,
2928                                                 MUSE_TYPE_INT, "code_len", code_len,
2929                                                 MUSE_TYPE_STRING, "code", (const char *)code);
2930         else
2931                 PLAYER_RETURN_MSG(api, ret, module);
2932
2933         if (code)
2934                 free(code);
2935
2936         return ret;
2937 }
2938
2939 int player_disp_set_pcm_extraction_mode(muse_module_h module)
2940 {
2941         int ret = PLAYER_ERROR_NONE;
2942         muse_player_handle_t *muse_player = NULL;
2943         muse_player_api_e api = MUSE_PLAYER_API_SET_PCM_EXTRACTION_MODE;
2944         int sync;
2945
2946         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2947         player_msg_get(sync, muse_server_module_get_msg(module));
2948
2949         ret = legacy_player_set_pcm_extraction_mode(muse_player->player_handle, sync, _audio_decoded_cb, module);
2950
2951         PLAYER_RETURN_MSG(api, ret, module);
2952
2953         return ret;
2954 }
2955
2956 int player_disp_set_pcm_spec(muse_module_h module)
2957 {
2958         int ret = PLAYER_ERROR_NONE;
2959         muse_player_handle_t *muse_player = NULL;
2960         muse_player_api_e api = MUSE_PLAYER_API_SET_PCM_SPEC;
2961         char format[MUSE_URI_MAX_LENGTH] = { 0, };
2962         int samplerate = 0;
2963         int channel = 0;
2964         bool ret_val = true;
2965
2966         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
2967                                                                 MUSE_TYPE_INT, "samplerate", (void *)&samplerate,
2968                                                                 MUSE_TYPE_INT, "channel", (void *)&channel,
2969                                                                 MUSE_TYPE_STRING, "format", (void *)format,
2970                                                                 INVALID_MUSE_TYPE_VALUE);
2971         if (ret_val) {
2972                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2973                 ret = legacy_player_set_pcm_spec(muse_player->player_handle, format, samplerate, channel);
2974         } else {
2975                 ret = PLAYER_ERROR_INVALID_OPERATION;
2976         }
2977
2978         PLAYER_RETURN_MSG(api, ret, module);
2979
2980         return ret;
2981 }
2982
2983 int player_disp_set_streaming_playback_rate(muse_module_h module)
2984 {
2985         int ret = PLAYER_ERROR_NONE;
2986         muse_player_handle_t *muse_player = NULL;
2987         muse_player_api_e api = MUSE_PLAYER_API_SET_STREAMING_PLAYBACK_RATE;
2988         double rate = 0;
2989
2990         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
2991         player_msg_get_type(rate, muse_server_module_get_msg(module), DOUBLE);
2992
2993         ret = legacy_player_set_streaming_playback_rate(muse_player->player_handle, (float)rate);
2994
2995         PLAYER_RETURN_MSG(api, ret, module);
2996
2997         return ret;
2998 }
2999
3000 int player_disp_return_buffer(muse_module_h module)     /* MUSE_PLAYER_API_RETURN_BUFFER */
3001 {
3002         int key = 0;
3003         /* muse_player_handle_t *muse_player = NULL; */
3004
3005         /* muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module); */
3006
3007         player_msg_get(key, muse_server_module_get_msg(module));
3008
3009         /* LOGD("handle : %p, key : %d", muse_player, key); */
3010
3011         if (!_remove_export_data(module, key, false))
3012                 LOGE("failed to remove export data : key %d", key);
3013
3014         /* This funct does not send return value to client.        *
3015          * You have to use PLAYER_SEND_MSG_ASYNC to return buffer. */
3016
3017         return PLAYER_ERROR_NONE;
3018 }
3019
3020 int player_disp_set_next_uri(muse_module_h module)
3021 {
3022         int ret = PLAYER_ERROR_NONE;
3023         muse_player_api_e api = MUSE_PLAYER_API_SET_NEXT_URI;
3024         muse_player_handle_t *muse_player = NULL;
3025         char path[MUSE_URI_MAX_LENGTH] = { 0, };
3026
3027         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3028         player_msg_get_string(path, muse_server_module_get_msg(module));
3029
3030         ret = legacy_player_set_next_uri(muse_player->player_handle, path);
3031
3032         PLAYER_RETURN_MSG(api, ret, module);
3033
3034         return ret;
3035 }
3036
3037 int player_disp_get_next_uri(muse_module_h module)
3038 {
3039         int ret = PLAYER_ERROR_NONE;
3040         muse_player_api_e api = MUSE_PLAYER_API_GET_NEXT_URI;
3041         muse_player_handle_t *muse_player = NULL;
3042         char *next_uri = NULL;
3043
3044         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3045
3046         ret = legacy_player_get_next_uri(muse_player->player_handle, &next_uri);
3047         if (ret == PLAYER_ERROR_NONE) {
3048                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_STRING, "next_uri", (const char *)next_uri);
3049                 if (next_uri)
3050                         free(next_uri);
3051         } else {
3052                 PLAYER_RETURN_MSG(api, ret, module);
3053         }
3054
3055         return ret;
3056 }
3057
3058 int player_disp_set_gapless(muse_module_h module)
3059 {
3060         int ret = PLAYER_ERROR_NONE;
3061         muse_player_api_e api = MUSE_PLAYER_API_SET_GAPLESS;
3062         muse_player_handle_t *muse_player = NULL;
3063         int gapless = 0;
3064
3065         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3066         player_msg_get(gapless, muse_server_module_get_msg(module));
3067
3068         ret = legacy_player_set_gapless(muse_player->player_handle, (bool)gapless);
3069
3070         PLAYER_RETURN_MSG(api, ret, module);
3071
3072         return ret;
3073 }
3074
3075 int player_disp_is_gapless(muse_module_h module)
3076 {
3077         int ret = PLAYER_ERROR_NONE;
3078         muse_player_api_e api = MUSE_PLAYER_API_IS_GAPLESS;
3079         muse_player_handle_t *muse_player = NULL;
3080         bool value = false;
3081
3082         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3083
3084         ret = legacy_player_is_gapless(muse_player->player_handle, &value);
3085
3086         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "value", (int)value);
3087
3088         return ret;
3089 }
3090
3091 int player_disp_get_media_packet_video_frame_pool_size(muse_module_h module)
3092 {
3093         int ret = PLAYER_ERROR_NONE;
3094         muse_player_api_e api = MUSE_PLAYER_API_GET_MEDIA_PACKET_VIDEO_FRAME_POOL_SIZE;
3095         muse_player_handle_t *muse_player = NULL;
3096         int value = 0;
3097
3098         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3099
3100         LOGD("size of v buffer: %d", muse_player->total_size_of_buffers);
3101         if (muse_player->total_size_of_buffers > DEFAULT_VDEC_TOTAL_SIZE_OF_BUFFER) {
3102                 value = muse_player->total_size_of_buffers;
3103                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "value", value);
3104         } else {
3105                 ret = PLAYER_ERROR_INVALID_STATE;
3106                 PLAYER_RETURN_MSG(api, ret, module);
3107         }
3108
3109         return ret;
3110 }
3111
3112 int player_disp_enable_media_packet_video_frame_decoded_cb(muse_module_h module)
3113 {
3114         int ret = PLAYER_ERROR_NONE;
3115         muse_player_api_e api = MUSE_PLAYER_API_ENABLE_MEDIA_PACKET_VIDEO_FRAME_DECODED_CB;
3116         muse_player_handle_t *muse_player = NULL;
3117         int enable = 0;
3118
3119         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3120         player_msg_get(enable, muse_server_module_get_msg(module));
3121
3122         ret = legacy_player_enable_media_packet_video_frame_decoded_cb(muse_player->player_handle, (bool)enable);
3123
3124         PLAYER_RETURN_MSG(api, ret, module);
3125
3126         return ret;
3127 }
3128
3129 int player_disp_get_adaptive_variant_info(muse_module_h module)
3130 {
3131         int ret = PLAYER_ERROR_NONE;
3132         muse_player_api_e api = MUSE_PLAYER_API_GET_ADAPTIVE_VARIANT_INFO;
3133         muse_player_handle_t *muse_player = NULL;
3134         char *var_info = NULL;
3135         int num = 0;
3136
3137         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3138
3139         ret = legacy_player_get_adaptive_variant_info(muse_player->player_handle, &num, &var_info);
3140
3141         if (ret != PLAYER_ERROR_NONE || num <= 0)
3142                 PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "num", num);
3143         else
3144                 PLAYER_RETURN_MSG(api, ret, module,
3145                                 MUSE_TYPE_INT, "num", num,
3146                                 MUSE_TYPE_STRING, "var_info", (const char *)var_info);
3147
3148         g_free(var_info);
3149
3150         return ret;
3151 }
3152
3153 int player_disp_set_max_adaptive_variant_limit(muse_module_h module)
3154 {
3155         int ret = PLAYER_ERROR_NONE;
3156         muse_player_api_e api = MUSE_PLAYER_API_SET_MAX_ADAPTIVE_VARIANT_LIMIT;
3157         muse_player_handle_t *muse_player = NULL;
3158         bool ret_val = true;
3159         int bandwidth = ADAPTIVE_VARIANT_DEFAULT_VALUE;
3160         int width = ADAPTIVE_VARIANT_DEFAULT_VALUE;
3161         int height = ADAPTIVE_VARIANT_DEFAULT_VALUE;
3162
3163         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
3164                                                                 MUSE_TYPE_INT, "bandwidth", (void *)&bandwidth,
3165                                                                 MUSE_TYPE_INT, "width", (void *)&width,
3166                                                                 MUSE_TYPE_INT, "height", (void *)&height,
3167                                                                 INVALID_MUSE_TYPE_VALUE);
3168         if (ret_val) {
3169                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3170                 ret = legacy_player_set_max_adaptive_variant_limit(muse_player->player_handle, bandwidth, width, height);
3171         } else {
3172                 ret = PLAYER_ERROR_INVALID_OPERATION;
3173         }
3174
3175         PLAYER_RETURN_MSG(api, ret, module);
3176         return ret;
3177 }
3178
3179 int player_disp_get_max_adaptive_variant_limit(muse_module_h module)
3180 {
3181         int ret = PLAYER_ERROR_NONE;
3182         muse_player_api_e api = MUSE_PLAYER_API_GET_MAX_ADAPTIVE_VARIANT_LIMIT;
3183         muse_player_handle_t *muse_player = NULL;
3184         int bandwidth = ADAPTIVE_VARIANT_DEFAULT_VALUE;
3185         int width = ADAPTIVE_VARIANT_DEFAULT_VALUE;
3186         int height = ADAPTIVE_VARIANT_DEFAULT_VALUE;
3187
3188         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3189
3190         ret = legacy_player_get_max_adaptive_variant_limit(muse_player->player_handle, &bandwidth, &width, &height);
3191         if (ret == PLAYER_ERROR_NONE)
3192                 PLAYER_RETURN_MSG(api, ret, module,
3193                                                 MUSE_TYPE_INT, "bandwidth", bandwidth,
3194                                                 MUSE_TYPE_INT, "width", width,
3195                                                 MUSE_TYPE_INT, "height", height);
3196         else
3197                 PLAYER_RETURN_MSG(api, ret, module);
3198
3199         return ret;
3200 }
3201
3202 int player_disp_set_audio_only(muse_module_h module)
3203 {
3204         int ret = PLAYER_ERROR_NONE;
3205         muse_player_api_e api = MUSE_PLAYER_API_SET_AUDIO_ONLY;
3206         muse_player_handle_t *muse_player = NULL;
3207         int audio_only = 0;
3208
3209         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3210         player_msg_get(audio_only, muse_server_module_get_msg(module));
3211
3212         ret = legacy_player_set_audio_only(muse_player->player_handle, (bool)audio_only);
3213
3214         PLAYER_RETURN_MSG(api, ret, module);
3215
3216         return ret;
3217 }
3218
3219 int player_disp_is_audio_only(muse_module_h module)
3220 {
3221         int ret = PLAYER_ERROR_NONE;
3222         muse_player_api_e api = MUSE_PLAYER_API_IS_AUDIO_ONLY;
3223         muse_player_handle_t *muse_player = NULL;
3224         bool audio_only;
3225
3226         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3227
3228         ret = legacy_player_is_audio_only(muse_player->player_handle, &audio_only);
3229
3230         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "audio_only", (int)audio_only);
3231
3232         return ret;
3233 }
3234
3235 int player_disp_set_streaming_buffering_time(muse_module_h module)
3236 {
3237         int ret = PLAYER_ERROR_NONE;
3238         muse_player_api_e api = MUSE_PLAYER_API_SET_STREAMING_BUFFERING_TIME;
3239         muse_player_handle_t *muse_player = NULL;
3240         int prebuffer_ms = -1, rebuffer_ms = -1;
3241         bool ret_val = true;
3242
3243         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
3244                                                                 MUSE_TYPE_INT, "prebuffer_ms", (void *)&prebuffer_ms,
3245                                                                 MUSE_TYPE_INT, "rebuffer_ms", (void *)&rebuffer_ms,
3246                                                                 INVALID_MUSE_TYPE_VALUE);
3247         if (ret_val) {
3248                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3249                 ret = legacy_player_set_streaming_buffering_time(muse_player->player_handle, prebuffer_ms, rebuffer_ms);
3250         } else {
3251                 ret = PLAYER_ERROR_INVALID_OPERATION; /* FIXME: mismatch with API return type */
3252         }
3253
3254         PLAYER_RETURN_MSG(api, ret, module);
3255         return ret;
3256 }
3257
3258 int player_disp_get_streaming_buffering_time(muse_module_h module)
3259 {
3260         int ret = PLAYER_ERROR_NONE;
3261         muse_player_api_e api = MUSE_PLAYER_API_GET_STREAMING_BUFFERING_TIME;
3262         muse_player_handle_t *muse_player = NULL;
3263         int prebuffer_ms = 0, rebuffer_ms = 0;
3264
3265         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3266
3267         ret = legacy_player_get_streaming_buffering_time(muse_player->player_handle, &prebuffer_ms, &rebuffer_ms);
3268         if (ret == PLAYER_ERROR_NONE)
3269                 PLAYER_RETURN_MSG(api, ret, module,
3270                         MUSE_TYPE_INT, "prebuffer_ms", prebuffer_ms, MUSE_TYPE_INT, "rebuffer_ms", rebuffer_ms);
3271         else
3272                 PLAYER_RETURN_MSG(api, ret, module);
3273
3274         return ret;
3275 }
3276
3277 int player_disp_360_is_content_spherical(muse_module_h module)
3278 {
3279         int ret = PLAYER_ERROR_NONE;
3280         muse_player_api_e api = MUSE_PLAYER_API_360_IS_CONTENT_SPHERICAL;
3281         muse_player_handle_t *muse_player = NULL;
3282         bool val;
3283
3284         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3285
3286         ret = legacy_player_360_is_content_spherical(muse_player->player_handle, &val);
3287
3288         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "val", (int)val);
3289         return ret;
3290 }
3291
3292 int player_disp_360_set_enabled(muse_module_h module)
3293 {
3294         int ret = PLAYER_ERROR_NONE;
3295         muse_player_api_e api = MUSE_PLAYER_API_360_SET_ENABLED;
3296         muse_player_handle_t *muse_player = NULL;
3297         int val = 0;
3298
3299         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3300         player_msg_get(val, muse_server_module_get_msg(module));
3301
3302         ret = legacy_player_360_set_enabled(muse_player->player_handle, (bool)val);
3303
3304         PLAYER_RETURN_MSG(api, ret, module);
3305         return ret;
3306 }
3307
3308 int player_disp_360_is_enabled(muse_module_h module)
3309 {
3310         int ret = PLAYER_ERROR_NONE;
3311         muse_player_api_e api = MUSE_PLAYER_API_360_IS_ENABLED;
3312         muse_player_handle_t *muse_player = NULL;
3313         bool val;
3314
3315         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3316
3317         ret = legacy_player_360_is_enabled(muse_player->player_handle, &val);
3318
3319         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "val", (int)val);
3320         return ret;
3321 }
3322
3323 int player_disp_360_set_direction_of_view(muse_module_h module)
3324 {
3325         int ret = PLAYER_ERROR_NONE;
3326         muse_player_api_e api = MUSE_PLAYER_API_360_SET_DIRECTION_OF_VIEW;
3327         muse_player_handle_t *muse_player = NULL;
3328         double yaw, pitch;
3329         bool ret_val = true;
3330
3331         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
3332                                                                 MUSE_TYPE_DOUBLE, "yaw", (void *)&yaw,
3333                                                                 MUSE_TYPE_DOUBLE, "pitch", (void *)&pitch,
3334                                                                 INVALID_MUSE_TYPE_VALUE);
3335         if (ret_val) {
3336                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3337                 ret = legacy_player_360_set_direction_of_view(muse_player->player_handle, (float)yaw, (float)pitch);
3338         } else {
3339                 ret = PLAYER_ERROR_INVALID_OPERATION;
3340         }
3341         PLAYER_RETURN_MSG(api, ret, module);
3342         return ret;
3343 }
3344
3345 int player_disp_360_get_direction_of_view(muse_module_h module)
3346 {
3347         int ret = PLAYER_ERROR_NONE;
3348         muse_player_api_e api = MUSE_PLAYER_API_360_GET_DIRECTION_OF_VIEW;
3349         muse_player_handle_t *muse_player = NULL;
3350         float yaw_val, pitch_val;
3351
3352         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3353
3354         ret = legacy_player_360_get_direction_of_view(muse_player->player_handle, &yaw_val, &pitch_val);
3355
3356         PLAYER_RETURN_MSG(api, ret, module,
3357                         MUSE_TYPE_DOUBLE, "yaw_val", (double)yaw_val,
3358                         MUSE_TYPE_DOUBLE, "pitch_val", (double)pitch_val);
3359
3360         return ret;
3361 }
3362
3363 int player_disp_360_set_zoom(muse_module_h module)
3364 {
3365         int ret = PLAYER_ERROR_NONE;
3366         muse_player_api_e api = MUSE_PLAYER_API_360_SET_ZOOM;
3367         muse_player_handle_t *muse_player = NULL;
3368         double level = 0;
3369
3370         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3371         player_msg_get_type(level, muse_server_module_get_msg(module), DOUBLE);
3372
3373         ret = legacy_player_360_set_zoom(muse_player->player_handle, (float)level);
3374
3375         PLAYER_RETURN_MSG(api, ret, module);
3376         return ret;
3377 }
3378
3379 int player_disp_360_get_zoom(muse_module_h module)
3380 {
3381         int ret = PLAYER_ERROR_NONE;
3382         muse_player_api_e api = MUSE_PLAYER_API_360_GET_ZOOM;
3383         muse_player_handle_t *muse_player = NULL;
3384         float zoom;
3385
3386         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3387
3388         ret = legacy_player_360_get_zoom(muse_player->player_handle, &zoom);
3389
3390         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_DOUBLE, "zoom", (double)zoom);
3391         return ret;
3392 }
3393
3394 int player_disp_360_set_field_of_view(muse_module_h module)
3395 {
3396         int ret = PLAYER_ERROR_NONE;
3397         muse_player_api_e api = MUSE_PLAYER_API_360_SET_FIELD_OF_VIEW;
3398         muse_player_handle_t *muse_player = NULL;
3399         int horizontal_degrees = 0, vertical_degrees = 0;
3400         bool ret_val = true;
3401
3402         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
3403                                                                 MUSE_TYPE_INT, "horizontal_degrees", (void *)&horizontal_degrees,
3404                                                                 MUSE_TYPE_INT, "vertical_degrees", (void *)&vertical_degrees,
3405                                                                 INVALID_MUSE_TYPE_VALUE);
3406         if (ret_val) {
3407                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3408                 ret = legacy_player_360_set_field_of_view(muse_player->player_handle, horizontal_degrees, vertical_degrees);
3409         } else {
3410                 ret = PLAYER_ERROR_INVALID_OPERATION;
3411         }
3412         PLAYER_RETURN_MSG(api, ret, module);
3413
3414         return ret;
3415 }
3416
3417 int player_disp_360_get_field_of_view(muse_module_h module)
3418 {
3419         int ret = PLAYER_ERROR_NONE;
3420         muse_player_api_e api = MUSE_PLAYER_API_360_GET_FIELD_OF_VIEW;
3421         muse_player_handle_t *muse_player = NULL;
3422         int h_val = -1, v_val = -1;
3423
3424         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3425
3426         ret = legacy_player_360_get_field_of_view(muse_player->player_handle, &h_val, &v_val);
3427
3428         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "h_val", h_val, MUSE_TYPE_INT, "v_val", v_val);
3429         return ret;
3430 }
3431
3432 int player_disp_360_set_zoom_with_field_of_view(muse_module_h module)
3433 {
3434         int ret = PLAYER_ERROR_NONE;
3435         muse_player_api_e api = MUSE_PLAYER_API_360_SET_ZOOM_WITH_FIELD_OF_VIEW;
3436         muse_player_handle_t *muse_player = NULL;
3437         int horizontal_degrees = 0, vertical_degrees = 0;
3438         double level = 0;
3439         bool ret_val = true;
3440
3441         ret_val = _player_disp_get_param_value(muse_server_module_get_msg(module),
3442                                                                 MUSE_TYPE_DOUBLE, "level", (void *)&level,
3443                                                                 MUSE_TYPE_INT, "horizontal_degrees", (void *)&horizontal_degrees,
3444                                                                 MUSE_TYPE_INT, "vertical_degrees", (void *)&vertical_degrees,
3445                                                                 INVALID_MUSE_TYPE_VALUE);
3446         if (ret_val) {
3447                 muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3448
3449                 ret = legacy_player_360_set_zoom(muse_player->player_handle, (float)level);
3450                 if (ret == MM_ERROR_NONE)
3451                         ret = legacy_player_360_set_field_of_view(muse_player->player_handle, horizontal_degrees, vertical_degrees);
3452         } else {
3453                 ret = PLAYER_ERROR_INVALID_OPERATION;
3454         }
3455
3456         PLAYER_RETURN_MSG(api, ret, module);
3457         return ret;
3458 }
3459
3460 int player_disp_set_codec_type(muse_module_h module)
3461 {
3462         int ret = PLAYER_ERROR_NONE;
3463         muse_player_handle_t *muse_player = NULL;
3464         muse_player_api_e api = MUSE_PLAYER_API_SET_CODEC_TYPE;
3465         int stream_type = 0, codec_type = 0;
3466
3467         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3468         player_msg_get(stream_type, muse_server_module_get_msg(module));
3469         player_msg_get(codec_type, muse_server_module_get_msg(module));
3470
3471         if (stream_type != PLAYER_STREAM_TYPE_AUDIO && stream_type != PLAYER_STREAM_TYPE_VIDEO) {
3472                 ret = PLAYER_ERROR_INVALID_PARAMETER;
3473                 goto EXIT;
3474         }
3475         if (codec_type < PLAYER_CODEC_TYPE_DEFAULT || codec_type > PLAYER_CODEC_TYPE_SW) {
3476                 ret = PLAYER_ERROR_INVALID_PARAMETER;
3477                 goto EXIT;
3478         }
3479
3480         ret = legacy_player_set_codec_type(muse_player->player_handle, (player_stream_type_e)stream_type, (player_codec_type_e)codec_type);
3481
3482 EXIT:
3483         PLAYER_RETURN_MSG(api, ret, module);
3484
3485         return ret;
3486 }
3487
3488 int player_disp_get_codec_type(muse_module_h module)
3489 {
3490         int ret = PLAYER_ERROR_NONE;
3491         muse_player_handle_t *muse_player = NULL;
3492         muse_player_api_e api = MUSE_PLAYER_API_GET_CODEC_TYPE;
3493         int stream_type = 0;
3494         player_codec_type_e codec_type = 0;
3495
3496         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3497         player_msg_get(stream_type, muse_server_module_get_msg(module));
3498
3499         ret = legacy_player_get_codec_type(muse_player->player_handle, (player_stream_type_e)stream_type, &codec_type);
3500
3501         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "codec_type", (int)codec_type);
3502
3503         return ret;
3504 }
3505
3506 int player_disp_set_replaygain_enabled(muse_module_h module)
3507 {
3508         int ret = PLAYER_ERROR_NONE;
3509         muse_player_api_e api = MUSE_PLAYER_API_SET_REPLAYGAIN_ENABLED;
3510         muse_player_handle_t *muse_player = NULL;
3511         int val;
3512         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3513         player_msg_get(val, muse_server_module_get_msg(module));
3514
3515         ret = legacy_player_set_replaygain_enabled(muse_player->player_handle, (bool)val);
3516
3517         PLAYER_RETURN_MSG(api, ret, module);
3518
3519         return ret;
3520 }
3521
3522 int player_disp_is_replaygain_enabled(muse_module_h module)
3523 {
3524         int ret = PLAYER_ERROR_NONE;
3525         muse_player_api_e api = MUSE_PLAYER_API_IS_REPLAYGAIN_ENABLED;
3526         muse_player_handle_t *muse_player = NULL;
3527         bool val;
3528
3529         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3530
3531         ret = legacy_player_is_replaygain_enabled(muse_player->player_handle, &val);
3532
3533         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "val", (int)val);
3534
3535         return ret;
3536 }
3537
3538 int player_disp_set_audio_offload_enabled(muse_module_h module)
3539 {
3540         int ret = PLAYER_ERROR_NONE;
3541         muse_player_api_e api = MUSE_PLAYER_API_SET_AUDIO_OFFLOAD_ENABLED;
3542         muse_player_handle_t *muse_player = NULL;
3543         int val = 0;
3544         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3545         player_msg_get(val, muse_server_module_get_msg(module));
3546
3547         ret = legacy_player_set_audio_offload_enabled(muse_player->player_handle, (bool)val);
3548
3549         PLAYER_RETURN_MSG(api, ret, module);
3550
3551         return ret;
3552 }
3553
3554 int player_disp_is_audio_offload_enabled(muse_module_h module)
3555 {
3556         int ret = PLAYER_ERROR_NONE;
3557         muse_player_api_e api = MUSE_PLAYER_API_IS_AUDIO_OFFLOAD_ENABLED;
3558         muse_player_handle_t *muse_player = NULL;
3559         bool val = false;
3560
3561         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3562
3563         ret = legacy_player_is_audio_offload_enabled(muse_player->player_handle, &val);
3564
3565         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "val", (int)val);
3566
3567         return ret;
3568 }
3569
3570 int player_disp_pitch_set_enabled(muse_module_h module)
3571 {
3572         int ret = PLAYER_ERROR_NONE;
3573         muse_player_api_e api = MUSE_PLAYER_API_PITCH_SET_ENABLED;
3574         muse_player_handle_t *muse_player = NULL;
3575         int val = 0;
3576         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3577         player_msg_get(val, muse_server_module_get_msg(module));
3578
3579         ret = legacy_player_pitch_set_enabled(muse_player->player_handle, (bool)val);
3580
3581         PLAYER_RETURN_MSG(api, ret, module);
3582
3583         return ret;
3584 }
3585
3586 int player_disp_pitch_is_enabled(muse_module_h module)
3587 {
3588         int ret = PLAYER_ERROR_NONE;
3589         muse_player_api_e api = MUSE_PLAYER_API_PITCH_IS_ENABLED;
3590         muse_player_handle_t *muse_player = NULL;
3591         bool val = false;
3592
3593         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3594
3595         ret = legacy_player_pitch_is_enabled(muse_player->player_handle, &val);
3596
3597         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_INT, "val", (int)val);
3598
3599         return ret;
3600 }
3601
3602 int player_disp_pitch_set_value(muse_module_h module)
3603 {
3604         int ret = PLAYER_ERROR_NONE;
3605         muse_player_api_e api = MUSE_PLAYER_API_PITCH_SET_VALUE;
3606         muse_player_handle_t *muse_player = NULL;
3607         double pitch = 0.0;
3608         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3609         player_msg_get_type(pitch, muse_server_module_get_msg(module), DOUBLE);
3610
3611         ret = legacy_player_pitch_set_value(muse_player->player_handle, (float)pitch);
3612
3613         PLAYER_RETURN_MSG(api, ret, module);
3614
3615         return ret;
3616 }
3617
3618 int player_disp_pitch_get_value(muse_module_h module)
3619 {
3620         int ret = PLAYER_ERROR_NONE;
3621         muse_player_api_e api = MUSE_PLAYER_API_PITCH_GET_VALUE;
3622         muse_player_handle_t *muse_player = NULL;
3623         float pitch = 0.0;
3624
3625         muse_player = (muse_player_handle_t *)muse_server_ipc_get_handle(module);
3626
3627         ret = legacy_player_pitch_get_value(muse_player->player_handle, &pitch);
3628
3629         PLAYER_RETURN_MSG(api, ret, module, MUSE_TYPE_DOUBLE, "pitch", (double)pitch);
3630
3631         return ret;
3632 }