src/mm_player.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>,
   7  * Seungbae Shin <seungbae.shin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <gst/gst.h>
  24 #include <string.h>
  25
  26 #include <dlog.h>
  27 #include <mm_types.h>
  28 #include <mm_message.h>
  29
  30 #include "mm_player.h"
  31 #include "mm_player_priv.h"
  32 #include "mm_player_attrs.h"
  33 #include "mm_player_utils.h"
  34 #include "mm_player_ini.h"
  35 #include "mm_player_capture.h"
  36 #include "mm_player_tracks.h"
  37 #include "mm_player_es.h"
  38 #include "mm_player_360.h"
  39
  40 int mm_player_create(MMHandleType *player)
  41 {
  42         int result = MM_ERROR_PLAYER_INTERNAL;
  43         mm_player_t* new_player = NULL;
  44
  45         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
  46
  47         /* alloc player structure */
  48         new_player = g_malloc(sizeof(mm_player_t));
  49         if (!new_player) {
  50                 LOGE("Cannot allocate memory for player\n");
  51                 result = MM_ERROR_PLAYER_RESOURCE_LIMIT;
  52                 goto ERROR;
  53         }
  54         memset(new_player, 0, sizeof(mm_player_t));
  55
  56         /* create player lock */
  57         g_mutex_init(&new_player->cmd_lock);
  58
  59         /* create player lock */
  60         g_mutex_init(&new_player->playback_lock);
  61
  62         /* load ini files */
  63         if (MM_ERROR_NONE != mm_player_ini_load(&new_player->ini)) {
  64                 LOGE("can't load ini");
  65                 goto ERROR;
  66         }
  67
  68         if (MM_ERROR_NONE != mm_player_audio_effect_ini_load(&new_player->ini)) {
  69                 LOGE("can't load audio ini");
  70                 goto ERROR;
  71         }
  72
  73         /* create player */
  74         result = _mmplayer_create_player((MMHandleType)new_player);
  75         if (result != MM_ERROR_NONE) {
  76                 LOGE("failed to create player");
  77                 if (result != MM_ERROR_PLAYER_RESOURCE_LIMIT)
  78                         result = MM_ERROR_PLAYER_INTERNAL;
  79                 goto ERROR;
  80         }
  81
  82         *player = (MMHandleType)new_player;
  83
  84         return MM_ERROR_NONE;
  85
  86 ERROR:
  87
  88         if (new_player) {
  89                 _mmplayer_destroy((MMHandleType)new_player);
  90                 g_mutex_clear(&new_player->cmd_lock);
  91                 g_mutex_clear(&new_player->playback_lock);
  92
  93                 MMPLAYER_FREEIF(new_player);
  94         }
  95
  96         *player = (MMHandleType)0;
  97         return result; /* MM_ERROR_PLAYER_INTERNAL or MM_ERROR_PLAYER_RESOURCE_LIMIT */
  98 }
  99
 100 int  mm_player_destroy(MMHandleType player)
 101 {
 102         int result = MM_ERROR_NONE;
 103
 104         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 105
 106         /* destroy the gst bus msg thread if it is remained.
 107            this funct have to be called before getting cmd lock. */
 108         __mmplayer_bus_msg_thread_destroy(player);
 109
 110         MMPLAYER_CMD_LOCK(player);
 111
 112         result = _mmplayer_destroy(player);
 113
 114         MMPLAYER_CMD_UNLOCK(player);
 115
 116         g_mutex_clear(&((mm_player_t*)player)->cmd_lock);
 117         g_mutex_clear(&((mm_player_t*)player)->playback_lock);
 118
 119         memset((mm_player_t*)player, 0x00, sizeof(mm_player_t));
 120
 121         /* free player */
 122         g_free((void*)player);
 123
 124         return result;
 125 }
 126
 127 int mm_player_realize(MMHandleType player)
 128 {
 129         int result = MM_ERROR_NONE;
 130
 131         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 132
 133         MMPLAYER_CMD_LOCK(player);
 134
 135         result = _mmplayer_realize(player);
 136
 137         MMPLAYER_CMD_UNLOCK(player);
 138
 139         return result;
 140 }
 141
 142 int mm_player_abort_pause(MMHandleType player)
 143 {
 144         int result = MM_ERROR_NONE;
 145
 146         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 147
 148         /* destroy the gst bus msg thread not to be blocked in pause(without cmd lock). */
 149         __mmplayer_bus_msg_thread_destroy(player);
 150
 151         /* abort the pause operation for preparing(without cmd lock). */
 152         result = _mmplayer_abort_pause(player);
 153
 154         return result;
 155 }
 156
 157 int mm_player_unrealize(MMHandleType player)
 158 {
 159         int result = MM_ERROR_NONE;
 160
 161         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 162
 163         MMPLAYER_CMD_LOCK(player);
 164
 165         result = _mmplayer_unrealize(player);
 166
 167         MMPLAYER_CMD_UNLOCK(player);
 168
 169         return result;
 170 }
 171
 172 int mm_player_set_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param)
 173 {
 174         int result = MM_ERROR_NONE;
 175
 176         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 177
 178         MMPLAYER_CMD_LOCK(player);
 179
 180         result = _mmplayer_set_message_callback(player, callback, user_param);
 181
 182         MMPLAYER_CMD_UNLOCK(player);
 183
 184         return result;
 185 }
 186
 187 int mm_player_set_pd_message_callback(MMHandleType player, MMMessageCallback callback, void *user_param)
 188 {
 189         int result = MM_ERROR_NONE;
 190
 191         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 192
 193         result = _mm_player_set_pd_downloader_message_cb(player, callback, user_param);
 194
 195         return result;
 196 }
 197
 198 int mm_player_set_audio_stream_callback(MMHandleType player, bool sync, mm_player_audio_stream_callback callback, void *user_param)
 199 {
 200         int result = MM_ERROR_NONE;
 201
 202         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 203
 204         MMPLAYER_CMD_LOCK(player);
 205
 206         result = _mmplayer_set_audiostream_cb(player, sync, callback, user_param);
 207
 208         MMPLAYER_CMD_UNLOCK(player);
 209
 210         return result;
 211 }
 212
 213 int mm_player_set_video_stream_callback(MMHandleType player, mm_player_video_stream_callback callback, void *user_param)
 214 {
 215         int result = MM_ERROR_NONE;
 216
 217         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 218
 219         MMPLAYER_CMD_LOCK(player);
 220
 221         result = _mmplayer_set_videostream_cb(player, callback, user_param);
 222
 223         MMPLAYER_CMD_UNLOCK(player);
 224
 225         return result;
 226 }
 227
 228 int mm_player_do_video_capture(MMHandleType player)
 229 {
 230         int result = MM_ERROR_NONE;
 231
 232         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 233
 234         MMPLAYER_CMD_LOCK(player);
 235
 236         result = _mmplayer_do_video_capture(player);
 237
 238         MMPLAYER_CMD_UNLOCK(player);
 239
 240         return result;
 241 }
 242
 243 int mm_player_set_volume(MMHandleType player, MMPlayerVolumeType *volume)
 244 {
 245         int result = MM_ERROR_NONE;
 246
 247         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 248         MMPLAYER_RETURN_VAL_IF_FAIL(volume, MM_ERROR_INVALID_ARGUMENT);
 249
 250         MMPLAYER_CMD_LOCK(player);
 251
 252         result = _mmplayer_set_volume(player, *volume);
 253
 254         MMPLAYER_CMD_UNLOCK(player);
 255
 256         return result;
 257 }
 258
 259 int mm_player_get_volume(MMHandleType player, MMPlayerVolumeType *volume)
 260 {
 261         int result = MM_ERROR_NONE;
 262
 263         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 264         MMPLAYER_RETURN_VAL_IF_FAIL(volume, MM_ERROR_INVALID_ARGUMENT);
 265
 266         MMPLAYER_CMD_LOCK(player);
 267
 268         result = _mmplayer_get_volume(player, volume);
 269
 270         MMPLAYER_CMD_UNLOCK(player);
 271
 272         return result;
 273 }
 274
 275 int mm_player_set_mute(MMHandleType player, int mute)
 276 {
 277         int result = MM_ERROR_NONE;
 278
 279         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 280
 281         MMPLAYER_CMD_LOCK(player);
 282
 283         result = _mmplayer_set_mute(player, mute);
 284
 285         MMPLAYER_CMD_UNLOCK(player);
 286
 287         return result;
 288 }
 289
 290 int mm_player_get_mute(MMHandleType player, int *mute)
 291 {
 292         int result = MM_ERROR_NONE;
 293
 294         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 295         MMPLAYER_RETURN_VAL_IF_FAIL(mute, MM_ERROR_INVALID_ARGUMENT);
 296
 297         MMPLAYER_CMD_LOCK(player);
 298
 299         result = _mmplayer_get_mute(player, mute);
 300
 301         MMPLAYER_CMD_UNLOCK(player);
 302
 303         return result;
 304 }
 305
 306 int mm_player_get_state(MMHandleType player, MMPlayerStateType *state)
 307 {
 308         int result = MM_ERROR_NONE;
 309
 310         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 311         MMPLAYER_RETURN_VAL_IF_FAIL(state, MM_ERROR_COMMON_INVALID_ARGUMENT);
 312
 313         *state = MM_PLAYER_STATE_NULL;
 314
 315         result = _mmplayer_get_state(player, (int*)state);
 316
 317         return result;
 318 }
 319
 320 /* NOTE : It does not support some use cases, eg using colorspace converter */
 321 int mm_player_change_videosink(MMHandleType player, MMDisplaySurfaceType display_surface_type, void *display_overlay)
 322 {
 323         int result = MM_ERROR_NONE;
 324
 325         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 326
 327         MMPLAYER_CMD_LOCK(player);
 328
 329         result = _mmplayer_change_videosink(player, display_surface_type, display_overlay);
 330
 331         MMPLAYER_CMD_UNLOCK(player);
 332
 333         return result;
 334 }
 335
 336 int mm_player_start(MMHandleType player)
 337 {
 338         int result = MM_ERROR_NONE;
 339
 340         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 341
 342         MMPLAYER_CMD_LOCK(player);
 343
 344         result = _mmplayer_start(player);
 345
 346         MMPLAYER_CMD_UNLOCK(player);
 347
 348         return result;
 349 }
 350
 351 int  mm_player_stop(MMHandleType player)
 352 {
 353         int result = MM_ERROR_NONE;
 354
 355         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 356
 357         MMPLAYER_CMD_LOCK(player);
 358
 359         result = _mmplayer_stop(player);
 360
 361         MMPLAYER_CMD_UNLOCK(player);
 362
 363         return result;
 364 }
 365
 366 int mm_player_pause(MMHandleType player)
 367 {
 368         int result = MM_ERROR_NONE;
 369
 370         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 371
 372         MMPLAYER_CMD_LOCK(player);
 373
 374         result = _mmplayer_pause(player);
 375
 376         MMPLAYER_CMD_UNLOCK(player);
 377
 378         return result;
 379 }
 380
 381 int mm_player_resume(MMHandleType player)
 382 {
 383         int result = MM_ERROR_NONE;
 384
 385         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 386
 387         MMPLAYER_CMD_LOCK(player);
 388
 389         result = _mmplayer_resume(player);
 390
 391         MMPLAYER_CMD_UNLOCK(player);
 392
 393         return result;
 394 }
 395
 396 int mm_player_set_play_speed(MMHandleType player, float rate, bool streaming)
 397 {
 398         int result = MM_ERROR_NONE;
 399
 400         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 401
 402         MMPLAYER_CMD_LOCK(player);
 403
 404         result = _mmplayer_set_playspeed(player, rate, streaming);
 405
 406         MMPLAYER_CMD_UNLOCK(player);
 407
 408         return result;
 409 }
 410
 411 int mm_player_set_position(MMHandleType player, int64_t pos)
 412 {
 413         int result = MM_ERROR_NONE;
 414
 415         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 416
 417         MMPLAYER_CMD_LOCK(player);
 418
 419         result = _mmplayer_set_position(player, pos);
 420
 421         MMPLAYER_CMD_UNLOCK(player);
 422
 423         return result;
 424 }
 425
 426 int mm_player_get_position(MMHandleType player, int64_t *pos)
 427 {
 428         int result = MM_ERROR_NONE;
 429
 430         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 431         MMPLAYER_RETURN_VAL_IF_FAIL(pos, MM_ERROR_COMMON_INVALID_ARGUMENT);
 432
 433         MMPLAYER_CMD_LOCK(player);
 434
 435         result = _mmplayer_get_position(player, pos);
 436
 437         MMPLAYER_CMD_UNLOCK(player);
 438
 439         return result;
 440 }
 441
 442 int mm_player_get_duration(MMHandleType player, int64_t *dur)
 443 {
 444         int result = MM_ERROR_NONE;
 445
 446         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 447         MMPLAYER_RETURN_VAL_IF_FAIL(dur, MM_ERROR_COMMON_INVALID_ARGUMENT);
 448
 449         MMPLAYER_CMD_LOCK(player);
 450
 451         result = _mmplayer_get_duration(player, dur);
 452
 453         MMPLAYER_CMD_UNLOCK(player);
 454
 455         return result;
 456 }
 457
 458
 459 int mm_player_get_buffer_position(MMHandleType player, MMPlayerPosFormatType format, unsigned long *start_pos, unsigned long *stop_pos)
 460 {
 461         int result = MM_ERROR_NONE;
 462
 463         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 464         MMPLAYER_RETURN_VAL_IF_FAIL(start_pos && stop_pos, MM_ERROR_COMMON_INVALID_ARGUMENT);
 465
 466         MMPLAYER_CMD_LOCK(player);
 467
 468         result = _mmplayer_get_buffer_position(player, (int)format, start_pos, stop_pos);
 469
 470         MMPLAYER_CMD_UNLOCK(player);
 471
 472         return result;
 473 }
 474
 475 int mm_player_set_external_subtitle_path(MMHandleType player, const char* path)
 476 {
 477         int result = MM_ERROR_NONE;
 478
 479         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 480
 481         MMPLAYER_CMD_LOCK(player);
 482
 483         result = _mmplayer_set_external_subtitle_path(player, path);
 484
 485         MMPLAYER_CMD_UNLOCK(player);
 486         return result;
 487 }
 488
 489 int mm_player_adjust_subtitle_position(MMHandleType player, MMPlayerPosFormatType format, int pos)
 490 {
 491         int result = MM_ERROR_NONE;
 492
 493         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 494
 495         if (format >= MM_PLAYER_POS_FORMAT_NUM) {
 496                 LOGE("wrong format(%d) \n", format);
 497                 return MM_ERROR_INVALID_ARGUMENT;
 498         }
 499
 500         MMPLAYER_CMD_LOCK(player);
 501
 502         result = _mmplayer_adjust_subtitle_postion(player, format, pos);
 503
 504         MMPLAYER_CMD_UNLOCK(player);
 505
 506         return result;
 507 }
 508
 509 int mm_player_set_subtitle_silent(MMHandleType player, int silent)
 510 {
 511         int result = MM_ERROR_NONE;
 512
 513         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 514
 515         MMPLAYER_CMD_LOCK(player);
 516
 517         result = _mmplayer_set_subtitle_silent(player, silent);
 518
 519         MMPLAYER_CMD_UNLOCK(player);
 520
 521         return result;
 522 }
 523
 524 int mm_player_get_subtitle_silent(MMHandleType player, int* silent)
 525 {
 526         int result = MM_ERROR_NONE;
 527
 528         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 529
 530         MMPLAYER_CMD_LOCK(player);
 531
 532         result = _mmplayer_get_subtitle_silent(player, silent);
 533
 534         MMPLAYER_CMD_UNLOCK(player);
 535
 536         return result;
 537 }
 538
 539 int mm_player_set_attribute(MMHandleType player,  char **err_attr_name, const char *first_attribute_name, ...)
 540 {
 541         int result = MM_ERROR_NONE;
 542         va_list var_args;
 543
 544         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 545         MMPLAYER_RETURN_VAL_IF_FAIL(first_attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 546
 547         va_start(var_args, first_attribute_name);
 548         result = _mmplayer_set_attribute(player, err_attr_name, first_attribute_name, var_args);
 549         va_end(var_args);
 550
 551         return result;
 552 }
 553
 554 int mm_player_get_attribute(MMHandleType player,  char **err_attr_name, const char *first_attribute_name, ...)
 555 {
 556         int result = MM_ERROR_NONE;
 557         va_list var_args;
 558
 559         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 560         MMPLAYER_RETURN_VAL_IF_FAIL(first_attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 561
 562         va_start(var_args, first_attribute_name);
 563         result = _mmplayer_get_attribute(player, err_attr_name, first_attribute_name, var_args);
 564         va_end(var_args);
 565
 566         return result;
 567 }
 568
 569 int mm_player_get_attribute_info(MMHandleType player,  const char *attribute_name, MMPlayerAttrsInfo *info)
 570 {
 571         int result = MM_ERROR_NONE;
 572
 573
 574         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 575         MMPLAYER_RETURN_VAL_IF_FAIL(attribute_name, MM_ERROR_COMMON_INVALID_ARGUMENT);
 576         MMPLAYER_RETURN_VAL_IF_FAIL(info, MM_ERROR_COMMON_INVALID_ARGUMENT);
 577
 578         result = _mmplayer_get_attributes_info((MMHandleType)player, attribute_name, info);
 579
 580         return result;
 581 }
 582
 583 int mm_player_get_pd_status(MMHandleType player, guint64 *current_pos, guint64 *total_size)
 584 {
 585         int result = MM_ERROR_NONE;
 586
 587         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 588         MMPLAYER_RETURN_VAL_IF_FAIL(current_pos, MM_ERROR_COMMON_INVALID_ARGUMENT);
 589         MMPLAYER_RETURN_VAL_IF_FAIL(total_size, MM_ERROR_COMMON_INVALID_ARGUMENT);
 590
 591         result = _mmplayer_get_pd_downloader_status(player, current_pos, total_size);
 592
 593         return result;
 594 }
 595
 596 int mm_player_get_track_count(MMHandleType player, MMPlayerTrackType type, int *count)
 597 {
 598         int result = MM_ERROR_NONE;
 599
 600         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 601         MMPLAYER_RETURN_VAL_IF_FAIL(count, MM_ERROR_COMMON_INVALID_ARGUMENT);
 602
 603         MMPLAYER_CMD_LOCK(player);
 604
 605         result = _mmplayer_get_track_count(player, type, count);
 606
 607         MMPLAYER_CMD_UNLOCK(player);
 608
 609         return result;
 610 }
 611
 612 int mm_player_select_track(MMHandleType player, MMPlayerTrackType type, int index)
 613 {
 614         int result = MM_ERROR_NONE;
 615
 616         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 617
 618         MMPLAYER_CMD_LOCK(player);
 619
 620         result = _mmplayer_select_track(player, type, index);
 621
 622         MMPLAYER_CMD_UNLOCK(player);
 623
 624         return result;
 625 }
 626
 627 int mm_player_get_current_track(MMHandleType player, MMPlayerTrackType type, int *index)
 628 {
 629         int result = MM_ERROR_NONE;
 630
 631         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 632         MMPLAYER_RETURN_VAL_IF_FAIL(index, MM_ERROR_COMMON_INVALID_ARGUMENT);
 633
 634         MMPLAYER_CMD_LOCK(player);
 635
 636         result = _mmplayer_get_current_track(player, type, index);
 637
 638         MMPLAYER_CMD_UNLOCK(player);
 639
 640         return result;
 641 }
 642
 643 int mm_player_get_track_language_code(MMHandleType player,  MMPlayerTrackType type, int index, char **code)
 644 {
 645         int result = MM_ERROR_NONE;
 646
 647         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 648
 649         MMPLAYER_CMD_LOCK(player);
 650
 651         result = _mmplayer_get_track_language_code(player, type, index, code);
 652
 653         MMPLAYER_CMD_UNLOCK(player);
 654
 655         return result;
 656 }
 657
 658 int mm_player_set_uri(MMHandleType player, const char *uri)
 659 {
 660         int result = MM_ERROR_NONE;
 661
 662         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 663
 664         MMPLAYER_CMD_LOCK(player);
 665
 666         result = _mmplayer_set_uri(player, uri);
 667
 668         MMPLAYER_CMD_UNLOCK(player);
 669
 670         return result;
 671
 672 }
 673
 674 int mm_player_set_next_uri(MMHandleType player, const char *uri)
 675 {
 676         int result = MM_ERROR_NONE;
 677
 678         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 679
 680         MMPLAYER_CMD_LOCK(player);
 681
 682         result = _mmplayer_set_next_uri(player, uri, FALSE);
 683
 684         MMPLAYER_CMD_UNLOCK(player);
 685
 686         return result;
 687
 688 }
 689
 690 int mm_player_get_next_uri(MMHandleType player, char **uri)
 691 {
 692         int result = MM_ERROR_NONE;
 693
 694         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 695
 696         MMPLAYER_CMD_LOCK(player);
 697
 698         result = _mmplayer_get_next_uri(player, uri);
 699
 700         MMPLAYER_CMD_UNLOCK(player);
 701
 702         return result;
 703
 704 }
 705
 706 int mm_player_has_closed_caption(MMHandleType player, bool *exist)
 707 {
 708         int result = MM_ERROR_NONE;
 709
 710         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 711         MMPLAYER_RETURN_VAL_IF_FAIL(exist, MM_ERROR_INVALID_ARGUMENT);
 712
 713         MMPLAYER_CMD_LOCK(player);
 714
 715         result = _mmplayer_has_closed_caption(player, exist);
 716
 717         MMPLAYER_CMD_UNLOCK(player);
 718
 719         return result;
 720 }
 721
 722 void mm_player_video_stream_internal_buffer_unref(void *buffer)
 723 {
 724         _mm_player_video_stream_internal_buffer_unref(buffer);
 725 }
 726
 727 int mm_player_submit_packet(MMHandleType player, media_packet_h packet)
 728 {
 729
 730         int result = MM_ERROR_NONE;
 731
 732         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 733
 734         /* no lock here, otherwise callback for the "need-data" signal of appsrc will be blocking */
 735         //MMPLAYER_CMD_LOCK(player);
 736
 737         result = _mmplayer_submit_packet(player, packet);
 738
 739         //MMPLAYER_CMD_UNLOCK(player);
 740
 741         return result;
 742 }
 743
 744 int mm_player_set_video_info(MMHandleType player, media_format_h format)
 745 {
 746         int result = MM_ERROR_NONE;
 747
 748         LOGD("\n");
 749
 750         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 751
 752         MMPLAYER_CMD_LOCK(player);
 753
 754         result = _mmplayer_set_video_info(player, format);
 755
 756         MMPLAYER_CMD_UNLOCK(player);
 757
 758         return result;
 759
 760 }
 761
 762 int mm_player_set_audio_info(MMHandleType player, media_format_h format)
 763 {
 764         int result = MM_ERROR_NONE;
 765
 766         LOGD("\n");
 767
 768         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 769
 770         MMPLAYER_CMD_LOCK(player);
 771
 772         result = _mmplayer_set_audio_info(player, format);
 773
 774         MMPLAYER_CMD_UNLOCK(player);
 775
 776         return result;
 777 }
 778
 779 int mm_player_set_subtitle_info(MMHandleType player, MMPlayerSubtitleStreamInfo *subtitle_stream_info)
 780 {
 781         int result = MM_ERROR_NONE;
 782
 783         LOGD("\n");
 784
 785         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 786
 787         MMPLAYER_CMD_LOCK(player);
 788
 789         result = _mmplayer_set_subtitle_info(player, subtitle_stream_info);
 790
 791         MMPLAYER_CMD_UNLOCK(player);
 792
 793         return result;
 794 }
 795
 796 int mm_player_set_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long max_size)
 797 {
 798         int result = MM_ERROR_NONE;
 799
 800         LOGD("\n");
 801
 802         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 803
 804         MMPLAYER_CMD_LOCK(player);
 805
 806         result = _mmplayer_set_media_stream_max_size(player, type, max_size);
 807
 808         MMPLAYER_CMD_UNLOCK(player);
 809
 810         return result;
 811 }
 812
 813 int mm_player_get_media_stream_buffer_max_size(MMHandleType player, MMPlayerStreamType type, unsigned long long *max_size)
 814 {
 815         int result = MM_ERROR_NONE;
 816         guint64 _max_size = 0;
 817
 818         LOGD("\n");
 819
 820         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 821         MMPLAYER_RETURN_VAL_IF_FAIL(max_size, MM_ERROR_INVALID_ARGUMENT);
 822
 823         MMPLAYER_CMD_LOCK(player);
 824
 825         result = _mmplayer_get_media_stream_max_size(player, type, &_max_size);
 826         *max_size = _max_size;
 827
 828         MMPLAYER_CMD_UNLOCK(player);
 829
 830         return result;
 831 }
 832
 833 int mm_player_set_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned min_percent)
 834 {
 835         int result = MM_ERROR_NONE;
 836
 837         LOGD("\n");
 838
 839         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 840
 841         MMPLAYER_CMD_LOCK(player);
 842
 843         result = _mmplayer_set_media_stream_min_percent(player, type, min_percent);
 844
 845         MMPLAYER_CMD_UNLOCK(player);
 846
 847         return result;
 848 }
 849
 850 int mm_player_get_media_stream_buffer_min_percent(MMHandleType player, MMPlayerStreamType type, unsigned int *min_percent)
 851 {
 852         int result = MM_ERROR_NONE;
 853
 854         LOGD("\n");
 855
 856         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 857         MMPLAYER_RETURN_VAL_IF_FAIL(min_percent, MM_ERROR_INVALID_ARGUMENT);
 858
 859         MMPLAYER_CMD_LOCK(player);
 860
 861         result = _mmplayer_get_media_stream_min_percent(player, type, min_percent);
 862
 863         MMPLAYER_CMD_UNLOCK(player);
 864
 865         return result;
 866 }
 867
 868 int mm_player_set_media_stream_buffer_status_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_buffer_status_callback callback, void * user_param)
 869 {
 870         int result = MM_ERROR_NONE;
 871
 872         LOGD("\n");
 873
 874         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 875
 876         MMPLAYER_CMD_LOCK(player);
 877
 878         result = _mmplayer_set_media_stream_buffer_status_cb(player, type, callback, user_param);
 879
 880         MMPLAYER_CMD_UNLOCK(player);
 881
 882         return result;
 883 }
 884
 885 int mm_player_set_media_stream_seek_data_callback(MMHandleType player, MMPlayerStreamType type, mm_player_media_stream_seek_data_callback callback, void * user_param)
 886 {
 887         int result = MM_ERROR_NONE;
 888
 889         LOGD("\n");
 890
 891         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 892
 893         MMPLAYER_CMD_LOCK(player);
 894
 895         result = _mmplayer_set_media_stream_seek_data_cb(player, type, callback, user_param);
 896
 897         MMPLAYER_CMD_UNLOCK(player);
 898
 899         return result;
 900 }
 901
 902 int mm_player_set_audio_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param)
 903 {
 904         int result = MM_ERROR_NONE;
 905
 906         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 907
 908         MMPLAYER_CMD_LOCK(player);
 909
 910         result = _mmplayer_set_audiostream_changed_cb(player, callback, user_param);
 911
 912         MMPLAYER_CMD_UNLOCK(player);
 913
 914         return result;
 915 }
 916
 917 int mm_player_set_video_stream_changed_callback(MMHandleType player, mm_player_stream_changed_callback callback, void *user_param)
 918 {
 919         int result = MM_ERROR_NONE;
 920
 921         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 922
 923         MMPLAYER_CMD_LOCK(player);
 924
 925         result = _mmplayer_set_videostream_changed_cb(player, callback, user_param);
 926
 927         MMPLAYER_CMD_UNLOCK(player);
 928
 929         return result;
 930 }
 931
 932 int mm_player_get_timeout(MMHandleType player, int *timeout)
 933 {
 934         int result = MM_ERROR_NONE;
 935
 936         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 937         MMPLAYER_RETURN_VAL_IF_FAIL(timeout, MM_ERROR_COMMON_INVALID_ARGUMENT);
 938
 939         MMPLAYER_CMD_LOCK(player);
 940
 941         result = _mmplayer_get_timeout(player, timeout);
 942
 943         MMPLAYER_CMD_UNLOCK(player);
 944
 945         return result;
 946 }
 947
 948 int mm_player_get_num_of_video_out_buffers(MMHandleType player, int *num, int *extra_num)
 949 {
 950         int result = MM_ERROR_NONE;
 951
 952         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 953         MMPLAYER_RETURN_VAL_IF_FAIL(num && extra_num, MM_ERROR_COMMON_INVALID_ARGUMENT);
 954
 955         MMPLAYER_CMD_LOCK(player);
 956
 957         result = _mmplayer_get_num_of_video_out_buffers(player, num, extra_num);
 958
 959         MMPLAYER_CMD_UNLOCK(player);
 960
 961         return result;
 962 }
 963
 964 int mm_player_set_media_stream_dynamic_resolution(MMHandleType player, bool drc)
 965 {
 966         int result = MM_ERROR_NONE;
 967
 968         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 969
 970         MMPLAYER_CMD_LOCK(player);
 971
 972         result = _mmplayer_set_media_stream_dynamic_resolution(player, drc);
 973
 974         MMPLAYER_CMD_UNLOCK(player);
 975
 976         return result;
 977 }
 978
 979 int mm_player_release_video_stream_bo(MMHandleType player, void* bo)
 980 {
 981         int result = MM_ERROR_NONE;
 982
 983         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
 984         MMPLAYER_RETURN_VAL_IF_FAIL(bo, MM_ERROR_COMMON_INVALID_ARGUMENT);
 985
 986         //MMPLAYER_CMD_LOCK(player);
 987
 988         result = _mmplayer_video_stream_release_bo(player, bo);
 989
 990         //MMPLAYER_CMD_UNLOCK(player);
 991
 992         return result;
 993 }
 994
 995 int mm_player_set_file_buffering_path(MMHandleType player, const char *file_path)
 996 {
 997         int result = MM_ERROR_NONE;
 998
 999         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1000
1001         MMPLAYER_CMD_LOCK(player);
1002
1003         result = _mmplayer_set_file_buffering_path(player, file_path);
1004
1005         MMPLAYER_CMD_UNLOCK(player);
1006
1007         return result;
1008 }
1009
1010 int mm_player_set_sound_stream_info(MMHandleType player, char *stream_type, int stream_index)
1011 {
1012         int result = MM_ERROR_NONE;
1013
1014         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1015         MMPLAYER_RETURN_VAL_IF_FAIL((stream_type && (stream_index >= 0)), MM_ERROR_INVALID_ARGUMENT);
1016
1017         MMPLAYER_CMD_LOCK(player);
1018
1019         result = mm_player_set_attribute(player, NULL, "sound_stream_type", stream_type, strlen(stream_type), "sound_stream_index", stream_index, NULL);
1020
1021         MMPLAYER_CMD_UNLOCK(player);
1022
1023         return result;
1024 }
1025
1026 int mm_player_manage_external_storage_state(MMHandleType player, int id, int state)
1027 {
1028         int result = MM_ERROR_NONE;
1029
1030         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1031
1032         MMPLAYER_CMD_LOCK(player);
1033
1034         result = _mmplayer_manage_external_storage_state(player, id, state);
1035
1036         MMPLAYER_CMD_UNLOCK(player);
1037
1038         return result;
1039 }
1040
1041 int mm_player_get_adaptive_variant_info(MMHandleType player, int *num, char **var_info)
1042 {
1043         int result = MM_ERROR_NONE;
1044
1045         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1046         MMPLAYER_RETURN_VAL_IF_FAIL(num && var_info, MM_ERROR_COMMON_INVALID_ARGUMENT);
1047
1048         MMPLAYER_CMD_LOCK(player);
1049
1050         result = _mmplayer_get_adaptive_variant_info(player, num, var_info);
1051
1052         MMPLAYER_CMD_UNLOCK(player);
1053
1054         return result;
1055 }
1056
1057 int mm_player_set_max_adaptive_variant_limit(MMHandleType player, int bandwidth, int width, int height)
1058 {
1059         int result = MM_ERROR_NONE;
1060
1061         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1062
1063         MMPLAYER_CMD_LOCK(player);
1064
1065         result = _mmplayer_set_max_adaptive_variant_limit(player, bandwidth, width, height);
1066
1067         MMPLAYER_CMD_UNLOCK(player);
1068
1069         return result;
1070 }
1071
1072 int mm_player_get_max_adaptive_variant_limit(MMHandleType player, int *bandwidth, int *width, int *height)
1073 {
1074         int result = MM_ERROR_NONE;
1075
1076         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1077         MMPLAYER_RETURN_VAL_IF_FAIL(bandwidth && width && height, MM_ERROR_COMMON_INVALID_ARGUMENT);
1078
1079         MMPLAYER_CMD_LOCK(player);
1080
1081         result = _mmplayer_get_max_adaptive_variant_limit(player, bandwidth, width, height);
1082
1083         MMPLAYER_CMD_UNLOCK(player);
1084
1085         return result;
1086 }
1087
1088 int mm_player_set_streaming_buffering_time(MMHandleType player, int buffer_ms, int rebuffer_ms)
1089 {
1090         int result = MM_ERROR_NONE;
1091         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1092
1093         MMPLAYER_CMD_LOCK(player);
1094
1095         result = _mmplayer_set_streaming_buffering_time(player, buffer_ms, rebuffer_ms);
1096
1097         MMPLAYER_CMD_UNLOCK(player);
1098
1099         return result;
1100 }
1101
1102 int mm_player_get_streaming_buffering_time(MMHandleType player, int *buffer_ms, int *rebuffer_ms)
1103 {
1104         int result = MM_ERROR_NONE;
1105
1106         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1107         MMPLAYER_RETURN_VAL_IF_FAIL(buffer_ms && rebuffer_ms, MM_ERROR_INVALID_ARGUMENT);
1108
1109         MMPLAYER_CMD_LOCK(player);
1110
1111         result = _mmplayer_get_streaming_buffering_time(player, buffer_ms, rebuffer_ms);
1112
1113         MMPLAYER_CMD_UNLOCK(player);
1114
1115         return result;
1116 }
1117
1118 int mm_player_set_audio_only(MMHandleType player, bool audio_only)
1119 {
1120         int result = MM_ERROR_NONE;
1121         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1122
1123         MMPLAYER_CMD_LOCK(player);
1124
1125         result = _mmplayer_set_audio_only(player, audio_only);
1126
1127         MMPLAYER_CMD_UNLOCK(player);
1128
1129         return result;
1130 }
1131
1132 int mm_player_get_audio_only(MMHandleType player, bool *audio_only)
1133 {
1134         int result = MM_ERROR_NONE;
1135
1136         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1137         MMPLAYER_RETURN_VAL_IF_FAIL(audio_only, MM_ERROR_INVALID_ARGUMENT);
1138
1139         MMPLAYER_CMD_LOCK(player);
1140
1141         result = _mmplayer_get_audio_only(player, audio_only);
1142
1143         MMPLAYER_CMD_UNLOCK(player);
1144
1145         return result;
1146 }
1147
1148 int mm_player_360_is_content_spherical(MMHandleType player, bool *is_spherical)
1149 {
1150         int result = MM_ERROR_NONE;
1151
1152         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1153         MMPLAYER_RETURN_VAL_IF_FAIL(is_spherical, MM_ERROR_INVALID_ARGUMENT);
1154
1155         MMPLAYER_CMD_LOCK(player);
1156
1157         result = _mmplayer_360_is_content_spherical(player, is_spherical);
1158
1159         MMPLAYER_CMD_UNLOCK(player);
1160
1161         return result;
1162 }
1163
1164 int mm_player_360_set_enabled(MMHandleType player, bool enabled)
1165 {
1166         int result = MM_ERROR_NONE;
1167         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1168
1169         MMPLAYER_CMD_LOCK(player);
1170
1171         result = _mmplayer_360_set_enabled(player, enabled);
1172
1173         MMPLAYER_CMD_UNLOCK(player);
1174
1175         return result;
1176 }
1177
1178 int mm_player_360_is_enabled(MMHandleType player, bool *enabled)
1179 {
1180         int result = MM_ERROR_NONE;
1181
1182         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1183         MMPLAYER_RETURN_VAL_IF_FAIL(enabled, MM_ERROR_INVALID_ARGUMENT);
1184
1185         MMPLAYER_CMD_LOCK(player);
1186
1187         result = _mmplayer_360_is_enabled(player, enabled);
1188
1189         MMPLAYER_CMD_UNLOCK(player);
1190
1191         return result;
1192 }
1193
1194 int mm_player_360_set_direction_of_view(MMHandleType player, float yaw, float pitch)
1195 {
1196         int result = MM_ERROR_NONE;
1197         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1198
1199         MMPLAYER_CMD_LOCK(player);
1200
1201         result = _mmplayer_360_set_direction_of_view(player, yaw, pitch);
1202
1203         MMPLAYER_CMD_UNLOCK(player);
1204
1205         return result;
1206 }
1207
1208 int mm_player_360_get_direction_of_view(MMHandleType player, float *yaw, float *pitch)
1209 {
1210         int result = MM_ERROR_NONE;
1211
1212         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1213         MMPLAYER_RETURN_VAL_IF_FAIL(yaw && pitch, MM_ERROR_INVALID_ARGUMENT);
1214
1215         MMPLAYER_CMD_LOCK(player);
1216
1217         result = _mmplayer_360_get_direction_of_view(player, yaw, pitch);
1218
1219         MMPLAYER_CMD_UNLOCK(player);
1220
1221         return result;
1222 }
1223
1224 int mm_player_360_set_zoom(MMHandleType player, float level)
1225 {
1226         int result = MM_ERROR_NONE;
1227         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1228
1229         MMPLAYER_CMD_LOCK(player);
1230
1231         result = _mmplayer_360_set_zoom(player, level);
1232
1233         MMPLAYER_CMD_UNLOCK(player);
1234
1235         return result;
1236 }
1237
1238 int mm_player_360_get_zoom(MMHandleType player, float *level)
1239 {
1240         int result = MM_ERROR_NONE;
1241
1242         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1243         MMPLAYER_RETURN_VAL_IF_FAIL(level, MM_ERROR_INVALID_ARGUMENT);
1244
1245         MMPLAYER_CMD_LOCK(player);
1246
1247         result = _mmplayer_360_get_zoom(player, level);
1248
1249         MMPLAYER_CMD_UNLOCK(player);
1250
1251         return result;
1252 }
1253
1254 int mm_player_360_set_field_of_view(MMHandleType player, int horizontal_degrees, int vertical_degrees)
1255 {
1256         int result = MM_ERROR_NONE;
1257         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1258
1259         MMPLAYER_CMD_LOCK(player);
1260
1261         result = _mmplayer_360_set_field_of_view(player, horizontal_degrees, vertical_degrees);
1262
1263         MMPLAYER_CMD_UNLOCK(player);
1264
1265         return result;
1266 }
1267
1268 int mm_player_360_get_field_of_view(MMHandleType player, int *horizontal_degrees, int *vertical_degrees)
1269 {
1270         int result = MM_ERROR_NONE;
1271
1272         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1273         MMPLAYER_RETURN_VAL_IF_FAIL(horizontal_degrees && vertical_degrees, MM_ERROR_INVALID_ARGUMENT);
1274
1275         MMPLAYER_CMD_LOCK(player);
1276
1277         result = _mmplayer_360_get_field_of_view(player, horizontal_degrees, vertical_degrees);
1278
1279         MMPLAYER_CMD_UNLOCK(player);
1280
1281         return result;
1282 }
1283
1284 int mm_player_set_codec_type(MMHandleType player, MMPlayerStreamType stream_type, MMPlayerVideoCodecType codec_type)
1285 {
1286         int result = MM_ERROR_NONE;
1287
1288         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1289
1290         MMPLAYER_CMD_LOCK(player);
1291
1292         result = _mmplayer_set_codec_type(player, stream_type, codec_type);
1293
1294         MMPLAYER_CMD_UNLOCK(player);
1295
1296         return result;
1297 }
1298
1299 int mm_player_set_replaygain_enabled(MMHandleType player, bool enabled)
1300 {
1301         int result = MM_ERROR_NONE;
1302
1303         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1304
1305         MMPLAYER_CMD_LOCK(player);
1306
1307         result = _mmplayer_set_replaygain_enabled(player, enabled);
1308
1309         MMPLAYER_CMD_UNLOCK(player);
1310
1311         return result;
1312 }
1313
1314 int mm_player_is_replaygain_enabled(MMHandleType player, bool *enabled)
1315 {
1316         int result = MM_ERROR_NONE;
1317
1318         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1319         MMPLAYER_RETURN_VAL_IF_FAIL(enabled, MM_ERROR_INVALID_ARGUMENT);
1320
1321         MMPLAYER_CMD_LOCK(player);
1322
1323         result = _mmplayer_is_replaygain_enabled(player, enabled);
1324
1325         MMPLAYER_CMD_UNLOCK(player);
1326
1327         return result;
1328 }
1329
1330 int mm_player_set_video_roi_area(MMHandleType player, double scale_x, double scale_y, double scale_width, double scale_height)
1331 {
1332         int result = MM_ERROR_NONE;
1333
1334         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1335
1336         MMPLAYER_CMD_LOCK(player);
1337
1338         result = _mmplayer_set_video_roi_area(player, scale_x, scale_y, scale_width, scale_height);
1339
1340         MMPLAYER_CMD_UNLOCK(player);
1341
1342         return result;
1343 }
1344
1345 int mm_player_get_video_roi_area(MMHandleType player, double *scale_x, double *scale_y, double *scale_width, double *scale_height)
1346 {
1347         int result = MM_ERROR_NONE;
1348
1349         MMPLAYER_RETURN_VAL_IF_FAIL(player, MM_ERROR_PLAYER_NOT_INITIALIZED);
1350
1351         MMPLAYER_CMD_LOCK(player);
1352
1353         result = _mmplayer_get_video_roi_area(player, scale_x, scale_y, scale_width, scale_height);
1354
1355         MMPLAYER_CMD_UNLOCK(player);
1356
1357         return result;
1358 }