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